@classytic/commerce-sdk 0.1.2 → 0.2.1

package/dist/catalog/hooks/category.d.ts

@@ -0,0 +1,201 @@
+import { ApiResponse } from "../../core/api-factory.js";
+import { Category, CategoryTreeNode, CategoryTreeResponse, CreateCategoryPayload, UpdateCategoryPayload } from "../types/category.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { UseQueryOptions } from "@tanstack/react-query";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/catalog/hooks/category.d.ts
+interface FlattenedNode extends CategoryTreeNode {
+  depth: number;
+  displayName: string;
+}
+interface SelectOption {
+  value: string;
+  label: string;
+}
+/**
+ * Category CRUD hooks
+ */
+declare const categoryHooks: _classytic_arc_next0.CrudHooksReturn<Category, CreateCategoryPayload, UpdateCategoryPayload>;
+declare const CATEGORY_KEYS: _classytic_arc_next_query0.QueryKeys, useCategories: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Category> | undefined): _classytic_arc_next_query0.ListQueryResult<Category>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Category> | undefined): _classytic_arc_next_query0.ListQueryResult<Category>;
+  }, useCategoryDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Category> | undefined): _classytic_arc_next_query0.DetailQueryResult<Category>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Category> | undefined): _classytic_arc_next_query0.DetailQueryResult<Category>;
+  }, useCategoryActions: () => _classytic_arc_next0.CrudActions<Category, CreateCategoryPayload, UpdateCategoryPayload>, useCategoryNavigation: () => _classytic_arc_next0.NavigateFn<Category>;
+/**
+ * Hook to get category tree (nested structure)
+ * FE should cache this and derive everything else from it
+ *
+ * @param token - Auth token (optional for public access)
+ * @param options - React Query options
+ * @returns Query result with tree data
+ *
+ * @example
+ * ```tsx
+ * function CategoryNav() {
+ *   const { data, isLoading } = useCategoryTree(token);
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <nav>
+ *       {data?.data?.map(category => (
+ *         <CategoryItem key={category.slug} category={category} />
+ *       ))}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ */
+declare function useCategoryTree(token?: string | null, options?: Omit<UseQueryOptions<CategoryTreeResponse>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<CategoryTreeResponse, Error>;
+/**
+ * Hook to get category by slug
+ *
+ * @param token - Auth token (optional for public access)
+ * @param slug - Category slug
+ * @param options - React Query options
+ * @returns Query result with category data
+ *
+ * @example
+ * ```tsx
+ * function CategoryPage({ slug }) {
+ *   const { data, isLoading } = useCategoryBySlug(token, slug);
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return <h1>{data?.data?.name}</h1>;
+ * }
+ * ```
+ */
+declare function useCategoryBySlug(token: string | null | undefined, slug: string, options?: Omit<UseQueryOptions<ApiResponse<Category>>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<ApiResponse<Category>, Error>;
+/**
+ * Hook to sync product counts for all categories
+ * POST /categories/sync-product-count
+ *
+ * Use when manual data fixes or migrations may have desynced counts.
+ *
+ * @param token - Auth token (admin or inventory staff required)
+ * @returns Mutation result with sync function
+ *
+ * @example
+ * ```tsx
+ * function AdminPanel() {
+ *   const { mutate: sync, isPending } = useCategorySyncProductCount(token);
+ *
+ *   return (
+ *     <Button onClick={() => sync()} disabled={isPending}>
+ *       Sync Product Counts
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCategorySyncProductCount(token: string): _tanstack_react_query0.UseMutationResult<ApiResponse<{
+  updated: number;
+}>, Error, void, unknown>;
+/**
+ * Flatten category tree with depth indicator
+ * Useful for building hierarchical selects
+ *
+ * @param nodes - Category tree nodes
+ * @param depth - Current depth (used recursively)
+ * @param result - Accumulator array (used recursively)
+ * @returns Flattened array with depth and displayName
+ *
+ * @example
+ * ```typescript
+ * const { data } = useCategoryTree(token);
+ * const flat = flattenCategoryTree(data?.data);
+ * // flat = [
+ * //   { slug: 'clothing', displayName: 'Clothing', depth: 0, ... },
+ * //   { slug: 't-shirts', displayName: '  T-Shirts', depth: 1, ... },
+ * // ]
+ * ```
+ */
+declare function flattenCategoryTree(nodes: CategoryTreeNode[] | undefined, depth?: number, result?: FlattenedNode[]): FlattenedNode[];
+/**
+ * Build parent category options for select (root categories only)
+ *
+ * @param tree - Category tree from useCategoryTree
+ * @returns Options array with value/label for select inputs
+ *
+ * @example
+ * ```tsx
+ * function ParentSelect() {
+ *   const { data } = useCategoryTree(token);
+ *   const options = getParentCategoryOptions(data?.data);
+ *
+ *   return (
+ *     <Select>
+ *       {options.map(opt => (
+ *         <SelectItem key={opt.value} value={opt.value}>
+ *           {opt.label}
+ *         </SelectItem>
+ *       ))}
+ *     </Select>
+ *   );
+ * }
+ * ```
+ */
+declare function getParentCategoryOptions(tree: CategoryTreeNode[] | undefined): SelectOption[];
+/**
+ * Build all category options for select (flattened with hierarchy)
+ *
+ * @param tree - Category tree from useCategoryTree
+ * @returns Options array with value/label showing hierarchy
+ *
+ * @example
+ * ```tsx
+ * function CategorySelect() {
+ *   const { data } = useCategoryTree(token);
+ *   const options = getAllCategoryOptions(data?.data);
+ *
+ *   return (
+ *     <Select>
+ *       {options.map(opt => (
+ *         <SelectItem key={opt.value} value={opt.value}>
+ *           {opt.label}
+ *         </SelectItem>
+ *       ))}
+ *     </Select>
+ *   );
+ * }
+ * ```
+ */
+declare function getAllCategoryOptions(tree: CategoryTreeNode[] | undefined): SelectOption[];
+/**
+ * Find a category in the tree by slug
+ *
+ * @param tree - Category tree nodes
+ * @param slug - Category slug to find
+ * @returns Category node or undefined
+ */
+declare function findCategoryBySlug(tree: CategoryTreeNode[] | undefined, slug: string): CategoryTreeNode | undefined;
+/**
+ * Get breadcrumb path for a category
+ *
+ * @param tree - Category tree nodes
+ * @param slug - Category slug
+ * @returns Array of categories from root to target
+ */
+declare function getCategoryBreadcrumb(tree: CategoryTreeNode[] | undefined, slug: string): CategoryTreeNode[];
+/**
+ * Get all children slugs for a category (recursive)
+ *
+ * @param tree - Category tree nodes
+ * @param parentSlug - Parent category slug
+ * @returns Array of child category slugs
+ */
+declare function getChildCategorySlugs(tree: CategoryTreeNode[] | undefined, parentSlug: string): string[];
+/**
+ * Get root categories only
+ *
+ * @param tree - Category tree nodes
+ * @returns Array of root category nodes
+ */
+declare function getRootCategories(tree: CategoryTreeNode[] | undefined): CategoryTreeNode[];
+//#endregion
+export { CATEGORY_KEYS, categoryHooks, findCategoryBySlug, flattenCategoryTree, getAllCategoryOptions, getCategoryBreadcrumb, getChildCategorySlugs, getParentCategoryOptions, getRootCategories, useCategories, useCategoryActions, useCategoryBySlug, useCategoryDetail, useCategoryNavigation, useCategorySyncProductCount, useCategoryTree };

package/dist/catalog/hooks/category.js

@@ -0,0 +1,295 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { categoryApi } from "../api/category.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/catalog/hooks/category.ts
+/**
+* Category Hooks
+*
+* Pre-built hooks for category CRUD operations with:
+* - Category tree support
+* - Optimistic updates
+* - Smart caching
+* - Type safety
+*/
+/**
+* Category CRUD hooks
+*/
+const categoryHooks = createCrudHooks({
+	api: categoryApi,
+	entityKey: "categories",
+	singular: "Category",
+	plural: "Categories",
+	defaults: { staleTime: 600 * 1e3 }
+});
+const { KEYS: CATEGORY_KEYS, useList: useCategories, useDetail: useCategoryDetail, useActions: useCategoryActions, useNavigation: useCategoryNavigation } = categoryHooks;
+/**
+* Hook to get category tree (nested structure)
+* FE should cache this and derive everything else from it
+*
+* @param token - Auth token (optional for public access)
+* @param options - React Query options
+* @returns Query result with tree data
+*
+* @example
+* ```tsx
+* function CategoryNav() {
+*   const { data, isLoading } = useCategoryTree(token);
+*
+*   if (isLoading) return <Spinner />;
+*
+*   return (
+*     <nav>
+*       {data?.data?.map(category => (
+*         <CategoryItem key={category.slug} category={category} />
+*       ))}
+*     </nav>
+*   );
+* }
+* ```
+*/
+function useCategoryTree(token, options = {}) {
+	return useQuery({
+		queryKey: [...CATEGORY_KEYS.all, "tree"],
+		queryFn: () => categoryApi.getTree({ token }),
+		staleTime: 1800 * 1e3,
+		gcTime: 3600 * 1e3,
+		...options
+	});
+}
+/**
+* Hook to get category by slug
+*
+* @param token - Auth token (optional for public access)
+* @param slug - Category slug
+* @param options - React Query options
+* @returns Query result with category data
+*
+* @example
+* ```tsx
+* function CategoryPage({ slug }) {
+*   const { data, isLoading } = useCategoryBySlug(token, slug);
+*
+*   if (isLoading) return <Spinner />;
+*
+*   return <h1>{data?.data?.name}</h1>;
+* }
+* ```
+*/
+function useCategoryBySlug(token, slug, options = {}) {
+	return useQuery({
+		queryKey: [
+			...CATEGORY_KEYS.all,
+			"slug",
+			slug
+		],
+		queryFn: () => categoryApi.getBySlug({
+			token,
+			slug
+		}),
+		enabled: !!slug,
+		staleTime: 1800 * 1e3,
+		...options
+	});
+}
+/**
+* Hook to sync product counts for all categories
+* POST /categories/sync-product-count
+*
+* Use when manual data fixes or migrations may have desynced counts.
+*
+* @param token - Auth token (admin or inventory staff required)
+* @returns Mutation result with sync function
+*
+* @example
+* ```tsx
+* function AdminPanel() {
+*   const { mutate: sync, isPending } = useCategorySyncProductCount(token);
+*
+*   return (
+*     <Button onClick={() => sync()} disabled={isPending}>
+*       Sync Product Counts
+*     </Button>
+*   );
+* }
+* ```
+*/
+function useCategorySyncProductCount(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	return useMutation({
+		mutationFn: () => categoryApi.syncProductCount({ token }),
+		onSuccess: (result) => {
+			const count = result?.data?.updated ?? 0;
+			toast.success(`Synced product counts for ${count} categories`);
+			queryClient.invalidateQueries({ queryKey: CATEGORY_KEYS.all });
+		},
+		onError: (error) => {
+			toast.error(error.message || "Failed to sync product counts");
+		}
+	});
+}
+/**
+* Flatten category tree with depth indicator
+* Useful for building hierarchical selects
+*
+* @param nodes - Category tree nodes
+* @param depth - Current depth (used recursively)
+* @param result - Accumulator array (used recursively)
+* @returns Flattened array with depth and displayName
+*
+* @example
+* ```typescript
+* const { data } = useCategoryTree(token);
+* const flat = flattenCategoryTree(data?.data);
+* // flat = [
+* //   { slug: 'clothing', displayName: 'Clothing', depth: 0, ... },
+* //   { slug: 't-shirts', displayName: '  T-Shirts', depth: 1, ... },
+* // ]
+* ```
+*/
+function flattenCategoryTree(nodes, depth = 0, result = []) {
+	for (const node of nodes || []) {
+		result.push({
+			...node,
+			depth,
+			displayName: "\xA0\xA0".repeat(depth) + node.name
+		});
+		if (node.children?.length) flattenCategoryTree(node.children, depth + 1, result);
+	}
+	return result;
+}
+/**
+* Build parent category options for select (root categories only)
+*
+* @param tree - Category tree from useCategoryTree
+* @returns Options array with value/label for select inputs
+*
+* @example
+* ```tsx
+* function ParentSelect() {
+*   const { data } = useCategoryTree(token);
+*   const options = getParentCategoryOptions(data?.data);
+*
+*   return (
+*     <Select>
+*       {options.map(opt => (
+*         <SelectItem key={opt.value} value={opt.value}>
+*           {opt.label}
+*         </SelectItem>
+*       ))}
+*     </Select>
+*   );
+* }
+* ```
+*/
+function getParentCategoryOptions(tree) {
+	return (tree || []).map((node) => ({
+		value: node.slug,
+		label: node.name
+	}));
+}
+/**
+* Build all category options for select (flattened with hierarchy)
+*
+* @param tree - Category tree from useCategoryTree
+* @returns Options array with value/label showing hierarchy
+*
+* @example
+* ```tsx
+* function CategorySelect() {
+*   const { data } = useCategoryTree(token);
+*   const options = getAllCategoryOptions(data?.data);
+*
+*   return (
+*     <Select>
+*       {options.map(opt => (
+*         <SelectItem key={opt.value} value={opt.value}>
+*           {opt.label}
+*         </SelectItem>
+*       ))}
+*     </Select>
+*   );
+* }
+* ```
+*/
+function getAllCategoryOptions(tree) {
+	return flattenCategoryTree(tree).map((node) => ({
+		value: node.slug,
+		label: node.displayName
+	}));
+}
+/**
+* Find a category in the tree by slug
+*
+* @param tree - Category tree nodes
+* @param slug - Category slug to find
+* @returns Category node or undefined
+*/
+function findCategoryBySlug(tree, slug) {
+	if (!tree || !slug) return void 0;
+	for (const node of tree) {
+		if (node.slug === slug) return node;
+		if (node.children?.length) {
+			const found = findCategoryBySlug(node.children, slug);
+			if (found) return found;
+		}
+	}
+}
+/**
+* Get breadcrumb path for a category
+*
+* @param tree - Category tree nodes
+* @param slug - Category slug
+* @returns Array of categories from root to target
+*/
+function getCategoryBreadcrumb(tree, slug) {
+	if (!tree || !slug) return [];
+	function findPath(nodes, target, path = []) {
+		for (const node of nodes) {
+			const currentPath = [...path, node];
+			if (node.slug === target) return currentPath;
+			if (node.children?.length) {
+				const found = findPath(node.children, target, currentPath);
+				if (found) return found;
+			}
+		}
+		return null;
+	}
+	return findPath(tree, slug) || [];
+}
+/**
+* Get all children slugs for a category (recursive)
+*
+* @param tree - Category tree nodes
+* @param parentSlug - Parent category slug
+* @returns Array of child category slugs
+*/
+function getChildCategorySlugs(tree, parentSlug) {
+	const parent = findCategoryBySlug(tree, parentSlug);
+	if (!parent?.children?.length) return [];
+	const slugs = [];
+	function collectSlugs(nodes) {
+		for (const node of nodes) {
+			slugs.push(node.slug);
+			if (node.children?.length) collectSlugs(node.children);
+		}
+	}
+	collectSlugs(parent.children);
+	return slugs;
+}
+/**
+* Get root categories only
+*
+* @param tree - Category tree nodes
+* @returns Array of root category nodes
+*/
+function getRootCategories(tree) {
+	return tree || [];
+}
+
+//#endregion
+export { CATEGORY_KEYS, categoryHooks, findCategoryBySlug, flattenCategoryTree, getAllCategoryOptions, getCategoryBreadcrumb, getChildCategorySlugs, getParentCategoryOptions, getRootCategories, useCategories, useCategoryActions, useCategoryBySlug, useCategoryDetail, useCategoryNavigation, useCategorySyncProductCount, useCategoryTree };

package/dist/catalog/hooks/index.d.ts

@@ -0,0 +1,4 @@
+import { PRODUCT_KEYS, UseProductRecommendationsReturn, productHooks, useDeletedProducts, useHardDeleteProduct, useProductActions, useProductBySlug, useProductDetail, useProductNavigation, useProductRecommendations, useProducts, useRestoreProduct, useSyncProductStock } from "./product.js";
+import { CATEGORY_KEYS, categoryHooks, findCategoryBySlug, flattenCategoryTree, getAllCategoryOptions, getCategoryBreadcrumb, getChildCategorySlugs, getParentCategoryOptions, getRootCategories, useCategories, useCategoryActions, useCategoryBySlug, useCategoryDetail, useCategoryNavigation, useCategorySyncProductCount, useCategoryTree } from "./category.js";
+import { SIZE_GUIDE_KEYS, findSizeGuideById, findSizeGuideBySlug, formatMeasurement, getSizeGuideOptions, getSizeTableHeaders, getSizeTableRows, sizeGuideHooks, useSizeGuideActions, useSizeGuideBySlug, useSizeGuideDetail, useSizeGuideNavigation, useSizeGuides } from "./size-guide.js";
+import { REVIEW_KEYS, reviewHooks, useMyReview, useReviewActions, useReviewDetail, useReviewNavigation, useReviews } from "./review.js";

package/dist/catalog/hooks/product.d.ts

@@ -0,0 +1,165 @@
+import { ApiResponse, PaginatedResponse } from "../../core/api-factory.js";
+import { CreateProductPayload, Product, ProductSyncStockResponse, UpdateProductPayload } from "../types/product.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { UseQueryOptions } from "@tanstack/react-query";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/catalog/hooks/product.d.ts
+/**
+ * Product CRUD hooks with optimistic updates
+ */
+declare const productHooks: _classytic_arc_next0.CrudHooksReturn<Product, CreateProductPayload, UpdateProductPayload>;
+declare const PRODUCT_KEYS: _classytic_arc_next_query0.QueryKeys, useProducts: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Product> | undefined): _classytic_arc_next_query0.ListQueryResult<Product>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Product> | undefined): _classytic_arc_next_query0.ListQueryResult<Product>;
+  }, useProductDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Product> | undefined): _classytic_arc_next_query0.DetailQueryResult<Product>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Product> | undefined): _classytic_arc_next_query0.DetailQueryResult<Product>;
+  }, useProductActions: () => _classytic_arc_next0.CrudActions<Product, CreateProductPayload, UpdateProductPayload>, useProductNavigation: () => _classytic_arc_next0.NavigateFn<Product>;
+/**
+ * Hook to get product by slug
+ *
+ * @param token - Auth token (optional for public access)
+ * @param slug - Product slug
+ * @param options - React Query options
+ * @returns Query result with product data
+ *
+ * @example
+ * ```tsx
+ * function ProductPage({ slug }) {
+ *   const { data, isLoading } = useProductBySlug(null, slug);
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return <h1>{data?.data?.name}</h1>;
+ * }
+ * ```
+ */
+declare function useProductBySlug(token: string | null | undefined, slug: string, options?: Omit<UseQueryOptions<ApiResponse<Product>>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<ApiResponse<Product>, Error>;
+interface UseProductRecommendationsReturn {
+  recommendations: Product[];
+  isLoading: boolean;
+  error: Error | null;
+}
+/**
+ * Hook to get product recommendations
+ *
+ * @param productId - Product ID to get recommendations for
+ * @param options - React Query options
+ * @returns Object with recommendations array, isLoading, and error
+ *
+ * @example
+ * ```tsx
+ * function ProductRecommendations({ productId }) {
+ *   const { recommendations, isLoading } = useProductRecommendations(productId);
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <div>
+ *       {recommendations.map(product => (
+ *         <ProductCard key={product._id} product={product} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useProductRecommendations(productId: string, options?: Omit<UseQueryOptions<ApiResponse<Product[]>>, "queryKey" | "queryFn">): UseProductRecommendationsReturn;
+/**
+ * Hook to get soft-deleted products (Recycle Bin)
+ *
+ * @param token - Auth token (required, admin only)
+ * @param params - Query parameters for pagination/filtering
+ * @param options - React Query options
+ * @returns Query result with deleted products
+ *
+ * @example
+ * ```tsx
+ * function RecycleBin() {
+ *   const { data, isLoading } = useDeletedProducts(token, { page: 1, limit: 20 });
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <div>
+ *       {data?.docs?.map(product => (
+ *         <DeletedProductRow key={product._id} product={product} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useDeletedProducts(token: string, params?: Record<string, unknown>, options?: Omit<UseQueryOptions<PaginatedResponse<Product>>, "queryKey" | "queryFn">): _tanstack_react_query0.UseQueryResult<PaginatedResponse<Product>, Error>;
+/**
+ * Hook to restore a soft-deleted product
+ *
+ * @param token - Auth token (required, admin only)
+ * @returns Mutation result with restore function
+ *
+ * @example
+ * ```tsx
+ * function RestoreButton({ productId }) {
+ *   const { mutate: restore, isPending } = useRestoreProduct(token);
+ *
+ *   return (
+ *     <Button onClick={() => restore(productId)} disabled={isPending}>
+ *       Restore Product
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useRestoreProduct(token: string): _tanstack_react_query0.UseMutationResult<ApiResponse<Product>, Error, string, unknown>;
+/**
+ * Hook to permanently delete a product (Hard delete)
+ *
+ * @param token - Auth token (required, admin only)
+ * @returns Mutation result with hard delete function
+ *
+ * @example
+ * ```tsx
+ * function PermanentDeleteButton({ productId }) {
+ *   const { mutate: hardDelete, isPending } = useHardDeleteProduct(token);
+ *
+ *   return (
+ *     <Button
+ *       variant="destructive"
+ *       onClick={() => hardDelete(productId)}
+ *       disabled={isPending}
+ *     >
+ *       Permanently Delete
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useHardDeleteProduct(token: string): _tanstack_react_query0.UseMutationResult<ApiResponse<{
+  deleted: boolean;
+}>, Error, string, unknown>;
+/**
+ * Hook to sync product stock quantity
+ *
+ * Recomputes product.quantity by summing all StockEntry quantities across branches.
+ *
+ * @param token - Auth token (requires: admin, warehouse-admin, warehouse-staff, or store-manager role)
+ * @returns Mutation result with sync function
+ *
+ * @example
+ * ```tsx
+ * function SyncStockButton({ productId }) {
+ *   const { mutate: syncStock, isPending } = useSyncProductStock(token);
+ *
+ *   return (
+ *     <Button onClick={() => syncStock(productId)} disabled={isPending}>
+ *       Sync Stock
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useSyncProductStock(token: string): _tanstack_react_query0.UseMutationResult<ProductSyncStockResponse, Error, string, unknown>;
+//#endregion
+export { PRODUCT_KEYS, UseProductRecommendationsReturn, productHooks, useDeletedProducts, useHardDeleteProduct, useProductActions, useProductBySlug, useProductDetail, useProductNavigation, useProductRecommendations, useProducts, useRestoreProduct, useSyncProductStock };