@reactionary/hcl 0.9.8 → 0.9.12

package/factories/cart/cart.factory.js

@@ -0,0 +1,135 @@
+import {
+  CartIdentifierSchema,
+  CartPaginatedSearchResultSchema
+} from "@reactionary/core";
+class HclCartFactory {
+  constructor(cartSchema, cartIdentifierSchema = CartIdentifierSchema, cartPaginatedSearchResultSchema = CartPaginatedSearchResultSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+    this.cartPaginatedSearchResultSchema = cartPaginatedSearchResultSchema;
+  }
+  parseCart(context, data) {
+    const cart = data;
+    const currency = cart.totalProductPriceCurrency ?? cart.grandTotalCurrency ?? "USD";
+    return this.cartSchema.parse({
+      identifier: { key: cart.orderId },
+      user: { userId: cart.buyerId ?? "" },
+      company: cart.orgUniqueID ? { id: cart.orgUniqueID } : void 0,
+      name: cart.orderDescription ?? context.session["hcl.cartName"] ?? "",
+      description: "",
+      items: (cart.orderItem ?? []).map((item) => ({
+        identifier: { key: item.orderItemId },
+        product: { key: item.productId ?? "" },
+        variant: { sku: item.partNumber },
+        quantity: Number(item.quantity),
+        price: {
+          unitPrice: {
+            value: Number(item.unitPrice),
+            currency: item.currency
+          },
+          totalPrice: {
+            value: Number(item.orderItemPrice),
+            currency: item.currency
+          },
+          unitDiscount: { value: 0, currency: item.currency },
+          totalDiscount: { value: 0, currency: item.currency }
+        }
+      })),
+      price: {
+        grandTotal: {
+          value: Number(cart.grandTotal ?? "0"),
+          currency
+        },
+        totalProductPrice: {
+          value: Number(cart.totalProductPrice ?? "0"),
+          currency
+        },
+        totalShipping: {
+          value: Number(cart.totalShippingCharge ?? "0"),
+          currency
+        },
+        totalTax: {
+          value: Number(cart.totalSalesTax ?? "0"),
+          currency
+        },
+        totalDiscount: {
+          value: Math.abs(Number(cart.totalAdjustment ?? "0")),
+          currency
+        },
+        totalSurcharge: { value: 0, currency }
+      },
+      appliedPromotions: (cart.adjustment ?? []).filter((adj) => adj.usage === "Discount").map((adj) => ({
+        code: adj.code,
+        isCouponCode: (cart.promotionCode ?? []).some(
+          (pc) => pc.code === adj.code
+        ),
+        name: adj.description ?? adj.code,
+        description: adj.description ?? "",
+        amount: {
+          value: Math.abs(Number(adj.amount)),
+          currency: adj.currency
+        }
+      }))
+    });
+  }
+  parseCartIdentifier(_context, data) {
+    const cart = data;
+    return this.cartIdentifierSchema.parse({
+      key: cart.orderId
+    });
+  }
+  parseCartPaginatedSearchResult(context, data, _query) {
+    const pageSize = _query.search.paginationOptions.pageSize;
+    const pageNumber = _query.search.paginationOptions.pageNumber;
+    const orderList = data;
+    if (Array.isArray(orderList.Order)) {
+      const orders = orderList.Order;
+      const total = Number(orderList.recordSetTotal ?? orders.length);
+      const items = orders.map((order) => {
+        const parsed = this.parseCart(context, order);
+        return {
+          ...parsed,
+          numItems: (order.orderItem ?? []).length,
+          lastModifiedDate: order.lastUpdateDate ?? ""
+        };
+      });
+      return this.cartPaginatedSearchResultSchema.parse({
+        identifier: _query.search,
+        items,
+        totalCount: total,
+        totalPages: Math.ceil(total / Math.max(1, pageSize)),
+        pageSize,
+        pageNumber
+      });
+    }
+    const cart = data;
+    if (!cart.orderId) {
+      return this.cartPaginatedSearchResultSchema.parse({
+        identifier: _query.search,
+        items: [],
+        totalCount: 0,
+        totalPages: 0,
+        pageSize,
+        pageNumber
+      });
+    }
+    const parsedCart = this.parseCart(context, cart);
+    return this.cartPaginatedSearchResultSchema.parse({
+      identifier: _query.search,
+      items: [
+        {
+          ...parsedCart,
+          numItems: (cart.orderItem ?? []).length,
+          lastModifiedDate: cart.lastUpdateDate ?? ""
+        }
+      ],
+      totalCount: 1,
+      totalPages: 1,
+      pageSize,
+      pageNumber
+    });
+  }
+}
+export {
+  HclCartFactory
+};

