api-core-lib 12.0.10 → 12.0.12

package/dist/index.cjs

@@ -1,5 +1,4 @@
 "use strict";
-"use client";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -33,7 +32,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ApiModuleProvider: () => ApiModuleProvider,
   buildPaginateQuery: () => buildPaginateQuery,
   cacheManager: () => cacheManager,
   callDynamicApi: () => callDynamicApi,
@@ -41,12 +39,7 @@ __export(index_exports, {
   createApiClient: () => createApiClient,
   createApiServices: () => createApiServices,
   globalStateManager: () => globalStateManager,
-  processResponse: () => processResponse,
-  useApi: () => useApi,
-  useApiModule: () => useApiModule,
-  useApiRecord: () => useApiRecord,
-  useDeepCompareEffect: () => useDeepCompareEffect,
-  useModuleContext: () => useModuleContext
+  processResponse: () => processResponse
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -695,452 +688,8 @@ var CacheManager = class {
   }
 };
 var cacheManager = new CacheManager();
-
-// src/hooks/useApi.ts
-var import_react = require("react");
-function buildDynamicPath(template, params) {
-  if (!params) return template;
-  let path = template;
-  for (const key in params) {
-    path = path.replace(new RegExp(`{${key}}`, "g"), String(params[key]));
-  }
-  return path;
-}
-function useApi(axiosInstance, config) {
-  const {
-    endpoint,
-    pathParams,
-    // [REMOVE] لم نعد بحاجة لهذا الخيار
-    // encodeQuery = true, 
-    initialData,
-    initialQuery = {},
-    enabled = true,
-    refetchAfterChange = true,
-    requestConfig,
-    onSuccess,
-    onError
-  } = config;
-  const finalEndpoint = (0, import_react.useMemo)(
-    () => buildDynamicPath(endpoint, pathParams),
-    [endpoint, pathParams]
-  );
-  const [state, setState] = (0, import_react.useState)({
-    data: initialData ?? null,
-    rawResponse: null,
-    loading: enabled,
-    error: null,
-    success: false,
-    message: void 0,
-    validationErrors: void 0
-  });
-  const [queryOptions, setQueryOptions] = (0, import_react.useState)(initialQuery);
-  const apiServices = (0, import_react.useMemo)(
-    () => createApiServices(axiosInstance, finalEndpoint),
-    [axiosInstance, finalEndpoint]
-  );
-  const savedOnSuccess = (0, import_react.useRef)(onSuccess);
-  const savedOnError = (0, import_react.useRef)(onError);
-  (0, import_react.useEffect)(() => {
-    savedOnSuccess.current = onSuccess;
-    savedOnError.current = onError;
-  }, [onSuccess, onError]);
-  const fetchData = (0, import_react.useCallback)(async (currentQueryOptions) => {
-    setState((prev) => ({ ...prev, loading: true, error: null }));
-    try {
-      const finalQuery = currentQueryOptions || queryOptions;
-      const hasQueryParams = Object.keys(finalQuery).length > 0;
-      const queryString = buildPaginateQuery(finalQuery);
-      const result = hasQueryParams ? await apiServices.getWithQuery(queryString, requestConfig) : await apiServices.get(void 0, requestConfig);
-      setState(result);
-      if (result.success && savedOnSuccess.current) {
-        savedOnSuccess.current(result.message || "Fetch successful!", result.data ?? void 0);
-      } else if (!result.success && savedOnError.current) {
-        savedOnError.current(result.message || "Fetch failed", result.error ?? void 0);
-      }
-    } catch (e) {
-      const apiError = { status: 500, message: e.message || "An unexpected client-side error occurred." };
-      setState((prev) => ({ ...prev, loading: false, error: apiError, success: false }));
-      if (savedOnError.current) {
-        savedOnError.current(apiError.message, apiError);
-      }
-    }
-  }, [apiServices, queryOptions, requestConfig]);
-  (0, import_react.useEffect)(() => {
-    if (enabled) {
-      fetchData();
-    }
-  }, [enabled, fetchData]);
-  const handleActionResult = (0, import_react.useCallback)(async (actionPromise) => {
-    setState((prev) => ({ ...prev, loading: true }));
-    try {
-      const result = await actionPromise;
-      if (result.success) {
-        if (savedOnSuccess.current) {
-          savedOnSuccess.current(result.message || "Action successful!", result.data ?? void 0);
-        }
-        if (refetchAfterChange) {
-          await fetchData(queryOptions);
-        } else {
-          setState((prev) => ({ ...prev, ...result, loading: false }));
-        }
-      } else {
-        if (savedOnError.current) {
-          savedOnError.current(result.message || "Action failed", result.error ?? void 0);
-        }
-        setState((prev) => ({ ...prev, loading: false, error: result.error, success: false }));
-      }
-      return result;
-    } catch (e) {
-      const apiError = { status: 500, message: e.message || "An unexpected error occurred during action." };
-      setState((prev) => ({ ...prev, loading: false, error: apiError, success: false }));
-      if (savedOnError.current) {
-        savedOnError.current(apiError.message, apiError);
-      }
-      return { data: null, error: apiError, loading: false, success: false, rawResponse: e };
-    }
-  }, [refetchAfterChange, fetchData, queryOptions]);
-  const actions = {
-    fetch: fetchData,
-    create: (newItem, options) => handleActionResult(apiServices.post(newItem, options)),
-    put: (id, item, options) => handleActionResult(apiServices.put(id, item, options)),
-    update: (id, updatedItem, options) => handleActionResult(apiServices.patch(id, updatedItem, options)),
-    remove: (id, options) => handleActionResult(apiServices.remove(id, options)),
-    bulkRemove: (ids, options) => handleActionResult(apiServices.bulkDelete(ids, options))
-  };
-  const query = {
-    options: queryOptions,
-    setOptions: setQueryOptions,
-    setPage: (page) => setQueryOptions((prev) => ({ ...prev, page })),
-    setLimit: (limit) => setQueryOptions((prev) => ({ ...prev, page: 1, limit })),
-    setSearchTerm: (search) => setQueryOptions((prev) => ({ ...prev, page: 1, search })),
-    setSorting: (sortBy) => setQueryOptions((prev) => ({ ...prev, sortBy })),
-    setFilters: (filter) => setQueryOptions((prev) => ({ ...prev, page: 1, filter })),
-    setQueryParam: (key, value) => setQueryOptions((prev) => ({ ...prev, [key]: value, page: key !== "page" ? 1 : value })),
-    reset: () => setQueryOptions(initialQuery)
-  };
-  return { state, setState, actions, query };
-}
-
-// src/hooks/useApiRecord/index.ts
-var import_react2 = require("react");
-function buildDynamicPath2(template, params) {
-  if (!params) return template;
-  let path = template;
-  for (const key in params) {
-    path = path.replace(new RegExp(`{${key}}`, "g"), String(params[key]));
-  }
-  return path;
-}
-function useApiRecord(axiosInstance, config) {
-  const {
-    endpoint,
-    pathParams,
-    recordId,
-    initialData,
-    enabled = true,
-    refetchAfterChange = true,
-    requestConfig,
-    onSuccess,
-    onError
-  } = config;
-  const finalEndpoint = (0, import_react2.useMemo)(
-    () => buildDynamicPath2(endpoint, pathParams),
-    [endpoint, pathParams]
-  );
-  const initialState = (0, import_react2.useMemo)(() => ({
-    data: initialData ?? null,
-    rawResponse: null,
-    error: null,
-    loading: enabled && !!recordId,
-    success: false,
-    message: void 0,
-    validationErrors: void 0
-  }), [initialData, enabled, recordId]);
-  const [state, setState] = (0, import_react2.useState)(initialState);
-  const savedOnSuccess = (0, import_react2.useRef)(onSuccess);
-  const savedOnError = (0, import_react2.useRef)(onError);
-  (0, import_react2.useEffect)(() => {
-    savedOnSuccess.current = onSuccess;
-    savedOnError.current = onError;
-  }, [onSuccess, onError]);
-  const apiServices = (0, import_react2.useMemo)(
-    () => createApiServices(axiosInstance, finalEndpoint),
-    [axiosInstance, finalEndpoint]
-  );
-  const fetchRecord = (0, import_react2.useCallback)(async () => {
-    if (!recordId) {
-      setState(initialState);
-      return;
-    }
-    setState((prev) => ({ ...prev, loading: true, error: null, success: false }));
-    try {
-      const result = await apiServices.get(recordId, requestConfig);
-      setState(result);
-      if (result.success && savedOnSuccess.current) {
-        savedOnSuccess.current(result.message || "Record fetched successfully!", result.data ?? void 0);
-      } else if (!result.success && savedOnError.current) {
-        savedOnError.current(result.message || "Fetch failed", result.error ?? void 0);
-      }
-    } catch (e) {
-      console.error("[useApiRecord Fetch Error]", e);
-      const apiError = {
-        status: e.response?.status || 500,
-        message: e.message || "An unexpected client-side error occurred.",
-        code: e.code
-      };
-      setState((prev) => ({ ...prev, loading: false, success: false, error: apiError }));
-      if (savedOnError.current) {
-        savedOnError.current(apiError.message, apiError);
-      }
-    }
-  }, [apiServices, recordId, requestConfig, initialState]);
-  (0, import_react2.useEffect)(() => {
-    if (enabled) {
-      fetchRecord();
-    }
-  }, [enabled, fetchRecord]);
-  const handleActionResult = (0, import_react2.useCallback)(
-    async (actionPromise, options) => {
-      setState((prev) => ({ ...prev, loading: true }));
-      try {
-        const result = await actionPromise;
-        if (result.success) {
-          if (savedOnSuccess.current) {
-            savedOnSuccess.current(result.message || "Action successful!", result.data);
-          }
-          const shouldRefetch = options?.refetch ?? refetchAfterChange;
-          if (shouldRefetch) {
-            await fetchRecord();
-          } else {
-            setState({ ...result, loading: false, data: result.data });
-          }
-        } else {
-          if (savedOnError.current) {
-            savedOnError.current(result.message || "Action failed", result.error ?? void 0);
-          }
-          setState((prev) => ({ ...prev, ...result, loading: false }));
-        }
-        return result;
-      } catch (e) {
-        console.error("[useApiRecord Action Error]", e);
-        const apiError = {
-          status: e.response?.status || 500,
-          message: e.message || "An unexpected error occurred during the action.",
-          code: e.code
-        };
-        const errorResponse = { ...initialState, loading: false, success: false, error: apiError, rawResponse: e, data: null };
-        setState(errorResponse);
-        if (savedOnError.current) {
-          savedOnError.current(apiError.message, apiError);
-        }
-        return errorResponse;
-      }
-    },
-    [refetchAfterChange, fetchRecord, initialState]
-  );
-  const actions = {
-    fetch: fetchRecord,
-    update: (updatedItem, options) => handleActionResult(apiServices.patch(recordId, updatedItem, { ...requestConfig, ...options }), options),
-    put: (item, options) => handleActionResult(apiServices.put(recordId, item, { ...requestConfig, ...options }), options),
-    remove: (options) => handleActionResult(apiServices.remove(recordId, { ...requestConfig, ...options }), options),
-    resetState: () => setState(initialState)
-  };
-  return { state, setState, actions };
-}
-
-// src/hooks/useDeepCompareEffect/index.ts
-var import_react3 = require("react");
-var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
-function useDeepCompareEffect(callback, dependencies) {
-  const currentDependenciesRef = (0, import_react3.useRef)();
-  if (!(0, import_fast_deep_equal.default)(currentDependenciesRef.current, dependencies)) {
-    currentDependenciesRef.current = dependencies;
-  }
-  (0, import_react3.useEffect)(callback, [currentDependenciesRef.current]);
-}
-
-// src/hooks/useApiModule/useApiModule.ts
-var import_react4 = require("react");
-var ApiModuleContext = (0, import_react4.createContext)(null);
-var ApiModuleProvider = ApiModuleContext.Provider;
-function useModuleContext() {
-  const context = (0, import_react4.useContext)(ApiModuleContext);
-  if (!context) {
-    throw new Error("useModuleContext must be used within an ApiModuleProvider");
-  }
-  return context;
-}
-var generateCacheKey = (moduleName, actionName, input, callOptions = {}) => {
-  const params = { path: callOptions.pathParams, body: input };
-  try {
-    return `${moduleName}/${actionName}::${JSON.stringify(params)}`;
-  } catch (error) {
-    return `${moduleName}/${actionName}::${Date.now()}`;
-  }
-};
-function useApiModule(axiosInstance, moduleConfig, options = {}) {
-  const { refetchOnWindowFocus = true, onSuccess, onError, pathParams: modulePathParams, enabled = true, hydratedState } = options;
-  const pathParamsString = (0, import_react4.useMemo)(() => JSON.stringify(modulePathParams || {}), [modulePathParams]);
-  const [queryOptions, setQueryOptions] = (0, import_react4.useState)({});
-  const savedCallbacks = (0, import_react4.useRef)({ onSuccess, onError });
-  (0, import_react4.useEffect)(() => {
-    savedCallbacks.current = { onSuccess, onError };
-  }, [onSuccess, onError]);
-  (0, import_react4.useMemo)(() => {
-    if (hydratedState) {
-      globalStateManager.rehydrate(hydratedState);
-    }
-  }, [hydratedState]);
-  const actions = (0, import_react4.useMemo)(() => {
-    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
-      const actionConfig = moduleConfig.actions[actionName];
-      const execute = async (input, options2 = {}) => {
-        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
-        const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
-        let mutationContext;
-        try {
-          if (options2.onMutate) {
-            mutationContext = await options2.onMutate(input);
-          }
-          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, loading: true, called: true, error: null, isStale: false }));
-          const result = await callDynamicApi(axiosInstance, moduleConfig.baseEndpoint, actionConfig, {
-            pathParams: finalPathParams,
-            body: input,
-            config: options2.config
-          });
-          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, ...result, loading: false }));
-          if (result.success) {
-            savedCallbacks.current.onSuccess?.(actionName, result.message || "Action successful", result.data);
-            options2.onSuccess?.(result.data, mutationContext);
-            actionConfig.invalidates?.forEach((keyToInvalidate) => {
-              const prefix = `${moduleConfig.baseEndpoint}/${keyToInvalidate}::`;
-              globalStateManager.invalidateByPrefix(prefix);
-            });
-          } else {
-            savedCallbacks.current.onError?.(actionName, result.message || "Action failed", result.error ?? void 0);
-            options2.onError?.(result.error, mutationContext);
-          }
-          return result;
-        } catch (error) {
-          const apiError = { status: 500, message: error.message };
-          const errorResult = { data: null, error: apiError, loading: false, success: false, rawResponse: error };
-          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, ...errorResult, loading: false }));
-          savedCallbacks.current.onError?.(actionName, apiError.message, apiError);
-          options2.onError?.(apiError, mutationContext);
-          return errorResult;
-        }
-      };
-      const reset = (input, options2 = {}) => {
-        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
-        const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
-        globalStateManager.setState(cacheKey, () => ({
-          data: null,
-          error: null,
-          loading: false,
-          success: false,
-          called: false,
-          isStale: false,
-          rawResponse: null
-        }));
-      };
-      acc[actionName] = { execute, reset };
-      return acc;
-    }, {});
-  }, [axiosInstance, moduleConfig, pathParamsString]);
-  const queries = (0, import_react4.useMemo)(() => {
-    const builtQueries = {};
-    for (const actionName in moduleConfig.actions) {
-      if (moduleConfig.actions[actionName]?.hasQuery) {
-        const setActionQueryOptions = (updater) => {
-          setQueryOptions((prev) => ({ ...prev, [actionName]: typeof updater === "function" ? updater(prev[actionName] || {}) : updater }));
-        };
-        builtQueries[actionName] = {
-          options: queryOptions[actionName] || {},
-          setOptions: setActionQueryOptions,
-          setPage: (page) => setActionQueryOptions((p) => ({ ...p, page })),
-          setLimit: (limit) => setActionQueryOptions((p) => ({ ...p, limit, page: 1 })),
-          setSearchTerm: (search) => setActionQueryOptions((p) => ({ ...p, search, page: 1 })),
-          setFilters: (filter) => setActionQueryOptions((p) => ({ ...p, filter, page: 1 })),
-          setSorting: (sortBy) => setActionQueryOptions((p) => ({ ...p, sortBy })),
-          setQueryParam: (key, value) => setActionQueryOptions((p) => ({ ...p, [key]: value, page: key !== "page" ? value : p.page })),
-          reset: () => setActionQueryOptions({})
-        };
-      }
-    }
-    return builtQueries;
-  }, [queryOptions, moduleConfig.actions]);
-  const states = (0, import_react4.useMemo)(() => {
-    const finalStates = {};
-    for (const actionName of Object.keys(moduleConfig.actions)) {
-      Object.defineProperty(finalStates, actionName, {
-        get: () => {
-          const actionConfig = moduleConfig.actions[actionName];
-          const query = queries[actionName]?.options;
-          const input = actionConfig.hasQuery ? query : void 0;
-          const pathParams = JSON.parse(pathParamsString);
-          const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams });
-          const state = (0, import_react4.useSyncExternalStore)(
-            (callback) => globalStateManager.subscribe(cacheKey, callback),
-            () => globalStateManager.getSnapshot(cacheKey)
-          );
-          (0, import_react4.useEffect)(() => {
-            if (enabled && state.isStale && !state.loading) {
-              actions[actionName].execute(input);
-            }
-          }, [enabled, state.isStale, state.loading, input, actions, actionName]);
-          return state;
-        },
-        enumerable: true
-      });
-    }
-    return finalStates;
-  }, [moduleConfig, pathParamsString, queries, enabled, actions]);
-  (0, import_react4.useEffect)(() => {
-    if (!enabled) return;
-    const actionKeys = Object.keys(moduleConfig.actions);
-    for (const actionName of actionKeys) {
-      const state = states[actionName];
-      const actionConfig = moduleConfig.actions[actionName];
-      if (actionConfig.autoFetch && state && !state.called && !state.loading) {
-        const query = queries[actionName]?.options;
-        const input = actionConfig.hasQuery ? query : void 0;
-        actions[actionName].execute(input);
-      }
-    }
-  }, [enabled, moduleConfig, actions, states, queries]);
-  const lastBlurTimestamp = (0, import_react4.useRef)(Date.now());
-  (0, import_react4.useEffect)(() => {
-    if (!enabled || !refetchOnWindowFocus) return;
-    const onFocus = () => {
-      if (Date.now() - lastBlurTimestamp.current > 1e4) {
-        const actionKeys = Object.keys(moduleConfig.actions);
-        for (const actionName of actionKeys) {
-          const state = states[actionName];
-          if (state && state.called && !state.loading) {
-            const prefix = `${moduleConfig.baseEndpoint}/${actionName}::`;
-            globalStateManager.invalidateByPrefix(prefix);
-          }
-        }
-      }
-    };
-    const onBlur = () => {
-      lastBlurTimestamp.current = Date.now();
-    };
-    window.addEventListener("focus", onFocus);
-    window.addEventListener("blur", onBlur);
-    return () => {
-      window.removeEventListener("focus", onFocus);
-      window.removeEventListener("blur", onBlur);
-    };
-  }, [enabled, refetchOnWindowFocus, moduleConfig, states]);
-  const dehydrate = (0, import_react4.useMemo)(() => {
-    return () => globalStateManager.dehydrate();
-  }, []);
-  return { actions, states, queries, dehydrate };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ApiModuleProvider,
   buildPaginateQuery,
   cacheManager,
   callDynamicApi,
