@classytic/commerce-sdk 0.1.2 → 0.2.1

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

@@ -0,0 +1,145 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/replenishment.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface ReplenishmentRule {
+  _id: string;
+  organizationId: string;
+  skuRef: string;
+  /** API-mapped scope type (backend maps scopeType → scope) */
+  scope: "node" | "location";
+  /** API-mapped scope reference (backend maps scopeRef → scopeId) */
+  scopeId: string;
+  /** @deprecated Use `scope` — raw Flow field */
+  scopeType?: "organization" | "node" | "location";
+  /** @deprecated Use `scopeId` — raw Flow field */
+  scopeRef?: string;
+  locationId?: string;
+  triggerType?: "reorder_point" | "min_max" | "scheduled";
+  reorderPoint: number;
+  targetLevel: number;
+  preferredSourceType?: "vendor" | "internal_transfer";
+  /** API-mapped preferred source (backend maps preferredSourceRef → preferredSourceId) */
+  preferredSourceId?: string;
+  /** @deprecated Use `preferredSourceId` — raw Flow field */
+  preferredSourceRef?: string;
+  procurementMode?: "purchase" | "transfer" | "manufacture";
+  leadTimeDays?: number;
+  minOrderQty?: number;
+  maxOrderQty?: number;
+  multipleOf?: number;
+  safetyStock?: number;
+  /** API-mapped active state (backend maps enabled → isActive) */
+  isActive: boolean;
+  /** @deprecated Use `isActive` — raw Flow field */
+  enabled?: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+}
+interface CreateRulePayload {
+  skuRef: string;
+  scope: "node" | "location";
+  scopeId: string;
+  reorderPoint: number;
+  targetLevel: number;
+  minOrderQty?: number;
+  maxOrderQty?: number;
+  multipleOf?: number;
+  leadTimeDays?: number;
+  safetyStock?: number;
+  preferredSourceId?: string;
+}
+interface UpdateRulePayload {
+  reorderPoint?: number;
+  targetLevel?: number;
+  minOrderQty?: number;
+  maxOrderQty?: number;
+  multipleOf?: number;
+  leadTimeDays?: number;
+  safetyStock?: number;
+  preferredSourceId?: string;
+  isActive?: boolean;
+}
+interface EvaluateResult {
+  triggers: Array<{
+    skuRef: string;
+    currentLevel: number;
+    reorderPoint: number;
+    orderQuantity: number;
+  }>;
+  ordersCreated: number;
+  orders?: unknown[];
+}
+declare class ReplenishmentApi extends BaseApi<ReplenishmentRule, CreateRulePayload, UpdateRulePayload> {
+  constructor(config?: {});
+  list({
+    token,
+    skuRef,
+    scopeId,
+    isActive,
+    options
+  }: {
+    token: string;
+    skuRef?: string;
+    scopeId?: string;
+    isActive?: boolean;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ReplenishmentRule[]>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ReplenishmentRule>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateRulePayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ReplenishmentRule>>;
+  update({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data: UpdateRulePayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ReplenishmentRule>>;
+  deleteRule({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<{
+    deleted: boolean;
+  }>>;
+  evaluate({
+    token,
+    skuRef,
+    nodeId,
+    dryRun,
+    options
+  }: {
+    token: string;
+    skuRef?: string;
+    nodeId?: string;
+    dryRun?: boolean;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<EvaluateResult>>;
+}
+declare const replenishmentApi: ReplenishmentApi;
+//#endregion
+export { CreateRulePayload, EvaluateResult, ReplenishmentApi, ReplenishmentRule, UpdateRulePayload, replenishmentApi };

package/dist/inventory/api/replenishment.js

@@ -0,0 +1,63 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/replenishment.ts
+/**
+* Replenishment Rules API — Flow-native auto-replenishment (Standard+)
+*/
+var ReplenishmentApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/replenishment", config);
+	}
+	async list({ token, skuRef, scopeId, isActive, options = {} }) {
+		const params = new URLSearchParams();
+		if (skuRef) params.set("skuRef", skuRef);
+		if (scopeId) params.set("scopeId", scopeId);
+		if (isActive !== void 0) params.set("isActive", String(isActive));
+		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
+		});
+	}
+	async deleteRule({ token, id, options = {} }) {
+		return handleApiRequest("DELETE", `${this.baseUrl}/${id}`, {
+			token,
+			...options
+		});
+	}
+	async evaluate({ token, skuRef, nodeId, dryRun, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/evaluate`, {
+			token,
+			body: {
+				skuRef,
+				nodeId,
+				dryRun
+			},
+			...options
+		});
+	}
+};
+const replenishmentApi = new ReplenishmentApi();
+
+//#endregion
+export { ReplenishmentApi, replenishmentApi };

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

@@ -0,0 +1,102 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/report.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface AgingReport {
+  buckets: Array<{
+    label: string;
+    minDays: number;
+    maxDays: number;
+    items: Array<{
+      skuRef: string;
+      quantity: number;
+      value: number;
+    }>;
+    totalQuantity: number;
+    totalValue: number;
+  }>;
+}
+interface TurnoverReport {
+  items: Array<{
+    skuRef: string;
+    turnoverRatio: number;
+    avgDaysOnHand: number;
+    classification: "A" | "B" | "C";
+    totalMoved: number;
+    avgOnHand: number;
+  }>;
+}
+interface AvailabilityMatrix {
+  matrix: Array<{
+    skuRef: string;
+    locations: Array<{
+      locationId: string;
+      quantityOnHand: number;
+      quantityAvailable: number;
+    }>;
+  }>;
+}
+interface HealthMetrics {
+  totalSkus: number;
+  totalQuantity: number;
+  totalValue: number;
+  coverageDays: number;
+  deadStockSkus: number;
+  lowStockSkus: number;
+  overstockSkus: number;
+  turnoverRatio: number;
+}
+declare class ReportApi extends BaseApi {
+  constructor(config?: {});
+  aging({
+    token,
+    nodeId,
+    skuRef,
+    buckets,
+    options
+  }: {
+    token: string;
+    nodeId?: string;
+    skuRef?: string;
+    buckets?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AgingReport>>;
+  turnover({
+    token,
+    nodeId,
+    skuRef,
+    startDate,
+    endDate,
+    options
+  }: {
+    token: string;
+    nodeId?: string;
+    skuRef?: string;
+    startDate?: string;
+    endDate?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<TurnoverReport>>;
+  availability({
+    token,
+    nodeId,
+    skuRefs,
+    options
+  }: {
+    token: string;
+    nodeId?: string;
+    skuRefs?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<AvailabilityMatrix>>;
+  health({
+    token,
+    nodeId,
+    options
+  }: {
+    token: string;
+    nodeId?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<HealthMetrics>>;
+}
+declare const reportApi: ReportApi;
+//#endregion
+export { AgingReport, AvailabilityMatrix, HealthMetrics, ReportApi, TurnoverReport, reportApi };

package/dist/inventory/api/report.js

@@ -0,0 +1,54 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/report.ts
+/**
+* Inventory Reports API — Flow-native analytics (Enterprise)
+*/
+var ReportApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/reports", config);
+	}
+	async aging({ token, nodeId, skuRef, buckets, options = {} }) {
+		const params = new URLSearchParams();
+		if (nodeId) params.set("nodeId", nodeId);
+		if (skuRef) params.set("skuRef", skuRef);
+		if (buckets) params.set("buckets", buckets);
+		return handleApiRequest("GET", `${this.baseUrl}/aging?${params}`, {
+			token,
+			...options
+		});
+	}
+	async turnover({ token, nodeId, skuRef, startDate, endDate, options = {} }) {
+		const params = new URLSearchParams();
+		if (nodeId) params.set("nodeId", nodeId);
+		if (skuRef) params.set("skuRef", skuRef);
+		if (startDate) params.set("startDate", startDate);
+		if (endDate) params.set("endDate", endDate);
+		return handleApiRequest("GET", `${this.baseUrl}/turnover?${params}`, {
+			token,
+			...options
+		});
+	}
+	async availability({ token, nodeId, skuRefs, options = {} }) {
+		const params = new URLSearchParams();
+		if (nodeId) params.set("nodeId", nodeId);
+		if (skuRefs) params.set("skuRefs", skuRefs);
+		return handleApiRequest("GET", `${this.baseUrl}/availability?${params}`, {
+			token,
+			...options
+		});
+	}
+	async health({ token, nodeId, options = {} }) {
+		const params = new URLSearchParams();
+		if (nodeId) params.set("nodeId", nodeId);
+		return handleApiRequest("GET", `${this.baseUrl}/health?${params}`, {
+			token,
+			...options
+		});
+	}
+};
+const reportApi = new ReportApi();
+
+//#endregion
+export { ReportApi, reportApi };

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

@@ -0,0 +1,157 @@
+import { ApiResponse, BaseApi, PaginatedResponse, RequestOptions } from "../../core/api-factory.js";
+import { CreateStockRequestPayload, StockRequest } from "../types/inventory.js";
+//#region src/inventory/api/request.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class RequestApi extends BaseApi<StockRequest, CreateStockRequestPayload> {
+  constructor(config?: {});
+  /**
+   * List stock requests
+   * GET /inventory/requests
+   */
+  list({
+    token,
+    params,
+    options
+  }: {
+    token: string;
+    params?: Record<string, unknown>;
+    options?: FetchOptions;
+  }): Promise<PaginatedResponse<StockRequest>>;
+  /**
+   * List pending stock requests
+   * GET /inventory/requests?status=pending
+   */
+  listPending({
+    token,
+    options
+  }: {
+    token: string;
+    options?: FetchOptions;
+  }): Promise<PaginatedResponse<StockRequest>>;
+  /**
+   * Get stock request by ID
+   * GET /inventory/requests/:id
+   */
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+  /**
+   * Create a stock request
+   * POST /inventory/requests
+   */
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateStockRequestPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+  /**
+   * Generic action endpoint
+   * POST /inventory/requests/:id/action
+   */
+  action({
+    token,
+    id,
+    action,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    action: "approve" | "reject" | "fulfill" | "cancel";
+    data?: Record<string, unknown>;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+  /**
+   * Approve a stock request
+   */
+  approve({
+    token,
+    id,
+    items,
+    reviewNotes,
+    notes,
+    options
+  }: {
+    token: string;
+    id: string;
+    items?: {
+      productId: string;
+      variantSku?: string;
+      quantityApproved: number;
+    }[];
+    reviewNotes?: string;
+    notes?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+  /**
+   * Reject a stock request
+   */
+  reject({
+    token,
+    id,
+    reason,
+    options
+  }: {
+    token: string;
+    id: string;
+    reason: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+  /**
+   * Fulfill a stock request (creates a transfer)
+   * Head office assigns carton numbers here for label printing
+   */
+  fulfill({
+    token,
+    id,
+    remarks,
+    documentType,
+    items,
+    transport,
+    options
+  }: {
+    token: string;
+    id: string;
+    remarks?: string;
+    documentType?: string;
+    items?: {
+      productId: string;
+      variantSku?: string;
+      quantity: number;
+      cartonNumber?: string;
+    }[];
+    transport?: {
+      vehicleNumber?: string;
+      driverName?: string;
+      driverPhone?: string;
+    };
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+  /**
+   * Cancel a stock request
+   */
+  cancel({
+    token,
+    id,
+    reason,
+    options
+  }: {
+    token: string;
+    id: string;
+    reason?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockRequest>>;
+}
+declare const requestApi: RequestApi;
+//#endregion
+export { RequestApi, requestApi };

package/dist/inventory/api/request.js

@@ -0,0 +1,140 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/request.ts
+/**
+* Stock Request API - Sub-branch -> Head Office requests
+*
+* Handles stock requests from sub-branches following the Stripe action-based pattern.
+* Status flow: pending -> approved -> fulfilled (or rejected/cancelled)
+*/
+var RequestApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/requests", config);
+	}
+	/**
+	* List stock requests
+	* GET /inventory/requests
+	*/
+	async list({ token, params = {}, options = {} }) {
+		const processedParams = this.prepareParams(params);
+		const queryString = this.createQueryString(processedParams);
+		return handleApiRequest("GET", `${this.baseUrl}?${queryString}`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* List pending stock requests
+	* GET /inventory/requests?status=pending
+	*/
+	async listPending({ token, options = {} }) {
+		return this.list({
+			token,
+			params: { status: "pending" },
+			options
+		});
+	}
+	/**
+	* Get stock request by ID
+	* GET /inventory/requests/:id
+	*/
+	async getById({ token, id, options = {} }) {
+		if (!id) throw new Error("Request ID is required");
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Create a stock request
+	* POST /inventory/requests
+	*/
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Generic action endpoint
+	* POST /inventory/requests/:id/action
+	*/
+	async action({ token, id, action, data = {}, options = {} }) {
+		if (!id) throw new Error("Request ID is required");
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: {
+				action,
+				...data
+			},
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Approve a stock request
+	*/
+	async approve({ token, id, items, reviewNotes, notes, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "approve",
+			data: {
+				items,
+				reviewNotes: reviewNotes ?? notes
+			},
+			options
+		});
+	}
+	/**
+	* Reject a stock request
+	*/
+	async reject({ token, id, reason, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "reject",
+			data: { reason },
+			options
+		});
+	}
+	/**
+	* Fulfill a stock request (creates a transfer)
+	* Head office assigns carton numbers here for label printing
+	*/
+	async fulfill({ token, id, remarks, documentType, items, transport, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "fulfill",
+			data: {
+				remarks,
+				documentType,
+				items,
+				transport
+			},
+			options
+		});
+	}
+	/**
+	* Cancel a stock request
+	*/
+	async cancel({ token, id, reason, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "cancel",
+			data: { reason },
+			options
+		});
+	}
+};
+const requestApi = new RequestApi();
+
+//#endregion
+export { RequestApi, requestApi };