api-core-lib 16.2.0 → 16.12.134

package/dist/index.cjs

@@ -0,0 +1,301 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+
+
+var _chunkJAMEOM7Tcjs = require('./chunk-JAMEOM7T.cjs');
+
+// src/core/client.ts
+var _axios = require('axios'); var _axios2 = _interopRequireDefault(_axios);
+var _uuid = require('uuid');
+async function runMiddleware(context, middlewares = []) {
+  const run = async (index) => {
+    if (index >= middlewares.length) return;
+    const middleware = middlewares[index];
+    await middleware(context, () => run(index + 1));
+  };
+  await run(0);
+}
+async function refreshToken(config, tokenManager) {
+  const { refreshTokenConfig } = config;
+  if (!refreshTokenConfig) {
+    console.warn("Token refresh is disabled: `refreshTokenConfig` is not provided.");
+    await tokenManager.clearTokens();
+    return null;
+  }
+  try {
+    const currentTokens = await tokenManager.getTokens();
+    if (!currentTokens.refreshToken) {
+      throw new Error("No refresh token available to perform refresh.");
+    }
+    const { path, buildRequestBody, buildRequestHeaders, extractTokens } = refreshTokenConfig;
+    const requestBody = buildRequestBody ? buildRequestBody(currentTokens.refreshToken) : { refresh_token: currentTokens.refreshToken };
+    const requestHeaders = buildRequestHeaders ? buildRequestHeaders(currentTokens) : {};
+    const response = await _axios2.default.post(
+      `${config.baseURL}${path}`,
+      requestBody,
+      { headers: requestHeaders, withCredentials: config.withCredentials }
+    );
+    const extracted = extractTokens(response.data);
+    if (!extracted || !extracted.accessToken || typeof extracted.expiresIn !== "number") {
+      throw new Error("extractTokens function failed to return a valid token structure.");
+    }
+    const newTokens = {
+      accessToken: extracted.accessToken,
+      refreshToken: extracted.refreshToken || currentTokens.refreshToken,
+      expiresAt: Date.now() + extracted.expiresIn * 1e3,
+      tokenType: extracted.tokenType || "Bearer"
+    };
+    await tokenManager.setTokens(newTokens);
+    console.info("Tokens refreshed successfully.");
+    return newTokens;
+  } catch (err) {
+    console.error("Failed to refresh token.", _optionalChain([err, 'access', _ => _.response, 'optionalAccess', _2 => _2.data]) || err.message);
+    if (config.onRefreshError) {
+      config.onRefreshError(err);
+    }
+    await tokenManager.clearTokens();
+    return null;
+  }
+}
+function createApiClient(config) {
+  const {
+    baseURL,
+    tokenManager,
+    timeout = 15e3,
+    headers = {},
+    withCredentials = false,
+    middleware = [],
+    defaultIsPublic = false,
+    maxTokenRefreshRetries = 2,
+    maxQueueSize = 50,
+    onRefreshError
+  } = config;
+  const axiosInstance = _axios2.default.create({
+    baseURL,
+    timeout,
+    headers: { "Content-Type": "application/json", ...headers },
+    withCredentials
+  });
+  let isRefreshing = false;
+  let refreshAttempts = 0;
+  let failedQueue = [];
+  const processQueue = (error, token = null) => {
+    failedQueue.forEach((prom) => error ? prom.reject(error) : prom.resolve(token));
+    failedQueue = [];
+  };
+  const safeRunMiddleware = async (context, middlewareList) => {
+    try {
+      await runMiddleware(context, middlewareList);
+    } catch (err) {
+      console.error("Middleware Error", err);
+    }
+  };
+  axiosInstance.interceptors.request.use(async (req) => {
+    req.headers["X-Request-ID"] = _uuid.v4.call(void 0, );
+    try {
+      const fullUrl = _axios2.default.getUri({ ...req, baseURL: _nullishCoalesce(req.baseURL, () => ( baseURL)) });
+      console.log(`Request Sent > ${_optionalChain([req, 'access', _3 => _3.method, 'optionalAccess', _4 => _4.toUpperCase, 'call', _5 => _5()])} ${fullUrl}`, `(ID: ${req.headers["X-Request-ID"]})`);
+    } catch (e) {
+      console.warn("Failed to build full request URL for logging.");
+    }
+    if (req.upload) {
+      delete req.headers["Content-Type"];
+    }
+    await safeRunMiddleware({ req, custom: {} }, middleware);
+    if (_nullishCoalesce(req.isPublic, () => ( defaultIsPublic))) {
+      return req;
+    }
+    if (tokenManager.isHttpOnly()) return req;
+    let tokens = await tokenManager.getTokens();
+    const now = Date.now();
+    const tokenBuffer = 60 * 1e3;
+    if (tokens.accessToken && tokens.expiresAt && tokens.expiresAt - now < tokenBuffer && !isRefreshing) {
+      if (config.refreshTokenConfig) {
+        console.info("Proactive token refresh initiated.");
+        isRefreshing = true;
+        try {
+          const newTokens = await refreshToken(config, tokenManager);
+          if (newTokens) tokens = newTokens;
+        } catch (err) {
+          console.error("Proactive refresh failed", err);
+        } finally {
+          isRefreshing = false;
+        }
+      }
+    }
+    if (tokens.accessToken) {
+      req.headers.Authorization = `${tokens.tokenType || "Bearer"} ${tokens.accessToken}`;
+    }
+    return req;
+  });
+  axiosInstance.interceptors.response.use(
+    async (res) => {
+      try {
+        const fullUrl = _axios2.default.getUri(res.config);
+        console.log(`Response Received < ${_optionalChain([res, 'access', _6 => _6.config, 'access', _7 => _7.method, 'optionalAccess', _8 => _8.toUpperCase, 'call', _9 => _9()])} ${fullUrl}`, `(ID: ${res.config.headers["X-Request-ID"]}, Status: ${res.status})`);
+      } catch (e2) {
+        console.warn("Failed to build full response URL for logging.");
+      }
+      await safeRunMiddleware({ req: res.config, res, custom: {} }, middleware);
+      return res;
+    },
+    async (error) => {
+      const originalRequest = error.config;
+      try {
+        const fullUrl = _axios2.default.getUri(originalRequest);
+        const method = _optionalChain([originalRequest, 'access', _10 => _10.method, 'optionalAccess', _11 => _11.toUpperCase, 'call', _12 => _12()]);
+        const status = _optionalChain([error, 'access', _13 => _13.response, 'optionalAccess', _14 => _14.status]);
+        const responseData = _optionalChain([error, 'access', _15 => _15.response, 'optionalAccess', _16 => _16.data]);
+        const summary = `Response Error < ${method} ${fullUrl} | Status: ${status || "N/A"}`;
+        const apiMessage = _optionalChain([responseData, 'optionalAccess', _17 => _17.message]) || error.message;
+        console.error(summary);
+        console.error(`> Message: ${apiMessage}`);
+        if (error.response) {
+          console.groupCollapsed("Full Error Response Details");
+          console.dir(error.response.data);
+          console.groupEnd();
+        }
+      } catch (e3) {
+        console.error("Response Error: Failed to build full URL for logging.", error.message);
+      }
+      await safeRunMiddleware({ req: originalRequest, error, custom: {} }, middleware);
+      const isHttpOnlyMode = tokenManager.isHttpOnly();
+      const canAttemptRefresh = _optionalChain([error, 'access', _18 => _18.response, 'optionalAccess', _19 => _19.status]) === 401 && !originalRequest._retry && config.refreshTokenConfig;
+      if (isHttpOnlyMode && canAttemptRefresh) {
+        console.error("401 in httpOnly mode. Token refresh must be handled by the server.");
+        return Promise.reject(error);
+      }
+      if (!isHttpOnlyMode && canAttemptRefresh) {
+        if (isRefreshing) {
+          if (failedQueue.length >= maxQueueSize) {
+            console.warn("Failed request queue overflow, rejecting request.");
+            return Promise.reject(error);
+          }
+          return new Promise((resolve, reject) => failedQueue.push({ resolve, reject })).then((token) => {
+            originalRequest.headers["Authorization"] = `Bearer ${token}`;
+            return axiosInstance(originalRequest);
+          });
+        }
+        if (refreshAttempts >= maxTokenRefreshRetries) {
+          console.error("Max token refresh attempts reached.");
+          return Promise.reject(error);
+        }
+        refreshAttempts++;
+        originalRequest._retry = true;
+        isRefreshing = true;
+        try {
+          const newTokens = await refreshToken(config, tokenManager);
+          if (!_optionalChain([newTokens, 'optionalAccess', _20 => _20.accessToken])) {
+            throw new Error("Token refresh failed to produce a new access token.");
+          }
+          processQueue(null, newTokens.accessToken);
+          originalRequest.headers["Authorization"] = `${newTokens.tokenType || "Bearer"} ${newTokens.accessToken}`;
+          return axiosInstance(originalRequest);
+        } catch (refreshError) {
+          processQueue(refreshError, null);
+          return Promise.reject(refreshError);
+        } finally {
+          isRefreshing = false;
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return axiosInstance;
+}
+
+// src/services/actions.ts
+function createAction(axiosInstance, method, endpoint) {
+  return async (payload, config) => {
+    try {
+      const response = await axiosInstance.request({
+        url: endpoint,
+        method,
+        ...method.toUpperCase() === "GET" ? { params: payload } : { data: payload },
+        ...config
+      });
+      return _chunkJAMEOM7Tcjs.processResponse.call(void 0, response);
+    } catch (error) {
+      return _chunkJAMEOM7Tcjs.processResponse.call(void 0, error);
+    }
+  };
+}
+function createApiActions(axiosInstance, actionsConfig) {
+  const actions = {};
+  for (const actionName in actionsConfig) {
+    if (Object.prototype.hasOwnProperty.call(actionsConfig, actionName)) {
+      const { method, endpoint, log } = actionsConfig[actionName];
+      actions[actionName] = createAction(axiosInstance, method, endpoint);
+    }
+  }
+  return actions;
+}
+
+// src/core/cache.ts
+var CacheManager = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  __init2() {this.defaultDuration = 15 * 60 * 1e3}
+  // 15 minutes
+  set(key, data, duration) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      duration: duration || this.defaultDuration
+    });
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    const isExpired = Date.now() - item.timestamp > item.duration;
+    if (isExpired) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item.data;
+  }
+  /**
+   * [FIX] تم تحويلها إلى دالة عامة (generic) لتعيد النوع الصحيح.
+   * الآن بدلًا من إرجاع CacheItem<unknown>، ستُرجع CacheItem<T>.
+   */
+  getWithMeta(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    const isExpired = Date.now() - item.timestamp > item.duration;
+    if (isExpired) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  invalidateByPrefix(prefix) {
+    const keysToDelete = [];
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        keysToDelete.push(key);
+      }
+    }
+    keysToDelete.forEach((key) => this.cache.delete(key));
+    console.log(`Invalidated ${keysToDelete.length} cache entries with prefix: ${prefix}`);
+  }
+}, _class);
+var cacheManager = new CacheManager();
+
+
+
+
+
+
+
+
+
+
+exports.buildPaginateQuery = _chunkJAMEOM7Tcjs.buildPaginateQuery; exports.cacheManager = cacheManager; exports.callDynamicApi = _chunkJAMEOM7Tcjs.callDynamicApi; exports.createApiActions = createApiActions; exports.createApiClient = createApiClient; exports.createApiServices = _chunkJAMEOM7Tcjs.createApiServices; exports.generateCacheKey = _chunkJAMEOM7Tcjs.generateCacheKey; exports.globalStateManager = _chunkJAMEOM7Tcjs.globalStateManager; exports.processResponse = _chunkJAMEOM7Tcjs.processResponse;

