enlace 0.0.1-beta.4 → 0.0.1-beta.6

package/dist/{next/hook → hook}/index.mjs

@@ -1,120 +1,8 @@
 "use client";
 "use client";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createEnlace: () => createEnlace
-});
-import {
-  createProxyHandler
-} from "enlace-core";
-
-// src/next/fetch.ts
-import {
-  buildUrl,
-  isJsonBody,
-  mergeHeaders
-} from "enlace-core";
-
-// src/utils/generateTags.ts
-function generateTags(path) {
-  return path.map((_, i) => path.slice(0, i + 1).join("/"));
-}
-
-// src/next/fetch.ts
-async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
-  const {
-    autoGenerateTags = true,
-    autoRevalidateTags = true,
-    revalidator,
-    headers: defaultHeaders,
-    ...restOptions
-  } = combinedOptions;
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultHeaders, requestOptions?.headers);
-  const isGet = method === "GET";
-  const autoTags = generateTags(path);
-  const fetchOptions = {
-    ...restOptions,
-    method
-  };
-  if (requestOptions?.cache) {
-    fetchOptions.cache = requestOptions.cache;
-  }
-  if (isGet) {
-    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
-    const nextFetchOptions = {};
-    if (tags) {
-      nextFetchOptions.tags = tags;
-    }
-    if (requestOptions?.revalidate !== void 0) {
-      nextFetchOptions.revalidate = requestOptions.revalidate;
-    }
-    fetchOptions.next = nextFetchOptions;
-  }
-  if (headers) {
-    fetchOptions.headers = headers;
-  }
-  if (requestOptions?.body !== void 0) {
-    if (isJsonBody(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    if (!isGet && !requestOptions?.skipRevalidator) {
-      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
-      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
-      if (revalidateTags.length || revalidatePaths.length) {
-        revalidator?.(revalidateTags, revalidatePaths);
-      }
-    }
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
-}
-
-// src/next/index.ts
-__reExport(next_exports, enlace_core_star);
-import * as enlace_core_star from "enlace-core";
-function createEnlace(baseUrl, defaultOptions = {}, nextOptions = {}) {
-  const combinedOptions = { ...defaultOptions, ...nextOptions };
-  return createProxyHandler(baseUrl, combinedOptions, [], executeNextFetch);
-}
+// src/react/createEnlaceHookReact.ts
+import { createEnlace } from "enlace-core";
 
 // src/react/useQueryMode.ts
 import { useRef, useReducer, useEffect } from "react";
@@ -130,7 +18,7 @@ var initialState = {
 function hookReducer(state, action) {
   switch (action.type) {
     case "RESET":
-      return action.state;
+      return action.state ?? initialState;
     case "FETCH_START":
       return {
         ...state,
@@ -160,6 +48,11 @@ function hookReducer(state, action) {
   }
 }
 
+// src/utils/generateTags.ts
+function generateTags(path) {
+  return path.map((_, i) => path.slice(0, i + 1).join("/"));
+}
+
 // src/utils/sortObjectKeys.ts
 function sortObjectKeys(obj) {
   if (obj === null || typeof obj !== "object") return obj;
@@ -273,7 +166,10 @@ function useQueryMode(api, trackedCall, options) {
   const { autoGenerateTags, staleTime, enabled } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
-  const resolvedPath = resolvePath(trackedCall.path, requestOptions?.pathParams);
+  const resolvedPath = resolvePath(
+    trackedCall.path,
+    requestOptions?.pathParams
+  );
   const queryTags = requestOptions?.tags ?? (autoGenerateTags ? generateTags(resolvedPath) : []);
   const getCacheState = (includeNeedsFetch = false) => {
     const cached = getCache(queryKey);
@@ -288,26 +184,22 @@ function useQueryMode(api, trackedCall, options) {
       error: cached?.error
     };
   };
-  const [state, dispatch] = useReducer(hookReducer, null, () => getCacheState(true));
+  const [state, dispatch] = useReducer(
+    hookReducer,
+    null,
+    () => getCacheState(true)
+  );
   const mountedRef = useRef(true);
   const fetchRef = useRef(null);
   useEffect(() => {
     mountedRef.current = true;
     if (!enabled) {
-      dispatch({
-        type: "RESET",
-        state: { loading: false, fetching: false, ok: void 0, data: void 0, error: void 0 }
-      });
+      dispatch({ type: "RESET" });
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
-    const unsubscribe = subscribeCache(queryKey, () => {
-      if (mountedRef.current) {
-        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
-      }
-    });
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -323,7 +215,7 @@ function useQueryMode(api, trackedCall, options) {
         if (mountedRef.current) {
           setCache(queryKey, {
             data: res.ok ? res.data : void 0,
-            error: res.ok ? void 0 : res.error,
+            error: res.ok || res.status === 0 ? void 0 : res.error,
             ok: res.ok,
             timestamp: Date.now(),
             tags: queryTags
@@ -342,6 +234,11 @@ function useQueryMode(api, trackedCall, options) {
     } else {
       doFetch();
     }
+    const unsubscribe = subscribeCache(queryKey, () => {
+      if (mountedRef.current) {
+        dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      }
+    });
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
@@ -360,6 +257,38 @@ function useQueryMode(api, trackedCall, options) {
   return state;
 }
 
+// src/react/types.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+
+// src/react/trackingProxy.ts
+function createTrackingProxy(onTrack) {
+  const createProxy = (path = []) => {
+    return new Proxy(() => {
+    }, {
+      get(_, prop) {
+        if (HTTP_METHODS.includes(prop)) {
+          const methodFn = (options) => {
+            onTrack({
+              trackedCall: { path, method: prop, options },
+              selectorPath: null,
+              selectorMethod: null
+            });
+            return Promise.resolve({ ok: true, data: void 0 });
+          };
+          onTrack({
+            trackedCall: null,
+            selectorPath: path,
+            selectorMethod: prop
+          });
+          return methodFn;
+        }
+        return createProxy([...path, prop]);
+      }
+    });
+  };
+  return createProxy();
+}
+
 // src/react/useSelectorMode.ts
 import { useRef as useRef2, useReducer as useReducer2 } from "react";
 function resolvePath2(path, pathParams) {
@@ -427,47 +356,117 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/types.ts
-var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+// src/react/createEnlaceHookReact.ts
+function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    staleTime = 0,
+    onSuccess,
+    onError
+  } = hookOptions;
+  const api = createEnlace(baseUrl, defaultOptions, { onSuccess, onError });
+  function useEnlaceHook(selectorOrQuery, queryOptions) {
+    let trackingResult = {
+      trackedCall: null,
+      selectorPath: null,
+      selectorMethod: null
+    };
+    const trackingProxy = createTrackingProxy((result2) => {
+      trackingResult = result2;
+    });
+    const result = selectorOrQuery(
+      trackingProxy
+    );
+    if (typeof result === "function") {
+      const actualResult = selectorOrQuery(api);
+      return useSelectorMode({
+        method: actualResult,
+        api,
+        path: trackingResult.selectorPath ?? [],
+        methodName: trackingResult.selectorMethod ?? "",
+        autoRevalidateTags
+      });
+    }
+    return useQueryMode(
+      api,
+      trackingResult.trackedCall,
+      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+    );
+  }
+  return useEnlaceHook;
+}
 
-// src/react/trackingProxy.ts
-function createTrackingProxy(onTrack) {
-  const createProxy = (path = []) => {
-    return new Proxy(() => {
-    }, {
-      get(_, prop) {
-        if (HTTP_METHODS.includes(prop)) {
-          const methodFn = (options) => {
-            onTrack({
-              trackedCall: { path, method: prop, options },
-              selectorPath: null,
-              selectorMethod: null
-            });
-            return Promise.resolve({ ok: true, data: void 0 });
-          };
-          onTrack({
-            trackedCall: null,
-            selectorPath: path,
-            selectorMethod: prop
-          });
-          return methodFn;
-        }
-        return createProxy([...path, prop]);
+// src/next/index.ts
+import {
+  createProxyHandler
+} from "enlace-core";
+
+// src/next/fetch.ts
+import {
+  executeFetch
+} from "enlace-core";
+async function executeNextFetch(baseUrl, path, method, combinedOptions, requestOptions) {
+  const {
+    autoGenerateTags = true,
+    autoRevalidateTags = true,
+    revalidator,
+    onSuccess,
+    ...coreOptions
+  } = combinedOptions;
+  const isGet = method === "GET";
+  const autoTags = generateTags(path);
+  const nextOnSuccess = (payload) => {
+    if (!isGet && !requestOptions?.skipRevalidator) {
+      const revalidateTags = requestOptions?.revalidateTags ?? (autoRevalidateTags ? autoTags : []);
+      const revalidatePaths = requestOptions?.revalidatePaths ?? [];
+      if (revalidateTags.length || revalidatePaths.length) {
+        revalidator?.(revalidateTags, revalidatePaths);
       }
-    });
+    }
+    onSuccess?.(payload);
   };
-  return createProxy();
+  const nextRequestOptions = { ...requestOptions };
+  if (isGet) {
+    const tags = requestOptions?.tags ?? (autoGenerateTags ? autoTags : void 0);
+    const nextFetchOptions = {};
+    if (tags) {
+      nextFetchOptions.tags = tags;
+    }
+    if (requestOptions?.revalidate !== void 0) {
+      nextFetchOptions.revalidate = requestOptions.revalidate;
+    }
+    nextRequestOptions.next = nextFetchOptions;
+  }
+  return executeFetch(
+    baseUrl,
+    path,
+    method,
+    { ...coreOptions, onSuccess: nextOnSuccess },
+    nextRequestOptions
+  );
+}
+
+// src/next/index.ts
+function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+  const combinedOptions = { ...defaultOptions, ...nextOptions };
+  return createProxyHandler(
+    baseUrl,
+    combinedOptions,
+    [],
+    executeNextFetch
+  );
 }
 
-// src/next/createEnlaceHook.ts
-function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/createEnlaceHookNext.ts
+function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlace(baseUrl, defaultOptions, {
+  const api = createEnlaceNext(baseUrl, defaultOptions, {
     autoGenerateTags,
     autoRevalidateTags,
     ...nextOptions
@@ -501,5 +500,7 @@ function createEnlaceHook(baseUrl, defaultOptions = {}, hookOptions = {}) {
   return useEnlaceHook;
 }
 export {
-  createEnlaceHook
+  HTTP_METHODS,
+  createEnlaceHookNext,
+  createEnlaceHookReact
 };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceCallbacks, EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
 export * from 'enlace-core';
 
 /** Per-request options for React hooks */
@@ -20,59 +20,7 @@ type ReactRequestOptionsBase = {
      */
     pathParams?: Record<string, string | number>;
 };
-/** Options for query mode hooks */
-type UseEnlaceQueryOptions = {
-    /**
-     * Whether the query should execute.
-     * Set to false to skip fetching (useful when ID is "new" or undefined).
-     * @default true
-     */
-    enabled?: boolean;
-};
-type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
-type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
-type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
-type HookState = {
-    loading: boolean;
-    fetching: boolean;
-    ok: boolean | undefined;
-    data: unknown;
-    error: unknown;
-};
-type TrackedCall = {
-    path: string[];
-    method: string;
-    options: unknown;
-};
-declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
-type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
-type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
-/** Discriminated union for hook response state - enables type narrowing on ok check */
-type HookResponseState<TData, TError> = {
-    ok: undefined;
-    data: undefined;
-    error: undefined;
-} | {
-    ok: true;
-    data: TData;
-    error: undefined;
-} | {
-    ok: false;
-    data: undefined;
-    error: TError;
-};
-/** Result when hook is called with query function (auto-fetch mode) */
-type UseEnlaceQueryResult<TData, TError> = {
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<TData, TError>;
-/** Result when hook is called with method selector (trigger mode) */
-type UseEnlaceSelectorResult<TMethod> = {
-    trigger: TMethod;
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -84,31 +32,52 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-type EnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
-};
+
 /**
- * Creates a React hook for making API calls.
- * Called at module level to create a reusable hook.
- *
- * @example
- * const useAPI = createEnlaceHook<ApiSchema>('https://api.com');
- *
- * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
- * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
- *
- * // Selector mode - typed trigger for lazy calls
- * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
- * onClick={() => trigger({ body: { id: 1 } })}
+ * Handler function called after successful mutations to trigger server-side revalidation.
+ * @param tags - Cache tags to revalidate
+ * @param paths - URL paths to revalidate
  */
-declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
-
-type Listener = (tags: string[]) => void;
-declare function invalidateTags(tags: string[]): void;
-declare function onRevalidate(callback: Listener): () => void;
+type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+/** Next.js-specific options (third argument for createEnlaceNext) */
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
+    /**
+     * Handler called after successful mutations to trigger server-side revalidation.
+     * Receives auto-generated or manually specified tags and paths.
+     * @example
+     * ```ts
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
+     * });
+     * ```
+     */
+    revalidator?: RevalidateHandler;
+};
+/** Per-request options for Next.js fetch - extends React's base options */
+type NextRequestOptionsBase = ReactRequestOptionsBase & {
+    /** Time in seconds to revalidate, or false to disable */
+    revalidate?: number | false;
+    /**
+     * URL paths to revalidate after mutation
+     * This doesn't do anything on the client by itself - it's passed to the revalidator handler.
+     * You must implement the revalidation logic in the revalidator.
+     */
+    revalidatePaths?: string[];
+    /**
+     * Skip server-side revalidation for this request.
+     * Useful when autoRevalidateTags is enabled but you want to opt-out for specific mutations.
+     * You can still pass empty [] to revalidateTags to skip triggering revalidation.
+     * But this flag can be used if you want to revalidate client-side and skip server-side entirely.
+     * Eg. you don't fetch any data on server component and you might want to skip the overhead of revalidation.
+     */
+    skipRevalidator?: boolean;
+};
 
-declare function clearCache(key?: string): void;
+declare function createEnlaceNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type ApiClient, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };
+export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { WildcardClient, EnlaceClient, EnlaceResponse, EnlaceOptions } from 'enlace-core';
+import { EnlaceCallbackPayload, EnlaceErrorCallbackPayload, EnlaceCallbacks, EnlaceOptions, WildcardClient, EnlaceClient } from 'enlace-core';
 export * from 'enlace-core';
 
 /** Per-request options for React hooks */
@@ -20,59 +20,7 @@ type ReactRequestOptionsBase = {
      */
     pathParams?: Record<string, string | number>;
 };
-/** Options for query mode hooks */
-type UseEnlaceQueryOptions = {
-    /**
-     * Whether the query should execute.
-     * Set to false to skip fetching (useful when ID is "new" or undefined).
-     * @default true
-     */
-    enabled?: boolean;
-};
-type ApiClient<TSchema, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TOptions>;
-type QueryFn<TSchema, TData, TError, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
-type SelectorFn<TSchema, TMethod, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TOptions>) => TMethod;
-type HookState = {
-    loading: boolean;
-    fetching: boolean;
-    ok: boolean | undefined;
-    data: unknown;
-    error: unknown;
-};
-type TrackedCall = {
-    path: string[];
-    method: string;
-    options: unknown;
-};
-declare const HTTP_METHODS: readonly ["get", "post", "put", "patch", "delete"];
-type ExtractData<T> = T extends (...args: any[]) => Promise<EnlaceResponse<infer D, unknown>> ? D : never;
-type ExtractError<T> = T extends (...args: any[]) => Promise<EnlaceResponse<unknown, infer E>> ? E : never;
-/** Discriminated union for hook response state - enables type narrowing on ok check */
-type HookResponseState<TData, TError> = {
-    ok: undefined;
-    data: undefined;
-    error: undefined;
-} | {
-    ok: true;
-    data: TData;
-    error: undefined;
-} | {
-    ok: false;
-    data: undefined;
-    error: TError;
-};
-/** Result when hook is called with query function (auto-fetch mode) */
-type UseEnlaceQueryResult<TData, TError> = {
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<TData, TError>;
-/** Result when hook is called with method selector (trigger mode) */
-type UseEnlaceSelectorResult<TMethod> = {
-    trigger: TMethod;
-    loading: boolean;
-    fetching: boolean;
-} & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-
+/** Options for createEnlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -84,31 +32,52 @@ type EnlaceHookOptions = {
     autoRevalidateTags?: boolean;
     /** Time in ms before cached data is considered stale. @default 0 (always stale) */
     staleTime?: number;
+    /** Callback called on successful API responses */
+    onSuccess?: (payload: EnlaceCallbackPayload<unknown>) => void;
+    /** Callback called on error responses (HTTP errors or network failures) */
+    onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-type EnlaceHook<TSchema> = {
-    <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
-};
+
 /**
- * Creates a React hook for making API calls.
- * Called at module level to create a reusable hook.
- *
- * @example
- * const useAPI = createEnlaceHook<ApiSchema>('https://api.com');
- *
- * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
- * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
- *
- * // Selector mode - typed trigger for lazy calls
- * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
- * onClick={() => trigger({ body: { id: 1 } })}
+ * Handler function called after successful mutations to trigger server-side revalidation.
+ * @param tags - Cache tags to revalidate
+ * @param paths - URL paths to revalidate
  */
-declare function createEnlaceHook<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema>;
-
-type Listener = (tags: string[]) => void;
-declare function invalidateTags(tags: string[]): void;
-declare function onRevalidate(callback: Listener): () => void;
+type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+/** Next.js-specific options (third argument for createEnlaceNext) */
+type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
+    /**
+     * Handler called after successful mutations to trigger server-side revalidation.
+     * Receives auto-generated or manually specified tags and paths.
+     * @example
+     * ```ts
+     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     *   revalidator: (tags, paths) => revalidateServerAction(tags, paths)
+     * });
+     * ```
+     */
+    revalidator?: RevalidateHandler;
+};
+/** Per-request options for Next.js fetch - extends React's base options */
+type NextRequestOptionsBase = ReactRequestOptionsBase & {
+    /** Time in seconds to revalidate, or false to disable */
+    revalidate?: number | false;
+    /**
+     * URL paths to revalidate after mutation
+     * This doesn't do anything on the client by itself - it's passed to the revalidator handler.
+     * You must implement the revalidation logic in the revalidator.
+     */
+    revalidatePaths?: string[];
+    /**
+     * Skip server-side revalidation for this request.
+     * Useful when autoRevalidateTags is enabled but you want to opt-out for specific mutations.
+     * You can still pass empty [] to revalidateTags to skip triggering revalidation.
+     * But this flag can be used if you want to revalidate client-side and skip server-side entirely.
+     * Eg. you don't fetch any data on server component and you might want to skip the overhead of revalidation.
+     */
+    skipRevalidator?: boolean;
+};
 
-declare function clearCache(key?: string): void;
+declare function createEnlaceNext<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { type ApiClient, type EnlaceHookOptions, HTTP_METHODS, type HookState, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, clearCache, createEnlaceHook, invalidateTags, onRevalidate };
+export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };