@reactionary/hcl 0.9.8 → 0.9.11

package/src/capabilities/cart.capability.d.ts

@@ -0,0 +1,69 @@
+import { CartCapability, type Cache, type CartFactory, type CartFactoryCartOutput, type CartFactoryIdentifierOutput, type CartFactoryWithOutput, type CartMutationApplyCoupon, type CartMutationChangeCurrency, type CartMutationCreateCart, type CartMutationDeleteCart, type CartMutationItemAdd, type CartMutationItemQuantityChange, type CartMutationItemRemove, type CartMutationRemoveCoupon, type CartMutationRenameCart, type CartQueryById, type CartQueryList, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import { type HclClient } from '../core/client.js';
+import type { HclCartFactory } from '../factories/cart/cart.factory.js';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclWcsCartResponse } from '../schema/hcl.schema.js';
+export declare class HclCartCapability<TFactory extends CartFactory = HclCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>, CartFactoryIdentifierOutput<TFactory>> {
+    protected config: HclConfiguration;
+    protected client: HclClient;
+    protected factory: CartFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: CartFactoryWithOutput<TFactory>);
+    protected setPendingOrderUrl(orderId: string): string;
+    protected setPendingOrderPayload(orderId: string): {
+        orderId: string;
+    };
+    /**
+     * Set the specified order as the current pending (@self) order.
+     * After this call, @self endpoints will operate on that orderId.
+     */
+    protected fetchSetPendingOrder(orderId: string): Promise<void>;
+    protected wcsOrderUrl(orderId: string): string;
+    /**
+     * Fetch a specific order by ID directly from the Order API.
+     * Does NOT call set_pending_order — safe to use for read-only access.
+     * Throws HclCartNotFoundError on 404.
+     */
+    protected fetchWcsOrder(orderId: string): Promise<HclWcsCartResponse>;
+    protected cartUrl(): string;
+    /**
+     * Fetch the raw WCS cart response.
+     * If orderId is provided, uses GET /order/{orderId} directly (no side effects).
+     * Without orderId, falls back to GET /cart/@self (current pending order).
+     * Throws HclCartNotFoundError on 404.
+     */
+    protected fetchWcsCart(orderId?: string): Promise<HclWcsCartResponse>;
+    /** Fetch and parse the current cart via the factory. */
+    protected fetchCart(orderId?: string): Promise<CartFactoryCartOutput<TFactory>>;
+    protected addOrderItemUrl(currency?: string): string;
+    protected addOrderItemPayload(partNumber: string, quantity: number): object;
+    protected updateOrderItemUrl(): string;
+    protected updateOrderItemPayload(orderItemId: string, quantity: number): object;
+    protected deleteOrderItemUrl(): string;
+    protected deleteOrderItemPayload(orderItemId: string): object;
+    protected deleteCartUrl(orderId?: string): string;
+    protected orderListUrl(): string;
+    protected createOrderUrl(): string;
+    protected createOrderParams(description?: string, currency?: string): URLSearchParams;
+    protected updateOrderDescriptionUrl(): string;
+    protected updateOrderDescriptionPayload(description: string, orderItem: Array<{
+        orderItemId: string;
+        quantity: string;
+    }>): object;
+    protected addPromotionCodeUrl(): string;
+    protected addPromotionCodePayload(code: string): {
+        promoCode: string;
+    };
+    protected removePromotionCodeUrl(code: string): string;
+    getById(payload: CartQueryById): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>>;
+    getActiveCartId(): Promise<Result<CartFactoryIdentifierOutput<TFactory>, NotFoundError>>;
+    add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    listCarts(payload: CartQueryList): Promise<Result<ReturnType<CartFactoryWithOutput<TFactory>['parseCartPaginatedSearchResult']>>>;
+    createCart(payload: CartMutationCreateCart): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
+    renameCart(payload: CartMutationRenameCart): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+}

package/src/capabilities/category.capability.d.ts