package/factories/checkout/checkout.factory.js

@@ -0,0 +1,131 @@
+import {
+  ShippingMethodSchema,
+  PaymentMethodSchema
+} from "@reactionary/core";
+class HclCheckoutFactory {
+  constructor(checkoutSchema, shippingMethodSchema = ShippingMethodSchema, paymentMethodSchema = PaymentMethodSchema) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+  parseCheckout(context, data) {
+    const cart = data;
+    const currency = cart.totalProductPriceCurrency ?? cart.grandTotalCurrency ?? "USD";
+    const shipModeId = cart.shipModeId ?? (cart.orderItem ?? [])[0]?.shipModeId;
+    const shippingInstruction = shipModeId ? {
+      shippingMethod: { key: shipModeId },
+      pickupPoint: "",
+      instructions: "",
+      consentForUnattendedDelivery: false
+    } : void 0;
+    const billingEmail = cart.x_billingAddress?.email1 ?? (cart.paymentInstruction ?? []).flatMap((pi) => pi.protocolData ?? []).find((pd) => pd.name === "email1")?.value ?? context.session["hcl.notificationEmail"] ?? "noreply@checkout.example.com";
+    const paymentInstructions = (cart.paymentInstruction ?? []).map((pi) => ({
+      identifier: { key: pi.piId },
+      paymentMethod: {
+        method: pi.payMethodId,
+        name: pi.payMethodId,
+        paymentProcessor: pi.payMethodId
+      },
+      amount: {
+        value: Number(pi.piAmount ?? "0"),
+        currency: pi.currency ?? currency
+      },
+      protocolData: (pi.protocolData ?? []).map((pd) => ({
+        key: pd.name,
+        value: pd.value
+      })),
+      status: "pending"
+    }));
+    const parseAddress = (addr) => {
+      if (!addr)
+        return void 0;
+      return {
+        identifier: { key: addr.addressId ?? "" },
+        firstName: addr.firstName ?? "",
+        lastName: addr.lastName ?? "",
+        streetAddress: (addr.addressLine ?? [])[0] ?? "",
+        streetNumber: "",
+        city: addr.city ?? "",
+        region: addr.state ?? "",
+        postalCode: addr.zipCode ?? "",
+        countryCode: addr.country ?? ""
+      };
+    };
+    return this.checkoutSchema.parse({
+      identifier: { key: cart.orderId },
+      originalCartReference: { key: cart.orderId },
+      resultingOrder: cart.resultingOrderKey ? { key: cart.resultingOrderKey } : void 0,
+      items: (cart.orderItem ?? []).map((item) => ({
+        identifier: { key: item.orderItemId },
+        variant: { sku: item.partNumber },
+        quantity: Number(item.quantity),
+        price: {
+          unitPrice: {
+            value: Number(item.unitPrice),
+            currency: item.currency
+          },
+          totalPrice: {
+            value: Number(item.orderItemPrice),
+            currency: item.currency
+          },
+          unitDiscount: { value: 0, currency: item.currency },
+          totalDiscount: { value: 0, currency: item.currency }
+        }
+      })),
+      price: {
+        grandTotal: { value: Number(cart.grandTotal ?? "0"), currency },
+        totalProductPrice: {
+          value: Number(cart.totalProductPrice ?? "0"),
+          currency
+        },
+        totalShipping: {
+          value: Number(cart.totalShippingCharge ?? "0"),
+          currency
+        },
+        totalTax: { value: Number(cart.totalSalesTax ?? "0"), currency },
+        totalDiscount: {
+          value: Math.abs(Number(cart.totalAdjustment ?? "0")),
+          currency
+        },
+        totalSurcharge: { value: 0, currency }
+      },
+      name: context.session["hcl.cartName"] ?? "",
+      description: "",
+      shippingAddress: parseAddress(cart.x_shippingAddress),
+      billingAddress: parseAddress(cart.x_billingAddress),
+      shippingInstruction,
+      paymentInstructions,
+      pointOfContact: {
+        email: billingEmail,
+        phone: cart.x_billingAddress?.phone1
+      },
+      readyForFinalization: paymentInstructions.length > 0 && !!cart.shipModeId
+    });
+  }
+  parseShippingMethod(_context, data) {
+    const mode = data;
+    return this.shippingMethodSchema.parse({
+      identifier: { key: mode.shipModeId },
+      name: mode.shipModeDescription || mode.shipModeCode,
+      description: mode.shipModeDescription || mode.shipModeCode,
+      price: { value: 0, currency: "USD" },
+      deliveryTime: mode.field2 ?? "",
+      carrier: mode.carrier
+    });
+  }
+  parsePaymentMethod(_context, data) {
+    const method = data;
+    return this.paymentMethodSchema.parse({
+      identifier: {
+        method: method.paymentMethodName,
+        name: method.description ?? method.paymentMethodName,
+        paymentProcessor: method.paymentMethodName
+      },
+      description: method.description ?? method.paymentMethodName,
+      isPunchOut: false
+    });
+  }
+}
+export {
+  HclCheckoutFactory
+};

