@djust-b2b/djust-front-sdk 1.11.0 → 1.12.0

package/lib/index.d.ts

@@ -21,6 +21,12 @@ export declare const DjustSDK: {
         storeId?: string;
         storeViewId?: string;
     }>) => void;
+    getOrderLogisticIncidents({ logisticOrderId, status, idType, page, size, sort, }: import("./services/incident/definitions").getOrderLogisticIncidentsParameters): Promise<import("./services/incident/definitions").getOrderLogisticIncidentsResponse>;
+    getOrderLogisticIncident({ logisticOrderId, incidentId, idType, }: import("./services/incident/definitions").getOrderLogisticIncidentParameters): Promise<import("./services/incident/definitions").getOrderLogisticIncidentResponse>;
+    getOrderLogisticLineIncidents({ logisticOrderId, lineId, status, idType, page, size, sort, }: import("./services/incident/definitions").getOrderLogisticLineIncidentsParameters): Promise<import("./services/incident/definitions").getOrderLogisticLineIncidentsResponse>;
+    createOrderLogisticIncident({ logisticOrderId, idType, customField, reasonCode, }: import("./services/incident/definitions").createOrderLogisticIncidentParameters): Promise<import("./services/incident/definitions").createOrderLogisticIncidentResponse>;
+    createOrderLogisticLineIncident({ logisticOrderId, idType, customFieldIdType, orderLines, reasonCode, }: import("./services/incident/definitions").createOrderLogisticLineIncidentParameters): Promise<import("./services/incident/definitions").createOrderLogisticLineIncidentResponse>;
+    getCustomerAccountIncidents({ customerAccountId, status, page, size, sort, }: import("./services/incident/definitions").getCustomerAccountIncidentsParameters): Promise<import("./services/incident/definitions").getCustomerAccountIncidentsResponse>;
     getCommercialOrders({ locale, nbPreviewLines, }: import("./interfaces").GetCommercialOrdersParameters): Promise<import("./interfaces").GetCommercialOrdersResponse>;
     createCommercialOrder({ nbPreviewLines, channel, customFields, locale, originId, paymentInfo, }: import("./interfaces").CreateCommercialOrderParameters): Promise<import("./interfaces").CreateCommercialOrderResponse>;
     getCommercialOrder({ orderId, idType, locale, nbPreviewLines, }: import("./interfaces").GetCommercialOrderParameters): Promise<import("./interfaces").GetCommercialOrderResponse>;