@@ -2,6 +2,7 @@ import { CategoryCapability, type Cache, type CategoryFactory, type CategoryFact
 import type { HclConfiguration } from '../schema/configuration.schema.js';
 import type { HclClient } from '../core/client.js';
 import type { HclCategoryFactory } from '../factories/category/category.factory.js';
+import type { HclFindCategoriesQuery, HclUrlResponse } from '../schema/hcl.schema.js';
 export declare class HclCategoryCapability<TFactory extends CategoryFactory = HclCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
     protected readonly config: HclConfiguration;
     protected readonly client: HclClient;
@@ -10,6 +11,24 @@ export declare class HclCategoryCapability<TFactory extends CategoryFactory = Hc
     getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
     getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
     getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Array<CategoryFactoryCategoryOutput<TFactory>>>>;
-    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>, NotFoundError>>;
     findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    protected getByIdUrl(_payload: CategoryQueryById): string;
+    protected getBySlugUrl(_token: HclUrlResponse): string;
+    protected getBreadcrumbLeafUrl(_payload: CategoryQueryForBreadcrumb): string;
+    protected getBreadcrumbAncestorsUrl(_ancestorIds: string[]): string;
+    protected findChildCategoriesParentUrl(_payload: CategoryQueryForChildCategories): string;
+    protected findChildCategoriesUrl(_parentUniqueId: string): string;
+    protected findTopCategoriesUrl(_payload: CategoryQueryForTopCategories): string;
+    protected getByIdPayload(payload: CategoryQueryById): URLSearchParams;
+    protected getBySlugPayload(token: HclUrlResponse): URLSearchParams;
+    protected getBreadcrumbLeafPayload(payload: CategoryQueryForBreadcrumb): URLSearchParams;
+    protected getBreadcrumbAncestorsPayload(ancestorIds: string[]): URLSearchParams;
+    protected findChildCategoriesParentPayload(payload: CategoryQueryForChildCategories): URLSearchParams;
+    protected findChildCategoriesPayload(parentUniqueId: string): URLSearchParams;
+    protected findTopCategoriesPayload(): URLSearchParams;
+    protected categoriesUrl(): string;
+    protected categoriesParams(query: HclFindCategoriesQuery): URLSearchParams;
+    protected urlsUrl(): string;
+    protected urlsParams(slug: string): URLSearchParams;
 }

package/src/capabilities/checkout.capability.d.ts