package/factories/identity/identity.factory.js

@@ -0,0 +1,12 @@
+class HclIdentityFactory {
+  identitySchema;
+  constructor(identitySchema) {
+    this.identitySchema = identitySchema;
+  }
+  parseIdentity(_context, data) {
+    return this.identitySchema.parse(data);
+  }
+}
+export {
+  HclIdentityFactory
+};

package/factories/index.js

@@ -1,3 +1,11 @@
+export * from "./cart/cart.factory.js";
+export * from "./checkout/checkout.factory.js";
 export * from "./product/product.factory.js";
 export * from "./category/category.factory.js";
 export * from "./product-search/product-search.factory.js";
+export * from "./price/price.factory.js";
+export * from "./inventory/inventory.factory.js";
+export * from "./identity/identity.factory.js";
+export * from "./profile/profile.factory.js";
+export * from "./order/order.factory.js";
+export * from "./order-search/order-search.factory.js";

package/factories/inventory/inventory.factory.js

@@ -0,0 +1,38 @@
+const HCL_STATUS_AVAILABLE = "Available";
+class HclInventoryFactory {
+  inventorySchema;
+  constructor(inventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+  /**
+   * Map an HclInventoryAvailabilityItem to an Inventory model.
+   * The `data.sku` is used for the identifier since WCS items carry only an
+   * internal `productId`, not the human-readable part number.
+   */
+  parseInventory(_context, data) {
+    const { item, sku, fulfilmentCenterKey } = data;
+    const identifier = {
+      variant: { sku },
+      fulfillmentCenter: { key: fulfilmentCenterKey || "online" }
+    };
+    return this.inventorySchema.parse({
+      identifier,
+      quantity: Number(item.availableQuantity ?? "0"),
+      status: item.inventoryStatus === HCL_STATUS_AVAILABLE ? "inStock" : "outOfStock"
+    });
+  }
+  /** Create an empty (out-of-stock) inventory when no matching record was found. */
+  createEmpty(sku, fulfilmentCenterKey) {
+    return this.inventorySchema.parse({
+      identifier: {
+        variant: { sku },
+        fulfillmentCenter: { key: fulfilmentCenterKey || "online" }
+      },
+      quantity: 0,
+      status: "outOfStock"
+    });
+  }
+}
+export {
+  HclInventoryFactory
+};

package/factories/order/order.factory.js

@@ -0,0 +1,124 @@
+function mapWcsOrderStatus(status) {
+  switch (status) {
+    case "S":
+      return "Shipped";
+    case "X":
+    case "R":
+    case "D":
+      return "Cancelled";
+    case "M":
+    case "G":
+    case "F":
+      return "ReleasedToFulfillment";
+    default:
+      return "AwaitingPayment";
+  }
+}
+class HclOrderFactory {
+  orderSchema;
+  constructor(orderSchema) {
+    this.orderSchema = orderSchema;
+  }
+  parseOrder(context, data) {
+    const currency = data.grandTotalCurrency ?? data.totalProductPriceCurrency ?? "USD";
+    const orderStatus = mapWcsOrderStatus(data.orderStatus ?? "");
+    const inventoryStatus = orderStatus === "Shipped" ? "Allocated" : "NotAllocated";
+    const userId = { userId: data.buyerId ?? "" };
+    const result = {
+      identifier: { key: data.orderId },
+      userId,
+      items: (data.orderItem ?? []).map(
+        (item) => this.parseOrderItem(context, item, currency)
+      ),
+      price: this.parseCostBreakdown(context, data, currency),
+      orderStatus,
+      inventoryStatus,
+      paymentInstructions: (data.paymentInstruction ?? []).map(
+        (pi) => this.parsePaymentInstruction(context, pi, currency)
+      ),
+      shippingAddress: data.x_shippingAddress ? {
+        identifier: {
+          nickName: data.x_shippingAddress.nickName ?? ""
+        },
+        firstName: data.x_shippingAddress.firstName ?? "",
+        lastName: data.x_shippingAddress.lastName ?? "",
+        streetAddress: data.x_shippingAddress.addressLine?.[0] ?? data.x_shippingAddress.address1 ?? "",
+        streetNumber: data.x_shippingAddress.addressLine?.[1] ?? "",
+        city: data.x_shippingAddress.city ?? "",
+        region: data.x_shippingAddress.state ?? "",
+        postalCode: data.x_shippingAddress.zipCode ?? "",
+        countryCode: data.x_shippingAddress.country ?? ""
+      } : void 0,
+      billingAddress: data.x_billingAddress ? {
+        identifier: {
+          nickName: data.x_billingAddress.nickName ?? ""
+        },
+        firstName: data.x_billingAddress.firstName ?? "",
+        lastName: data.x_billingAddress.lastName ?? "",
+        streetAddress: data.x_billingAddress.addressLine?.[0] ?? data.x_billingAddress.address1 ?? "",
+        streetNumber: data.x_billingAddress.addressLine?.[1] ?? "",
+        city: data.x_billingAddress.city ?? "",
+        region: data.x_billingAddress.state ?? "",
+        postalCode: data.x_billingAddress.zipCode ?? "",
+        countryCode: data.x_billingAddress.country ?? ""
+      } : void 0
+    };
+    return this.orderSchema.parse(result);
+  }
+  parseOrderItem(_context, item, defaultCurrency) {
+    const currency = item.currency ?? defaultCurrency;
+    const price = {
+      unitPrice: { value: Number(item.unitPrice), currency },
+      totalPrice: { value: Number(item.orderItemPrice), currency },
+      unitDiscount: { value: 0, currency },
+      totalDiscount: { value: 0, currency }
+    };
+    return {
+      identifier: { key: item.orderItemId },
+      variant: { sku: item.partNumber },
+      quantity: Number(item.quantity),
+      price,
+      inventoryStatus: "Allocated"
+    };
+  }
+  parseCostBreakdown(_context, data, currency) {
+    return {
+      grandTotal: { value: Number(data.grandTotal ?? "0"), currency },
+      totalProductPrice: {
+        value: Number(data.totalProductPrice ?? "0"),
+        currency
+      },
+      totalShipping: {
+        value: Number(data.totalShippingCharge ?? "0"),
+        currency
+      },
+      totalTax: { value: Number(data.totalSalesTax ?? "0"), currency },
+      totalDiscount: {
+        value: Math.abs(Number(data.totalAdjustment ?? "0")),
+        currency
+      },
+      totalSurcharge: { value: 0, currency }
+    };
+  }
+  parsePaymentInstruction(_context, pi, defaultCurrency) {
+    const currency = pi.currency ?? defaultCurrency;
+    const paymentMethod = {
+      method: pi.payMethodId,
+      name: pi.piDescription ?? pi.payMethodId,
+      paymentProcessor: pi.payMethodId
+    };
+    return {
+      identifier: { key: pi.piId },
+      amount: { value: Number(pi.piAmount ?? "0"), currency },
+      paymentMethod,
+      protocolData: (pi.protocolData ?? []).map((pd) => ({
+        key: pd.name,
+        value: pd.value
+      })),
+      status: "pending"
+    };
+  }
+}
+export {
+  HclOrderFactory
+};

package/factories/order-search/order-search.factory.js

@@ -0,0 +1,59 @@
+function mapWcsOrderStatus(status) {
+  switch (status) {
+    case "S":
+      return "Shipped";
+    case "X":
+    case "R":
+    case "D":
+      return "Cancelled";
+    case "M":
+    case "G":
+    case "F":
+      return "ReleasedToFulfillment";
+    default:
+      return "AwaitingPayment";
+  }
+}
+class HclOrderSearchFactory {
+  orderSearchResultSchema;
+  constructor(orderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+  parseOrderSearchResult(context, data, query) {
+    const items = (data.Order ?? []).map(
+      (o) => this.parseOrderSearchResultItem(context, o)
+    );
+    const totalCount = Number(data.recordSetTotal ?? items.length);
+    const { pageSize, pageNumber } = query.search.paginationOptions;
+    const result = {
+      identifier: { ...query.search },
+      items,
+      totalCount,
+      pageSize,
+      pageNumber,
+      totalPages: Math.ceil(totalCount / Math.max(1, pageSize))
+    };
+    return this.orderSearchResultSchema.parse(result);
+  }
+  parseOrderSearchResultItem(_context, item) {
+    const orderStatus = mapWcsOrderStatus(item.orderStatus ?? "");
+    const inventoryStatus = orderStatus === "Shipped" ? "Allocated" : "NotAllocated";
+    const userId = { userId: item.buyerId ?? "" };
+    const totalAmount = {
+      value: Number(item.grandTotal ?? "0"),
+      currency: item.grandTotalCurrency ?? "USD"
+    };
+    return {
+      identifier: { key: item.orderId },
+      userId,
+      customerName: "",
+      orderDate: item.lastUpdateDate ?? "",
+      orderStatus,
+      inventoryStatus,
+      totalAmount
+    };
+  }
+}
+export {
+  HclOrderSearchFactory
+};

package/factories/price/price.factory.js

@@ -0,0 +1,39 @@
+class HclPriceFactory {
+  priceSchema;
+  constructor(priceSchema) {
+    this.priceSchema = priceSchema;
+  }
+  /**
+   * Map a price response item to a Price model.
+   * Supports both /price (EntitledPrice with capital `UnitPrice`) and
+   * /display_price (resultList with lowercase `unitPrice`) response shapes.
+   * The `item.partNumber` is used as the variant SKU identifier.
+   */
+  parsePrice(_context, data) {
+    const { item } = data;
+    const entitledItem = item;
+    const displayItem = item;
+    const priceEntry = entitledItem.UnitPrice?.[0]?.price ?? displayItem.unitPrice?.[0]?.price;
+    return this.priceSchema.parse({
+      identifier: { variant: { sku: item.partNumber ?? "" } },
+      unitPrice: {
+        value: priceEntry?.value ?? -1,
+        currency: priceEntry?.currency ?? ""
+      },
+      onSale: false,
+      tieredPrices: []
+    });
+  }
+  /** Create an empty (placeholder) price when no result was found for a SKU. */
+  createEmpty(sku, currency) {
+    return this.priceSchema.parse({
+      identifier: { variant: { sku } },
+      unitPrice: { value: -1, currency },
+      onSale: false,
+      tieredPrices: []
+    });
+  }
+}
+export {
+  HclPriceFactory
+};

package/factories/profile/profile.factory.js

@@ -0,0 +1,49 @@
+const BILLING_NICK_NAME = "Billing";
+class HclProfileFactory {
+  profileSchema;
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(context, data) {
+    const contacts = data.contact ?? [];
+    const billingContact = contacts.find(
+      (c) => c.nickName === BILLING_NICK_NAME
+    );
+    const shippingContacts = contacts.filter(
+      (c) => c.nickName !== BILLING_NICK_NAME
+    );
+    const defaultShipping = shippingContacts.find((c) => c.primary === "1") ?? shippingContacts[0];
+    const alternates = shippingContacts.filter((c) => c !== defaultShipping);
+    const result = {
+      identifier: { userId: data.userId },
+      email: data.email1 ?? data.logonId ?? "",
+      phone: data.phone1 ?? "",
+      emailVerified: false,
+      phoneVerified: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      billingAddress: billingContact ? this.parseAddress(context, billingContact) : void 0,
+      shippingAddress: defaultShipping ? this.parseAddress(context, defaultShipping) : void 0,
+      alternateShippingAddresses: alternates.map(
+        (c) => this.parseAddress(context, c)
+      )
+    };
+    return this.profileSchema.parse(result);
+  }
+  parseAddress(_context, contact) {
+    return {
+      identifier: { nickName: contact.nickName },
+      firstName: contact.firstName ?? "",
+      lastName: contact.lastName ?? "",
+      streetAddress: contact.addressLine?.[0] ?? contact.address1 ?? "",
+      streetNumber: contact.addressLine?.[1] ?? "",
+      city: contact.city ?? "",
+      region: contact.stateOrProvinceName ?? "",
+      postalCode: contact.zipCode ?? "",
+      countryCode: contact.country ?? ""
+    };
+  }
+}
+export {
+  HclProfileFactory
+};

package/index.js

@@ -6,6 +6,14 @@ export * from "./core/client.js";
 export * from "./core/initialize.js";
 export * from "./core/initialize.types.js";
 export * from "./factories/index.js";
+export * from "./capabilities/cart.capability.js";
+export * from "./capabilities/checkout.capability.js";
 export * from "./capabilities/product.capability.js";
 export * from "./capabilities/category.capability.js";
 export * from "./capabilities/product-search.capability.js";
+export * from "./capabilities/price.capability.js";
+export * from "./capabilities/inventory.capability.js";
+export * from "./capabilities/identity.capability.js";
+export * from "./capabilities/profile.capability.js";
+export * from "./capabilities/order.capability.js";
+export * from "./capabilities/order-search.capability.js";

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "@reactionary/hcl",
-  "version": "0.9.8",
+  "version": "0.9.12",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.9.8",
-    "zod": "4.1.9",
-    "vitest": "^4.0.9",
-    "@nx/vite": "22.4.5"
+    "@reactionary/core": "0.9.12",
+    "debug": "^4.4.3",
+    "zod": "4.1.9"
+  },
+  "devDependencies": {
+    "@nx/vite": "22.4.5",
+    "vitest": "^4.0.9"
   },
   "sideEffects": false
 }

