@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/inventory/api/warehouse.d.ts

@@ -0,0 +1,199 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+import { AuditCountLine, AuditReconcileResult, AuditSession, AuditVarianceReport, BulkCreateLocationPayload, CreateAuditPayload, CreateLocationPayload, CreateNodePayload, UpdateLocationPayload, UpdateNodePayload, WarehouseLayout, WarehouseLocation, WarehouseNode } from "../types/warehouse.js";
+import { Availability } from "./availability.js";
+
+//#region src/inventory/api/warehouse.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class NodeApi extends BaseApi<WarehouseNode, CreateNodePayload, UpdateNodePayload> {
+  constructor(config?: {});
+  list({
+    token,
+    options
+  }: {
+    token: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseNode[]>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseNode>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateNodePayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseNode>>;
+  update({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data: UpdateNodePayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseNode>>;
+}
+declare class LocationApi extends BaseApi<WarehouseLocation, CreateLocationPayload, UpdateLocationPayload> {
+  constructor(config?: {});
+  list({
+    token,
+    nodeId,
+    type,
+    parentLocationId,
+    status,
+    options
+  }: {
+    token: string;
+    nodeId: string;
+    type?: string;
+    parentLocationId?: string;
+    status?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseLocation[]>>;
+  getLayout({
+    token,
+    nodeId,
+    options
+  }: {
+    token: string;
+    nodeId: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseLayout>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseLocation>>;
+  getStock({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Availability>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateLocationPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseLocation>>;
+  bulkCreate({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: BulkCreateLocationPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<{
+    created: number;
+    locations: WarehouseLocation[];
+  }>>;
+  update({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data: UpdateLocationPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<WarehouseLocation>>;
+}
+declare class AuditApi extends BaseApi<AuditSession, CreateAuditPayload, Partial<CreateAuditPayload>> {
+  constructor(config?: {});
+  list({
+    token,
+    status,
+    options
+  }: {
+    token: string;
+    status?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AuditSession[]>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AuditSession>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateAuditPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AuditSession>>;
+  submitLines({
+    token,
+    id,
+    lines,
+    options
+  }: {
+    token: string;
+    id: string;
+    lines: AuditCountLine[];
+    options?: FetchOptions;
+  }): Promise<ApiResponse<unknown>>;
+  getVariance({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AuditVarianceReport>>;
+  reconcile({
+    token,
+    id,
+    autoApproveThreshold,
+    options
+  }: {
+    token: string;
+    id: string;
+    autoApproveThreshold?: number;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AuditReconcileResult>>;
+  postMoves({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<{
+    posted: boolean;
+  }>>;
+}
+declare const nodeApi: NodeApi;
+declare const locationApi: LocationApi;
+declare const auditApi: AuditApi;
+//#endregion
+export { AuditApi, LocationApi, NodeApi, auditApi, locationApi, nodeApi };

package/dist/inventory/api/warehouse.js

@@ -0,0 +1,155 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/warehouse.ts
+/**
+* Warehouse API — Node, Location, Audit
+*
+* REST clients for warehouse management endpoints.
+*/
+var NodeApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/nodes", config);
+	}
+	async list({ token, options = {} }) {
+		return handleApiRequest("GET", this.baseUrl, {
+			token,
+			...options
+		});
+	}
+	async getById({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			...options
+		});
+	}
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async update({ token, id, data, options = {} }) {
+		return handleApiRequest("PATCH", `${this.baseUrl}/${id}`, {
+			token,
+			body: data,
+			...options
+		});
+	}
+};
+var LocationApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/locations", config);
+	}
+	async list({ token, nodeId, type, parentLocationId, status, options = {} }) {
+		const params = new URLSearchParams({ nodeId });
+		if (type) params.set("type", type);
+		if (parentLocationId) params.set("parentLocationId", parentLocationId);
+		if (status) params.set("status", status);
+		return handleApiRequest("GET", `${this.baseUrl}?${params}`, {
+			token,
+			...options
+		});
+	}
+	async getLayout({ token, nodeId, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/layout?nodeId=${nodeId}`, {
+			token,
+			...options
+		});
+	}
+	async getById({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			...options
+		});
+	}
+	async getStock({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}/stock`, {
+			token,
+			...options
+		});
+	}
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async bulkCreate({ token, data, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/bulk`, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async update({ token, id, data, options = {} }) {
+		return handleApiRequest("PATCH", `${this.baseUrl}/${id}`, {
+			token,
+			body: data,
+			...options
+		});
+	}
+};
+var AuditApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/audits", config);
+	}
+	async list({ token, status, options = {} }) {
+		const params = status ? `?status=${status}` : "";
+		return handleApiRequest("GET", `${this.baseUrl}${params}`, {
+			token,
+			...options
+		});
+	}
+	async getById({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			...options
+		});
+	}
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async submitLines({ token, id, lines, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/lines`, {
+			token,
+			body: { lines },
+			...options
+		});
+	}
+	async getVariance({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}/variance`, {
+			token,
+			...options
+		});
+	}
+	async reconcile({ token, id, autoApproveThreshold, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: {
+				action: "reconcile",
+				autoApproveThreshold
+			},
+			...options
+		});
+	}
+	async postMoves({ token, id, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: { action: "post-moves" },
+			...options
+		});
+	}
+};
+const nodeApi = new NodeApi();
+const locationApi = new LocationApi();
+const auditApi = new AuditApi();
+
+//#endregion
+export { AuditApi, LocationApi, NodeApi, auditApi, locationApi, nodeApi };

package/dist/inventory/hooks/adjustment.d.ts

@@ -0,0 +1,24 @@
+import { AdjustStockResult, CreateAdjustmentPayload } from "../types/inventory.js";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/inventory/hooks/adjustment.d.ts
+/**
+ * Adjustment hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useAdjustments: List adjustments with filtering/pagination
+ * - useAdjustmentDetail: Get single adjustment
+ * - useAdjustmentActions: Create mutations
+ * - useAdjustmentNavigation: Navigation between adjustments
+ */
+declare const adjustmentHooks: _classytic_arc_next0.CrudHooksReturn<AdjustStockResult, CreateAdjustmentPayload, Partial<CreateAdjustmentPayload>>;
+declare const ADJUSTMENT_KEYS: _classytic_arc_next_query0.QueryKeys, useAdjustments: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<AdjustStockResult> | undefined): _classytic_arc_next_query0.ListQueryResult<AdjustStockResult>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<AdjustStockResult> | undefined): _classytic_arc_next_query0.ListQueryResult<AdjustStockResult>;
+  }, useAdjustmentDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<AdjustStockResult> | undefined): _classytic_arc_next_query0.DetailQueryResult<AdjustStockResult>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<AdjustStockResult> | undefined): _classytic_arc_next_query0.DetailQueryResult<AdjustStockResult>;
+  }, useAdjustmentActions: () => _classytic_arc_next0.CrudActions<AdjustStockResult, CreateAdjustmentPayload, Partial<CreateAdjustmentPayload>>, useAdjustmentNavigation: () => _classytic_arc_next0.NavigateFn<AdjustStockResult>;
+//#endregion
+export { ADJUSTMENT_KEYS, adjustmentHooks, useAdjustmentActions, useAdjustmentDetail, useAdjustmentNavigation, useAdjustments };

package/dist/inventory/hooks/adjustment.js

@@ -0,0 +1,30 @@
+"use client";
+
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { adjustmentApi } from "../api/adjustment.js";
+
+//#region src/inventory/hooks/adjustment.ts
+/**
+* Adjustment Hooks
+*
+* React hooks for stock adjustment operations using the factory pattern.
+*/
+/**
+* Adjustment hooks using createCrudHooks factory
+*
+* Provides:
+* - useAdjustments: List adjustments with filtering/pagination
+* - useAdjustmentDetail: Get single adjustment
+* - useAdjustmentActions: Create mutations
+* - useAdjustmentNavigation: Navigation between adjustments
+*/
+const adjustmentHooks = createCrudHooks({
+	api: adjustmentApi,
+	entityKey: "adjustments",
+	singular: "Adjustment",
+	plural: "Adjustments"
+});
+const { KEYS: ADJUSTMENT_KEYS, useList: useAdjustments, useDetail: useAdjustmentDetail, useActions: useAdjustmentActions, useNavigation: useAdjustmentNavigation } = adjustmentHooks;
+
+//#endregion
+export { ADJUSTMENT_KEYS, adjustmentHooks, useAdjustmentActions, useAdjustmentDetail, useAdjustmentNavigation, useAdjustments };

package/dist/inventory/hooks/availability.d.ts

@@ -0,0 +1,16 @@
+import { Availability } from "../api/availability.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/inventory/hooks/availability.d.ts
+declare const AVAILABILITY_KEYS: {
+  all: readonly ["availability"];
+  get: (skuRef?: string, branchId?: string) => readonly ["availability", string | undefined, string | undefined];
+};
+/**
+ * Get stock availability for a SKU at a branch
+ */
+declare function useAvailability(token: string, skuRef?: string, branchId?: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<Availability, Error>;
+//#endregion
+export { AVAILABILITY_KEYS, useAvailability };

package/dist/inventory/hooks/availability.js

@@ -0,0 +1,35 @@
+"use client";
+
+import { availabilityApi } from "../api/availability.js";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/availability.ts
+/**
+* Availability Hooks — Flow-native stock availability queries
+*/
+const AVAILABILITY_KEYS = {
+	all: ["availability"],
+	get: (skuRef, branchId) => [
+		...AVAILABILITY_KEYS.all,
+		skuRef,
+		branchId
+	]
+};
+/**
+* Get stock availability for a SKU at a branch
+*/
+function useAvailability(token, skuRef, branchId, options = {}) {
+	return useQuery({
+		queryKey: AVAILABILITY_KEYS.get(skuRef, branchId),
+		queryFn: () => availabilityApi.get({
+			token,
+			skuRef,
+			branchId
+		}),
+		enabled: options.enabled !== false && !!token && !!skuRef,
+		select: (res) => res.data
+	});
+}
+
+//#endregion
+export { AVAILABILITY_KEYS, useAvailability };

package/dist/inventory/hooks/cost.d.ts

@@ -0,0 +1,21 @@
+import { CostLayer, Valuation } from "../api/cost.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/inventory/hooks/cost.d.ts
+declare const COST_KEYS: {
+  all: readonly ["cost"];
+  valuation: (skuRef?: string, nodeId?: string) => readonly ["cost", "valuation", string | undefined, string | undefined];
+  layers: (skuRef: string, locationId?: string) => readonly ["cost", "layers", string, string | undefined];
+};
+declare function useValuation(token: string, params?: {
+  skuRef?: string;
+  locationId?: string;
+  nodeId?: string;
+}, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<Valuation, Error>;
+declare function useCostLayers(token: string, skuRef: string, locationId?: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<CostLayer[], Error>;
+//#endregion
+export { COST_KEYS, useCostLayers, useValuation };

package/dist/inventory/hooks/cost.js

@@ -0,0 +1,50 @@
+"use client";
+
+import { costApi } from "../api/cost.js";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/cost.ts
+/**
+* Cost Layers & Valuation Hooks (Standard+)
+*/
+const COST_KEYS = {
+	all: ["cost"],
+	valuation: (skuRef, nodeId) => [
+		...COST_KEYS.all,
+		"valuation",
+		skuRef,
+		nodeId
+	],
+	layers: (skuRef, locationId) => [
+		...COST_KEYS.all,
+		"layers",
+		skuRef,
+		locationId
+	]
+};
+function useValuation(token, params = {}, options = {}) {
+	return useQuery({
+		queryKey: COST_KEYS.valuation(params.skuRef, params.nodeId),
+		queryFn: () => costApi.getValuation({
+			token,
+			...params
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useCostLayers(token, skuRef, locationId, options = {}) {
+	return useQuery({
+		queryKey: COST_KEYS.layers(skuRef, locationId),
+		queryFn: () => costApi.getLayers({
+			token,
+			skuRef,
+			locationId
+		}),
+		enabled: options.enabled !== false && !!token && !!skuRef,
+		select: (res) => res.data
+	});
+}
+
+//#endregion
+export { COST_KEYS, useCostLayers, useValuation };

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

@@ -0,0 +1,18 @@
+import { AVAILABILITY_KEYS, useAvailability } from "./availability.js";
+import { RESERVATION_KEYS, useReservationActions } from "./reservation.js";
+import { SCAN_KEYS, useScanResolve } from "./scan.js";
+import { INVENTORY_KEYS, InventoryFilters, InventoryPagination, InventorySummary, UseInventoryReturn, UseStockActionsReturn, getStockStatus, getStockStatusBadge, useInventory, useInventoryLookup, useStockActions } from "./inventory.js";
+import { PURCHASE_KEYS, UsePurchaseStateActionsReturn, purchaseHooks, usePurchaseActions, usePurchaseDetail, usePurchaseNavigation, usePurchaseStateActions, usePurchases } from "./purchase.js";
+import { TRANSFER_KEYS, TRANSFER_STATS_KEYS, UseTransferStateActionsReturn, transferHooks, useTransferActions, useTransferDetail, useTransferNavigation, useTransferStateActions, useTransferStats, useTransfers } from "./transfer.js";
+import { ADJUSTMENT_KEYS, adjustmentHooks, useAdjustmentActions, useAdjustmentDetail, useAdjustmentNavigation, useAdjustments } from "./adjustment.js";
+import { MOVEMENT_KEYS, UseMovementsReturn, getStockChangeInvalidationKeys, useLowStock, useMovements } from "./movement.js";
+import { REQUEST_KEYS, UseStockRequestActionsReturn, UseStockRequestsReturn, getTransferStateInvalidationKeys, usePendingStockRequests, useStockRequestActions, useStockRequestDetail, useStockRequests } from "./request.js";
+import { SUPPLIER_KEYS, supplierHooks, useSupplierActions, useSupplierDetail, useSupplierNavigation, useSuppliers } from "./supplier.js";
+import { AUDIT_KEYS, LOCATION_KEYS, NODE_KEYS, useAuditActions, useAuditDetail, useAuditVariance, useAudits, useLocationActions, useLocationDetail, useLocationStock, useLocations, useWarehouseActions, useWarehouseDetail, useWarehouseLayout, useWarehouses } from "./warehouse.js";
+import { LOT_KEYS, useLotActions, useLotDetail, useLots } from "./lot.js";
+import { PACKAGE_KEYS, usePackageActions, usePackageContents, usePackages } from "./package.js";
+import { PROCUREMENT_KEYS, useProcurementActions, useProcurementDetail, useProcurementOrders } from "./procurement.js";
+import { REPLENISHMENT_KEYS, useReplenishmentActions, useReplenishmentRuleDetail, useReplenishmentRules } from "./replenishment.js";
+import { COST_KEYS, useCostLayers, useValuation } from "./cost.js";
+import { TRACE_KEYS, useLotTrace, useRecallAnalysis, useSerialTrace } from "./trace.js";
+import { REPORT_KEYS, useAvailabilityMatrix, useStockAging, useStockHealth, useStockTurnover } from "./report.js";

package/dist/inventory/hooks/inventory.d.ts

@@ -0,0 +1,130 @@
+import { PosLookupResponse, PosProduct, PosProductsResponse } from "../../sales/types/pos.js";
+import { BulkAdjustmentPayload, CreateAdjustmentPayload } from "../types/inventory.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/inventory/hooks/inventory.d.ts
+declare const INVENTORY_KEYS: {
+  all: readonly ["inventory"];
+  products: (branchId?: string) => readonly ["inventory", "products", string | undefined];
+  productsList: (branchId?: string, params?: Record<string, unknown>) => readonly ["inventory", "products", string | undefined, Record<string, unknown> | undefined];
+  lookup: (code: string, branchId?: string) => readonly ["inventory", "lookup", string, string | undefined];
+};
+interface InventoryFilters {
+  category?: string;
+  parentCategory?: string;
+  search?: string;
+  inStockOnly?: boolean;
+  lowStockOnly?: boolean;
+  outOfStockOnly?: boolean;
+  page?: number;
+  limit?: number;
+  sort?: string;
+  [key: string]: unknown;
+}
+interface InventorySummary {
+  totalItems: number;
+  totalQuantity: number;
+  lowStockCount: number;
+  outOfStockCount: number;
+}
+interface InventoryPagination {
+  page: number;
+  limit: number;
+  total: number;
+  pages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}
+interface UseInventoryReturn {
+  items: PosProduct[];
+  summary: InventorySummary;
+  branch: PosProductsResponse["branch"];
+  pagination: InventoryPagination;
+  isLoading: boolean;
+  isFetching: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+interface UseStockActionsReturn {
+  adjust: (data: CreateAdjustmentPayload) => Promise<unknown>;
+  isAdjusting: boolean;
+  setStock: (params: {
+    productId: string;
+    quantity: number;
+    branchId?: string;
+    variantSku?: string;
+    notes?: string;
+  }) => Promise<unknown>;
+  isSettingStock: boolean;
+  bulkAdjust: (data: BulkAdjustmentPayload) => Promise<unknown>;
+  isBulkAdjusting: boolean;
+  isLoading: boolean;
+}
+interface QueryOptions {
+  enabled?: boolean;
+}
+declare function useInventory(token: string, branchId: string | undefined, filters?: InventoryFilters, options?: QueryOptions): UseInventoryReturn;
+/**
+ * Hook for barcode/SKU lookup
+ *
+ * @param token - Auth token
+ * @param code - Barcode or SKU to lookup
+ * @param branchId - Branch for stock info
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function BarcodeScanner({ branchId }) {
+ *   const [code, setCode] = useState('');
+ *   const { data, isFetching } = useInventoryLookup(token, code, branchId, {
+ *     enabled: code.length >= 2,
+ *   });
+ *
+ *   return <Input value={code} onChange={e => setCode(e.target.value)} />;
+ * }
+ * ```
+ */
+declare function useInventoryLookup(token: string, code: string, branchId?: string, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<PosLookupResponse, Error>;
+/**
+ * Hook for stock adjustment actions
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function StockAdjuster({ product, branchId }) {
+ *   const { adjust, isAdjusting } = useStockActions(token);
+ *
+ *   const handleAdjust = async (quantity: number) => {
+ *     await adjust({
+ *       productId: product._id,
+ *       quantity,
+ *       mode: 'set',
+ *       branchId,
+ *     });
+ *   };
+ *
+ *   return <Button onClick={() => handleAdjust(10)} disabled={isAdjusting}>Set Stock</Button>;
+ * }
+ * ```
+ */
+declare function useStockActions(token: string): UseStockActionsReturn;
+/**
+ * Helper to determine stock status
+ */
+declare function getStockStatus(quantity: number, lowThreshold?: number): "out" | "low" | "ok";
+/**
+ * Helper to format stock status badge props
+ */
+declare function getStockStatusBadge(status: "out" | "low" | "ok"): {
+  variant: "destructive";
+  label: string;
+} | {
+  variant: "warning";
+  label: string;
+} | {
+  variant: "success";
+  label: string;
+};
+//#endregion
+export { INVENTORY_KEYS, InventoryFilters, InventoryPagination, InventorySummary, UseInventoryReturn, UseStockActionsReturn, getStockStatus, getStockStatusBadge, useInventory, useInventoryLookup, useStockActions };