@classytic/commerce-sdk 0.1.2 → 0.2.1

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

@@ -0,0 +1,77 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/reservation.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface Reservation {
+  _id: string;
+  organizationId: string;
+  reservationType: "soft" | "hard";
+  ownerType: string;
+  ownerId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  quantity: number;
+  quantityConsumed?: number;
+  status: "active" | "partially_consumed" | "consumed" | "released" | "expired" | "cancelled";
+  expiresAt?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+interface CreateReservationPayload {
+  reservationType: "soft" | "hard";
+  ownerType: string;
+  ownerId: string;
+  skuRef: string;
+  locationId?: string;
+  quantity: number;
+  expiresAt?: string;
+  branchId?: string;
+}
+declare class ReservationApi extends BaseApi<Reservation, CreateReservationPayload, Partial<CreateReservationPayload>> {
+  constructor(config?: {});
+  /**
+   * Reserve stock
+   * POST /inventory/reservations
+   */
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateReservationPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Reservation>>;
+  /**
+   * Release a reservation
+   * POST /inventory/reservations/:id/release
+   */
+  release({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Reservation>>;
+  /**
+   * Consume a reservation (partially or fully)
+   * POST /inventory/reservations/:id/consume
+   */
+  consume({
+    token,
+    id,
+    quantity,
+    options
+  }: {
+    token: string;
+    id: string;
+    quantity: number;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Reservation>>;
+}
+declare const reservationApi: ReservationApi;
+//#endregion
+export { CreateReservationPayload, Reservation, ReservationApi, reservationApi };

package/dist/inventory/api/reservation.js

@@ -0,0 +1,51 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/reservation.ts
+/**
+* Reservation API — Flow-native stock reservations
+*
+* First-class stock reservations with expiry, partial consumption, and release.
+* Replaces the old StockReservation model with Flow's ReservationService.
+*/
+var ReservationApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/reservations", config);
+	}
+	/**
+	* Reserve stock
+	* POST /inventory/reservations
+	*/
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	/**
+	* Release a reservation
+	* POST /inventory/reservations/:id/release
+	*/
+	async release({ token, id, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/release`, {
+			token,
+			...options
+		});
+	}
+	/**
+	* Consume a reservation (partially or fully)
+	* POST /inventory/reservations/:id/consume
+	*/
+	async consume({ token, id, quantity, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/consume`, {
+			token,
+			body: { quantity },
+			...options
+		});
+	}
+};
+const reservationApi = new ReservationApi();
+
+//#endregion
+export { ReservationApi, reservationApi };

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

@@ -0,0 +1,29 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/scan.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface ScanResolution {
+  token: string;
+  resolvedType: "sku" | "location" | "lot" | "serial" | "unknown";
+  resolvedId: string | null;
+  resolvedEntity: Record<string, unknown> | null;
+}
+declare class ScanApi extends BaseApi {
+  constructor(config?: {});
+  /**
+   * Resolve a barcode/SKU/lot/serial token
+   * POST /inventory/scan/resolve
+   */
+  resolve({
+    token,
+    scanToken,
+    options
+  }: {
+    token: string;
+    scanToken: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ScanResolution>>;
+}
+declare const scanApi: ScanApi;
+//#endregion
+export { ScanApi, ScanResolution, scanApi };

package/dist/inventory/api/scan.js

@@ -0,0 +1,30 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/scan.ts
+/**
+* Scan API — Flow-native barcode/token resolution
+*
+* Resolves barcodes, SKUs, lot codes, serial codes through
+* Flow's chain resolver (GS1-128 → location → lot → serial → SKU).
+*/
+var ScanApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/scan", config);
+	}
+	/**
+	* Resolve a barcode/SKU/lot/serial token
+	* POST /inventory/scan/resolve
+	*/
+	async resolve({ token, scanToken, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/resolve`, {
+			token,
+			body: { token: scanToken },
+			...options
+		});
+	}
+};
+const scanApi = new ScanApi();
+
+//#endregion
+export { ScanApi, scanApi };

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

@@ -0,0 +1,9 @@
+import { BaseApi } from "../../core/api-factory.js";
+import { Supplier, SupplierCreatePayload, SupplierQueryParams, SupplierUpdatePayload } from "../types/supplier.js";
+//#region src/inventory/api/supplier.d.ts
+declare class SupplierApi extends BaseApi<Supplier, SupplierCreatePayload, SupplierUpdatePayload> {
+  constructor(config?: {});
+}
+declare const supplierApi: SupplierApi;
+//#endregion
+export { SupplierApi, supplierApi };

package/dist/inventory/api/supplier.js

@@ -0,0 +1,24 @@
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/supplier.ts
+/**
+* Supplier (Vendor) API
+*
+* Base path: /api/v1/inventory/suppliers
+*
+* Standard CRUD (inherited from BaseApi):
+* - getAll({ token, params }) - list with filtering/search/pagination
+* - getById({ token, id }) - get by ID
+* - create({ token, data }) - create supplier
+* - update({ token, id, data }) - update supplier
+* - delete({ token, id }) - deactivate supplier (soft delete)
+*/
+var SupplierApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/suppliers", config);
+	}
+};
+const supplierApi = new SupplierApi();
+
+//#endregion
+export { SupplierApi, supplierApi };

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

@@ -0,0 +1,71 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/trace.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface TraceResult {
+  moves: Array<{
+    _id: string;
+    type: string;
+    sourceLocationId?: string;
+    destinationLocationId?: string;
+    quantity: number;
+    status: string;
+    createdAt?: string;
+  }>;
+  currentLocations: Array<{
+    locationId: string;
+    quantityOnHand: number;
+  }>;
+  shippedMoves: Array<{
+    _id: string;
+    quantity: number;
+    createdAt?: string;
+  }>;
+}
+interface RecallResult {
+  affectedLocations: Array<{
+    locationId: string;
+    quantity: number;
+  }>;
+  affectedShipments: Array<{
+    moveId: string;
+    quantity: number;
+    createdAt?: string;
+  }>;
+  totalAffectedQuantity: number;
+}
+declare class TraceApi extends BaseApi {
+  constructor(config?: {});
+  traceLot({
+    token,
+    lotId,
+    options
+  }: {
+    token: string;
+    lotId: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<TraceResult>>;
+  traceSerial({
+    token,
+    serialCode,
+    skuRef,
+    options
+  }: {
+    token: string;
+    serialCode: string;
+    skuRef: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<TraceResult>>;
+  recall({
+    token,
+    lotId,
+    options
+  }: {
+    token: string;
+    lotId: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<RecallResult>>;
+}
+declare const traceApi: TraceApi;
+//#endregion
+export { RecallResult, TraceApi, TraceResult, traceApi };

package/dist/inventory/api/trace.js

@@ -0,0 +1,39 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/trace.ts
+/**
+* Traceability API — Flow-native lot/serial tracing (Enterprise)
+*/
+var TraceApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/trace", config);
+	}
+	async traceLot({ token, lotId, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/lot?lotId=${lotId}`, {
+			token,
+			...options
+		});
+	}
+	async traceSerial({ token, serialCode, skuRef, options = {} }) {
+		const params = new URLSearchParams({
+			serialCode,
+			skuRef
+		});
+		return handleApiRequest("GET", `${this.baseUrl}/serial?${params}`, {
+			token,
+			...options
+		});
+	}
+	async recall({ token, lotId, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/recall`, {
+			token,
+			body: { lotId },
+			...options
+		});
+	}
+};
+const traceApi = new TraceApi();
+
+//#endregion
+export { TraceApi, traceApi };

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

@@ -0,0 +1,162 @@
+import { ApiResponse, BaseApi, PaginatedResponse, RequestOptions } from "../../core/api-factory.js";
+import { CreateTransferPayload, DispatchTransferPayload, ReceiveTransferPayload, Transfer, TransferStats, UpdateTransferPayload } from "../types/inventory.js";
+//#region src/inventory/api/transfer.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class TransferApi extends BaseApi<Transfer, CreateTransferPayload, UpdateTransferPayload> {
+  constructor(config?: {});
+  /**
+   * List transfers with filtering
+   * GET /inventory/transfers
+   */
+  list({
+    token,
+    params,
+    options
+  }: {
+    token: string;
+    params?: Record<string, unknown>;
+    options?: FetchOptions;
+  }): Promise<PaginatedResponse<Transfer>>;
+  /**
+   * Get transfer by ID or challan number
+   * GET /inventory/transfers/:id
+   */
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Create a new transfer (draft)
+   * POST /inventory/transfers
+   */
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateTransferPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Update a draft transfer
+   * PATCH /inventory/transfers/:id
+   */
+  update({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data: UpdateTransferPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Get transfer statistics
+   * GET /inventory/transfers/stats
+   */
+  stats({
+    token,
+    params,
+    options
+  }: {
+    token: string;
+    params?: {
+      branchId?: string;
+    };
+    options?: FetchOptions;
+  }): Promise<ApiResponse<TransferStats>>;
+  /**
+   * Generic action endpoint
+   * POST /inventory/transfers/:id/action
+   */
+  action({
+    token,
+    id,
+    action,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    action: "approve" | "dispatch" | "in-transit" | "receive" | "cancel";
+    data?: Record<string, unknown>;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Approve a transfer (validates stock availability)
+   */
+  approve({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Dispatch a transfer (decrements sender stock)
+   */
+  dispatch({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data?: DispatchTransferPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Mark transfer as in-transit
+   */
+  markInTransit({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Receive a transfer (increments receiver stock)
+   */
+  receive({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data?: ReceiveTransferPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+  /**
+   * Cancel a transfer
+   */
+  cancel({
+    token,
+    id,
+    reason,
+    options
+  }: {
+    token: string;
+    id: string;
+    reason?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Transfer>>;
+}
+declare const transferApi: TransferApi;
+//#endregion
+export { TransferApi, transferApi };

package/dist/inventory/api/transfer.js

@@ -0,0 +1,155 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/transfer.ts
+/**
+* Transfer API - Inter-branch Stock Movement
+*
+* Handles challan/transfer documents following the Stripe action-based pattern.
+* Status flow: draft -> approved -> dispatched -> in_transit -> received
+*/
+var TransferApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/transfers", config);
+	}
+	/**
+	* List transfers with filtering
+	* GET /inventory/transfers
+	*/
+	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
+		});
+	}
+	/**
+	* Get transfer by ID or challan number
+	* GET /inventory/transfers/:id
+	*/
+	async getById({ token, id, options = {} }) {
+		if (!id) throw new Error("Transfer ID or challan number is required");
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Create a new transfer (draft)
+	* POST /inventory/transfers
+	*/
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Update a draft transfer
+	* PATCH /inventory/transfers/:id
+	*/
+	async update({ token, id, data, options = {} }) {
+		if (!id) throw new Error("Transfer ID is required");
+		return handleApiRequest("PATCH", `${this.baseUrl}/${id}`, {
+			token,
+			body: data,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Get transfer statistics
+	* GET /inventory/transfers/stats
+	*/
+	async stats({ token, params = {}, options = {} }) {
+		const queryString = this.createQueryString(params);
+		return handleApiRequest("GET", queryString ? `${this.baseUrl}/stats?${queryString}` : `${this.baseUrl}/stats`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Generic action endpoint
+	* POST /inventory/transfers/:id/action
+	*/
+	async action({ token, id, action, data = {}, options = {} }) {
+		if (!id) throw new Error("Transfer ID is required");
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: {
+				action,
+				...data
+			},
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Approve a transfer (validates stock availability)
+	*/
+	async approve({ token, id, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "approve",
+			options
+		});
+	}
+	/**
+	* Dispatch a transfer (decrements sender stock)
+	*/
+	async dispatch({ token, id, data, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "dispatch",
+			data,
+			options
+		});
+	}
+	/**
+	* Mark transfer as in-transit
+	*/
+	async markInTransit({ token, id, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "in-transit",
+			options
+		});
+	}
+	/**
+	* Receive a transfer (increments receiver stock)
+	*/
+	async receive({ token, id, data, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "receive",
+			data,
+			options
+		});
+	}
+	/**
+	* Cancel a transfer
+	*/
+	async cancel({ token, id, reason, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "cancel",
+			data: { reason },
+			options
+		});
+	}
+};
+const transferApi = new TransferApi();
+
+//#endregion
+export { TransferApi, transferApi };