@@ -1148,10 +697,5 @@ function useApiModule(axiosInstance, moduleConfig, options = {}) {
   createApiClient,
   createApiServices,
   globalStateManager,
-  processResponse,
-  useApi,
-  useApiModule,
-  useApiRecord,
-  useDeepCompareEffect,
-  useModuleContext
+  processResponse
 });

package/dist/index.d.cts

@@ -1,8 +1,8 @@
 import { AxiosInstance, AxiosRequestConfig, Method, AxiosResponse, AxiosError } from 'axios';
-import { A as ApiClientConfig, a as ActionConfigModule, S as StandardResponse, b as ActionOptions, R as RequestConfig, c as ActionStateModule, Q as QueryOptions, U as UseApiConfig, d as ApiError, e as ApiModuleConfig, f as UseApiModuleOptions, g as UseApiModuleReturn, h as UseApiQuery, L as LogLevel } from './apiModule.types-2yhaJWN3.cjs';
-export { l as ActionConfig, n as ActionState, E as ExecutableAction, o as ExecuteOptions, I as InputOf, j as Middleware, M as MiddlewareContext, p as ModuleActions, q as ModuleStates, O as OutputOf, P as PaginationMeta, k as RefreshTokenConfig, i as TokenManager, T as Tokens, m as UseApiState, V as ValidationError } from './apiModule.types-2yhaJWN3.cjs';
-import * as React$1 from 'react';
-import { Dispatch, SetStateAction } from 'react';
+import { d as ApiClientConfig, A as ActionConfigModule, S as StandardResponse, e as ActionOptions, R as RequestConfig, f as ActionStateModule, Q as QueryOptions, g as UseApiQuery, h as ApiError, L as LogLevel } from './apiModule.types-CpwGDEpG.cjs';
+export { l as ActionConfig, n as ActionState, a as ApiModuleConfig, E as ExecutableAction, o as ExecuteOptions, I as InputOf, j as Middleware, M as MiddlewareContext, p as ModuleActions, q as ModuleStates, O as OutputOf, P as PaginationMeta, k as RefreshTokenConfig, i as TokenManager, T as Tokens, U as UseApiConfig, b as UseApiModuleOptions, c as UseApiModuleReturn, m as UseApiState, V as ValidationError } from './apiModule.types-CpwGDEpG.cjs';
+export { c as UseApiRecordActions, U as UseApiRecordConfig, a as UseApiRecordReturn, b as UseApiRecordState } from './useApiRecord.types-B45E0qux.cjs';
+import 'react';
 
 declare function createApiClient(config: ApiClientConfig): AxiosInstance;
 
