@diffsome/react 1.1.0

package/dist/index.js

@@ -0,0 +1,2340 @@
+"use strict";
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DiffsomeContext: () => DiffsomeContext,
+  DiffsomeProvider: () => DiffsomeProvider,
+  useAuth: () => useAuth,
+  useAvailableSlots: () => useAvailableSlots,
+  useBlog: () => useBlog,
+  useBlogCategories: () => useBlogCategories,
+  useBlogPost: () => useBlogPost,
+  useBlogSearch: () => useBlogSearch,
+  useBlogTags: () => useBlogTags,
+  useBoard: () => useBoard,
+  useBoardPost: () => useBoardPost,
+  useBoardPosts: () => useBoardPosts,
+  useBoards: () => useBoards,
+  useBundleItems: () => useBundleItems,
+  useBundleProducts: () => useBundleProducts,
+  useCanReview: () => useCanReview,
+  useCart: () => useCart,
+  useCategories: () => useCategories,
+  useClient: () => useClient,
+  useComments: () => useComments,
+  useCoupons: () => useCoupons,
+  useCreateBoardPost: () => useCreateBoardPost,
+  useCreateOrder: () => useCreateOrder,
+  useCreateReservation: () => useCreateReservation,
+  useCreateReview: () => useCreateReview,
+  useCreateSubscription: () => useCreateSubscription,
+  useDiffsome: () => useDiffsome,
+  useDigitalProducts: () => useDigitalProducts,
+  useDownloads: () => useDownloads,
+  useEntities: () => useEntities,
+  useEntity: () => useEntity,
+  useEntityRecord: () => useEntityRecord,
+  useEntityRecords: () => useEntityRecords,
+  useFeaturedBlog: () => useFeaturedBlog,
+  useFeaturedProducts: () => useFeaturedProducts,
+  useForm: () => useForm,
+  useMedia: () => useMedia,
+  useMyReservations: () => useMyReservations,
+  useMyReviews: () => useMyReviews,
+  useOrder: () => useOrder,
+  useOrderDownloads: () => useOrderDownloads,
+  useOrders: () => useOrders,
+  usePaymentStatus: () => usePaymentStatus,
+  useProduct: () => useProduct,
+  useProductReviews: () => useProductReviews,
+  useProducts: () => useProducts,
+  useProductsByType: () => useProductsByType,
+  useReservationServices: () => useReservationServices,
+  useReservationSettings: () => useReservationSettings,
+  useReservationStaffs: () => useReservationStaffs,
+  useSocialAuth: () => useSocialAuth,
+  useStripePayment: () => useStripePayment,
+  useSubscription: () => useSubscription,
+  useSubscriptionProducts: () => useSubscriptionProducts,
+  useSubscriptions: () => useSubscriptions,
+  useTossPayment: () => useTossPayment,
+  useTypedEntity: () => useTypedEntity,
+  useValidateCoupon: () => useValidateCoupon,
+  useWishlist: () => useWishlist
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/context/DiffsomeContext.tsx
+var import_react = require("react");
+var import_sdk = require("@diffsome/sdk");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DiffsomeContext = (0, import_react.createContext)(null);
+function DiffsomeProvider({ children, config }) {
+  const [isReady, setIsReady] = (0, import_react.useState)(false);
+  const client = (0, import_react.useMemo)(() => {
+    return new import_sdk.Diffsome({
+      ...config,
+      persistToken: config.persistToken ?? true,
+      storageType: config.storageType ?? "localStorage"
+    });
+  }, [config.tenantId, config.baseUrl, config.apiKey]);
+  (0, import_react.useEffect)(() => {
+    setIsReady(true);
+  }, []);
+  const value = (0, import_react.useMemo)(() => ({
+    client,
+    isReady
+  }), [client, isReady]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DiffsomeContext.Provider, { value, children });
+}
+function useDiffsome() {
+  const context = (0, import_react.useContext)(DiffsomeContext);
+  if (!context) {
+    throw new Error("useDiffsome must be used within DiffsomeProvider");
+  }
+  return context;
+}
+function useClient() {
+  const { client } = useDiffsome();
+  return client;
+}
+
+// src/hooks/useAuth.ts
+var import_react2 = require("react");
+function useAuth() {
+  const client = useClient();
+  const [user, setUser] = (0, import_react2.useState)(null);
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const isAuthenticated = !!user && client.isAuthenticated();
+  const fetchProfile = (0, import_react2.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setUser(null);
+      setLoading(false);
+      return;
+    }
+    try {
+      const profile = await client.auth.me();
+      setUser(profile);
+      setError(null);
+    } catch (err) {
+      setUser(null);
+      setError(err instanceof Error ? err : new Error("Failed to fetch profile"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react2.useEffect)(() => {
+    fetchProfile();
+  }, [fetchProfile]);
+  const login = (0, import_react2.useCallback)(async (credentials) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.auth.login(credentials);
+      setUser(response.user);
+      return response;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Login failed");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const register = (0, import_react2.useCallback)(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.auth.register(data);
+      setUser(response.user);
+      return response;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Registration failed");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const logout = (0, import_react2.useCallback)(async () => {
+    setLoading(true);
+    try {
+      await client.auth.logout();
+    } finally {
+      setUser(null);
+      setLoading(false);
+    }
+  }, [client]);
+  const getProfile = (0, import_react2.useCallback)(async () => {
+    const profile = await client.auth.me();
+    setUser(profile);
+    return profile;
+  }, [client]);
+  const updateProfile = (0, import_react2.useCallback)(async (data) => {
+    const profile = await client.auth.updateProfile(data);
+    setUser(profile);
+    return profile;
+  }, [client]);
+  const forgotPassword = (0, import_react2.useCallback)(async (email) => {
+    return await client.auth.forgotPassword({ email });
+  }, [client]);
+  const resetPassword = (0, import_react2.useCallback)(async (data) => {
+    return await client.auth.resetPassword(data);
+  }, [client]);
+  const refresh = (0, import_react2.useCallback)(async () => {
+    await fetchProfile();
+  }, [fetchProfile]);
+  return {
+    user,
+    isAuthenticated,
+    loading,
+    error,
+    login,
+    register,
+    logout,
+    getProfile,
+    updateProfile,
+    forgotPassword,
+    resetPassword,
+    refresh
+  };
+}
+
+// src/hooks/useSocialAuth.ts
+var import_react3 = require("react");
+function useSocialAuth() {
+  const client = useClient();
+  const [providers, setProviders] = (0, import_react3.useState)([]);
+  const [loading, setLoading] = (0, import_react3.useState)(true);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const fetchProviders = (0, import_react3.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.auth.getSocialProviders();
+      setProviders(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch providers"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react3.useEffect)(() => {
+    fetchProviders();
+  }, [fetchProviders]);
+  const getAuthUrl = (0, import_react3.useCallback)(async (provider) => {
+    const result = await client.auth.getSocialAuthUrl(provider);
+    return result.url;
+  }, [client]);
+  const handleCallback = (0, import_react3.useCallback)(async (provider, code) => {
+    return await client.auth.socialCallback(provider, code);
+  }, [client]);
+  return {
+    providers,
+    loading,
+    error,
+    getAuthUrl,
+    handleCallback,
+    refresh: fetchProviders
+  };
+}
+
+// src/hooks/useCart.ts
+var import_react4 = require("react");
+function useCart() {
+  const client = useClient();
+  const [cart, setCart] = (0, import_react4.useState)(null);
+  const [loading, setLoading] = (0, import_react4.useState)(true);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const fetchCart = (0, import_react4.useCallback)(async () => {
+    try {
+      const cartData = await client.shop.getCart();
+      setCart(cartData);
+      setError(null);
+    } catch (err) {
+      setCart(null);
+      setError(err instanceof Error ? err : new Error("Failed to fetch cart"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react4.useEffect)(() => {
+    fetchCart();
+  }, [fetchCart]);
+  const addToCart = (0, import_react4.useCallback)(async (productId, quantity = 1, variantId, options) => {
+    const data = {
+      product_id: productId,
+      quantity,
+      variant_id: variantId,
+      options
+    };
+    const updatedCart = await client.shop.addToCart(data);
+    setCart(updatedCart);
+    return updatedCart;
+  }, [client]);
+  const updateItem = (0, import_react4.useCallback)(async (itemId, quantity) => {
+    const updatedCart = await client.shop.updateCartItem(itemId, { quantity });
+    setCart(updatedCart);
+    return updatedCart;
+  }, [client]);
+  const removeItem = (0, import_react4.useCallback)(async (itemId) => {
+    const updatedCart = await client.shop.removeFromCart(itemId);
+    setCart(updatedCart);
+    return updatedCart;
+  }, [client]);
+  const clearCart = (0, import_react4.useCallback)(async () => {
+    await client.shop.clearCart();
+    setCart(null);
+  }, [client]);
+  const refresh = (0, import_react4.useCallback)(async () => {
+    setLoading(true);
+    await fetchCart();
+  }, [fetchCart]);
+  const isInCart = (0, import_react4.useCallback)((productId, variantId) => {
+    if (!cart?.items) return false;
+    return cart.items.some(
+      (item) => item.product_id === productId && (variantId === void 0 || item.variant_id === variantId)
+    );
+  }, [cart]);
+  const getItemQuantity = (0, import_react4.useCallback)((productId, variantId) => {
+    if (!cart?.items) return 0;
+    const item = cart.items.find(
+      (item2) => item2.product_id === productId && (variantId === void 0 || item2.variant_id === variantId)
+    );
+    return item?.quantity ?? 0;
+  }, [cart]);
+  return {
+    cart,
+    items: cart?.items ?? [],
+    itemCount: cart?.item_count ?? 0,
+    totalQuantity: cart?.total_quantity ?? 0,
+    subtotal: cart?.subtotal ?? 0,
+    shippingFee: cart?.shipping_fee ?? 0,
+    total: cart?.total ?? 0,
+    loading,
+    error,
+    addToCart,
+    updateItem,
+    removeItem,
+    clearCart,
+    refresh,
+    isInCart,
+    getItemQuantity
+  };
+}
+
+// src/hooks/useWishlist.ts
+var import_react5 = require("react");
+function useWishlist() {
+  const client = useClient();
+  const [items, setItems] = (0, import_react5.useState)([]);
+  const [loading, setLoading] = (0, import_react5.useState)(true);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const [wishlistMap, setWishlistMap] = (0, import_react5.useState)({});
+  const fetchWishlist = (0, import_react5.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setItems([]);
+      setWishlistMap({});
+      setLoading(false);
+      return;
+    }
+    try {
+      const response = await client.shop.getWishlist({ per_page: 100 });
+      setItems(response.data);
+      const map = {};
+      response.data.forEach((item) => {
+        const key = item.variant_id ? `${item.product_id}_${item.variant_id}` : String(item.product_id);
+        map[key] = true;
+      });
+      setWishlistMap(map);
+      setError(null);
+    } catch (err) {
+      setItems([]);
+      setWishlistMap({});
+      setError(err instanceof Error ? err : new Error("Failed to fetch wishlist"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react5.useEffect)(() => {
+    fetchWishlist();
+  }, [fetchWishlist]);
+  const isInWishlist = (0, import_react5.useCallback)((productId, variantId) => {
+    const key = variantId ? `${productId}_${variantId}` : String(productId);
+    return wishlistMap[key] || false;
+  }, [wishlistMap]);
+  const toggleWishlist = (0, import_react5.useCallback)(async (productId, variantId) => {
+    const result = await client.shop.toggleWishlist(productId, variantId);
+    const key = variantId ? `${productId}_${variantId}` : String(productId);
+    setWishlistMap((prev) => ({
+      ...prev,
+      [key]: result.in_wishlist
+    }));
+    if (result.action === "added") {
+      await fetchWishlist();
+    } else {
+      setItems((prev) => prev.filter(
+        (item) => !(item.product_id === productId && item.variant_id === variantId)
+      ));
+    }
+    return result;
+  }, [client, fetchWishlist]);
+  const addToWishlist = (0, import_react5.useCallback)(async (productId, variantId, note) => {
+    const item = await client.shop.addToWishlist({
+      product_id: productId,
+      variant_id: variantId,
+      note
+    });
+    await fetchWishlist();
+    return item;
+  }, [client, fetchWishlist]);
+  const removeFromWishlist = (0, import_react5.useCallback)(async (wishlistId) => {
+    const item = items.find((i) => i.id === wishlistId);
+    await client.shop.removeFromWishlist(wishlistId);
+    if (item) {
+      const key = item.variant_id ? `${item.product_id}_${item.variant_id}` : String(item.product_id);
+      setWishlistMap((prev) => {
+        const next = { ...prev };
+        delete next[key];
+        return next;
+      });
+    }
+    setItems((prev) => prev.filter((i) => i.id !== wishlistId));
+  }, [client, items]);
+  const moveToCart = (0, import_react5.useCallback)(async (wishlistIds) => {
+    const result = await client.shop.moveWishlistToCart(wishlistIds);
+    await fetchWishlist();
+    return result;
+  }, [client, fetchWishlist]);
+  const updateNote = (0, import_react5.useCallback)(async (wishlistId, note) => {
+    const item = await client.shop.updateWishlistNote(wishlistId, note);
+    setItems((prev) => prev.map((i) => i.id === wishlistId ? item : i));
+    return item;
+  }, [client]);
+  const getProductWishlistCount = (0, import_react5.useCallback)(async (productSlug) => {
+    return await client.shop.getProductWishlistCount(productSlug);
+  }, [client]);
+  const refresh = (0, import_react5.useCallback)(async () => {
+    setLoading(true);
+    await fetchWishlist();
+  }, [fetchWishlist]);
+  return {
+    items,
+    count: items.length,
+    loading,
+    error,
+    isInWishlist,
+    toggleWishlist,
+    addToWishlist,
+    removeFromWishlist,
+    moveToCart,
+    updateNote,
+    getProductWishlistCount,
+    refresh
+  };
+}
+
+// src/hooks/useProducts.ts
+var import_react6 = require("react");
+function useProducts(options = {}) {
+  const { autoFetch = true, ...params } = options;
+  const client = useClient();
+  const [products, setProducts] = (0, import_react6.useState)([]);
+  const [meta, setMeta] = (0, import_react6.useState)(null);
+  const [loading, setLoading] = (0, import_react6.useState)(autoFetch);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const [currentParams, setCurrentParams] = (0, import_react6.useState)(params);
+  const fetchProducts = (0, import_react6.useCallback)(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listProducts(fetchParams);
+      if (append) {
+        setProducts((prev) => [...prev, ...response.data]);
+      } else {
+        setProducts(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch products"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react6.useEffect)(() => {
+    if (autoFetch) {
+      fetchProducts(params);
+    }
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = (0, import_react6.useCallback)(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchProducts({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchProducts]);
+  const refresh = (0, import_react6.useCallback)(async () => {
+    setCurrentParams(params);
+    await fetchProducts(params);
+  }, [params, fetchProducts]);
+  const search = (0, import_react6.useCallback)(async (query) => {
+    const searchParams = { ...params, search: query, page: 1 };
+    setCurrentParams(searchParams);
+    await fetchProducts(searchParams);
+  }, [params, fetchProducts]);
+  return {
+    products,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh,
+    search
+  };
+}
+function useProduct(idOrSlug) {
+  const client = useClient();
+  const [product, setProduct] = (0, import_react6.useState)(null);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchProduct = (0, import_react6.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getProduct(idOrSlug);
+      setProduct(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch product"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, idOrSlug]);
+  (0, import_react6.useEffect)(() => {
+    fetchProduct();
+  }, [fetchProduct]);
+  return {
+    product,
+    loading,
+    error,
+    refresh: fetchProduct
+  };
+}
+function useCategories() {
+  const client = useClient();
+  const [categories, setCategories] = (0, import_react6.useState)([]);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchCategories = (0, import_react6.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listCategories();
+      setCategories(response.data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch categories"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react6.useEffect)(() => {
+    fetchCategories();
+  }, [fetchCategories]);
+  return {
+    categories,
+    loading,
+    error,
+    refresh: fetchCategories
+  };
+}
+function useFeaturedProducts(limit = 8) {
+  const client = useClient();
+  const [products, setProducts] = (0, import_react6.useState)([]);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchProducts = (0, import_react6.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.featuredProducts(limit);
+      setProducts(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch featured products"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, limit]);
+  (0, import_react6.useEffect)(() => {
+    fetchProducts();
+  }, [fetchProducts]);
+  return {
+    products,
+    loading,
+    error,
+    refresh: fetchProducts
+  };
+}
+function useProductsByType(type, params) {
+  const client = useClient();
+  const [products, setProducts] = (0, import_react6.useState)([]);
+  const [meta, setMeta] = (0, import_react6.useState)(null);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchProducts = (0, import_react6.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listProductsByType(type, params);
+      setProducts(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch products"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, type, params]);
+  (0, import_react6.useEffect)(() => {
+    fetchProducts();
+  }, [fetchProducts]);
+  return {
+    products,
+    meta,
+    loading,
+    error,
+    refresh: fetchProducts
+  };
+}
+function useDigitalProducts(params) {
+  return useProductsByType("digital", params);
+}
+function useSubscriptionProducts(params) {
+  return useProductsByType("subscription", params);
+}
+function useBundleProducts(params) {
+  return useProductsByType("bundle", params);
+}
+function useBundleItems(productSlug) {
+  const client = useClient();
+  const [bundle, setBundle] = (0, import_react6.useState)(null);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchBundle = (0, import_react6.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getBundleItems(productSlug);
+      setBundle(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch bundle items"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, productSlug]);
+  (0, import_react6.useEffect)(() => {
+    fetchBundle();
+  }, [fetchBundle]);
+  return {
+    bundle,
+    loading,
+    error,
+    refresh: fetchBundle
+  };
+}
+
+// src/hooks/useOrders.ts
+var import_react7 = require("react");
+function useOrders(params) {
+  const client = useClient();
+  const [orders, setOrders] = (0, import_react7.useState)([]);
+  const [meta, setMeta] = (0, import_react7.useState)(null);
+  const [loading, setLoading] = (0, import_react7.useState)(true);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const fetchOrders = (0, import_react7.useCallback)(async (fetchParams, append = false) => {
+    if (!client.isAuthenticated()) {
+      setOrders([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.listOrders(fetchParams);
+      if (append) {
+        setOrders((prev) => [...prev, ...response.data]);
+      } else {
+        setOrders(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch orders"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react7.useEffect)(() => {
+    fetchOrders(params);
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = (0, import_react7.useCallback)(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchOrders({ ...params, page: nextPage }, true);
+  }, [hasMore, loading, meta, params, fetchOrders]);
+  const refresh = (0, import_react7.useCallback)(async () => {
+    await fetchOrders(params);
+  }, [params, fetchOrders]);
+  return {
+    orders,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}
+function useOrder(idOrNumber) {
+  const client = useClient();
+  const [order, setOrder] = (0, import_react7.useState)(null);
+  const [loading, setLoading] = (0, import_react7.useState)(true);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const fetchOrder = (0, import_react7.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getOrder(idOrNumber);
+      setOrder(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch order"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, idOrNumber]);
+  (0, import_react7.useEffect)(() => {
+    fetchOrder();
+  }, [fetchOrder]);
+  const cancel = (0, import_react7.useCallback)(async () => {
+    if (!order) throw new Error("Order not loaded");
+    const cancelled = await client.shop.cancelOrder(order.id);
+    setOrder(cancelled);
+    return cancelled;
+  }, [client, order]);
+  return {
+    order,
+    loading,
+    error,
+    cancel,
+    refresh: fetchOrder
+  };
+}
+function useCreateOrder() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react7.useState)(false);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const createOrder = (0, import_react7.useCallback)(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.createOrder(data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create order");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createOrder,
+    loading,
+    error
+  };
+}
+
+// src/hooks/usePayment.ts
+var import_react8 = require("react");
+function usePaymentStatus() {
+  const client = useClient();
+  const [status, setStatus] = (0, import_react8.useState)(null);
+  const [loading, setLoading] = (0, import_react8.useState)(true);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const fetchStatus = (0, import_react8.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getPaymentStatus();
+      setStatus(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch payment status"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    status,
+    loading,
+    error,
+    refresh: fetchStatus,
+    isTossAvailable: status?.toss?.available ?? false,
+    isStripeAvailable: status?.stripe?.available ?? false,
+    stripePublishableKey: status?.stripe?.publishable_key ?? null
+  };
+}
+function useTossPayment() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const preparePayment = (0, import_react8.useCallback)(async (orderNumber, successUrl, failUrl) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.tossPaymentReady({
+        order_number: orderNumber,
+        success_url: successUrl,
+        fail_url: failUrl
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to prepare payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const confirmPayment = (0, import_react8.useCallback)(async (paymentKey, orderId, amount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.tossPaymentConfirm({
+        payment_key: paymentKey,
+        order_id: orderId,
+        amount
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to confirm payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const cancelPayment = (0, import_react8.useCallback)(async (orderNumber, reason, amount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      await client.shop.tossPaymentCancel(orderNumber, reason, amount);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to cancel payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    preparePayment,
+    confirmPayment,
+    cancelPayment,
+    loading,
+    error
+  };
+}
+function useStripePayment() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const createCheckout = (0, import_react8.useCallback)(async (orderNumber, successUrl, cancelUrl) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.stripeCheckout({
+        order_number: orderNumber,
+        success_url: successUrl,
+        cancel_url: cancelUrl
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create checkout");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const verifyPayment = (0, import_react8.useCallback)(async (sessionId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.stripeVerify({ session_id: sessionId });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to verify payment");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const refund = (0, import_react8.useCallback)(async (orderNumber, reason, amount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      await client.shop.stripeRefund(orderNumber, reason, amount);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to refund");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createCheckout,
+    verifyPayment,
+    refund,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useCoupons.ts
+var import_react9 = require("react");
+function useCoupons() {
+  const client = useClient();
+  const [coupons, setCoupons] = (0, import_react9.useState)([]);
+  const [loading, setLoading] = (0, import_react9.useState)(true);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const fetchCoupons = (0, import_react9.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setCoupons([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.myCoupons();
+      setCoupons(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch coupons"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react9.useEffect)(() => {
+    fetchCoupons();
+  }, [fetchCoupons]);
+  return {
+    coupons,
+    loading,
+    error,
+    refresh: fetchCoupons
+  };
+}
+function useValidateCoupon() {
+  const client = useClient();
+  const [validation, setValidation] = (0, import_react9.useState)(null);
+  const [loading, setLoading] = (0, import_react9.useState)(false);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const validate = (0, import_react9.useCallback)(async (code, orderAmount) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.shop.validateCoupon(code, orderAmount);
+      setValidation(result);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to validate coupon");
+      setError(error2);
+      setValidation({ valid: false, message: error2.message });
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const reset = (0, import_react9.useCallback)(() => {
+    setValidation(null);
+    setError(null);
+  }, []);
+  return {
+    validate,
+    validation,
+    loading,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useSubscriptions.ts
+var import_react10 = require("react");
+function useSubscriptions() {
+  const client = useClient();
+  const [subscriptions, setSubscriptions] = (0, import_react10.useState)([]);
+  const [loading, setLoading] = (0, import_react10.useState)(true);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const fetchSubscriptions = (0, import_react10.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setSubscriptions([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getSubscriptions();
+      setSubscriptions(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch subscriptions"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react10.useEffect)(() => {
+    fetchSubscriptions();
+  }, [fetchSubscriptions]);
+  const activeSubscription = subscriptions.find((s) => s.is_active) ?? null;
+  const hasActiveSubscription = !!activeSubscription;
+  return {
+    subscriptions,
+    loading,
+    error,
+    activeSubscription,
+    hasActiveSubscription,
+    refresh: fetchSubscriptions
+  };
+}
+function useSubscription(id) {
+  const client = useClient();
+  const [subscription, setSubscription] = (0, import_react10.useState)(null);
+  const [loading, setLoading] = (0, import_react10.useState)(true);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const fetchSubscription = (0, import_react10.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getSubscription(id);
+      setSubscription(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch subscription"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, id]);
+  (0, import_react10.useEffect)(() => {
+    fetchSubscription();
+  }, [fetchSubscription]);
+  const cancel = (0, import_react10.useCallback)(async (immediately = false) => {
+    const updated = await client.shop.cancelSubscription(id, immediately);
+    setSubscription(updated);
+    return updated;
+  }, [client, id]);
+  const pause = (0, import_react10.useCallback)(async () => {
+    const updated = await client.shop.pauseSubscription(id);
+    setSubscription(updated);
+    return updated;
+  }, [client, id]);
+  const resume = (0, import_react10.useCallback)(async () => {
+    const updated = await client.shop.resumeSubscription(id);
+    setSubscription(updated);
+    return updated;
+  }, [client, id]);
+  return {
+    subscription,
+    loading,
+    error,
+    cancel,
+    pause,
+    resume,
+    refresh: fetchSubscription
+  };
+}
+function useCreateSubscription() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react10.useState)(false);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const createCheckout = (0, import_react10.useCallback)(async (planId, successUrl, cancelUrl) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.createSubscriptionCheckout({
+        plan_id: planId,
+        success_url: successUrl,
+        cancel_url: cancelUrl
+      });
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create checkout");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const verifyCheckout = (0, import_react10.useCallback)(async (sessionId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.shop.verifySubscriptionCheckout(sessionId);
+      return result.subscription;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to verify checkout");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  const createSetupIntent = (0, import_react10.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.shop.createSetupIntent();
+      return result.client_secret;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create setup intent");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createCheckout,
+    verifyCheckout,
+    createSetupIntent,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useDownloads.ts
+var import_react11 = require("react");
+function useDownloads() {
+  const client = useClient();
+  const [downloads, setDownloads] = (0, import_react11.useState)([]);
+  const [loading, setLoading] = (0, import_react11.useState)(true);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const fetchDownloads = (0, import_react11.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setDownloads([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getMyDownloads();
+      setDownloads(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch downloads"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react11.useEffect)(() => {
+    fetchDownloads();
+  }, [fetchDownloads]);
+  const getDownloadUrl = (0, import_react11.useCallback)((token) => {
+    return client.shop.getDownloadUrl(token);
+  }, [client]);
+  const getDownloadInfo = (0, import_react11.useCallback)(async (token) => {
+    return await client.shop.getDownloadInfo(token);
+  }, [client]);
+  return {
+    downloads,
+    loading,
+    error,
+    getDownloadUrl,
+    getDownloadInfo,
+    refresh: fetchDownloads
+  };
+}
+function useOrderDownloads(orderNumber) {
+  const client = useClient();
+  const [downloads, setDownloads] = (0, import_react11.useState)([]);
+  const [loading, setLoading] = (0, import_react11.useState)(true);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const fetchDownloads = (0, import_react11.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setDownloads([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.shop.getOrderDownloads(orderNumber);
+      setDownloads(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch downloads"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, orderNumber]);
+  (0, import_react11.useEffect)(() => {
+    fetchDownloads();
+  }, [fetchDownloads]);
+  const getDownloadUrl = (0, import_react11.useCallback)((token) => {
+    return client.shop.getDownloadUrl(token);
+  }, [client]);
+  const getDownloadInfo = (0, import_react11.useCallback)(async (token) => {
+    return await client.shop.getDownloadInfo(token);
+  }, [client]);
+  return {
+    downloads,
+    loading,
+    error,
+    getDownloadUrl,
+    getDownloadInfo,
+    refresh: fetchDownloads
+  };
+}
+
+// src/hooks/useReviews.ts
+var import_react12 = require("react");
+function useProductReviews(productSlug, params) {
+  const client = useClient();
+  const [reviews, setReviews] = (0, import_react12.useState)([]);
+  const [stats, setStats] = (0, import_react12.useState)(null);
+  const [meta, setMeta] = (0, import_react12.useState)(null);
+  const [loading, setLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchReviews = (0, import_react12.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.getProductReviews(productSlug, params);
+      setReviews(response.data);
+      setStats(response.stats);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch reviews"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, productSlug, params]);
+  (0, import_react12.useEffect)(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+  return {
+    reviews,
+    stats,
+    meta,
+    loading,
+    error,
+    refresh: fetchReviews
+  };
+}
+function useCanReview(productSlug) {
+  const client = useClient();
+  const [canReview, setCanReview] = (0, import_react12.useState)(false);
+  const [reason, setReason] = (0, import_react12.useState)(null);
+  const [loading, setLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const check = (0, import_react12.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.canReviewProduct(productSlug);
+      setCanReview(response.can_review);
+      setReason(response.reason ?? null);
+      return response;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to check review eligibility"));
+      return { can_review: false, reason: "not_logged_in" };
+    } finally {
+      setLoading(false);
+    }
+  }, [client, productSlug]);
+  (0, import_react12.useEffect)(() => {
+    if (client.isAuthenticated()) {
+      check();
+    } else {
+      setCanReview(false);
+      setReason("not_logged_in");
+      setLoading(false);
+    }
+  }, [check, client]);
+  return {
+    canReview,
+    reason,
+    loading,
+    error,
+    check
+  };
+}
+function useCreateReview() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const createReview = (0, import_react12.useCallback)(async (productSlug, data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.shop.createReview(productSlug, data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create review");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createReview,
+    loading,
+    error
+  };
+}
+function useMyReviews(params) {
+  const client = useClient();
+  const [reviews, setReviews] = (0, import_react12.useState)([]);
+  const [meta, setMeta] = (0, import_react12.useState)(null);
+  const [loading, setLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchReviews = (0, import_react12.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setReviews([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.shop.myReviews(params);
+      setReviews(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch reviews"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, params]);
+  (0, import_react12.useEffect)(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+  const deleteReview = (0, import_react12.useCallback)(async (reviewId) => {
+    await client.shop.deleteReview(reviewId);
+    setReviews((prev) => prev.filter((r) => r.id !== reviewId));
+  }, [client]);
+  const updateReview = (0, import_react12.useCallback)(async (reviewId, data) => {
+    const updated = await client.shop.updateReview(reviewId, data);
+    setReviews((prev) => prev.map((r) => r.id === reviewId ? updated : r));
+    return updated;
+  }, [client]);
+  return {
+    reviews,
+    meta,
+    loading,
+    error,
+    refresh: fetchReviews,
+    deleteReview,
+    updateReview
+  };
+}
+
+// src/hooks/useBlog.ts
+var import_react13 = require("react");
+function useBlog(options = {}) {
+  const { autoFetch = true, ...params } = options;
+  const client = useClient();
+  const [posts, setPosts] = (0, import_react13.useState)([]);
+  const [meta, setMeta] = (0, import_react13.useState)(null);
+  const [loading, setLoading] = (0, import_react13.useState)(autoFetch);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const [currentParams, setCurrentParams] = (0, import_react13.useState)(params);
+  const fetchPosts = (0, import_react13.useCallback)(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.blog.list(fetchParams);
+      if (append) {
+        setPosts((prev) => [...prev, ...response.data]);
+      } else {
+        setPosts(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    if (autoFetch) {
+      fetchPosts(params);
+    }
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = (0, import_react13.useCallback)(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchPosts({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchPosts]);
+  const refresh = (0, import_react13.useCallback)(async () => {
+    setCurrentParams(params);
+    await fetchPosts(params);
+  }, [params, fetchPosts]);
+  return {
+    posts,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}
+function useBlogPost(slug) {
+  const client = useClient();
+  const [post, setPost] = (0, import_react13.useState)(null);
+  const [loading, setLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchPost = (0, import_react13.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.get(slug);
+      setPost(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog post"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  (0, import_react13.useEffect)(() => {
+    fetchPost();
+  }, [fetchPost]);
+  return {
+    post,
+    loading,
+    error,
+    refresh: fetchPost
+  };
+}
+function useBlogCategories() {
+  const client = useClient();
+  const [categories, setCategories] = (0, import_react13.useState)([]);
+  const [loading, setLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchCategories = (0, import_react13.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.categories();
+      setCategories(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog categories"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchCategories();
+  }, [fetchCategories]);
+  return {
+    categories,
+    loading,
+    error,
+    refresh: fetchCategories
+  };
+}
+function useBlogTags() {
+  const client = useClient();
+  const [tags, setTags] = (0, import_react13.useState)([]);
+  const [loading, setLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchTags = (0, import_react13.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.tags();
+      setTags(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch blog tags"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchTags();
+  }, [fetchTags]);
+  return {
+    tags,
+    loading,
+    error,
+    refresh: fetchTags
+  };
+}
+function useFeaturedBlog(limit = 5) {
+  const client = useClient();
+  const [posts, setPosts] = (0, import_react13.useState)([]);
+  const [loading, setLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchPosts = (0, import_react13.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.blog.featured(limit);
+      setPosts(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch featured posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, limit]);
+  (0, import_react13.useEffect)(() => {
+    fetchPosts();
+  }, [fetchPosts]);
+  return {
+    posts,
+    loading,
+    error,
+    refresh: fetchPosts
+  };
+}
+function useBlogSearch() {
+  const client = useClient();
+  const [posts, setPosts] = (0, import_react13.useState)([]);
+  const [meta, setMeta] = (0, import_react13.useState)(null);
+  const [loading, setLoading] = (0, import_react13.useState)(false);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const search = (0, import_react13.useCallback)(async (query) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.blog.search(query);
+      setPosts(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to search posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    posts,
+    meta,
+    loading,
+    error,
+    search
+  };
+}
+
+// src/hooks/useBoards.ts
+var import_react14 = require("react");
+function useBoards(params) {
+  const client = useClient();
+  const [boards, setBoards] = (0, import_react14.useState)([]);
+  const [loading, setLoading] = (0, import_react14.useState)(true);
+  const [error, setError] = (0, import_react14.useState)(null);
+  const fetchBoards = (0, import_react14.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.boards.list(params);
+      setBoards(response.data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch boards"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, params]);
+  (0, import_react14.useEffect)(() => {
+    fetchBoards();
+  }, [fetchBoards]);
+  return {
+    boards,
+    loading,
+    error,
+    refresh: fetchBoards
+  };
+}
+function useBoard(slug) {
+  const client = useClient();
+  const [board, setBoard] = (0, import_react14.useState)(null);
+  const [loading, setLoading] = (0, import_react14.useState)(true);
+  const [error, setError] = (0, import_react14.useState)(null);
+  const fetchBoard = (0, import_react14.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.boards.get(slug);
+      setBoard(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch board"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  (0, import_react14.useEffect)(() => {
+    fetchBoard();
+  }, [fetchBoard]);
+  return {
+    board,
+    loading,
+    error,
+    refresh: fetchBoard
+  };
+}
+function useBoardPosts(boardSlug, params) {
+  const client = useClient();
+  const [posts, setPosts] = (0, import_react14.useState)([]);
+  const [meta, setMeta] = (0, import_react14.useState)(null);
+  const [loading, setLoading] = (0, import_react14.useState)(true);
+  const [error, setError] = (0, import_react14.useState)(null);
+  const [currentParams, setCurrentParams] = (0, import_react14.useState)(params);
+  const fetchPosts = (0, import_react14.useCallback)(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.boards.listPosts(boardSlug, fetchParams);
+      if (append) {
+        setPosts((prev) => [...prev, ...response.data]);
+      } else {
+        setPosts(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch posts"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, boardSlug]);
+  (0, import_react14.useEffect)(() => {
+    fetchPosts(params);
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = (0, import_react14.useCallback)(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchPosts({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchPosts]);
+  const refresh = (0, import_react14.useCallback)(async () => {
+    setCurrentParams(params);
+    await fetchPosts(params);
+  }, [params, fetchPosts]);
+  return {
+    posts,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    refresh
+  };
+}
+function useBoardPost(postId) {
+  const client = useClient();
+  const [post, setPost] = (0, import_react14.useState)(null);
+  const [loading, setLoading] = (0, import_react14.useState)(true);
+  const [error, setError] = (0, import_react14.useState)(null);
+  const fetchPost = (0, import_react14.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.boards.getPost(postId);
+      setPost(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch post"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, postId]);
+  (0, import_react14.useEffect)(() => {
+    fetchPost();
+  }, [fetchPost]);
+  return {
+    post,
+    loading,
+    error,
+    refresh: fetchPost
+  };
+}
+function useCreateBoardPost() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react14.useState)(false);
+  const [error, setError] = (0, import_react14.useState)(null);
+  const createPost = (0, import_react14.useCallback)(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await client.boards.createPost(data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create post");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createPost,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useComments.ts
+var import_react15 = require("react");
+function useComments(options) {
+  const { type, target, page, per_page } = options;
+  const client = useClient();
+  const [comments, setComments] = (0, import_react15.useState)([]);
+  const [meta, setMeta] = (0, import_react15.useState)(null);
+  const [loading, setLoading] = (0, import_react15.useState)(true);
+  const [error, setError] = (0, import_react15.useState)(null);
+  const fetchComments = (0, import_react15.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      let response;
+      const params = { page, per_page };
+      switch (type) {
+        case "board":
+          response = await client.comments.boardPost(target, params);
+          break;
+        case "blog":
+          response = await client.comments.blogPost(target, params);
+          break;
+        case "standalone":
+          response = await client.comments.standalone(target, params);
+          break;
+      }
+      setComments(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch comments"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, type, target, page, per_page]);
+  (0, import_react15.useEffect)(() => {
+    fetchComments();
+  }, [fetchComments]);
+  const createComment = (0, import_react15.useCallback)(async (data) => {
+    let response;
+    switch (type) {
+      case "board":
+        response = await client.comments.createBoardPost(target, data);
+        break;
+      case "blog":
+        response = await client.comments.createBlogPost(target, data);
+        break;
+      case "standalone":
+        response = await client.comments.createStandalone(target, data);
+        break;
+    }
+    await fetchComments();
+    return response.data;
+  }, [client, type, target, fetchComments]);
+  const updateComment = (0, import_react15.useCallback)(async (commentId, content) => {
+    const response = await client.comments.update(commentId, { content });
+    setComments((prev) => prev.map((c) => c.id === commentId ? response.data : c));
+    return response.data;
+  }, [client]);
+  const deleteComment = (0, import_react15.useCallback)(async (commentId, password) => {
+    await client.comments.delete(commentId, password ? { password } : void 0);
+    setComments((prev) => prev.filter((c) => c.id !== commentId));
+  }, [client]);
+  const likeComment = (0, import_react15.useCallback)(async (commentId) => {
+    const response = await client.comments.like(commentId);
+    setComments((prev) => prev.map(
+      (c) => c.id === commentId ? { ...c, likes: response.data.likes } : c
+    ));
+    return response.data.likes;
+  }, [client]);
+  return {
+    comments,
+    meta,
+    loading,
+    error,
+    createComment,
+    updateComment,
+    deleteComment,
+    likeComment,
+    refresh: fetchComments
+  };
+}
+
+// src/hooks/useForms.ts
+var import_react16 = require("react");
+function useForm(formSlug) {
+  const client = useClient();
+  const [form, setForm] = (0, import_react16.useState)(null);
+  const [loading, setLoading] = (0, import_react16.useState)(true);
+  const [error, setError] = (0, import_react16.useState)(null);
+  const [submitting, setSubmitting] = (0, import_react16.useState)(false);
+  const [submitted, setSubmitted] = (0, import_react16.useState)(false);
+  const fetchForm = (0, import_react16.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.forms.get(formSlug);
+      setForm(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch form"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, formSlug]);
+  (0, import_react16.useEffect)(() => {
+    fetchForm();
+  }, [fetchForm]);
+  const submit = (0, import_react16.useCallback)(async (data) => {
+    setSubmitting(true);
+    setError(null);
+    try {
+      const submission = await client.forms.submit(formSlug, data);
+      setSubmitted(true);
+      return submission;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to submit form");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSubmitting(false);
+    }
+  }, [client, formSlug]);
+  const reset = (0, import_react16.useCallback)(() => {
+    setSubmitted(false);
+    setError(null);
+  }, []);
+  return {
+    form,
+    loading,
+    error,
+    submit,
+    submitting,
+    submitted,
+    reset
+  };
+}
+
+// src/hooks/useReservation.ts
+var import_react17 = require("react");
+function useReservationServices() {
+  const client = useClient();
+  const [services, setServices] = (0, import_react17.useState)([]);
+  const [loading, setLoading] = (0, import_react17.useState)(true);
+  const [error, setError] = (0, import_react17.useState)(null);
+  const fetchServices = (0, import_react17.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.listServices();
+      setServices(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch services"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react17.useEffect)(() => {
+    fetchServices();
+  }, [fetchServices]);
+  return {
+    services,
+    loading,
+    error,
+    refresh: fetchServices
+  };
+}
+function useReservationStaffs() {
+  const client = useClient();
+  const [staffs, setStaffs] = (0, import_react17.useState)([]);
+  const [loading, setLoading] = (0, import_react17.useState)(true);
+  const [error, setError] = (0, import_react17.useState)(null);
+  const fetchStaffs = (0, import_react17.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.listStaff();
+      setStaffs(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch staffs"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react17.useEffect)(() => {
+    fetchStaffs();
+  }, [fetchStaffs]);
+  return {
+    staffs,
+    loading,
+    error,
+    refresh: fetchStaffs
+  };
+}
+function useAvailableSlots(serviceId, date, staffId) {
+  const client = useClient();
+  const [slots, setSlots] = (0, import_react17.useState)([]);
+  const [loading, setLoading] = (0, import_react17.useState)(true);
+  const [error, setError] = (0, import_react17.useState)(null);
+  const fetchSlots = (0, import_react17.useCallback)(async () => {
+    if (!serviceId || !date) {
+      setSlots([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.getAvailableSlots({
+        service_id: serviceId,
+        date,
+        staff_id: staffId
+      });
+      setSlots(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch slots"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, serviceId, date, staffId]);
+  (0, import_react17.useEffect)(() => {
+    fetchSlots();
+  }, [fetchSlots]);
+  return {
+    slots,
+    loading,
+    error,
+    refresh: fetchSlots
+  };
+}
+function useMyReservations(params) {
+  const client = useClient();
+  const [reservations, setReservations] = (0, import_react17.useState)([]);
+  const [meta, setMeta] = (0, import_react17.useState)(null);
+  const [loading, setLoading] = (0, import_react17.useState)(true);
+  const [error, setError] = (0, import_react17.useState)(null);
+  const fetchReservations = (0, import_react17.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setReservations([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.reservation.list(params);
+      setReservations(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch reservations"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, params]);
+  (0, import_react17.useEffect)(() => {
+    fetchReservations();
+  }, [fetchReservations]);
+  return {
+    reservations,
+    meta,
+    loading,
+    error,
+    refresh: fetchReservations
+  };
+}
+function useCreateReservation() {
+  const client = useClient();
+  const [loading, setLoading] = (0, import_react17.useState)(false);
+  const [error, setError] = (0, import_react17.useState)(null);
+  const createReservation = (0, import_react17.useCallback)(async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.reservation.create(data);
+      return result.reservation;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create reservation");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  return {
+    createReservation,
+    loading,
+    error
+  };
+}
+function useReservationSettings() {
+  const client = useClient();
+  const [settings, setSettings] = (0, import_react17.useState)(null);
+  const [loading, setLoading] = (0, import_react17.useState)(true);
+  const [error, setError] = (0, import_react17.useState)(null);
+  const fetchSettings = (0, import_react17.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.reservation.getSettings();
+      setSettings(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch settings"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react17.useEffect)(() => {
+    fetchSettings();
+  }, [fetchSettings]);
+  return {
+    settings,
+    loading,
+    error,
+    refresh: fetchSettings
+  };
+}
+
+// src/hooks/useMedia.ts
+var import_react18 = require("react");
+function useMedia(options = {}) {
+  const { type, page, per_page, autoFetch = true } = options;
+  const client = useClient();
+  const [files, setFiles] = (0, import_react18.useState)([]);
+  const [meta, setMeta] = (0, import_react18.useState)(null);
+  const [loading, setLoading] = (0, import_react18.useState)(autoFetch);
+  const [error, setError] = (0, import_react18.useState)(null);
+  const [uploading, setUploading] = (0, import_react18.useState)(false);
+  const [uploadProgress, setUploadProgress] = (0, import_react18.useState)(0);
+  const fetchMedia = (0, import_react18.useCallback)(async () => {
+    if (!client.isAuthenticated()) {
+      setFiles([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.media.list({ type, page, per_page });
+      setFiles(response.data);
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch media"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, type, page, per_page]);
+  (0, import_react18.useEffect)(() => {
+    if (autoFetch) {
+      fetchMedia();
+    }
+  }, [autoFetch, fetchMedia]);
+  const upload = (0, import_react18.useCallback)(async (file) => {
+    setUploading(true);
+    setUploadProgress(0);
+    setError(null);
+    try {
+      const media = await client.media.upload(file);
+      setFiles((prev) => [media, ...prev]);
+      setUploadProgress(100);
+      return media;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to upload file");
+      setError(error2);
+      throw error2;
+    } finally {
+      setUploading(false);
+    }
+  }, [client]);
+  const uploadMultiple = (0, import_react18.useCallback)(async (filesToUpload) => {
+    setUploading(true);
+    setUploadProgress(0);
+    setError(null);
+    try {
+      const results = [];
+      for (let i = 0; i < filesToUpload.length; i++) {
+        const media = await client.media.upload(filesToUpload[i]);
+        results.push(media);
+        setUploadProgress(Math.round((i + 1) / filesToUpload.length * 100));
+      }
+      setFiles((prev) => [...results, ...prev]);
+      return results;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to upload files");
+      setError(error2);
+      throw error2;
+    } finally {
+      setUploading(false);
+    }
+  }, [client]);
+  const deleteFile = (0, import_react18.useCallback)(async (mediaId) => {
+    await client.media.delete(mediaId);
+    setFiles((prev) => prev.filter((f) => f.id !== mediaId));
+  }, [client]);
+  return {
+    files,
+    meta,
+    loading,
+    error,
+    upload,
+    uploadMultiple,
+    deleteFile,
+    refresh: fetchMedia,
+    uploading,
+    uploadProgress
+  };
+}
+
+// src/hooks/useEntities.ts
+var import_react19 = require("react");
+function useEntities() {
+  const client = useClient();
+  const [entities, setEntities] = (0, import_react19.useState)([]);
+  const [loading, setLoading] = (0, import_react19.useState)(true);
+  const [error, setError] = (0, import_react19.useState)(null);
+  const fetchEntities = (0, import_react19.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.entities.list();
+      setEntities(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch entities"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  (0, import_react19.useEffect)(() => {
+    fetchEntities();
+  }, [fetchEntities]);
+  return {
+    entities,
+    loading,
+    error,
+    refresh: fetchEntities
+  };
+}
+function useEntity(slug) {
+  const client = useClient();
+  const [entity, setEntity] = (0, import_react19.useState)(null);
+  const [loading, setLoading] = (0, import_react19.useState)(true);
+  const [error, setError] = (0, import_react19.useState)(null);
+  const fetchEntity = (0, import_react19.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.entities.get(slug);
+      setEntity(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch entity"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  (0, import_react19.useEffect)(() => {
+    fetchEntity();
+  }, [fetchEntity]);
+  return {
+    entity,
+    loading,
+    error,
+    refresh: fetchEntity
+  };
+}
+function useEntityRecords(slug, params) {
+  const client = useClient();
+  const [records, setRecords] = (0, import_react19.useState)([]);
+  const [meta, setMeta] = (0, import_react19.useState)(null);
+  const [loading, setLoading] = (0, import_react19.useState)(true);
+  const [error, setError] = (0, import_react19.useState)(null);
+  const [currentParams, setCurrentParams] = (0, import_react19.useState)(params);
+  const fetchRecords = (0, import_react19.useCallback)(async (fetchParams, append = false) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await client.entities.listRecords(slug, fetchParams);
+      if (append) {
+        setRecords((prev) => [...prev, ...response.data]);
+      } else {
+        setRecords(response.data);
+      }
+      setMeta(response.meta);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch records"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug]);
+  (0, import_react19.useEffect)(() => {
+    fetchRecords(params);
+  }, []);
+  const hasMore = meta ? meta.current_page < meta.last_page : false;
+  const loadMore = (0, import_react19.useCallback)(async () => {
+    if (!hasMore || loading) return;
+    const nextPage = (meta?.current_page ?? 0) + 1;
+    await fetchRecords({ ...currentParams, page: nextPage }, true);
+  }, [hasMore, loading, meta, currentParams, fetchRecords]);
+  const createRecord = (0, import_react19.useCallback)(async (data) => {
+    const record = await client.entities.createRecord(slug, data);
+    setRecords((prev) => [record, ...prev]);
+    return record;
+  }, [client, slug]);
+  const updateRecord = (0, import_react19.useCallback)(async (id, data) => {
+    const record = await client.entities.updateRecord(slug, id, data);
+    setRecords((prev) => prev.map((r) => r.id === id ? record : r));
+    return record;
+  }, [client, slug]);
+  const deleteRecord = (0, import_react19.useCallback)(async (id) => {
+    await client.entities.deleteRecord(slug, id);
+    setRecords((prev) => prev.filter((r) => r.id !== id));
+  }, [client, slug]);
+  const refresh = (0, import_react19.useCallback)(async () => {
+    setCurrentParams(params);
+    await fetchRecords(params);
+  }, [params, fetchRecords]);
+  return {
+    records,
+    meta,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    createRecord,
+    updateRecord,
+    deleteRecord,
+    refresh
+  };
+}
+function useEntityRecord(slug, id) {
+  const client = useClient();
+  const [record, setRecord] = (0, import_react19.useState)(null);
+  const [loading, setLoading] = (0, import_react19.useState)(true);
+  const [error, setError] = (0, import_react19.useState)(null);
+  const fetchRecord = (0, import_react19.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await client.entities.getRecord(slug, id);
+      setRecord(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch record"));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, slug, id]);
+  (0, import_react19.useEffect)(() => {
+    fetchRecord();
+  }, [fetchRecord]);
+  const update = (0, import_react19.useCallback)(async (data) => {
+    const updated = await client.entities.updateRecord(slug, id, data);
+    setRecord(updated);
+    return updated;
+  }, [client, slug, id]);
+  return {
+    record,
+    loading,
+    error,
+    update,
+    refresh: fetchRecord
+  };
+}
+function useTypedEntity(slug) {
+  const client = useClient();
+  return (0, import_react19.useMemo)(() => ({
+    useRecords: (params) => {
+      const result = useEntityRecords(slug, params);
+      return {
+        ...result,
+        records: result.records
+      };
+    },
+    useRecord: (id) => {
+      const result = useEntityRecord(slug, id);
+      return {
+        ...result,
+        record: result.record
+      };
+    },
+    create: async (data) => {
+      const record = await client.entities.createRecord(slug, data);
+      return record;
+    },
+    update: async (id, data) => {
+      const record = await client.entities.updateRecord(slug, id, data);
+      return record;
+    },
+    delete: (id) => client.entities.deleteRecord(slug, id)
+  }), [client, slug]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DiffsomeContext,
+  DiffsomeProvider,
+  useAuth,
+  useAvailableSlots,
+  useBlog,
+  useBlogCategories,
+  useBlogPost,
+  useBlogSearch,
+  useBlogTags,
+  useBoard,
+  useBoardPost,
+  useBoardPosts,
+  useBoards,
+  useBundleItems,
+  useBundleProducts,
+  useCanReview,
+  useCart,
+  useCategories,
+  useClient,
+  useComments,
+  useCoupons,
+  useCreateBoardPost,
+  useCreateOrder,
+  useCreateReservation,
+  useCreateReview,
+  useCreateSubscription,
+  useDiffsome,
+  useDigitalProducts,
+  useDownloads,
+  useEntities,
+  useEntity,
+  useEntityRecord,
+  useEntityRecords,
+  useFeaturedBlog,
+  useFeaturedProducts,
+  useForm,
+  useMedia,
+  useMyReservations,
+  useMyReviews,
+  useOrder,
+  useOrderDownloads,
+  useOrders,
+  usePaymentStatus,
+  useProduct,
+  useProductReviews,
+  useProducts,
+  useProductsByType,
+  useReservationServices,
+  useReservationSettings,
+  useReservationStaffs,
+  useSocialAuth,
+  useStripePayment,
+  useSubscription,
+  useSubscriptionProducts,
+  useSubscriptions,
+  useTossPayment,
+  useTypedEntity,
+  useValidateCoupon,
+  useWishlist
+});