@@ -0,0 +1,41 @@
+import { CheckoutCapability, type Cache, type CheckoutFactory, type CheckoutFactoryCheckoutOutput, type CheckoutFactoryPaymentMethodOutput, type CheckoutFactoryShippingMethodOutput, type CheckoutFactoryWithOutput, type CheckoutMutationAddPaymentInstruction, type CheckoutMutationFinalizeCheckout, type CheckoutMutationInitiateCheckout, type CheckoutMutationRemovePaymentInstruction, type CheckoutMutationSetShippingAddress, type CheckoutMutationSetShippingInstruction, type CheckoutQueryById, type CheckoutQueryForAvailablePaymentMethods, type CheckoutQueryForAvailableShippingMethods, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import { type HclClient } from '../core/client.js';
+import type { HclCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { HclWcsAddress, HclWcsCartResponse } from '../schema/hcl.schema.js';
+export declare class HclCheckoutCapability<TFactory extends CheckoutFactory = HclCheckoutFactory> extends CheckoutCapability<CheckoutFactoryCheckoutOutput<TFactory>, CheckoutFactoryShippingMethodOutput<TFactory>, CheckoutFactoryPaymentMethodOutput<TFactory>> {
+    protected config: HclConfiguration;
+    protected client: HclClient;
+    protected factory: CheckoutFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: CheckoutFactoryWithOutput<TFactory>);
+    protected cartUrl(): string;
+    /** Fetch the raw WCS cart response. Throws HclCartNotFoundError on 404. */
+    protected fetchWcsCart(): Promise<HclWcsCartResponse>;
+    /** Fetch and parse the active cart as a Checkout. */
+    protected fetchCheckout(extra?: Partial<HclWcsCartResponse & {
+        resultingOrderKey?: string;
+    }>): Promise<CheckoutFactoryCheckoutOutput<TFactory>>;
+    protected paymentMethodsUrl(): string;
+    protected addPaymentInstructionUrl(): string;
+    protected deletePaymentInstructionUrl(piId: string): string;
+    protected shippingModesUrl(): string;
+    protected shippingModesParams(): URLSearchParams;
+    protected shippingInfoUrl(): string;
+    protected setShippingInfoPayload(body: {
+        shipModeId?: string;
+        orderItemId?: string[];
+        x_addr?: HclWcsAddress;
+    }): object;
+    protected setShippingAddressForItemsPayload(orderItemIds: string[], addr: HclWcsAddress): object;
+    protected precheckoutUrl(): string;
+    protected submitCheckoutUrl(): string;
+    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    getById(_payload: CheckoutQueryById): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>>;
+    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    getAvailableShippingMethods(_payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>>;
+    getAvailablePaymentMethods(_payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<CheckoutFactoryPaymentMethodOutput<TFactory>[]>>;
+    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    finalizeCheckout(_payload: CheckoutMutationFinalizeCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+}

package/src/capabilities/identity.capability.d.ts

@@ -0,0 +1,29 @@
+import { type Cache, type IdentityFactory, type IdentityFactoryOutput, type IdentityFactoryWithOutput, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, IdentityCapability, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclIdentityFactory } from '../factories/identity/identity.factory.js';
+export declare class HclIdentityCapability<TFactory extends IdentityFactory = HclIdentityFactory> extends IdentityCapability<IdentityFactoryOutput<TFactory>> {
+    protected config: HclConfiguration;
+    protected client: HclClient;
+    protected factory: IdentityFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: IdentityFactoryWithOutput<TFactory>);
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    login(payload: IdentityMutationLogin): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    register(payload: IdentityMutationRegister): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    private storeSessionTokens;
+    private clearSessionTokens;
+    protected loginIdentityUrl(): string;
+    protected loginIdentityPayload(logonId: string, logonPassword: string): {
+        logonId: string;
+        logonPassword: string;
+    };
+    protected deleteLoginIdentityUrl(userId: string): string;
+    protected createGuestIdentityUrl(): string;
+    protected registerPersonUrl(): string;
+    protected registerPersonPayload(logonId: string, logonPassword: string): {
+        logonId: string;
+        logonPassword: string;
+        logonPasswordVerify: string;
+    };
+}

package/src/capabilities/inventory.capability.d.ts

@@ -0,0 +1,13 @@
+import { InventoryCapability, type Cache, type InventoryFactory, type InventoryFactoryOutput, type InventoryFactoryWithOutput, type InventoryQueryBySKU, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class HclInventoryCapability<TFactory extends InventoryFactory = HclInventoryFactory> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: InventoryFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: InventoryFactoryWithOutput<TFactory>);
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>>;
+    protected getBySKUUrl(payload: InventoryQueryBySKU): string;
+    protected getBySKUPayload(payload: InventoryQueryBySKU): URLSearchParams;
+}

package/src/capabilities/price.capability.d.ts

@@ -0,0 +1,16 @@
+import { PriceCapability, type Cache, type CustomerPriceQuery, type ListPriceQuery, type PriceFactory, type PriceFactoryOutput, type PriceFactoryWithOutput, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclPriceFactory } from '../factories/price/price.factory.js';
+export declare class HclPriceCapability<TFactory extends PriceFactory = HclPriceFactory> extends PriceCapability<PriceFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: PriceFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: PriceFactoryWithOutput<TFactory>);
+    getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    protected getListPriceUrl(): string;
+    protected getListPricePayload(sku: string, priceRuleId: string): URLSearchParams;
+    protected getCustomerPriceUrl(): string;
+    protected getCustomerPricePayload(sku: string): URLSearchParams;
+}

package/src/capabilities/product-search.capability.d.ts