@@ -116,7 +122,7 @@ export declare const DjustSDK: {
     updateCustomerAccountOrganisationUser({ organisationId, customerUserId, civility, customFieldValues, firstName, lastName, phone, }: import("./interfaces").UpdateCustomerAccountOrganisationUserParameters): Promise<import("./interfaces").UpdateCustomerAccountOrganisationUserResponse>;
     deleteCarts(): Promise<import("./interfaces").DeleteCartsResponse>;
     getCarts(params: import("./interfaces").GetCartsParameters): Promise<import("./interfaces").GetCartsResponse>;
-    createCart(params: import("./interfaces").CreateCartParameters): Promise<void>;
+    createCart(params: import("./interfaces").CreateCartParameters): Promise<import("./interfaces").GetCartResponse>;
     deleteCart(params: import("./interfaces").DeleteCartParameters): Promise<void>;
     getCart(params: import("./interfaces").GetCartParameters): Promise<import("./interfaces").GetCartResponse>;
     updateCart(params: import("./interfaces").UpdateCartParameters): Promise<void>;

package/lib/index.js

@@ -48,6 +48,7 @@ const QuoteServices = __importStar(require("./services/quote"));
 const SupplierServices = __importStar(require("./services/supplier"));
 const LogisticOrderServices = __importStar(require("./services/logistic-order"));
 const CommercialOrderServices = __importStar(require("./services/commercial-order"));
+const IncidentServices = __importStar(require("./services/incident"));
 const fetch_instance_1 = require("./settings/fetch-instance");
 exports.DjustSDK = {
     ...AuthServices,
@@ -61,6 +62,7 @@ exports.DjustSDK = {
     ...SupplierServices,
     ...LogisticOrderServices,
     ...CommercialOrderServices,
+    ...IncidentServices,
     initialize: fetch_instance_1.initialize,
     updateConfiguration: fetch_instance_1.updateConfiguration,
 };

package/lib/interfaces/models/incident.d.ts

@@ -0,0 +1,29 @@
+import { CustomFieldValueObject } from "./custom-field";
+export type IncidentStatus = "OPEN" | "ON_GOING" | "CLOSED";
+export type IncidentIdType = "DJUST_ID" | "EXTERNAL_ID";
+export interface IncidentLogisticOrder {
+    id: string;
+    externalId: string;
+    customFieldValues: CustomFieldValueObject[];
+}
+export interface IncidentOrderLine {
+    id: string;
+    externalId: string;
+    customFieldValues: CustomFieldValueObject[];
+    quantity: number;
+    status: IncidentStatus;
+}
+export interface IncidentDto {
+    createdAt: string;
+    externalId: string;
+    id: string;
+    logisticOrder: IncidentLogisticOrder;
+    orderLines: IncidentOrderLine[];
+    reasons: string[];
+    status: IncidentStatus;
+    threadId: string;
+}
+export interface IncidentCreatedDto {
+    externalId: string;
+    incidentId: string;
+}

package/lib/interfaces/models/incident.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/services/cart/index.d.ts

@@ -93,7 +93,7 @@ export declare function getCarts(params: GetCartsParameters): Promise<GetCartsRe
  *
  * The name of the cart to create.
  *
- * @returns {Promise<void>} - A promise that resolves when the cart is created.
+ * @returns {Promise<GetCartResponse>} - A promise that resolves when the cart is created.
  *
  * @example
  * #### input
@@ -107,7 +107,7 @@ export declare function getCarts(params: GetCartsParameters): Promise<GetCartsRe
  * }
  * ```
  */
-export declare function createCart(params: CreateCartParameters): Promise<void>;
+export declare function createCart(params: CreateCartParameters): Promise<GetCartResponse>;
 /**
  * APICODE(cART300)
  * Deletes a specific cart.

package/lib/services/cart/index.js

@@ -127,7 +127,7 @@ async function getCarts(params) {
  *
  * The name of the cart to create.
  *
- * @returns {Promise<void>} - A promise that resolves when the cart is created.
+ * @returns {Promise<GetCartResponse>} - A promise that resolves when the cart is created.
  *
  * @example
  * #### input
@@ -143,11 +143,12 @@ async function getCarts(params) {
  */
 async function createCart(params) {
     const { name } = params;
-    (0, fetch_instance_1.enhancedFetch)({
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
         method: "POST",
         path: `/v2/shop/carts`,
         body: JSON.stringify({ name }),
     });
+    return data;
 }
 /**
  * APICODE(cART300)

package/lib/services/incident/definitions.d.ts

@@ -0,0 +1,68 @@
+import { IncidentDto, IncidentStatus, IncidentIdType, IncidentCreatedDto } from "../../interfaces/models/incident";
+import { CustomFieldValueRequest } from "../../interfaces/models/custom-field";
+/**
+ * Request parameters type definitions
+ */
+export interface getOrderLogisticIncidentsParameters {
+    logisticOrderId: string;
+    status: IncidentStatus[];
+    idType: IncidentIdType;
+    page: number;
+    size: number;
+    sort: String[];
+}
+export interface getOrderLogisticIncidentParameters {
+    logisticOrderId: string;
+    incidentId: string;
+    idType: IncidentIdType;
+}
+export interface getOrderLogisticLineIncidentsParameters {
+    logisticOrderId: string;
+    lineId: string;
+    status: IncidentStatus[];
+    idType: IncidentIdType;
+    page: number;
+    size: number;
+    sort: String[];
+}
+export interface createOrderLogisticIncidentParameters {
+    logisticOrderId: string;
+    idType: IncidentIdType;
+    customField: {
+        customFieldValues: CustomFieldValueRequest[];
+        idType: IncidentIdType;
+    };
+    reasonCode: string[];
+}
+export interface createOrderLogisticLineIncidentParameters {
+    logisticOrderId: string;
+    idType: IncidentIdType;
+    customFieldIdType: IncidentIdType;
+    orderLines: {
+        customFieldValues: CustomFieldValueRequest[];
+        lineId: string;
+        quantity: number;
+    }[];
+    reasonCode: string[];
+}
+export interface getCustomerAccountIncidentsParameters {
+    customerAccountId: string;
+    status: IncidentStatus[];
+    page: number;
+    size: number;
+    sort: String[];
+}
+/**
+ */
+export interface getOrderLogisticIncidentsResponse extends Array<IncidentDto> {
+}
+export interface getOrderLogisticIncidentResponse extends IncidentDto {
+}
+export interface getOrderLogisticLineIncidentsResponse extends Array<IncidentDto> {
+}
+export interface createOrderLogisticIncidentResponse extends IncidentCreatedDto {
+}
+export interface createOrderLogisticLineIncidentResponse extends IncidentCreatedDto {
+}
+export interface getCustomerAccountIncidentsResponse extends Array<IncidentDto> {
+}

package/lib/services/incident/definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/services/incident/index.d.ts

@@ -0,0 +1,222 @@
+import { getOrderLogisticIncidentsParameters, getOrderLogisticIncidentParameters, getOrderLogisticLineIncidentsParameters, createOrderLogisticIncidentParameters, createOrderLogisticLineIncidentParameters, getCustomerAccountIncidentsParameters, getOrderLogisticIncidentsResponse, getOrderLogisticIncidentResponse, getOrderLogisticLineIncidentsResponse, createOrderLogisticIncidentResponse, createOrderLogisticLineIncidentResponse, getCustomerAccountIncidentsResponse } from "./definitions";
+/**
+ * 🚚 Fetches logistic order incidents.
+ *
+ * This function retrieves a paginated list of incidents for a specific logistic order,
+ * filtered by status and other parameters. The `logisticOrderId` parameter is mandatory
+ * and validated before the request is executed.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/logistic-orders/{logisticOrderId}/incidents [ORDER-557]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `logisticOrderId` | `string`                       | ✅         | The ID of the logistic order to fetch incidents for. |
+ * | `status`          | `IncidentStatus[]`             | ❌         | Array of statuses to filter incidents (e.g., `["OPEN"]`). |
+ * | `idType`          | `IncidentIdType`               | ❌         | Specifies whether the ID is internal (`DJUST_ID`) or external (`EXTERNAL_ID`). |
+ * | `page`            | `number`                       | ❌         | The page number for pagination.          |
+ * | `size`            | `number`                       | ❌         | The number of results per page.          |
+ * | `sort`            | `String[]`                    | ❌         | Sorting criteria (e.g., `["createdAt,desc"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to an array of `IncidentDto` objects representing the incidents.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incidents = await getOrderLogisticIncidents({
+ *   logisticOrderId: "12345",
+ *   status: ["OPEN", "CLOSED"],
+ *   idType: "EXTERNAL_ID",
+ *   page: 1,
+ *   size: 10,
+ *   sort: ["createdAt,desc"],
+ * });
+ * ```
+ *
+ * @param {getOrderLogisticIncidentsParameters} params - The parameters for the request.
+ * @throws {Error} If `logisticOrderId` is missing.
+ * @returns {Promise<getOrderLogisticIncidentsResponse>} A promise resolving to the response containing the incidents.
+ */
+export declare function getOrderLogisticIncidents({ logisticOrderId, status, idType, page, size, sort, }: getOrderLogisticIncidentsParameters): Promise<getOrderLogisticIncidentsResponse>;
+/**
+ * 🚚 Fetches a specific logistic order incident.
+ *
+ * This function retrieves a specific incident for a logistic order, identified by both
+ * the `logisticOrderId` and `incidentId`. Both parameters are mandatory and validated
+ * before the request is executed.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/logistic-orders/{logisticOrderId}/incidents/{incidentId} [ORDER-503]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `logisticOrderId` | `string`                       | ✅         | The ID of the logistic order to fetch the incident for. |
+ * | `incidentId`      | `string`                       | ✅         | The ID of the specific incident to fetch. |
+ * | `idType`          | `IncidentIdType`               | ❌         | Specifies whether the ID is internal (`DJUST_ID`) or external (`EXTERNAL_ID`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a single `getOrderLogisticIncidentResponse` object representing the incident.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incident = await getOrderLogisticIncident({
+ *   logisticOrderId: "12345",
+ *   incidentId: "incident_1",
+ *   idType: "EXTERNAL_ID",
+ * });
+ * ```
+ *
+ * @param {getOrderLogisticIncidentParameters} params - The parameters for the request.
+ * @throws {Error} If `logisticOrderId` or `incidentId` is missing.
+ * @returns {Promise<getOrderLogisticIncidentResponse>} A promise resolving to the response containing the incident.
+ */
+export declare function getOrderLogisticIncident({ logisticOrderId, incidentId, idType, }: getOrderLogisticIncidentParameters): Promise<getOrderLogisticIncidentResponse>;
+/**
+ * 🚚 Fetches incidents for a specific line of a logistic order.
+ *
+ * This function retrieves a list of incidents for a specific line in a logistic order,
+ * filtered by status and other parameters. The `logisticOrderId` and `lineId` parameters
+ * are mandatory and validated before the request is executed.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/logistic-orders/{logisticOrderId}/incidents/lines/{lineId} [ORDER-559]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `logisticOrderId` | `string`                       | ✅         | The ID of the logistic order to fetch incidents for. |
+ * | `lineId`          | `string`                       | ✅         | The ID of the line in the logistic order to fetch incidents for. |
+ * | `status`          | `IncidentStatus[]`             | ❌         | Array of statuses to filter incidents (e.g., `["OPEN"]`). |
+ * | `idType`          | `IncidentIdType`               | ❌         | Specifies whether the ID is internal (`DJUST_ID`) or external (`EXTERNAL_ID`). |
+ * | `page`            | `number`                       | ❌         | The page number for pagination.          |
+ * | `size`            | `number`                       | ❌         | The number of results per page.          |
+ * | `sort`            | `String[]`                     | ❌         | Sorting criteria (e.g., `["createdAt,desc"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to an array of `getOrderLogisticLineIncidentsResponse` objects representing the incidents.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incidents = await getOrderLogisticLineIncidents({
+ *   logisticOrderId: "12345",
+ *   lineId: "line_1",
+ *   status: ["OPEN"],
+ *   idType: "EXTERNAL_ID",
+ *   page: 1,
+ *   size: 10,
+ *   sort: ["createdAt,desc"],
+ * });
+ * ```
+ *
+ * @param {getOrderLogisticLineIncidentsParameters} params - The parameters for the request.
+ * @throws {Error} If `logisticOrderId` or `lineId` is missing.
+ * @returns {Promise<getOrderLogisticLineIncidentsResponse>} A promise resolving to the response containing the incidents.
+ */
+export declare function getOrderLogisticLineIncidents({ logisticOrderId, lineId, status, idType, page, size, sort, }: getOrderLogisticLineIncidentsParameters): Promise<getOrderLogisticLineIncidentsResponse>;
+/**
+ * 🚚 Creates a new incident for a specific logistic order.
+ *
+ * This function allows the creation of an incident for a given logistic order,
+ * requiring essential parameters like the `logisticOrderId` and `reasonCode`.
+ * The `customField` and `idType` are used to provide additional information for the incident creation.
+ *
+ * 🛠 **Endpoint**: `POST /v1/shop/logistic-orders/{logisticOrderId}/incidents [ORDER-101]`
+ *
+ * | Parameter        | Type                                | Required   | Description                                              |
+ * |------------------|-------------------------------------|------------|----------------------------------------------------------|
+ * | `logisticOrderId`| `string`                            | ✅         | The ID of the logistic order for which the incident is created. |
+ * | `idType`         | `IncidentIdType`                    | ❌         | The type of incident ID (e.g., `DJUST_ID`, `EXTERNAL_ID`). |
+ * | `customField`    | `{ customFieldValues: CustomFieldValueRequest[], idType: IncidentIdType }` | ❌         | The custom field data for the incident, including custom field values and ID type. |
+ * | `reasonCode`     | `string[]`                          | ✅         | The reason codes for the incident (e.g., `["PRODUCT_DEFECT"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a `createOrderLogisticIncidentResponse` object,
+ * containing the `incidentId` and `externalId` of the created incident.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incident = await createOrderLogisticIncident({
+ *   logisticOrderId: "12345",
+ *   idType: "EXTERNAL_ID",
+ *   customField: { customFieldValues: [], idType: "EXTERNAL_ID" },
+ *   reasonCode: ["PRODUCT_DEFECT"]
+ * });
+ * ```
+ *
+ * @param {createOrderLogisticIncidentParameters} params - The parameters for creating the incident.
+ * @throws {Error} If `logisticOrderId` or `reasonCode` is missing.
+ * @returns {Promise<createOrderLogisticIncidentResponse>} A promise resolving to the response containing the created incident's details.
+ */
+export declare function createOrderLogisticIncident({ logisticOrderId, idType, customField, reasonCode, }: createOrderLogisticIncidentParameters): Promise<createOrderLogisticIncidentResponse>;
+/**
+ * 🚚 Creates a new incident for a specific line within a logistic order.
+ *
+ * This function allows the creation of an incident for one or more lines within a logistic order.
+ * The `logisticOrderId`, `reasonCode`, and `orderLines` are required parameters.
+ * The `customFieldIdType` and `idType` are used for specifying additional information about the incident.
+ *
+ * 🛠 **Endpoint**: `POST /v1/shop/logistic-orders/{logisticOrderId}/lines/incidents [ORDER-102]`
+ *
+ * | Parameter          | Type                                | Required   | Description                                              |
+ * |--------------------|-------------------------------------|------------|----------------------------------------------------------|
+ * | `logisticOrderId`  | `string`                            | ✅         | The ID of the logistic order for which the line incident is created. |
+ * | `idType`           | `IncidentIdType`                    | ❌         | The type of incident ID (e.g., `DJUST_ID`, `EXTERNAL_ID`). |
+ * | `customFieldIdType`| `IncidentIdType`                    | ❌         | The ID type for custom field values (e.g., `EXTERNAL_ID`). |
+ * | `orderLines`       | `{ customFieldValues: CustomFieldValueRequest[], lineId: string, quantity: number }[]` | ✅         | An array of objects describing the order lines, including custom field values, line ID, and quantity. |
+ * | `reasonCode`       | `string[]`                          | ✅         | The reason codes for the incident (e.g., `["PRODUCT_DEFECT"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a `createOrderLogisticLineIncidentResponse` object,
+ * containing the `incidentId` and `externalId` of the created incident.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incident = await createOrderLogisticLineIncident({
+ *   logisticOrderId: "12345",
+ *   idType: "EXTERNAL_ID",
+ *   customFieldIdType: "DJUST_ID",
+ *   orderLines: [
+ *     { customFieldValues: [], lineId: "line_1", quantity: 2 }
+ *   ],
+ *   reasonCode: ["PRODUCT_DEFECT"]
+ * });
+ * ```
+ *
+ * @param {createOrderLogisticLineIncidentParameters} params - The parameters for creating the incident.
+ * @throws {Error} If `logisticOrderId`, `reasonCode`, or `orderLines` is missing.
+ * @returns {Promise<createOrderLogisticLineIncidentResponse>} A promise resolving to the response containing the created incident's details.
+ */
+export declare function createOrderLogisticLineIncident({ logisticOrderId, idType, customFieldIdType, orderLines, reasonCode, }: createOrderLogisticLineIncidentParameters): Promise<createOrderLogisticLineIncidentResponse>;
+/**
+ * 🧑‍💼 Fetches incidents for a specific customer account.
+ *
+ * This function retrieves incidents associated with a particular customer account,
+ * using parameters such as `status`, `page`, `size`, and `sort` to filter and paginate the results.
+ * The `customerAccountId` is a mandatory parameter and is validated before making the request.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/customer-accounts/{customerAccountId}/incidents [ACCOUNT-551]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `customerAccountId`| `string`                       | ✅         | The ID of the customer account for which incidents are to be fetched. |
+ * | `status`          | `IncidentStatus[]`             | ❌         | Array of statuses to filter incidents by (e.g., `["OPEN"]`). |
+ * | `page`            | `number`                       | ❌         | The page number for pagination.          |
+ * | `size`            | `number`                       | ❌         | The number of results per page.          |
+ * | `sort`            | `string[]`                     | ❌         | Sorting criteria (e.g., `["createdAt,desc"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to an array of `getCustomerAccountIncidentsResponse` objects,
+ * representing the incidents for the given customer account.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incidents = await getCustomerAccountIncidents({
+ *   customerAccountId: "98765",
+ *   status: ["OPEN"],
+ *   page: 1,
+ *   size: 10,
+ *   sort: ["createdAt,desc"],
+ * });
+ * ```
+ *
+ * @param {getCustomerAccountIncidentsParameters} params - The parameters for the request.
+ * @throws {Error} If `customerAccountId` is missing.
+ * @returns {Promise<getCustomerAccountIncidentsResponse>} A promise resolving to the incidents response.
+ */
+export declare function getCustomerAccountIncidents({ customerAccountId, status, page, size, sort, }: getCustomerAccountIncidentsParameters): Promise<getCustomerAccountIncidentsResponse>;

package/lib/services/incident/index.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderLogisticIncidents = getOrderLogisticIncidents;
+exports.getOrderLogisticIncident = getOrderLogisticIncident;
+exports.getOrderLogisticLineIncidents = getOrderLogisticLineIncidents;
+exports.createOrderLogisticIncident = createOrderLogisticIncident;
+exports.createOrderLogisticLineIncident = createOrderLogisticLineIncident;
+exports.getCustomerAccountIncidents = getCustomerAccountIncidents;
+const parameters_validation_1 = require("../../helpers/parameters-validation");
+const fetch_instance_1 = require("../../settings/fetch-instance");
+/**
+ * 🚚 Fetches logistic order incidents.
+ *
+ * This function retrieves a paginated list of incidents for a specific logistic order,
+ * filtered by status and other parameters. The `logisticOrderId` parameter is mandatory
+ * and validated before the request is executed.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/logistic-orders/{logisticOrderId}/incidents [ORDER-557]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `logisticOrderId` | `string`                       | ✅         | The ID of the logistic order to fetch incidents for. |
+ * | `status`          | `IncidentStatus[]`             | ❌         | Array of statuses to filter incidents (e.g., `["OPEN"]`). |
+ * | `idType`          | `IncidentIdType`               | ❌         | Specifies whether the ID is internal (`DJUST_ID`) or external (`EXTERNAL_ID`). |
+ * | `page`            | `number`                       | ❌         | The page number for pagination.          |
+ * | `size`            | `number`                       | ❌         | The number of results per page.          |
+ * | `sort`            | `String[]`                    | ❌         | Sorting criteria (e.g., `["createdAt,desc"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to an array of `IncidentDto` objects representing the incidents.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incidents = await getOrderLogisticIncidents({
+ *   logisticOrderId: "12345",
+ *   status: ["OPEN", "CLOSED"],
+ *   idType: "EXTERNAL_ID",
+ *   page: 1,
+ *   size: 10,
+ *   sort: ["createdAt,desc"],
+ * });
+ * ```
+ *
+ * @param {getOrderLogisticIncidentsParameters} params - The parameters for the request.
+ * @throws {Error} If `logisticOrderId` is missing.
+ * @returns {Promise<getOrderLogisticIncidentsResponse>} A promise resolving to the response containing the incidents.
+ */
+async function getOrderLogisticIncidents({ logisticOrderId, status, idType, page, size, sort, }) {
+    (0, parameters_validation_1.required)({ logisticOrderId });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/logistic-orders/${logisticOrderId}/incidents`,
+        params: {
+            status,
+            idType,
+            page,
+            size,
+            sort,
+        },
+    });
+    return data;
+}
+/**
+ * 🚚 Fetches a specific logistic order incident.
+ *
+ * This function retrieves a specific incident for a logistic order, identified by both
+ * the `logisticOrderId` and `incidentId`. Both parameters are mandatory and validated
+ * before the request is executed.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/logistic-orders/{logisticOrderId}/incidents/{incidentId} [ORDER-503]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `logisticOrderId` | `string`                       | ✅         | The ID of the logistic order to fetch the incident for. |
+ * | `incidentId`      | `string`                       | ✅         | The ID of the specific incident to fetch. |
+ * | `idType`          | `IncidentIdType`               | ❌         | Specifies whether the ID is internal (`DJUST_ID`) or external (`EXTERNAL_ID`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a single `getOrderLogisticIncidentResponse` object representing the incident.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incident = await getOrderLogisticIncident({
+ *   logisticOrderId: "12345",
+ *   incidentId: "incident_1",
+ *   idType: "EXTERNAL_ID",
+ * });
+ * ```
+ *
+ * @param {getOrderLogisticIncidentParameters} params - The parameters for the request.
+ * @throws {Error} If `logisticOrderId` or `incidentId` is missing.
+ * @returns {Promise<getOrderLogisticIncidentResponse>} A promise resolving to the response containing the incident.
+ */
+async function getOrderLogisticIncident({ logisticOrderId, incidentId, idType, }) {
+    (0, parameters_validation_1.required)({ logisticOrderId, incidentId });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/logistic-orders/${logisticOrderId}/incidents/${incidentId}`,
+        params: {
+            idType,
+        },
+    });
+    return data;
+}
+/**
+ * 🚚 Fetches incidents for a specific line of a logistic order.
+ *
+ * This function retrieves a list of incidents for a specific line in a logistic order,
+ * filtered by status and other parameters. The `logisticOrderId` and `lineId` parameters
+ * are mandatory and validated before the request is executed.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/logistic-orders/{logisticOrderId}/incidents/lines/{lineId} [ORDER-559]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `logisticOrderId` | `string`                       | ✅         | The ID of the logistic order to fetch incidents for. |
+ * | `lineId`          | `string`                       | ✅         | The ID of the line in the logistic order to fetch incidents for. |
+ * | `status`          | `IncidentStatus[]`             | ❌         | Array of statuses to filter incidents (e.g., `["OPEN"]`). |
+ * | `idType`          | `IncidentIdType`               | ❌         | Specifies whether the ID is internal (`DJUST_ID`) or external (`EXTERNAL_ID`). |
+ * | `page`            | `number`                       | ❌         | The page number for pagination.          |
+ * | `size`            | `number`                       | ❌         | The number of results per page.          |
+ * | `sort`            | `String[]`                     | ❌         | Sorting criteria (e.g., `["createdAt,desc"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to an array of `getOrderLogisticLineIncidentsResponse` objects representing the incidents.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incidents = await getOrderLogisticLineIncidents({
+ *   logisticOrderId: "12345",
+ *   lineId: "line_1",
+ *   status: ["OPEN"],
+ *   idType: "EXTERNAL_ID",
+ *   page: 1,
+ *   size: 10,
+ *   sort: ["createdAt,desc"],
+ * });
+ * ```
+ *
+ * @param {getOrderLogisticLineIncidentsParameters} params - The parameters for the request.
+ * @throws {Error} If `logisticOrderId` or `lineId` is missing.
+ * @returns {Promise<getOrderLogisticLineIncidentsResponse>} A promise resolving to the response containing the incidents.
+ */
+async function getOrderLogisticLineIncidents({ logisticOrderId, lineId, status, idType, page, size, sort, }) {
+    (0, parameters_validation_1.required)({ logisticOrderId, lineId });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/logistic-orders/${logisticOrderId}/incidents/lines/${lineId}`,
+        params: {
+            status,
+            idType,
+            page,
+            size,
+            sort,
+        },
+    });
+    return data;
+}
+/**
+ * 🚚 Creates a new incident for a specific logistic order.
+ *
+ * This function allows the creation of an incident for a given logistic order,
+ * requiring essential parameters like the `logisticOrderId` and `reasonCode`.
+ * The `customField` and `idType` are used to provide additional information for the incident creation.
+ *
+ * 🛠 **Endpoint**: `POST /v1/shop/logistic-orders/{logisticOrderId}/incidents [ORDER-101]`
+ *
+ * | Parameter        | Type                                | Required   | Description                                              |
+ * |------------------|-------------------------------------|------------|----------------------------------------------------------|
+ * | `logisticOrderId`| `string`                            | ✅         | The ID of the logistic order for which the incident is created. |
+ * | `idType`         | `IncidentIdType`                    | ❌         | The type of incident ID (e.g., `DJUST_ID`, `EXTERNAL_ID`). |
+ * | `customField`    | `{ customFieldValues: CustomFieldValueRequest[], idType: IncidentIdType }` | ❌         | The custom field data for the incident, including custom field values and ID type. |
+ * | `reasonCode`     | `string[]`                          | ✅         | The reason codes for the incident (e.g., `["PRODUCT_DEFECT"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a `createOrderLogisticIncidentResponse` object,
+ * containing the `incidentId` and `externalId` of the created incident.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incident = await createOrderLogisticIncident({
+ *   logisticOrderId: "12345",
+ *   idType: "EXTERNAL_ID",
+ *   customField: { customFieldValues: [], idType: "EXTERNAL_ID" },
+ *   reasonCode: ["PRODUCT_DEFECT"]
+ * });
+ * ```
+ *
+ * @param {createOrderLogisticIncidentParameters} params - The parameters for creating the incident.
+ * @throws {Error} If `logisticOrderId` or `reasonCode` is missing.
+ * @returns {Promise<createOrderLogisticIncidentResponse>} A promise resolving to the response containing the created incident's details.
+ */
+async function createOrderLogisticIncident({ logisticOrderId, idType, customField, reasonCode, }) {
+    (0, parameters_validation_1.required)({ logisticOrderId, reasonCode });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "POST",
+        path: `/v1/shop/logistic-orders/${logisticOrderId}/incidents`,
+        params: {
+            idType,
+        },
+        body: JSON.stringify({
+            customField,
+            reasonCode,
+        }),
+    });
+    return data;
+}
+/**
+ * 🚚 Creates a new incident for a specific line within a logistic order.
+ *
+ * This function allows the creation of an incident for one or more lines within a logistic order.
+ * The `logisticOrderId`, `reasonCode`, and `orderLines` are required parameters.
+ * The `customFieldIdType` and `idType` are used for specifying additional information about the incident.
+ *
+ * 🛠 **Endpoint**: `POST /v1/shop/logistic-orders/{logisticOrderId}/lines/incidents [ORDER-102]`
+ *
+ * | Parameter          | Type                                | Required   | Description                                              |
+ * |--------------------|-------------------------------------|------------|----------------------------------------------------------|
+ * | `logisticOrderId`  | `string`                            | ✅         | The ID of the logistic order for which the line incident is created. |
+ * | `idType`           | `IncidentIdType`                    | ❌         | The type of incident ID (e.g., `DJUST_ID`, `EXTERNAL_ID`). |
+ * | `customFieldIdType`| `IncidentIdType`                    | ❌         | The ID type for custom field values (e.g., `EXTERNAL_ID`). |
+ * | `orderLines`       | `{ customFieldValues: CustomFieldValueRequest[], lineId: string, quantity: number }[]` | ✅         | An array of objects describing the order lines, including custom field values, line ID, and quantity. |
+ * | `reasonCode`       | `string[]`                          | ✅         | The reason codes for the incident (e.g., `["PRODUCT_DEFECT"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a `createOrderLogisticLineIncidentResponse` object,
+ * containing the `incidentId` and `externalId` of the created incident.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incident = await createOrderLogisticLineIncident({
+ *   logisticOrderId: "12345",
+ *   idType: "EXTERNAL_ID",
+ *   customFieldIdType: "DJUST_ID",
+ *   orderLines: [
+ *     { customFieldValues: [], lineId: "line_1", quantity: 2 }
+ *   ],
+ *   reasonCode: ["PRODUCT_DEFECT"]
+ * });
+ * ```
+ *
+ * @param {createOrderLogisticLineIncidentParameters} params - The parameters for creating the incident.
+ * @throws {Error} If `logisticOrderId`, `reasonCode`, or `orderLines` is missing.
+ * @returns {Promise<createOrderLogisticLineIncidentResponse>} A promise resolving to the response containing the created incident's details.
+ */
+async function createOrderLogisticLineIncident({ logisticOrderId, idType, customFieldIdType, orderLines, reasonCode, }) {
+    (0, parameters_validation_1.required)({ logisticOrderId, reasonCode, orderLines });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "POST",
+        path: `/v1/shop/logistic-orders/${logisticOrderId}/lines/incidents`,
+        params: {
+            idType,
+        },
+        body: JSON.stringify({
+            customFieldIdType,
+            orderLines,
+            reasonCode,
+        }),
+    });
+    return data;
+}
+/**
+ * 🧑‍💼 Fetches incidents for a specific customer account.
+ *
+ * This function retrieves incidents associated with a particular customer account,
+ * using parameters such as `status`, `page`, `size`, and `sort` to filter and paginate the results.
+ * The `customerAccountId` is a mandatory parameter and is validated before making the request.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/customer-accounts/{customerAccountId}/incidents [ACCOUNT-551]`
+ *
+ * | Parameter         | Type                            | Required   | Description                              |
+ * |-------------------|---------------------------------|------------|------------------------------------------|
+ * | `customerAccountId`| `string`                       | ✅         | The ID of the customer account for which incidents are to be fetched. |
+ * | `status`          | `IncidentStatus[]`             | ❌         | Array of statuses to filter incidents by (e.g., `["OPEN"]`). |
+ * | `page`            | `number`                       | ❌         | The page number for pagination.          |
+ * | `size`            | `number`                       | ❌         | The number of results per page.          |
+ * | `sort`            | `string[]`                     | ❌         | Sorting criteria (e.g., `["createdAt,desc"]`). |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to an array of `getCustomerAccountIncidentsResponse` objects,
+ * representing the incidents for the given customer account.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const incidents = await getCustomerAccountIncidents({
+ *   customerAccountId: "98765",
+ *   status: ["OPEN"],
+ *   page: 1,
+ *   size: 10,
+ *   sort: ["createdAt,desc"],
+ * });
+ * ```
+ *
+ * @param {getCustomerAccountIncidentsParameters} params - The parameters for the request.
+ * @throws {Error} If `customerAccountId` is missing.
+ * @returns {Promise<getCustomerAccountIncidentsResponse>} A promise resolving to the incidents response.
+ */
+async function getCustomerAccountIncidents({ customerAccountId, status, page, size, sort, }) {
+    (0, parameters_validation_1.required)({ customerAccountId });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/customer-accounts/${customerAccountId}/incidents`,
+        params: {
+            status,
+            page,
+            size,
+            sort,
+        },
+    });
+    return data;
+}

package/lib/services/product-variant/definitions.d.ts

@@ -0,0 +1,145 @@
+import { AttributeObject } from "../../interfaces/models/attribute";
+import { PageableParameters } from "../../interfaces/models/common";
+import { OfferResponse } from "../../interfaces/models/offer";
+import { PageProductVariantResponse, Product, ProductAutocomplete, ProductReviewDto, ProductReviewRatings, ProductReviewsSummary, SearchThumbnailsAndAggregation } from "../../interfaces/models/product";
+import { SearchProduct } from "../../interfaces/models/searchProduct";
+import { SupplierSimpleView } from "../../interfaces/models/supplier";
+import { Order, PageableObject } from "../../interfaces/models/common";
+/**
+ * Requests parameters type definitions
+ */
+export interface CreateProductReviewParameters {
+    message: string;
+    productSku: string;
+    rating: number;
+}
+export interface UpdateProductReviewParameters {
+    productReviewId: string;
+    message: string;
+    rating: number;
+}
+declare enum AggregationType {
+    PRODUCT = "PRODUCT",
+    VARIANT = "VARIANT"
+}
+export interface GetProductsListParameters {
+    locale: string;
+    filters?: {
+        currency: string;
+        categoryIds?: string[];
+        skus?: string[];
+        brand?: string[];
+        query?: string;
+        productTags?: string[];
+        aggregation?: AggregationType;
+        attributes?: string[];
+        suppliers?: string[];
+        customFields?: string[];
+        offerUpdatedTime?: string;
+        productUpdatedTime?: string;
+    };
+    pageable?: PageableParameters;
+}
+export interface GetProductStatReviewsParameters {
+    productIdentifier: string;
+    productIdType: string;
+}
+export interface GetProductReviewsParameters {
+    productIdentifier: string;
+    productIdType: string;
+}
+export interface GetProductParameters {
+    productIdentifier: string;
+    productIdType: string;
+    locale?: string;
+}
+export interface GetProductOffersParameters {
+    productIdentifier: string;
+    productIdType: string;
+    locale?: string;
+    currency?: string;
+}
+export interface GetProductVariantsListParameters {
+    productSku: string;
+    locale?: string;
+    pageable?: PageableParameters;
+}
+export interface GetProductVariantAttributesParameters {
+    productIdentifier: string;
+    productIdType: string;
+    locale?: string;
+}
+export interface AutoCompleteSearchProductsParameters {
+    input: string;
+    locale: string;
+    currency: string;
+    aggregation?: AggregationType;
+    productTags?: string[];
+    pageable?: PageableParameters;
+}
+export interface GetProductVariantSuppliersParameters {
+    productVariantId: string;
+}
+export interface GetProductVariantOffersParameters {
+    productIdentifier: string;
+    productIdType: string;
+    currency?: string;
+}
+export interface GetRelatedProductsParameters {
+    productIdentifier: string;
+    productIdType: string;
+    locale?: string;
+    currency?: string;
+    pageable?: PageableParameters;
+}
+/**
+ * Responses type definitions
+ */
+export interface CreateProductReviewResponse extends ProductReviewsSummary {
+}
+export interface UpdateProductReviewResponse extends ProductReviewDto {
+}
+export interface GetProductsListResponse extends SearchProduct {
+}
+export interface GetProductStatReviewsResponse extends ProductReviewRatings {
+}
+export interface GetProductReviewsResponse extends Array<ProductReviewsSummary> {
+}
+export interface GetProductResponse extends Product {
+}
+export interface GetProductOffersResponse extends Array<OfferResponse> {
+}
+export interface GetProductVariantsListResponse extends PageProductVariantResponse {
+}
+export interface GetProductVariantAttributesResponse extends Array<AttributeObject> {
+}
+export interface SearchProductsResponse extends Array<ProductAutocomplete> {
+}
+export interface GetProductVariantSuppliersResponse extends Array<SupplierSimpleView> {
+}
+export interface GetProductVariantOffersResponse extends Array<OfferResponse> {
+}
+export interface GetRelatedProductsResponse extends SearchThumbnailsAndAggregation {
+}
+export interface GetProductPaginatedOffersParameters {
+    productIdentifier: string;
+    productIdType?: string;
+    locale?: string;
+    currency?: string;
+    withoutPrices?: boolean;
+    pageable?: PageableParameters;
+}
+export interface GetProductPaginatedOffersResponse {
+    content: OfferResponse[];
+    empty: boolean;
+    first: boolean;
+    last: boolean;
+    number: number;
+    numberOfElements: number;
+    pageable: PageableObject;
+    size: number;
+    sort: Order[];
+    totalElements: number;
+    totalPages: number;
+}
+export {};

package/lib/services/product-variant/definitions.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AggregationType;
+(function (AggregationType) {
+    AggregationType["PRODUCT"] = "PRODUCT";
+    AggregationType["VARIANT"] = "VARIANT";
+})(AggregationType || (AggregationType = {}));

package/lib/services/product-variant/index.d.ts

@@ -0,0 +1,200 @@
+import { GetProductVariantAttributesParameters, GetProductVariantAttributesResponse, GetProductVariantSuppliersParameters, GetProductVariantSuppliersResponse, GetProductVariantsListParameters, GetProductVariantsListResponse } from "./definitions";
+/**
+ * APICODE(pVAR300)
+ * Retrieves a paginated list of product variants.
+ *
+ * This function fetches a list of product variants associated with a specific product SKU.
+ *
+ * @param {GetProductVariantsListParameters} params - The parameters to filter the product variants list, including:
+ * #### productSku - `string` | <strong style={{ color: 'red' }}>required</strong>
+ * The SKU of the product to fetch variants for.
+ *
+ * #### locale - `string` | optional
+ * The locale for the product variants.
+ *
+ * #### pageable - `object` | optional
+ * Pagination details, including:
+ * - `page`: The page number.
+ * - `size`: The number of items per page.
+ * - `sort`: Sorting criteria.
+ *
+ * @returns {Promise<GetProductVariantsListResponse>} - A promise that resolves with the paginated list of product variants.
+ *
+ * @example
+ * #### input
+ * ```typescript
+ * await getProductVariantsList({
+ *   productSku: 'product123',
+ *   locale: 'en-US',
+ *   pageable: { page: 1, size: 10, sort: 'name,asc' },
+ * });
+ * ```
+ * #### output
+ * ```json
+ * {
+ *   "content": [
+ *     { "id": "variant1", "name": "Variant 1" },
+ *     { "id": "variant2", "name": "Variant 2" }
+ *   ],
+ *   "pageable": {
+ *     "page": 1,
+ *     "size": 10,
+ *     "totalPages": 5
+ *   }
+ * }
+ * ```
+ */
+export declare function getProductVariantsList({ productSku, locale, pageable, }: GetProductVariantsListParameters): Promise<GetProductVariantsListResponse>;
+/**
+ * APICODE(vSUP300)
+ * Retrieves suppliers of a specific product variant.
+ *
+ * This function fetches a list of suppliers associated with a product variant.
+ *
+ * @param {GetProductVariantSuppliersParameters} params - The parameters to identify the product variant, including:
+ * #### productVariantId - `string` | <strong style={{ color: 'red' }}>required</strong>
+ * The ID of the product variant to fetch suppliers for.
+ *
+ * @returns {Promise<GetProductVariantSuppliersResponse>} - A promise that resolves with the suppliers of the product variant.
+ *
+ * @example
+ * #### input
+ * ```typescript
+ * await getProductVariantSuppliers({ productVariantId: 'variant123' });
+ * ```
+ * #### output
+ * ```json
+ * {
+ *   "suppliers": [
+ *     { "id": "supplier1", "name": "Supplier 1" },
+ *     { "id": "supplier2", "name": "Supplier 2" }
+ *   ]
+ * }
+ * ```
+ */
+export declare function getProductVariantSuppliers({ productVariantId, }: GetProductVariantSuppliersParameters): Promise<GetProductVariantSuppliersResponse>;
+/**
+ * ## 🛒 APICODE(vATT300) - Fetch Product Variant Attributes
+ *
+ * Retrieves detailed attributes of a product variant identified by SKU, ID, or external ID.
+ * This metadata includes key details such as **color**, **size**, and **material**, making it easier to describe the variant.
+ *
+ * ---
+ *
+ * ### 📥 Parameters
+ *
+ * | Parameter           | Type     | Required | Description                                                                 |
+ * |---------------------|----------|----------|-----------------------------------------------------------------------------|
+ * | `productIdentifier` | `string` | ✅ Yes    | The unique identifier of the product variant (e.g., SKU, ID, external ID). |
+ * | `productIdType`     | `string` | ✅ Yes    | The type of the identifier: `"sku"`, `"id"`, or `"externalId"`.            |
+ * | `locale`            | `string` | ❌ No     | The locale for localized data (e.g., `"en-US"`, `"fr-FR"`). Defaults to the system locale. |
+ *
+ * ---
+ *
+ * ### 📤 Returns
+ * **Type:** `Promise<GetProductVariantAttributesResponse>`
+ * Resolves with the following structure:
+ *
+ * ```typescript
+ * {
+ *   attributes: Array<{
+ *     id: string;
+ *     name: string;
+ *     value: string | number;
+ *     type: string;
+ *     isRequired: boolean;
+ *     description: string;
+ *   }>;
+ *   locale: string;
+ *   productIdentifier: string;
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### 🧑‍💻 Example Usage
+ *
+ * **Basic Example:**
+ * ```typescript
+ * const attributes = await getProductVariantAttributes({
+ *   productIdentifier: 'sku123',
+ *   productIdType: 'sku',
+ *   locale: 'en-US',
+ * });
+ * console.log(attributes);
+ * ```
+ *
+ * **Alternative Locale:**
+ * ```typescript
+ * const attributes = await getProductVariantAttributes({
+ *   productIdentifier: 'prod789',
+ *   productIdType: 'externalId',
+ *   locale: 'fr-FR',
+ * });
+ * console.log(attributes);
+ * ```
+ *
+ * ---
+ *
+ * ### 📝 Example Input
+ * ```json
+ * {
+ *   "productIdentifier": "sku123",
+ *   "productIdType": "sku",
+ *   "locale": "en-US"
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### 📦 Example Output
+ * ```json
+ * {
+ *   "attributes": [
+ *     {
+ *       "id": "attr1",
+ *       "name": "Color",
+ *       "value": "Red",
+ *       "type": "text",
+ *       "isRequired": true,
+ *       "description": "The color of the product variant."
+ *     },
+ *     {
+ *       "id": "attr2",
+ *       "name": "Size",
+ *       "value": "M",
+ *       "type": "text",
+ *       "isRequired": false,
+ *       "description": "The size of the product variant."
+ *     }
+ *   ],
+ *   "locale": "en-US",
+ *   "productIdentifier": "sku123"
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### 🚨 Error Responses
+ *
+ * | Code  | Message                                  | Description                                          |
+ * |-------|------------------------------------------|------------------------------------------------------|
+ * | `400` | `Bad Request`                            | Missing or invalid `productIdentifier` or `productIdType`. |
+ * | `404` | `Not Found`                              | The specified product variant does not exist.       |
+ * | `500` | `Internal Server Error`                  | Unexpected error on the server.                    |
+ *
+ * ---
+ *
+ * ### 📚 Notes
+ * - Ensure the `productIdType` matches the `productIdentifier` value to avoid mismatched requests.
+ * - Providing a valid `locale` is recommended for fetching localized attribute data when applicable.
+ * - This API version supports strict versioning; ensure compatibility with your application's requirements.
+ *
+ * ---
+ *
+ * ### 🔗 Additional Resources
+ * - [API Authentication Guide](https://docs.example.com/api-authentication)
+ * - [Product Variants Documentation](https://docs.example.com/product-variants)
+ * - [Common Error Codes](https://docs.example.com/error-codes)
+ */
+export declare function getProductVariantAttributes({ productIdentifier, productIdType, locale, }: GetProductVariantAttributesParameters): Promise<GetProductVariantAttributesResponse>;

package/lib/services/product-variant/index.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProductVariantsList = getProductVariantsList;
+exports.getProductVariantSuppliers = getProductVariantSuppliers;
+exports.getProductVariantAttributes = getProductVariantAttributes;
+const parameters_validation_1 = require("../../helpers/parameters-validation");
+const fetch_instance_1 = require("../../settings/fetch-instance");
+/**
+ * APICODE(pVAR300)
+ * Retrieves a paginated list of product variants.
+ *
+ * This function fetches a list of product variants associated with a specific product SKU.
+ *
+ * @param {GetProductVariantsListParameters} params - The parameters to filter the product variants list, including:
+ * #### productSku - `string` | <strong style={{ color: 'red' }}>required</strong>
+ * The SKU of the product to fetch variants for.
+ *
+ * #### locale - `string` | optional
+ * The locale for the product variants.
+ *
+ * #### pageable - `object` | optional
+ * Pagination details, including:
+ * - `page`: The page number.
+ * - `size`: The number of items per page.
+ * - `sort`: Sorting criteria.
+ *
+ * @returns {Promise<GetProductVariantsListResponse>} - A promise that resolves with the paginated list of product variants.
+ *
+ * @example
+ * #### input
+ * ```typescript
+ * await getProductVariantsList({
+ *   productSku: 'product123',
+ *   locale: 'en-US',
+ *   pageable: { page: 1, size: 10, sort: 'name,asc' },
+ * });
+ * ```
+ * #### output
+ * ```json
+ * {
+ *   "content": [
+ *     { "id": "variant1", "name": "Variant 1" },
+ *     { "id": "variant2", "name": "Variant 2" }
+ *   ],
+ *   "pageable": {
+ *     "page": 1,
+ *     "size": 10,
+ *     "totalPages": 5
+ *   }
+ * }
+ * ```
+ */
+async function getProductVariantsList({ productSku, locale, pageable, }) {
+    (0, parameters_validation_1.required)({ productSku });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/product-variants`,
+        params: {
+            productSku,
+            locale,
+            page: pageable === null || pageable === void 0 ? void 0 : pageable.page,
+            size: pageable === null || pageable === void 0 ? void 0 : pageable.size,
+            sort: pageable === null || pageable === void 0 ? void 0 : pageable.sort,
+        },
+    });
+    return data;
+}
+/**
+ * APICODE(vSUP300)
+ * Retrieves suppliers of a specific product variant.
+ *
+ * This function fetches a list of suppliers associated with a product variant.
+ *
+ * @param {GetProductVariantSuppliersParameters} params - The parameters to identify the product variant, including:
+ * #### productVariantId - `string` | <strong style={{ color: 'red' }}>required</strong>
+ * The ID of the product variant to fetch suppliers for.
+ *
+ * @returns {Promise<GetProductVariantSuppliersResponse>} - A promise that resolves with the suppliers of the product variant.
+ *
+ * @example
+ * #### input
+ * ```typescript
+ * await getProductVariantSuppliers({ productVariantId: 'variant123' });
+ * ```
+ * #### output
+ * ```json
+ * {
+ *   "suppliers": [
+ *     { "id": "supplier1", "name": "Supplier 1" },
+ *     { "id": "supplier2", "name": "Supplier 2" }
+ *   ]
+ * }
+ * ```
+ */
+async function getProductVariantSuppliers({ productVariantId, }) {
+    (0, parameters_validation_1.required)({ productVariantId });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/product-variants/${productVariantId}/suppliers`,
+    });
+    return data;
+}
+/**
+ * ## 🛒 APICODE(vATT300) - Fetch Product Variant Attributes
+ *
+ * Retrieves detailed attributes of a product variant identified by SKU, ID, or external ID.
+ * This metadata includes key details such as **color**, **size**, and **material**, making it easier to describe the variant.
+ *
+ * ---
+ *
+ * ### 📥 Parameters
+ *
+ * | Parameter           | Type     | Required | Description                                                                 |
+ * |---------------------|----------|----------|-----------------------------------------------------------------------------|
+ * | `productIdentifier` | `string` | ✅ Yes    | The unique identifier of the product variant (e.g., SKU, ID, external ID). |
+ * | `productIdType`     | `string` | ✅ Yes    | The type of the identifier: `"sku"`, `"id"`, or `"externalId"`.            |
+ * | `locale`            | `string` | ❌ No     | The locale for localized data (e.g., `"en-US"`, `"fr-FR"`). Defaults to the system locale. |
+ *
+ * ---
+ *
+ * ### 📤 Returns
+ * **Type:** `Promise<GetProductVariantAttributesResponse>`
+ * Resolves with the following structure:
+ *
+ * ```typescript
+ * {
+ *   attributes: Array<{
+ *     id: string;
+ *     name: string;
+ *     value: string | number;
+ *     type: string;
+ *     isRequired: boolean;
+ *     description: string;
+ *   }>;
+ *   locale: string;
+ *   productIdentifier: string;
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### 🧑‍💻 Example Usage
+ *
+ * **Basic Example:**
+ * ```typescript
+ * const attributes = await getProductVariantAttributes({
+ *   productIdentifier: 'sku123',
+ *   productIdType: 'sku',
+ *   locale: 'en-US',
+ * });
+ * console.log(attributes);
+ * ```
+ *
+ * **Alternative Locale:**
+ * ```typescript
+ * const attributes = await getProductVariantAttributes({
+ *   productIdentifier: 'prod789',
+ *   productIdType: 'externalId',
+ *   locale: 'fr-FR',
+ * });
+ * console.log(attributes);
+ * ```
+ *
+ * ---
+ *
+ * ### 📝 Example Input
+ * ```json
+ * {
+ *   "productIdentifier": "sku123",
+ *   "productIdType": "sku",
+ *   "locale": "en-US"
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### 📦 Example Output
+ * ```json
+ * {
+ *   "attributes": [
+ *     {
+ *       "id": "attr1",
+ *       "name": "Color",
+ *       "value": "Red",
+ *       "type": "text",
+ *       "isRequired": true,
+ *       "description": "The color of the product variant."
+ *     },
+ *     {
+ *       "id": "attr2",
+ *       "name": "Size",
+ *       "value": "M",
+ *       "type": "text",
+ *       "isRequired": false,
+ *       "description": "The size of the product variant."
+ *     }
+ *   ],
+ *   "locale": "en-US",
+ *   "productIdentifier": "sku123"
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### 🚨 Error Responses
+ *
+ * | Code  | Message                                  | Description                                          |
+ * |-------|------------------------------------------|------------------------------------------------------|
+ * | `400` | `Bad Request`                            | Missing or invalid `productIdentifier` or `productIdType`. |
+ * | `404` | `Not Found`                              | The specified product variant does not exist.       |
+ * | `500` | `Internal Server Error`                  | Unexpected error on the server.                    |
+ *
+ * ---
+ *
+ * ### 📚 Notes
+ * - Ensure the `productIdType` matches the `productIdentifier` value to avoid mismatched requests.
+ * - Providing a valid `locale` is recommended for fetching localized attribute data when applicable.
+ * - This API version supports strict versioning; ensure compatibility with your application's requirements.
+ *
+ * ---
+ *
+ * ### 🔗 Additional Resources
+ * - [API Authentication Guide](https://docs.example.com/api-authentication)
+ * - [Product Variants Documentation](https://docs.example.com/product-variants)
+ * - [Common Error Codes](https://docs.example.com/error-codes)
+ */
+async function getProductVariantAttributes({ productIdentifier, productIdType, locale, }) {
+    (0, parameters_validation_1.required)({ productIdentifier, productIdType });
+    const { data } = await (0, fetch_instance_1.enhancedFetch)({
+        method: "GET",
+        path: `/v1/shop/products/${productIdentifier}/variant-attributes`,
+        params: {
+            productIdType,
+            locale,
+        },
+    });
+    return data;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djust-b2b/djust-front-sdk",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "DJUST Front SDK is a versatile JavaScript Software Development Kit (SDK) ",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",