@@ -147,114 +147,6 @@ declare class CacheManager {
 }
 declare const cacheManager: CacheManager;
 
-declare function useApi<T>(axiosInstance: AxiosInstance, config: UseApiConfig<T>): any;
-
-/**
- * Represents the internal state of the `useApiRecord` hook.
- * It mirrors the `StandardResponse` structure, which is the unified response format
- * used across the library.
- * @template T The data type of the record.
- */
-type UseApiRecordState<T> = StandardResponse<T>;
-/**
- * Defines the action methods provided by the `useApiRecord` hook to interact with
- * a single API resource.
- * @template T The data type of the record.
- */
-interface UseApiRecordActions<T> {
-    /**
-     * Manually fetches or refetches the record from the API.
-     */
-    fetch: () => Promise<void>;
-    /**
-     * Partially updates the record using an HTTP PATCH request.
-     * @param updatedItem An object containing the fields to update.
-     * @param options Additional request options, allowing overrides for this specific action.
-     * @returns A promise that resolves to the standard response object for the updated record.
-     */
-    update: (updatedItem: Partial<T>, options?: ActionOptions) => Promise<StandardResponse<T>>;
-    /**
-     * Replaces the entire record with a new one using an HTTP PUT request.
-     * @param item The complete new record object.
-     * @param options Additional request options.
-     * @returns A promise that resolves to the standard response object for the replaced record.
-     */
-    put: (item: T, options?: ActionOptions) => Promise<StandardResponse<T>>;
-    /**
-     * Deletes the record using an HTTP DELETE request.
-     * @param options Additional request options.
-     * @returns A promise that resolves to a standard response object with a null data payload.
-     */
-    remove: (options?: ActionOptions) => Promise<StandardResponse<null>>;
-    /**
-     * Resets the hook's state to its initial value.
-     */
-    resetState: () => void;
-}
-/**
- * Defines the configuration options for the `useApiRecord` hook.
- * @template T The data type of the record.
- */
-interface UseApiRecordConfig<T> {
-    /**
-     * The base API endpoint template for the resource.
-     * Can contain placeholders like `{endpointName}`.
-     * @example 'v1/dynamic/{endpointName}'
-     */
-    endpoint: string;
-    /**
-     * An object containing key-value pairs to replace placeholders in the endpoint template.
-     * @example { endpointName: 'products' }
-     */
-    pathParams?: Record<string, string | number>;
-    /** The unique identifier of the record to fetch or modify. */
-    recordId?: string | number | null;
-    /** Optional initial data to populate the state before the first fetch is complete. */
-    initialData?: T | null;
-    /** If `false`, the hook will not automatically fetch data on mount. Defaults to `true`. */
-    enabled?: boolean;
-    /** If `true`, the record will be refetched after a successful `update`, `put`, or `remove` action. Defaults to `true`. */
-    refetchAfterChange?: boolean;
-    /** Default `RequestConfig` to apply to the initial GET request made by the hook. */
-    requestConfig?: RequestConfig;
-    /** A callback function executed on a successful API action. */
-    onSuccess?: (message: string, data?: any) => void;
-    /** A callback function executed on a failed API action. */
-    onError?: (message: string, error?: ApiError) => void;
-}
-/**
- * The return value of the `useApiRecord` hook.
- * @template T The data type of the record.
- */
-interface UseApiRecordReturn<T> {
-    /** The current state of the API request, including data, loading, and error status. */
-    state: UseApiRecordState<T>;
-    /** Action methods to manipulate the record. */
-    actions: UseApiRecordActions<T>;
-    /** A React dispatch function to manually set the hook's state. Use with caution. */
-    setState: Dispatch<SetStateAction<UseApiRecordState<T>>>;
-}
-
-/**
- * A React hook for managing the lifecycle of a single API resource (a record).
- * It handles fetching, updating, replacing, and deleting a record, while managing
- * loading, error, and data states. It supports dynamic path parameters for flexible API routing.
- *
- * @template T The data type of the record being managed.
- * @param {AxiosInstance} axiosInstance - The configured Axios instance for making API calls.
- * @param {UseApiRecordConfig<T>} config - Configuration options for the hook.
- * @returns {UseApiRecordReturn<T>} An object containing the state, actions, and setState function.
- */
-declare function useApiRecord<T>(axiosInstance: AxiosInstance, config: UseApiRecordConfig<T>): UseApiRecordReturn<T>;
-
-type EffectCallback = () => (void | (() => void));
-type DependencyList = readonly any[];
-declare function useDeepCompareEffect(callback: EffectCallback, dependencies: DependencyList): void;
-
-declare const ApiModuleProvider: React$1.Provider<UseApiModuleReturn<any> | null>;
-declare function useModuleContext<TModule extends ApiModuleConfig<any>>(): UseApiModuleReturn<TModule['actions']>;
-declare function useApiModule<TActions extends Record<string, ActionConfigModule<any, any>>>(axiosInstance: AxiosInstance, moduleConfig: ApiModuleConfig<TActions>, options?: UseApiModuleOptions): UseApiModuleReturn<TActions>;
-
 /**
  * @file src/hooks/useApi.types.ts
  * @description This file defines the professional, publicly-facing types for the `useApi` hook,
@@ -336,4 +228,4 @@ interface UseApiResourceReturn<T, TCreate, TUpdate, TPathParams> {
     setQuery: React.Dispatch<React.SetStateAction<QueryOptions>>;
 }
 
-export { ActionConfigModule, ActionOptions, ActionStateModule, ApiClientConfig, ApiError, ApiModuleConfig, ApiModuleProvider, type ApiResourceStatus, LogLevel, QueryOptions, RequestConfig, StandardResponse, type UseApiActions, UseApiConfig, UseApiModuleOptions, UseApiModuleReturn, UseApiQuery, type UseApiRecordActions, type UseApiRecordConfig, type UseApiRecordReturn, type UseApiRecordState, type UseApiResourceActions, type UseApiResourceConfig, type UseApiResourceReturn, type UseApiResourceState, type UseApiReturn, buildPaginateQuery, cacheManager, callDynamicApi, createApiActions, createApiClient, createApiServices, globalStateManager, processResponse, useApi, useApiModule, useApiRecord, useDeepCompareEffect, useModuleContext };
+export { ActionConfigModule, ActionOptions, ActionStateModule, ApiClientConfig, ApiError, type ApiResourceStatus, LogLevel, QueryOptions, RequestConfig, StandardResponse, type UseApiActions, UseApiQuery, type UseApiResourceActions, type UseApiResourceConfig, type UseApiResourceReturn, type UseApiResourceState, type UseApiReturn, buildPaginateQuery, cacheManager, callDynamicApi, createApiActions, createApiClient, createApiServices, globalStateManager, processResponse };