@@ -2,13 +2,18 @@ import { ProductSearchCapability, type Cache, type FacetValueIdentifier, type Pr
 import type { HclConfiguration } from '../schema/configuration.schema.js';
 import type { HclClient } from '../core/client.js';
 import type { HclProductSearchFactory } from '../factories/product-search/product-search.factory.js';
-import type { HclFindProductsQuery } from '../schema/hcl.schema.js';
+import type { HclFindCategoriesQuery, HclFindProductsQuery } from '../schema/hcl.schema.js';
 export declare class HclProductSearchCapability<TFactory extends ProductSearchFactory = HclProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
     protected readonly config: HclConfiguration;
     protected readonly client: HclClient;
     protected readonly factory: ProductSearchFactoryWithOutput<TFactory>;
     constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductSearchFactoryWithOutput<TFactory>);
-    protected queryByTermPayload(payload: ProductSearchQueryByTerm): HclFindProductsQuery;
+    protected queryByTermPayload(payload: ProductSearchQueryByTerm): URLSearchParams;
     queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
     createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+    protected queryByTermUrl(_payload: ProductSearchQueryByTerm): string;
+    protected productsUrl(): string;
+    protected productsParams(query: HclFindProductsQuery): URLSearchParams;
+    protected categoriesUrl(): string;
+    protected categoriesParams(query: HclFindCategoriesQuery): URLSearchParams;
 }

package/src/capabilities/product.capability.d.ts

