@classytic/commerce-sdk 0.1.1 → 0.2.1

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

@@ -0,0 +1,123 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+import { AdjustStockPayload, AdjustStockResult, CreateAdjustmentPayload } from "../types/inventory.js";
+//#region src/inventory/api/adjustment.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class AdjustmentApi extends BaseApi<AdjustStockResult, CreateAdjustmentPayload> {
+  constructor(config?: {});
+  /**
+   * Create a manual stock adjustment
+   * POST /inventory/adjustments
+   *
+   * @example Single item adjustment
+   * adjustmentApi.create({
+   *   token,
+   *   data: {
+   *     productId: '...',
+   *     variantSku: 'SKU-RED-M',
+   *     quantity: 5,
+   *     mode: 'remove',
+   *     reason: 'damaged',
+   *     lostAmount: 2500 // Creates expense transaction (opt-in)
+   *   }
+   * })
+   *
+   * @example Bulk adjustment
+   * adjustmentApi.create({
+   *   token,
+   *   data: {
+   *     adjustments: [
+   *       { productId: '...', quantity: 5, mode: 'add' },
+   *       { productId: '...', quantity: 3, mode: 'remove' }
+   *     ],
+   *     reason: 'inventory recount'
+   *   }
+   * })
+   */
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateAdjustmentPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AdjustStockResult>>;
+  /**
+   * Adjust stock (single item, POS format)
+   * POST /inventory/adjustments
+   */
+  adjustStock({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: AdjustStockPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AdjustStockResult>>;
+  /**
+   * Add stock to a product
+   */
+  addStock({
+    token,
+    productId,
+    variantSku,
+    quantity,
+    branchId,
+    reason,
+    options
+  }: {
+    token: string;
+    productId: string;
+    variantSku?: string;
+    quantity: number;
+    branchId?: string;
+    reason?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AdjustStockResult>>;
+  /**
+   * Remove stock from a product
+   */
+  removeStock({
+    token,
+    productId,
+    variantSku,
+    quantity,
+    branchId,
+    reason,
+    lostAmount,
+    options
+  }: {
+    token: string;
+    productId: string;
+    variantSku?: string;
+    quantity: number;
+    branchId?: string;
+    reason?: string;
+    lostAmount?: number;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AdjustStockResult>>;
+  /**
+   * Set stock to a specific quantity
+   */
+  setStock({
+    token,
+    productId,
+    variantSku,
+    quantity,
+    branchId,
+    reason,
+    options
+  }: {
+    token: string;
+    productId: string;
+    variantSku?: string;
+    quantity: number;
+    branchId?: string;
+    reason?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AdjustStockResult>>;
+}
+declare const adjustmentApi: AdjustmentApi;
+//#endregion
+export { AdjustmentApi, adjustmentApi };

package/dist/inventory/api/adjustment.js

@@ -0,0 +1,120 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/adjustment.ts
+/**
+* Adjustment API - Manual Stock Corrections
+*
+* Handles manual stock adjustments (add, remove, set).
+* Creates adjustment movements and optionally expense transactions.
+*/
+var AdjustmentApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/adjustments", config);
+	}
+	/**
+	* Create a manual stock adjustment
+	* POST /inventory/adjustments
+	*
+	* @example Single item adjustment
+	* adjustmentApi.create({
+	*   token,
+	*   data: {
+	*     productId: '...',
+	*     variantSku: 'SKU-RED-M',
+	*     quantity: 5,
+	*     mode: 'remove',
+	*     reason: 'damaged',
+	*     lostAmount: 2500 // Creates expense transaction (opt-in)
+	*   }
+	* })
+	*
+	* @example Bulk adjustment
+	* adjustmentApi.create({
+	*   token,
+	*   data: {
+	*     adjustments: [
+	*       { productId: '...', quantity: 5, mode: 'add' },
+	*       { productId: '...', quantity: 3, mode: 'remove' }
+	*     ],
+	*     reason: 'inventory recount'
+	*   }
+	* })
+	*/
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Adjust stock (single item, POS format)
+	* POST /inventory/adjustments
+	*/
+	async adjustStock({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Add stock to a product
+	*/
+	async addStock({ token, productId, variantSku, quantity, branchId, reason, options = {} }) {
+		return this.adjustStock({
+			token,
+			data: {
+				productId,
+				variantSku,
+				quantity,
+				mode: "add",
+				branchId,
+				reason
+			},
+			options
+		});
+	}
+	/**
+	* Remove stock from a product
+	*/
+	async removeStock({ token, productId, variantSku, quantity, branchId, reason, lostAmount, options = {} }) {
+		return this.create({
+			token,
+			data: {
+				productId,
+				variantSku,
+				quantity,
+				mode: "remove",
+				branchId,
+				reason,
+				lostAmount
+			},
+			options
+		});
+	}
+	/**
+	* Set stock to a specific quantity
+	*/
+	async setStock({ token, productId, variantSku, quantity, branchId, reason, options = {} }) {
+		return this.adjustStock({
+			token,
+			data: {
+				productId,
+				variantSku,
+				quantity,
+				mode: "set",
+				branchId,
+				reason
+			},
+			options
+		});
+	}
+};
+const adjustmentApi = new AdjustmentApi();
+
+//#endregion
+export { AdjustmentApi, adjustmentApi };

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

@@ -0,0 +1,70 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/availability.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface Availability {
+  quantityOnHand: number;
+  quantityReserved: number;
+  quantityAvailable: number;
+  quantityIncoming: number;
+  quantityOutgoing: number;
+  breakdowns: Array<{
+    skuRef: string;
+    locationId: string;
+    quantityOnHand: number;
+    quantityReserved: number;
+    quantityAvailable: number;
+    unitCost?: number;
+  }>;
+}
+interface AvailabilityCheckItem {
+  skuRef: string;
+  quantity: number;
+}
+interface AvailabilityCheckResult {
+  items: Array<{
+    skuRef: string;
+    requested: number;
+    available: number;
+    sufficient: boolean;
+  }>;
+  allAvailable: boolean;
+}
+declare class AvailabilityApi extends BaseApi {
+  constructor(config?: {});
+  /**
+   * Get stock availability for a SKU
+   * GET /inventory/availability?skuRef=...&branchId=...
+   */
+  get({
+    token,
+    skuRef,
+    branchId,
+    locationId,
+    options
+  }: {
+    token: string;
+    skuRef?: string;
+    branchId?: string;
+    locationId?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Availability>>;
+  /**
+   * Batch availability check
+   * POST /inventory/availability/check
+   */
+  check({
+    token,
+    items,
+    branchId,
+    options
+  }: {
+    token: string;
+    items: AvailabilityCheckItem[];
+    branchId: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AvailabilityCheckResult>>;
+}
+declare const availabilityApi: AvailabilityApi;
+//#endregion
+export { Availability, AvailabilityApi, AvailabilityCheckItem, AvailabilityCheckResult, availabilityApi };

package/dist/inventory/api/availability.js

@@ -0,0 +1,47 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/availability.ts
+/**
+* Availability API — Flow-native stock availability queries
+*
+* Provides real-time stock availability checks powered by @classytic/flow.
+* Replaces direct StockEntry queries with Flow's StockQuant aggregation.
+*/
+var AvailabilityApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/availability", config);
+	}
+	/**
+	* Get stock availability for a SKU
+	* GET /inventory/availability?skuRef=...&branchId=...
+	*/
+	async get({ token, skuRef, branchId, locationId, options = {} }) {
+		const params = new URLSearchParams();
+		if (skuRef) params.set("skuRef", skuRef);
+		if (branchId) params.set("branchId", branchId);
+		if (locationId) params.set("locationId", locationId);
+		return handleApiRequest("GET", `${this.baseUrl}?${params}`, {
+			token,
+			...options
+		});
+	}
+	/**
+	* Batch availability check
+	* POST /inventory/availability/check
+	*/
+	async check({ token, items, branchId, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/check`, {
+			token,
+			body: {
+				items,
+				branchId
+			},
+			...options
+		});
+	}
+};
+const availabilityApi = new AvailabilityApi();
+
+//#endregion
+export { AvailabilityApi, availabilityApi };

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

@@ -0,0 +1,58 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/cost.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface CostLayer {
+  _id: string;
+  organizationId: string;
+  skuRef: string;
+  locationId?: string;
+  quantity: number;
+  remainingQuantity: number;
+  unitCost: number;
+  procurementRef?: string;
+  expiresAt?: string;
+  createdAt?: string;
+}
+interface Valuation {
+  totalValue: number;
+  totalQuantity: number;
+  averageUnitCost: number;
+  breakdowns: Array<{
+    skuRef: string;
+    locationId?: string;
+    quantity: number;
+    value: number;
+    avgCost: number;
+  }>;
+}
+declare class CostApi extends BaseApi {
+  constructor(config?: {});
+  getValuation({
+    token,
+    skuRef,
+    locationId,
+    nodeId,
+    options
+  }: {
+    token: string;
+    skuRef?: string;
+    locationId?: string;
+    nodeId?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Valuation>>;
+  getLayers({
+    token,
+    skuRef,
+    locationId,
+    options
+  }: {
+    token: string;
+    skuRef: string;
+    locationId?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<CostLayer[]>>;
+}
+declare const costApi: CostApi;
+//#endregion
+export { CostApi, CostLayer, Valuation, costApi };

package/dist/inventory/api/cost.js

@@ -0,0 +1,34 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/cost.ts
+/**
+* Cost Layers & Valuation API — Flow-native COGS tracking (Standard+)
+*/
+var CostApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/cost", config);
+	}
+	async getValuation({ token, skuRef, locationId, nodeId, options = {} }) {
+		const params = new URLSearchParams();
+		if (skuRef) params.set("skuRef", skuRef);
+		if (locationId) params.set("locationId", locationId);
+		if (nodeId) params.set("nodeId", nodeId);
+		return handleApiRequest("GET", `${this.baseUrl}/valuation?${params}`, {
+			token,
+			...options
+		});
+	}
+	async getLayers({ token, skuRef, locationId, options = {} }) {
+		const params = new URLSearchParams({ skuRef });
+		if (locationId) params.set("locationId", locationId);
+		return handleApiRequest("GET", `${this.baseUrl}/layers?${params}`, {
+			token,
+			...options
+		});
+	}
+};
+const costApi = new CostApi();
+
+//#endregion
+export { CostApi, costApi };

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

@@ -0,0 +1,18 @@
+import { SupplierQueryParams } from "../types/supplier.js";
+import { Availability, AvailabilityApi, AvailabilityCheckItem, AvailabilityCheckResult, availabilityApi } from "./availability.js";
+import { CreateReservationPayload, Reservation, ReservationApi, reservationApi } from "./reservation.js";
+import { ScanApi, ScanResolution, scanApi } from "./scan.js";
+import { PurchaseApi, purchaseApi } from "./purchase.js";
+import { TransferApi, transferApi } from "./transfer.js";
+import { RequestApi, requestApi } from "./request.js";
+import { MovementApi, movementApi } from "./movement.js";
+import { AdjustmentApi, adjustmentApi } from "./adjustment.js";
+import { SupplierApi, supplierApi } from "./supplier.js";
+import { AuditApi, LocationApi, NodeApi, auditApi, locationApi, nodeApi } from "./warehouse.js";
+import { CreateLotPayload, LotApi, StockLot, UpdateLotPayload, lotApi } from "./lot.js";
+import { CreatePackagePayload, PackageApi, PackageContents, StockPackage, packageApi } from "./package.js";
+import { CreateProcurementPayload, ProcurementApi, ProcurementItem, ProcurementOrder, ReceiveProcurementPayload, procurementApi } from "./procurement.js";
+import { CreateRulePayload, EvaluateResult, ReplenishmentApi, ReplenishmentRule, UpdateRulePayload, replenishmentApi } from "./replenishment.js";
+import { CostApi, CostLayer, Valuation, costApi } from "./cost.js";
+import { RecallResult, TraceApi, TraceResult, traceApi } from "./trace.js";
+import { AgingReport, AvailabilityMatrix, HealthMetrics, ReportApi, TurnoverReport, reportApi } from "./report.js";

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

@@ -0,0 +1,82 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/lot.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface StockLot {
+  _id: string;
+  organizationId: string;
+  skuRef: string;
+  trackingType: "lot" | "serial";
+  lotCode?: string;
+  serialCode?: string;
+  status: "active" | "recalled" | "expired";
+  manufacturedAt?: string;
+  receivedAt?: string;
+  expiresAt?: string;
+  vendorBatchRef?: string;
+  metadata?: Record<string, unknown>;
+}
+interface CreateLotPayload {
+  skuRef: string;
+  trackingType: "lot" | "serial";
+  lotCode?: string;
+  serialCode?: string;
+  manufacturedAt?: string;
+  receivedAt?: string;
+  expiresAt?: string;
+  vendorBatchRef?: string;
+  metadata?: Record<string, unknown>;
+}
+interface UpdateLotPayload {
+  status?: "active" | "recalled" | "expired";
+  expiresAt?: string;
+  metadata?: Record<string, unknown>;
+}
+declare class LotApi extends BaseApi<StockLot, CreateLotPayload, UpdateLotPayload> {
+  constructor(config?: {});
+  list({
+    token,
+    skuRef,
+    trackingType,
+    status,
+    options
+  }: {
+    token: string;
+    skuRef?: string;
+    trackingType?: string;
+    status?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockLot[]>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockLot>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateLotPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockLot>>;
+  update({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data: UpdateLotPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockLot>>;
+}
+declare const lotApi: LotApi;
+//#endregion
+export { CreateLotPayload, LotApi, StockLot, UpdateLotPayload, lotApi };

package/dist/inventory/api/lot.js

@@ -0,0 +1,46 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/lot.ts
+/**
+* Lot/Serial Tracking API — Flow-native lot and serial management (Standard+)
+*/
+var LotApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/lots", config);
+	}
+	async list({ token, skuRef, trackingType, status, options = {} }) {
+		const params = new URLSearchParams();
+		if (skuRef) params.set("skuRef", skuRef);
+		if (trackingType) params.set("trackingType", trackingType);
+		if (status) params.set("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 update({ token, id, data, options = {} }) {
+		return handleApiRequest("PATCH", `${this.baseUrl}/${id}`, {
+			token,
+			body: data,
+			...options
+		});
+	}
+};
+const lotApi = new LotApi();
+
+//#endregion
+export { LotApi, lotApi };

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

@@ -0,0 +1,71 @@
+import { ApiResponse, BaseApi, PaginatedResponse, RequestOptions } from "../../core/api-factory.js";
+import { LowStockItem, MovementQueryParams, StockMovement } from "../types/inventory.js";
+//#region src/inventory/api/movement.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class MovementApi extends BaseApi<StockMovement> {
+  constructor(config?: {});
+  /**
+   * Get stock movements (audit trail)
+   * GET /inventory/movements
+   *
+   * @param params - Filters (productId, branchId, type, startDate, endDate, page, limit, sort, after/cursor)
+   */
+  list({
+    token,
+    params,
+    options
+  }: {
+    token: string;
+    params?: MovementQueryParams;
+    options?: FetchOptions;
+  }): Promise<PaginatedResponse<StockMovement>>;
+  /**
+   * Get movements by type
+   * GET /inventory/movements?type=<type>
+   */
+  listByType({
+    token,
+    type,
+    params,
+    options
+  }: {
+    token: string;
+    type: StockMovement["operationType"];
+    params?: Omit<MovementQueryParams, "type">;
+    options?: FetchOptions;
+  }): Promise<PaginatedResponse<StockMovement>>;
+  /**
+   * Get movements for a specific product
+   * GET /inventory/movements?productId=<id>
+   */
+  listByProduct({
+    token,
+    productId,
+    params,
+    options
+  }: {
+    token: string;
+    productId: string;
+    params?: Omit<MovementQueryParams, "productId">;
+    options?: FetchOptions;
+  }): Promise<PaginatedResponse<StockMovement>>;
+  /**
+   * Get low stock items
+   * GET /inventory/low-stock
+   */
+  lowStock({
+    token,
+    params,
+    options
+  }: {
+    token: string;
+    params?: {
+      branchId?: string;
+      threshold?: number;
+    };
+    options?: FetchOptions;
+  }): Promise<ApiResponse<LowStockItem[]>>;
+}
+declare const movementApi: MovementApi;
+//#endregion
+export { MovementApi, movementApi };