package/dist/index.d.cts

@@ -0,0 +1,225 @@
+import { AxiosInstance, AxiosRequestConfig, Method, AxiosResponse, AxiosError } from 'axios';
+import { e as ApiClientConfig, f as ActionConfigModule, S as StandardResponse, g as ActionOptions, R as RequestConfig, h as ActionStateModule, Q as QueryOptions, i as UseApiQuery, j as ApiError, L as LogLevel } from './apiModule.types-DEskFzOY.cjs';
+export { o as ActionConfig, v as ActionMethods, q as ActionState, u as ActionsWithQuery, A as ApiModuleConfig, E as ExecutableAction, s as ExecuteOptions, I as InputOf, m as Middleware, l as MiddlewareContext, c as ModuleActions, d as ModuleQueries, M as ModuleStates, O as OutputOf, P as PaginationMeta, n as RefreshTokenConfig, k as TokenManager, T as Tokens, r as UrlSyncOptions, U as UseApiConfig, a as UseApiModuleOptions, b as UseApiModuleReturn, p as UseApiState, V as ValidationError, t } from './apiModule.types-DEskFzOY.cjs';
+export { c as UseApiRecordActions, U as UseApiRecordConfig, a as UseApiRecordReturn, b as UseApiRecordState } from './useApiRecord.types-mpeiDoxm.cjs';
+import 'react';
+
+declare function createApiClient(config: ApiClientConfig): AxiosInstance;
+
+declare function createApiServices<T>(axiosInstance: AxiosInstance, baseEndpoint: string): {
+    get: (id?: string | number, config?: ActionOptions) => Promise<StandardResponse<T>>;
+    getWithQuery: (query: string, config?: RequestConfig) => Promise<StandardResponse<T>>;
+    post: (data: Partial<T>, config?: ActionOptions) => Promise<StandardResponse<T>>;
+    put: (id: string | number, data: T, config?: ActionOptions) => Promise<StandardResponse<T>>;
+    patch: (id: string | number, data: Partial<T>, config?: ActionOptions) => Promise<StandardResponse<T>>;
+    remove: (id: string | number, config?: ActionOptions) => Promise<StandardResponse<any>>;
+    bulkDelete: (ids: Array<string | number>, config?: ActionOptions) => Promise<StandardResponse<any>>;
+    upload: (file: File, additionalData?: Record<string, any>, config?: ActionOptions) => Promise<StandardResponse<any>>;
+};
+declare function callDynamicApi(axiosInstance: AxiosInstance, baseEndpoint: string, actionConfig: ActionConfigModule<any, any>, params: {
+    pathParams?: Record<string, string | number>;
+    body?: any;
+    config?: AxiosRequestConfig;
+}): Promise<StandardResponse<any>>;
+
+/**
+ * Defines a single custom API action.
+ * @template TRequest - The type of the data sent in the request body/params.
+ * @template TResponse - The type of the data expected in the successful API response.
+ */
+type ApiAction<TRequest, TResponse> = (payload: TRequest, config?: RequestConfig) => Promise<StandardResponse<TResponse>>;
+/**
+ * A factory function to create a collection of typed, custom API actions.
+ *
+ * @template TActions - An object type where keys are action names and values are objects
+ *                      defining the endpoint, method, and types for that action.
+ * @param axiosInstance - The configured Axios instance from `createApiClient`.
+ * @param actionsConfig - An object defining the configuration for each custom action.
+ * @returns A fully-typed object of executable API action functions.
+ *
+ * @example
+ * const authActions = createApiActions(apiClient, {
+ *   login: { method: 'POST', endpoint: '/auth/login', requestType: {} as LoginCredentials, responseType: {} as AuthResponse },
+ *   getProfile: { method: 'GET', endpoint: '/user/profile', requestType: {} as void, responseType: {} as UserProfile }
+ * });
+ *
+ * // Usage:
+ * const result = await authActions.login({ email: '..', password: '..' });
+ */
+declare function createApiActions<TActions extends Record<string, {
+    method: Method;
+    endpoint: string;
+    requestType: any;
+    responseType: any;
+    log?: boolean;
+}>>(axiosInstance: AxiosInstance, actionsConfig: TActions): {
+    [K in keyof TActions]: ApiAction<TActions[K]['requestType'], TActions[K]['responseType']>;
+};
+
+declare class GlobalStateManager {
+    private store;
+    getSnapshot<T>(key: string): ActionStateModule<T>;
+    /**
+     * يسجل دالة callback للاستماع إلى التغييرات على مفتاح معين.
+     * @returns دالة لإلغاء الاشتراك.
+     */
+    subscribe(key: string, callback: () => void): () => void;
+    /**
+     * يحدّث الحالة لمفتاح معين ويقوم بإعلام جميع المشتركين.
+     */
+    setState<T>(key: string, updater: (prevState: ActionStateModule<T>) => ActionStateModule<T>): void;
+    /**
+     * يجعل البيانات المرتبطة بمفتاح معين "قديمة" (stale).
+     */
+    invalidate(key: string): void;
+    /**
+   * [نسخة محدثة وأكثر قوة]
+   * يجعل كل البيانات التي تبدأ بمفتاح معين "قديمة" (stale).
+   * @example invalidateByPrefix('myModule/list::') سيبطل كل صفحات القائمة.
+   */
+    invalidateByPrefix(prefix: string): void;
+    /**
+   * Serializes the current state of the query store into a JSON string.
+   * This is used on the server to pass the initial state to the client.
+   * @returns A JSON string representing the dehydrated state.
+   */
+    dehydrate(): string;
+    /**
+     * Merges a dehydrated state object into the current store.
+     * This is used on the client to hydrate the state received from the server.
+     * @param hydratedState - A JSON string from the `dehydrate` method.
+     */
+    rehydrate(hydratedState: string): void;
+}
+declare const globalStateManager: GlobalStateManager;
+
+/**
+ * [نسخة مطورة] يبني سلسلة استعلام (query string) من كائن الخيارات.
+ * يدعم الآن الفلاتر المتداخلة (filter[key]=value) والترتيب المتعدد.
+ * @param options - كائن خيارات الاستعلام (فلترة, ترتيب, ...).
+ * @returns سلسلة استعلام جاهزة للإضافة للرابط.
+ */
+declare function buildPaginateQuery(options: QueryOptions): string;
+
+/**
+ * [النسخة النهائية والمضمونة]
+ * تستخدم دوال حماية النوع المخصصة للقضاء على أخطاء 'never' بشكل نهائي.
+ */
+declare const processResponse: <T>(responseOrError: AxiosResponse<any> | AxiosError) => StandardResponse<T>;
+
+interface CacheItem<T> {
+    data: T;
+    timestamp: number;
+    duration: number;
+}
+declare class CacheManager {
+    private cache;
+    private defaultDuration;
+    set<T>(key: string, data: T, duration?: number): void;
+    get<T>(key: string): T | null;
+    /**
+     * [FIX] تم تحويلها إلى دالة عامة (generic) لتعيد النوع الصحيح.
+     * الآن بدلًا من إرجاع CacheItem<unknown>، ستُرجع CacheItem<T>.
+     */
+    getWithMeta<T>(key: string): CacheItem<T> | null;
+    delete(key: string): void;
+    clear(): void;
+    invalidateByPrefix(prefix: string): void;
+}
+declare const cacheManager: CacheManager;
+
+/**
+ * يقوم بإنشاء مفتاح تخزين مؤقت فريد وثابت لإجراء معين ومدخلاته.
+ * هذا يضمن أن نفس الطلب ينتج دائمًا نفس المفتاح.
+ * @param moduleName - عادةً ما يكون `baseEndpoint` للموديول.
+ * @param actionName - اسم الإجراء (مثل 'list', 'create').
+ * @param input - بيانات الطلب (body/query params).
+ * @param callOptions - خيارات إضافية مثل `pathParams`.
+ * @returns سلسلة نصية فريدة تمثل مفتاح التخزين المؤقت.
+ */
+declare const generateCacheKey: (moduleName: string, actionName: string, input?: unknown, callOptions?: {
+    pathParams?: Record<string, any>;
+}) => string;
+
+/**
+ * @file src/hooks/useApi.types.ts
+ * @description This file defines the professional, publicly-facing types for the `useApi` hook,
+ * providing a clean and stable contract for consumers.
+ */
+
+/**
+ * Configuration object for the `useApi` hook.
+ * @template T The type of the data entity.
+ */
+/**
+ * A collection of callable functions for performing CRUD and other operations.
+ * These actions automatically handle state updates like loading and refetching.
+ * @template T The type of the data entity being managed.
+ */
+interface UseApiActions<T, TListItem = T extends (infer U)[] ? U : T> {
+    fetch: (querryOptions?: QueryOptions) => Promise<void>;
+    create: (newItem: Partial<TListItem>, options?: ActionOptions) => Promise<StandardResponse<TListItem>>;
+    put: (id: string | number, item: TListItem, options?: ActionOptions) => Promise<StandardResponse<TListItem>>;
+    update: (id: string | number, updatedItem: Partial<TListItem>, options?: ActionOptions) => Promise<StandardResponse<TListItem>>;
+    remove: (id: string | number, options?: ActionOptions) => Promise<StandardResponse<any>>;
+    bulkRemove: (ids: Array<string | number>, options?: ActionOptions) => Promise<StandardResponse<any>>;
+}
+/**
+ * The complete return type of the `useApi` hook.
+ * It encapsulates the state, actions, and query controls for a given API resource.
+ * @template T The type of the data entity being managed.
+ */
+interface UseApiReturn<T> {
+    state: StandardResponse<T>;
+    setState: React.Dispatch<React.SetStateAction<StandardResponse<T>>>;
+    actions: UseApiActions<T>;
+    query: UseApiQuery;
+}
+
+type ApiResourceStatus = 'idle' | 'loading' | 'success' | 'error';
+interface UseApiResourceState<T> {
+    data: T | T[] | null;
+    error: ApiError | null;
+    status: ApiResourceStatus;
+    isFetching: boolean;
+    isMutating: boolean;
+    isSuccess: boolean;
+    lastResponse?: StandardResponse<any>;
+}
+interface UseApiResourceActions<T, TCreate, TUpdate, TPathParams> {
+    fetch: (pathParams?: TPathParams, queryOptions?: QueryOptions) => Promise<StandardResponse<T[]>>;
+    fetchOne: (pathParams: TPathParams & {
+        id: string | number;
+    }, queryOptions?: QueryOptions) => Promise<StandardResponse<T>>;
+    create: (newItem: TCreate, pathParams?: TPathParams, options?: ActionOptions) => Promise<StandardResponse<T>>;
+    update: (id: string | number, updatedItem: TUpdate, pathParams?: TPathParams, options?: ActionOptions) => Promise<StandardResponse<T>>;
+    remove: (id: string | number, pathParams?: TPathParams, options?: ActionOptions) => Promise<StandardResponse<any>>;
+    reset: () => void;
+}
+interface UseApiResourceConfig<TPathParams> {
+    /**
+     * The API endpoint template. Can be a static string or a function
+     * that builds the URL from parameters.
+     * @example '/users'
+     * @example (params) => `/modules/${params.moduleName}/records`
+     */
+    endpoint: string | ((params: TPathParams) => string);
+    /** Initial data to populate the state. */
+    initialData?: any;
+    /** Controls the verbosity of console logs for debugging. */
+    logLevel?: LogLevel;
+    /** Unique identifier for this hook instance, used in logging. */
+    logKey?: string;
+    /** Callback for success */
+    onSuccess?: (message: string, data?: any) => void;
+    /** Callback for error */
+    onError?: (message: string, error?: ApiError) => void;
+}
+interface UseApiResourceReturn<T, TCreate, TUpdate, TPathParams> {
+    state: UseApiResourceState<T>;
+    actions: UseApiResourceActions<T, TCreate, TUpdate, TPathParams>;
+    query: UseApiQuery;
+    setQuery: React.Dispatch<React.SetStateAction<QueryOptions>>;
+}
+
+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, generateCacheKey, globalStateManager, processResponse };