@@ -2,7 +2,7 @@ import { ProductCapability, type Cache, type NotFoundError, type ProductFactory,
 import type { HclConfiguration } from '../schema/configuration.schema.js';
 import type { HclClient } from '../core/client.js';
 import type { HclProductFactory } from '../factories/product/product.factory.js';
-import type { HclProductResponse } from '../schema/hcl.schema.js';
+import type { HclFindCategoriesQuery, HclFindProductsQuery, HclProductResponse, HclUrlResponse } from '../schema/hcl.schema.js';
 export declare class HclProductCapability<TFactory extends ProductFactory = HclProductFactory> extends ProductCapability<ProductFactoryOutput<TFactory>> {
     protected readonly config: HclConfiguration;
     protected readonly client: HclClient;
@@ -16,5 +16,17 @@ export declare class HclProductCapability<TFactory extends ProductFactory = HclP
      * category identifiers (e.g. "LivingRoomFurniture") so the factory receives
      * human-readable keys rather than internal uniqueIDs.
      */
-    protected withResolvedParentCategories(data: HclProductResponse, langId: string): Promise<HclProductResponse>;
+    protected withResolvedParentCategories(data: HclProductResponse): Promise<HclProductResponse>;
+    protected getByIdUrl(_payload: ProductQueryById): string;
+    protected getBySlugUrl(_token: HclUrlResponse): string;
+    protected getBySKUUrl(_payload: ProductQueryBySKU): string;
+    protected getByIdPayload(payload: ProductQueryById): URLSearchParams;
+    protected getBySlugPayload(token: HclUrlResponse): URLSearchParams;
+    protected getBySKUPayload(payload: ProductQueryBySKU): URLSearchParams;
+    protected productsUrl(): string;
+    protected productsParams(query: HclFindProductsQuery): URLSearchParams;
+    protected categoriesUrl(): string;
+    protected categoriesParams(query: HclFindCategoriesQuery): URLSearchParams;
+    protected urlsUrl(): string;
+    protected urlsParams(slug: string): URLSearchParams;
 }

package/src/core/client.d.ts

@@ -1,19 +1,46 @@
+import type { RequestContext } from '@reactionary/core';
 import type { HclConfiguration } from '../schema/configuration.schema.js';
-import type { HclCategoryQueryResponse, HclFindCategoriesQuery, HclFindProductsQuery, HclProductQueryResponse, HclUrlResponse } from '../schema/hcl.schema.js';
+/** Thrown when the WCS server returns 404 for a cart endpoint (no active cart). */
+export declare class HclCartNotFoundError extends Error {
+    constructor();
+}
+/**
+ * Unified HCL Commerce HTTP client.
+ *
+ * Covers both the Query Service (catalog/search) and the WCS Transaction
+ * Service through two base URL prefixes:
+ *
+ *   catalogBaseUrl     — {apiUrl}/search/resources
+ *   transactionBaseUrl — {apiUrl}/wcs/resources/store/{storeId}
+ *
+ * Auth headers are read from the injected RequestContext on every request,
+ * so capabilities never need to extract and forward session tokens manually.
+ *
+ * Use the generic `callGet` / `callPost` / `callPut` / `callDelete` helpers
+ * in capability subclasses, passing the appropriate base URL + path, so that
+ * project-level subclasses can intercept and customise individual API calls.
+ */
 export declare class HclClient {
-    private readonly config;
-    private readonly baseUrl;
-    constructor(config: HclConfiguration);
-    findProducts(query: HclFindProductsQuery): Promise<HclProductQueryResponse>;
-    /**
-     * Resolve a URL slug to an HCL token (product partNumber, category ID, etc.).
-     * Calls GET /api/v2/urls?storeId=X&identifier=<slug>
-     * Returns undefined when the slug is not found (404).
-     */
-    resolveSlug(slug: string, langId?: string): Promise<HclUrlResponse | undefined>;
+    protected readonly config: HclConfiguration;
+    protected readonly context: RequestContext;
+    /** Base URL for the Query Service (catalog / search). */
+    readonly catalogBaseUrl: string;
+    /** Base URL for the Transaction Service (WCS REST). */
+    readonly transactionBaseUrl: string;
+    constructor(config: HclConfiguration, context: RequestContext);
+    callGet<T>(url: string, params?: URLSearchParams): Promise<T>;
+    callGet<T>(url: string, params: URLSearchParams | undefined, opts: {
+        allowUndefined: true;
+    }): Promise<T | undefined>;
+    callPost<T>(url: string, body?: unknown): Promise<T>;
+    callPut<T>(url: string, body: unknown): Promise<T>;
+    callDelete(url: string, opts?: {
+        ignore404?: boolean;
+    }): Promise<void>;
     /**
-     * Query categories from the HCL Commerce Query Service.
-     * Calls GET /api/v2/categories with the given query parameters.
+     * Merges caller-supplied params with locale defaults (langId, currency)
+     * derived from the request context. Caller-supplied values always win.
      */
-    findCategories(query: HclFindCategoriesQuery): Promise<HclCategoryQueryResponse>;
+    protected buildParams(params?: URLSearchParams): URLSearchParams;
+    protected buildHeaders(): Record<string, string>;
 }

package/src/core/initialize.types.d.ts

@@ -1,9 +1,14 @@
 import type { ClientFromCapabilities } from '@reactionary/core';
 import type { HclCapabilities } from '../schema/capabilities.schema.js';
+import type { HclCartCapability } from '../capabilities/cart.capability.js';
+import type { HclCheckoutCapability } from '../capabilities/checkout.capability.js';
 import type { HclProductCapability } from '../capabilities/product.capability.js';
 import type { HclCategoryCapability } from '../capabilities/category.capability.js';
 import type { HclProductSearchCapability } from '../capabilities/product-search.capability.js';
-type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'inventory';
+import type { HclPriceCapability } from '../capabilities/price.capability.js';
+import type { HclInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { HclIdentityCapability } from '../capabilities/identity.capability.js';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'inventory' | 'identity';
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
 } ? true : false;
@@ -17,11 +22,12 @@ type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapabil
 type DefaultCapabilityMap = {
     product: HclProductCapability;
     productSearch: HclProductSearchCapability;
-    cart: never;
-    checkout: never;
+    cart: HclCartCapability;
+    checkout: HclCheckoutCapability;
     category: HclCategoryCapability;
-    price: never;
-    inventory: never;
+    price: HclPriceCapability;
+    inventory: HclInventoryCapability;
+    identity: HclIdentityCapability;
 };
 type CapabilityImplementationMap<T extends HclCapabilities> = {
     [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap[K]>;

package/src/core/session-keys.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Session key constants for WCS auth data stored in RequestContext.session.
+ * All keys use the `hcl.` prefix per provider convention.
+ *
+ * Centralised here so that both HclTransactionClient (which reads them to build
+ * auth headers) and HclIdentityCapability (which writes them after login/logout)
+ * use the exact same string values.
+ */
+export declare const SESSION_KEY_WC_TOKEN = "hcl.WCToken";
+export declare const SESSION_KEY_WC_TRUSTED_TOKEN = "hcl.WCTrustedToken";
+export declare const SESSION_KEY_USER_ID = "hcl.userId";
+export declare const SESSION_KEY_IDENTITY_TYPE = "hcl.identityType";
+export declare const SESSION_KEY_PERSONALIZATION_ID = "hcl.personalizationID";
+export declare const SESSION_KEY_PRICE_RULE_ID = "hcl.priceRuleId";

package/src/factories/cart/cart.factory.d.ts

@@ -0,0 +1,11 @@
+import type * as z from 'zod';
+import { type CartSchema, CartIdentifierSchema, CartPaginatedSearchResultSchema, type AnyCartSchema, type AnyCartIdentifierSchema, type AnyCartPaginatedSearchResult, type CartFactory, type RequestContext, type CartQueryList } from '@reactionary/core';
+export declare class HclCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema, TCartPaginatedSearchResult extends AnyCartPaginatedSearchResult = typeof CartPaginatedSearchResultSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema, TCartPaginatedSearchResult> {
+    readonly cartSchema: TCartSchema;
+    readonly cartIdentifierSchema: TCartIdentifierSchema;
+    readonly cartPaginatedSearchResultSchema: TCartPaginatedSearchResult;
+    constructor(cartSchema: TCartSchema, cartIdentifierSchema?: TCartIdentifierSchema, cartPaginatedSearchResultSchema?: TCartPaginatedSearchResult);
+    parseCart(context: RequestContext, data: unknown): z.output<TCartSchema>;
+    parseCartIdentifier(_context: RequestContext, data: unknown): z.output<TCartIdentifierSchema>;
+    parseCartPaginatedSearchResult(context: RequestContext, data: unknown, _query: CartQueryList): z.output<TCartPaginatedSearchResult>;
+}

package/src/factories/checkout/checkout.factory.d.ts

@@ -0,0 +1,11 @@
+import type * as z from 'zod';
+import { type CheckoutSchema, ShippingMethodSchema, PaymentMethodSchema, type AnyCheckoutSchema, type AnyShippingMethodSchema, type AnyPaymentMethodSchema, type CheckoutFactory, type RequestContext } from '@reactionary/core';
+export declare class HclCheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema> {
+    readonly checkoutSchema: TCheckoutSchema;
+    readonly shippingMethodSchema: TShippingMethodSchema;
+    readonly paymentMethodSchema: TPaymentMethodSchema;
+    constructor(checkoutSchema: TCheckoutSchema, shippingMethodSchema?: TShippingMethodSchema, paymentMethodSchema?: TPaymentMethodSchema);
+    parseCheckout(context: RequestContext, data: unknown): z.output<TCheckoutSchema>;
+    parseShippingMethod(_context: RequestContext, data: unknown): z.output<TShippingMethodSchema>;
+    parsePaymentMethod(_context: RequestContext, data: unknown): z.output<TPaymentMethodSchema>;
+}

package/src/factories/identity/identity.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyIdentitySchema, IdentityFactory, IdentitySchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class HclIdentityFactory<TIdentitySchema extends AnyIdentitySchema = typeof IdentitySchema> implements IdentityFactory<TIdentitySchema> {
+    readonly identitySchema: TIdentitySchema;
+    constructor(identitySchema: TIdentitySchema);
+    parseIdentity(_context: RequestContext, data: unknown): z.output<TIdentitySchema>;
+}

package/src/factories/index.d.ts

@@ -1,3 +1,8 @@
+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';

package/src/factories/inventory/inventory.factory.d.ts

@@ -0,0 +1,29 @@
+import type { InventorySchema, AnyInventorySchema, Inventory, InventoryFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclInventoryAvailabilityItem } from '../../schema/hcl.schema.js';
+/**
+ * Input shape for HclInventoryFactory.parseInventory.
+ * Bundles the WCS response item with request context needed to build the identifier.
+ */
+export interface HclInventoryFactoryInput {
+    /** One entry from InventoryAvailability[] in the WCS response. */
+    item: HclInventoryAvailabilityItem;
+    /** The requested part number / SKU (from the getBySKU payload). */
+    sku: string;
+    /** The requested fulfilment center key. Empty string means online inventory. */
+    fulfilmentCenterKey: string;
+}
+export declare class HclInventoryFactory<TSchema extends AnyInventorySchema = typeof InventorySchema> implements InventoryFactory<TSchema> {
+    readonly inventorySchema: TSchema;
+    constructor(inventorySchema: TSchema);
+    /**
+     * 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: RequestContext, data: HclInventoryFactoryInput): z.output<TSchema>;
+    /** Create an empty (out-of-stock) inventory when no matching record was found. */
+    createEmpty(sku: string, fulfilmentCenterKey: string): z.output<TSchema>;
+}
+export type AnyHclInventorySchema = AnyInventorySchema;
+export type HclInventoryFactoryOutput<T extends InventoryFactory> = T extends HclInventoryFactory<infer TSchema> ? z.output<TSchema> : Inventory;

package/src/factories/price/price.factory.d.ts

@@ -0,0 +1,26 @@
+import type { PriceSchema, AnyPriceSchema, Price, PriceFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { HclDisplayPriceItem, HclEntitledPriceItem } from '../../schema/hcl.schema.js';
+/**
+ * Input shape for HclPriceFactory.parsePrice.
+ * Accepts items from either the /price (EntitledPrice) or /display_price (resultList) endpoints.
+ * The `item.partNumber` is used as the variant SKU identifier.
+ */
+export interface HclPriceFactoryInput {
+    item: HclEntitledPriceItem | HclDisplayPriceItem;
+}
+export declare class HclPriceFactory<TSchema extends AnyPriceSchema = typeof PriceSchema> implements PriceFactory<TSchema> {
+    readonly priceSchema: TSchema;
+    constructor(priceSchema: TSchema);
+    /**
+     * 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: RequestContext, data: HclPriceFactoryInput): z.output<TSchema>;
+    /** Create an empty (placeholder) price when no result was found for a SKU. */
+    createEmpty(sku: string, currency: string): z.output<TSchema>;
+}
+export type AnyHclPriceSchema = AnyPriceSchema;
+export type HclPriceFactoryOutput<T extends PriceFactory> = T extends HclPriceFactory<infer TSchema> ? z.output<TSchema> : Price;

package/src/index.d.ts

@@ -6,6 +6,11 @@ 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';

package/src/schema/capabilities.schema.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, RequestContext, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability } from '@reactionary/core';
+import type { Cache, RequestContext, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability } from '@reactionary/core';
 import type { HclConfiguration } from './configuration.schema.js';
 import type { HclClient } from '../core/client.js';
 import * as z from 'zod';
@@ -33,6 +33,11 @@ export declare const HclCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    identity: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
     productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;
         factory: z.ZodOptional<z.ZodUnknown>;
@@ -61,3 +66,4 @@ export type HclInventoryCapabilityConfig = HclCapabilityConfig<InventoryFactoryW
 export type HclPriceCapabilityConfig = HclCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
 export type HclProductCapabilityConfig = HclCapabilityConfig<ProductFactoryWithOutput<ProductFactory>, ProductCapability>;
 export type HclProductSearchCapabilityConfig = HclCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
+export type HclIdentityCapabilityConfig = HclCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityCapability>;

package/src/schema/configuration.schema.d.ts

@@ -15,5 +15,11 @@ export declare const HclConfigurationSchema: z.ZodObject<{
         productSearch: z.ZodDefault<z.ZodString>;
         categoryBrowse: z.ZodDefault<z.ZodString>;
     }, z.core.$loose>>;
+    /**
+     * 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.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type HclConfiguration = z.infer<typeof HclConfigurationSchema>;