package/schema/capabilities.schema.js

@@ -12,7 +12,11 @@ const HclCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
   price: true,
   inventory: true,
-  productSearch: true
+  identity: true,
+  productSearch: true,
+  profile: true,
+  order: true,
+  orderSearch: true
 }).extend({
   cart: OverridableCapabilitySchema.optional(),
   checkout: OverridableCapabilitySchema.optional(),
@@ -20,7 +24,11 @@ const HclCapabilitiesSchema = CapabilitiesSchema.pick({
   product: OverridableCapabilitySchema.optional(),
   price: OverridableCapabilitySchema.optional(),
   inventory: OverridableCapabilitySchema.optional(),
-  productSearch: OverridableCapabilitySchema.optional()
+  identity: OverridableCapabilitySchema.optional(),
+  productSearch: OverridableCapabilitySchema.optional(),
+  profile: OverridableCapabilitySchema.optional(),
+  order: OverridableCapabilitySchema.optional(),
+  orderSearch: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   HclCapabilitiesSchema

package/schema/configuration.schema.js

@@ -29,7 +29,15 @@ const HclConfigurationSchema = z.looseObject({
   localeMap: z.record(z.string(), z.string()).default({ "en-US": "-1" }).meta({
     description: "Mapping from BCP 47 locale (RequestContext.languageContext.locale) to HCL langId."
   }),
-  profiles: HclProfilesSchema
+  profiles: HclProfilesSchema,
+  /**
+   * Optional price rule ID passed to /display_price?q=byPartNumbersAndPriceRuleId.
+   * When omitted the server applies its default configured price rule.
+   * In Karkkainen this is '10003'.
+   */
+  priceRuleId: z.string().optional().meta({
+    description: "Price rule ID for /display_price WCS calls. Optional \u2014 the server uses its default rule when absent."
+  })
 });
 export {
   HclConfigurationSchema