@reactionary/hcl 0.9.13 → 0.9.14

package/capabilities/store.capability.js

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  Reactionary,
+  StoreCapability,
+  StoreQueryByProximitySchema,
+  StoreSchema,
+  success
+} from "@reactionary/core";
+import * as z from "zod";
+import createDebug from "debug";
+const debug = createDebug("reactionary:hcl:store");
+class HclStoreCapability extends StoreCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async queryByProximity(payload) {
+    debug(
+      "queryByProximity lat=%d lon=%d dist=%d",
+      payload.latitude,
+      payload.longitude,
+      payload.distance
+    );
+    const response = await this.client.callGet(
+      this.getStoreLocatorUrl(payload),
+      this.getStoreLocatorParams(payload),
+      { allowUndefined: true }
+    );
+    const stores = (response?.PhysicalStore ?? []).map(
+      (store) => this.factory.parseStore(this.context, store)
+    );
+    return success(stores);
+  }
+  // ---------------------------------------------------------------------------
+  // Extension points
+  // ---------------------------------------------------------------------------
+  getStoreLocatorUrl(payload) {
+    return `${this.client.transactionBaseUrl}/storelocator/latitude/${payload.latitude}/longitude/${payload.longitude}`;
+  }
+  getStoreLocatorParams(payload) {
+    const params = new URLSearchParams();
+    params.set("maxItems", String(payload.limit));
+    params.set("radius", String(payload.distance));
+    params.set("radiusUOM", "km");
+    params.set("siteLevelStoreSearch", "false");
+    return params;
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByProximitySchema,
+    outputSchema: z.array(StoreSchema)
+  })
+], HclStoreCapability.prototype, "queryByProximity", 1);
+export {
+  HclStoreCapability
+};

package/core/initialize.js

@@ -1,13 +1,20 @@
 import {
   CategoryPaginatedResultSchema,
+  CompanyPaginatedListSchema,
+  CompanySchema,
   IdentitySchema,
   OrderSchema,
   OrderSearchResultSchema,
   PersonalizationProfileSchema,
   ProductAssociationSchema,
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListSchema,
   ProductRecommendationSchema,
   ProductSchema,
-  ProfileSchema
+  ProfileSchema,
+  StoreSchema
 } from "@reactionary/core";
 import { HclCategorySchema } from "../schema/category.schema.js";
 import {
@@ -24,6 +31,7 @@ import {
   HclCartFactory,
   HclCategoryFactory,
   HclCheckoutFactory,
+  HclCompanyFactory,
   HclIdentityFactory,
   HclInventoryFactory,
   HclOrderFactory,
@@ -32,9 +40,11 @@ import {
   HclPriceFactory,
   HclProductAssociationsFactory,
   HclProductFactory,
+  HclProductListFactory,
   HclProductRecommendationsFactory,
   HclProductSearchFactory,
-  HclProfileFactory
+  HclProfileFactory,
+  HclStoreFactory
 } from "../factories/index.js";
 import { HclCartCapability } from "../capabilities/cart.capability.js";
 import { HclCheckoutCapability } from "../capabilities/checkout.capability.js";
@@ -51,6 +61,9 @@ import { HclAnalyticsCapability } from "../capabilities/analytics.capability.js"
 import { HclProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
 import { HclProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
 import { HclPersonalizationProfileCapability } from "../capabilities/personalization-profile.capability.js";
+import { HclCompanyCapability } from "../capabilities/company.capability.js";
+import { HclStoreCapability } from "../capabilities/store.capability.js";
+import { HclProductListCapability } from "../capabilities/product-list.capability.js";
 import {
   CartIdentifierSchema,
   CartPaginatedSearchResultSchema,
@@ -329,6 +342,62 @@ function withHclCapabilities(configuration, capabilities) {
         buildCapabilityArgs
       );
     }
+    if (caps.company?.enabled) {
+      client.company = resolveCapabilityWithFactory(
+        capabilities.company,
+        {
+          factory: new HclCompanyFactory(
+            CompanySchema,
+            CompanyPaginatedListSchema
+          ),
+          capability: (args) => new HclCompanyCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityWithFactory(
+        capabilities.store,
+        {
+          factory: new HclStoreFactory(StoreSchema),
+          capability: (args) => new HclStoreCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.productList?.enabled) {
+      client.productList = resolveCapabilityWithFactory(
+        capabilities.productList,
+        {
+          factory: new HclProductListFactory(
+            ProductListSchema,
+            ProductListItemSchema,
+            ProductListPaginatedResultsSchema,
+            ProductListItemPaginatedResultsSchema
+          ),
+          capability: (args) => new HclProductListCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.hclClient,
+            args.factory
+          )
+        },
+        buildCapabilityArgs
+      );
+    }
     return client;
   };
 }

package/factories/company/company.factory.js

@@ -0,0 +1,77 @@
+class HclCompanyFactory {
+  companySchema;
+  companyPaginatedListSchema;
+  constructor(companySchema, companyPaginatedListSchema) {
+    this.companySchema = companySchema;
+    this.companyPaginatedListSchema = companyPaginatedListSchema;
+  }
+  parseCompany(_context, data) {
+    const result = {
+      identifier: {
+        taxIdentifier: data.taxPayerId ?? data.organizationId ?? data.orgEntityId ?? ""
+      },
+      name: data.organizationName ?? data.displayName ?? "",
+      dunsIdentifier: void 0,
+      tinIdentifier: data.legalId,
+      logo: void 0,
+      // state '0' = locked/blocked; any other value (or absent) = active
+      status: data.state === "0" ? "blocked" : "active",
+      pointOfContact: {
+        email: data.contactInfo?.email1 ?? "",
+        phone: data.contactInfo?.phone1
+      },
+      billingAddress: data.contactInfo ? this.parseOrgContact(data.contactInfo, "default") : this.parseOrgContact(
+        {
+          nickName: "default",
+          firstName: "",
+          lastName: "",
+          addressLine: [],
+          city: "",
+          stateOrProvinceName: "",
+          zipCode: "",
+          country: ""
+        },
+        "default"
+      ),
+      alternateShippingAddresses: (data.addressBook ?? []).map(
+        (c, i) => this.parseOrgContact(c, c.nickName ?? `address-${i}`)
+      ),
+      isCustomAddressesAllowed: false,
+      isSelfManagementOfShippingAddressesAllowed: false
+    };
+    return this.companySchema.parse(result);
+  }
+  parseCompanyPaginatedList(context, data, _query) {
+    const items = (data.organizationDataBeans ?? []).map(
+      (org) => this.parseCompany(context, org)
+    );
+    const pageSize = Math.max(1, items.length);
+    const result = {
+      identifier: {
+        paginationOptions: { pageNumber: 1, pageSize }
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize,
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.companyPaginatedListSchema.parse(result);
+  }
+  parseOrgContact(contact, defaultNickName) {
+    return {
+      identifier: { nickName: contact.nickName ?? defaultNickName },
+      firstName: contact.firstName ?? "",
+      lastName: contact.lastName ?? "",
+      streetAddress: contact.addressLine?.[0] ?? "",
+      streetNumber: contact.addressLine?.[1] ?? "",
+      city: contact.city ?? "",
+      region: contact.stateOrProvinceName ?? "",
+      postalCode: contact.zipCode ?? "",
+      countryCode: contact.country ?? ""
+    };
+  }
+}
+export {
+  HclCompanyFactory
+};

package/factories/index.js

@@ -1,5 +1,6 @@
 export * from "./cart/cart.factory.js";
 export * from "./checkout/checkout.factory.js";
+export * from "./company/company.factory.js";
 export * from "./product/product.factory.js";
 export * from "./category/category.factory.js";
 export * from "./product-search/product-search.factory.js";
@@ -10,5 +11,7 @@ export * from "./profile/profile.factory.js";
 export * from "./order/order.factory.js";
 export * from "./order-search/order-search.factory.js";
 export * from "./product-associations/product-associations.factory.js";
+export * from "./product-list/product-list.factory.js";
 export * from "./product-recommendations/product-recommendations.factory.js";
 export * from "./personalization-profile/personalization-profile.factory.js";
+export * from "./store/store.factory.js";

package/factories/product-list/product-list.factory.js

@@ -0,0 +1,158 @@
+const WISHLIST_TYPES = /* @__PURE__ */ new Set(["favorite", "wish", "shopping"]);
+function encodeWishlistType(type, description) {
+  return `${type}:${description ?? ""}`;
+}
+function decodeWishlistType(raw) {
+  if (raw) {
+    const colonIdx = raw.indexOf(":");
+    if (colonIdx > 0) {
+      const prefix = raw.slice(0, colonIdx);
+      if (WISHLIST_TYPES.has(prefix)) {
+        const desc = raw.slice(colonIdx + 1);
+        return {
+          type: prefix,
+          description: desc || void 0
+        };
+      }
+    }
+  }
+  return { type: "wish", description: raw || void 0 };
+}
+class HclProductListFactory {
+  productListSchema;
+  productListItemSchema;
+  productListPaginatedSchema;
+  productListItemPaginatedSchema;
+  constructor(productListSchema, productListItemSchema, productListPaginatedSchema, productListItemPaginatedSchema) {
+    this.productListSchema = productListSchema;
+    this.productListItemSchema = productListItemSchema;
+    this.productListPaginatedSchema = productListPaginatedSchema;
+    this.productListItemPaginatedSchema = productListItemPaginatedSchema;
+  }
+  parseProductList(_context, data) {
+    const key = data.uniqueID ?? data.externalIdentifier ?? "";
+    const { type, description } = decodeWishlistType(data.description);
+    const result = {
+      identifier: { key, listType: type },
+      type,
+      name: data.descriptionName ?? "",
+      description,
+      published: true
+    };
+    return this.productListSchema.parse(result);
+  }
+  parseProductListItem(_context, data) {
+    const result = {
+      identifier: { key: data.item.giftListItemID ?? "", list: data.list },
+      variant: { sku: data.item.productId ?? data.item.partNumber ?? "" },
+      quantity: Math.max(1, Number(data.item.quantityRequested ?? 1)),
+      order: 1
+    };
+    return this.productListItemSchema.parse(result);
+  }
+  parseProductListPaginatedResult(context, data, query) {
+    const items = (data.GiftList ?? []).map((w) => this.parseProductList(context, w)).filter(
+      (item) => item.identifier.listType === query.search.listType
+    );
+    const result = {
+      identifier: {
+        listType: query.search.listType,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: items.length,
+      pageSize: Math.max(1, items.length),
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListPaginatedSchema.parse(result);
+  }
+  parseProductListItemPaginatedResult(context, data, query) {
+    const rawItems = data.GiftList?.[0]?.item ?? [];
+    const items = rawItems.map(
+      (i) => this.parseProductListItem(context, { item: i, list: query.search.list })
+    );
+    const result = {
+      identifier: {
+        list: query.search.list,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize: items.length,
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListItemPaginatedSchema.parse(result);
+  }
+  // ---------------------------------------------------------------------------
+  // Requisition list parsers
+  // ---------------------------------------------------------------------------
+  parseRequisitionList(_context, data) {
+    const result = {
+      identifier: {
+        key: data.requisitionListId ?? "",
+        listType: "requisition"
+      },
+      type: "requisition",
+      name: data.name ?? "",
+      description: data.description,
+      published: true
+    };
+    return this.productListSchema.parse(result);
+  }
+  parseRequisitionListItem(_context, data) {
+    const result = {
+      identifier: {
+        key: data.item.requisitionListItemId ?? "",
+        list: data.list
+      },
+      variant: { sku: data.item.productId ?? data.item.partNumber ?? "" },
+      quantity: Math.max(1, Number(data.item.quantity ?? 1)),
+      order: 1
+    };
+    return this.productListItemSchema.parse(result);
+  }
+  parseRequisitionListPaginatedResult(context, data, query) {
+    const items = (data.resultList ?? []).map(
+      (r) => this.parseRequisitionList(context, r)
+    );
+    const result = {
+      identifier: {
+        listType: query.search.listType,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize: Math.max(1, items.length),
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListPaginatedSchema.parse(result);
+  }
+  parseRequisitionListItemPaginatedResult(context, data, query) {
+    const rawItems = data.resultList?.[0]?.item ?? [];
+    const items = rawItems.map(
+      (i) => this.parseRequisitionListItem(context, {
+        item: i,
+        list: query.search.list
+      })
+    );
+    const result = {
+      identifier: {
+        list: query.search.list,
+        paginationOptions: query.search.paginationOptions
+      },
+      items,
+      totalCount: Number(data.recordSetTotal ?? items.length),
+      pageSize: Math.max(1, items.length),
+      pageNumber: 1,
+      totalPages: 1
+    };
+    return this.productListItemPaginatedSchema.parse(result);
+  }
+}
+export {
+  HclProductListFactory,
+  encodeWishlistType
+};

package/factories/store/store.factory.js

@@ -0,0 +1,18 @@
+class HclStoreFactory {
+  storeSchema;
+  constructor(storeSchema) {
+    this.storeSchema = storeSchema;
+  }
+  parseStore(_context, data) {
+    const name = data.Description?.[0]?.displayStoreName ?? data.storeName ?? data.uniqueID;
+    const result = {
+      identifier: { key: data.uniqueID },
+      name,
+      fulfillmentCenter: { key: data.uniqueID }
+    };
+    return this.storeSchema.parse(result);
+  }
+}
+export {
+  HclStoreFactory
+};

package/index.js

@@ -21,3 +21,6 @@ export * from "./capabilities/analytics.capability.js";
 export * from "./capabilities/product-associations.capability.js";
 export * from "./capabilities/product-recommendations.capability.js";
 export * from "./capabilities/personalization-profile.capability.js";
+export * from "./capabilities/company.capability.js";
+export * from "./capabilities/store.capability.js";
+export * from "./capabilities/product-list.capability.js";

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@reactionary/hcl",
-  "version": "0.9.13",
+  "version": "0.9.14",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.9.13",
+    "@reactionary/core": "0.9.14",
     "debug": "^4.4.3",
     "zod": "4.1.9"
   },

package/schema/capabilities.schema.js

@@ -9,34 +9,40 @@ const HclCapabilitiesSchema = CapabilitiesSchema.pick({
   cart: true,
   checkout: true,
   category: true,
+  company: true,
   product: true,
   price: true,
   inventory: true,
   identity: true,
   productSearch: true,
+  productList: true,
   profile: true,
   order: true,
   orderSearch: true,
   analytics: true,
   productAssociations: true,
   productRecommendations: true,
-  personalizationProfile: true
+  personalizationProfile: true,
+  store: true
 }).extend({
   cart: OverridableCapabilitySchema.optional(),
   checkout: OverridableCapabilitySchema.optional(),
   category: OverridableCapabilitySchema.optional(),
+  company: OverridableCapabilitySchema.optional(),
   product: OverridableCapabilitySchema.optional(),
   price: OverridableCapabilitySchema.optional(),
   inventory: OverridableCapabilitySchema.optional(),
   identity: OverridableCapabilitySchema.optional(),
   productSearch: OverridableCapabilitySchema.optional(),
+  productList: OverridableCapabilitySchema.optional(),
   profile: OverridableCapabilitySchema.optional(),
   order: OverridableCapabilitySchema.optional(),
   orderSearch: OverridableCapabilitySchema.optional(),
   analytics: OverridableCapabilitySchema.optional(),
   productAssociations: OverridableCapabilitySchema.optional(),
   productRecommendations: OverridableCapabilitySchema.optional(),
-  personalizationProfile: OverridableCapabilitySchema.optional()
+  personalizationProfile: OverridableCapabilitySchema.optional(),
+  store: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   HclCapabilitiesSchema

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

@@ -0,0 +1,26 @@
+import { type Address, type Cache, CompanyCapability, type CompanyFactory, type CompanyFactoryOutput, type CompanyFactoryWithOutput, type CompanyMutationAddShippingAddress, type CompanyMutationMakeShippingAddressDefault, type CompanyMutationRemoveShippingAddress, type CompanyMutationUpdateShippingAddress, type CompanyPaginatedList, type CompanyQueryById, type CompanyQueryList, 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 { HclCompanyFactory } from '../factories/company/company.factory.js';
+import type { HclOrganizationItem, HclWcsOrgContact } from '../schema/hcl.schema.js';
+export declare class HclCompanyCapability<TFactory extends CompanyFactory = HclCompanyFactory> extends CompanyCapability {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: CompanyFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: CompanyFactoryWithOutput<TFactory>);
+    getById(payload: CompanyQueryById): Promise<Result<CompanyFactoryOutput<TFactory>>>;
+    listCompanies(payload: CompanyQueryList): Promise<Result<CompanyPaginatedList>>;
+    addShippingAddress(payload: CompanyMutationAddShippingAddress): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    updateShippingAddress(payload: CompanyMutationUpdateShippingAddress): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    removeShippingAddress(payload: CompanyMutationRemoveShippingAddress): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    makeShippingAddressDefault(payload: CompanyMutationMakeShippingAddressDefault): Promise<Result<CompanyFactoryOutput<TFactory>, NotFoundError>>;
+    protected getOrganizationUrl(orgId: string): string;
+    protected getOrganizationDetailsParams(): URLSearchParams;
+    protected getOrganizationListUrl(): string;
+    protected getOrganizationListParams(query: CompanyQueryList): URLSearchParams;
+    protected getUpdateOrganizationUrl(orgId: string): string;
+    protected getUpdateOrganizationBody(org: HclOrganizationItem, addressBook: HclWcsOrgContact[]): Record<string, unknown>;
+    protected fetchOrganization(orgId: string): Promise<HclOrganizationItem | undefined>;
+    protected fetchOrganizationOrThrow(orgId: string): Promise<HclOrganizationItem>;
+    protected toOrgContact(address: Address): HclWcsOrgContact;
+}

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

@@ -0,0 +1,42 @@
+import { type Cache, ProductListCapability, type ProductListFactory, type ProductListFactoryItemOutput, type ProductListFactoryItemPaginatedOutput, type ProductListFactoryListOutput, type ProductListFactoryListPaginatedOutput, type ProductListFactoryWithOutput, type ProductListItemMutationCreate, type ProductListItemMutationDelete, type ProductListItemMutationUpdate, type ProductListItemsQuery, type ProductListMutationCreate, type ProductListMutationDelete, type ProductListMutationUpdate, type ProductListQuery, type ProductListQueryById, type RequestContext, type Result } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclProductListFactory, HclRequisitionListFactoryExtension } from '../factories/product-list/product-list.factory.js';
+export declare class HclProductListCapability<TFactory extends ProductListFactory = HclProductListFactory> extends ProductListCapability<ProductListFactoryListOutput<TFactory>, ProductListFactoryItemOutput<TFactory>, ProductListFactoryListPaginatedOutput<TFactory>, ProductListFactoryItemPaginatedOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: ProductListFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: ProductListFactoryWithOutput<TFactory>);
+    /**
+     * Returns the factory cast to include the HCL-specific requisition list parse methods.
+     * Subclasses can override this if they provide a custom factory.
+     */
+    protected get requisitionFactory(): ProductListFactoryWithOutput<TFactory> & HclRequisitionListFactoryExtension;
+    getById(payload: ProductListQueryById): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    queryLists(query: ProductListQuery): Promise<Result<ProductListFactoryListPaginatedOutput<TFactory>>>;
+    addList(mutation: ProductListMutationCreate): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    deleteList(mutation: ProductListMutationDelete): Promise<Result<void>>;
+    queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListFactoryItemPaginatedOutput<TFactory>>>;
+    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
+    updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
+    deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
+    protected getWishlistsUrl(): string;
+    protected getWishlistUrl(listId: string): string;
+    protected getWishlistItemsUrl(listId: string): string;
+    protected getWishlistItemUrl(listId: string, itemId: string): string;
+    protected getWishlistItemsParams(query: ProductListItemsQuery): URLSearchParams;
+    protected getCreateWishlistBody(mutation: ProductListMutationCreate): Record<string, unknown>;
+    protected getUpdateWishlistBody(mutation: ProductListMutationUpdate): Record<string, unknown>;
+    protected getAddItemParams(): URLSearchParams;
+    protected getAddItemBody(mutation: ProductListItemMutationCreate): Record<string, unknown>;
+    protected getRequisitionListsUrl(): string;
+    protected getRequisitionListUrl(listId: string): string;
+    protected getRequisitionListItemsUrl(listId: string): string;
+    protected getRequisitionListItemUrl(listId: string, itemId: string): string;
+    protected getRequisitionListItemsParams(query: ProductListItemsQuery): URLSearchParams;
+    protected getCreateRequisitionListBody(mutation: ProductListMutationCreate): Record<string, unknown>;
+    protected getUpdateRequisitionListBody(mutation: ProductListMutationUpdate): Record<string, unknown>;
+    protected getRequisitionAddItemParams(): URLSearchParams;
+    protected getRequisitionAddItemBody(mutation: ProductListItemMutationCreate): Record<string, unknown>;
+}

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

@@ -0,0 +1,13 @@
+import { type Cache, type RequestContext, type Result, StoreCapability, type StoreFactory, type StoreFactoryOutput, type StoreFactoryWithOutput, type StoreQueryByProximity } from '@reactionary/core';
+import type { HclConfiguration } from '../schema/configuration.schema.js';
+import type { HclClient } from '../core/client.js';
+import type { HclStoreFactory } from '../factories/store/store.factory.js';
+export declare class HclStoreCapability<TFactory extends StoreFactory = HclStoreFactory> extends StoreCapability<StoreFactoryOutput<TFactory>> {
+    protected readonly config: HclConfiguration;
+    protected readonly client: HclClient;
+    protected readonly factory: StoreFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: HclConfiguration, client: HclClient, factory: StoreFactoryWithOutput<TFactory>);
+    queryByProximity(payload: StoreQueryByProximity): Promise<Result<StoreFactoryOutput<TFactory>[]>>;
+    protected getStoreLocatorUrl(payload: StoreQueryByProximity): string;
+    protected getStoreLocatorParams(payload: StoreQueryByProximity): URLSearchParams;
+}

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

@@ -2,16 +2,19 @@ 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 { HclCompanyCapability } from '../capabilities/company.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';
 import type { HclPriceCapability } from '../capabilities/price.capability.js';
 import type { HclInventoryCapability } from '../capabilities/inventory.capability.js';
 import type { HclIdentityCapability } from '../capabilities/identity.capability.js';
+import type { HclProductListCapability } from '../capabilities/product-list.capability.js';
 import type { HclProfileCapability } from '../capabilities/profile.capability.js';
 import type { HclOrderCapability } from '../capabilities/order.capability.js';
 import type { HclOrderSearchCapability } from '../capabilities/order-search.capability.js';
-type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'inventory' | 'identity' | 'profile' | 'order' | 'orderSearch';
+import type { HclStoreCapability } from '../capabilities/store.capability.js';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'company' | 'price' | 'inventory' | 'identity' | 'productList' | 'profile' | 'order' | 'orderSearch' | 'store';
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
 } ? true : false;
@@ -28,12 +31,15 @@ type DefaultCapabilityMap = {
     cart: HclCartCapability;
     checkout: HclCheckoutCapability;
     category: HclCategoryCapability;
+    company: HclCompanyCapability;
     price: HclPriceCapability;
     inventory: HclInventoryCapability;
     identity: HclIdentityCapability;
+    productList: HclProductListCapability;
     profile: HclProfileCapability;
     order: HclOrderCapability;
     orderSearch: HclOrderSearchCapability;
+    store: HclStoreCapability;
 };
 type CapabilityImplementationMap<T extends HclCapabilities> = {
     [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap[K]>;

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

@@ -0,0 +1,11 @@
+import type * as z from 'zod';
+import type { Address, AnyCompanyPaginatedListSchema, AnyCompanySchema, CompanyFactory, CompanyQueryList, CompanySchema, CompanyPaginatedListSchema, RequestContext } from '@reactionary/core';
+import type { HclOrganizationItem, HclOrganizationListResponse, HclWcsOrgContact } from '../../schema/hcl.schema.js';
+export declare class HclCompanyFactory<TCompanySchema extends AnyCompanySchema = typeof CompanySchema, TCompanyPaginatedListSchema extends AnyCompanyPaginatedListSchema = typeof CompanyPaginatedListSchema> implements CompanyFactory<TCompanySchema, TCompanyPaginatedListSchema> {
+    readonly companySchema: TCompanySchema;
+    readonly companyPaginatedListSchema: TCompanyPaginatedListSchema;
+    constructor(companySchema: TCompanySchema, companyPaginatedListSchema: TCompanyPaginatedListSchema);
+    parseCompany(_context: RequestContext, data: HclOrganizationItem): z.output<TCompanySchema>;
+    parseCompanyPaginatedList(context: RequestContext, data: HclOrganizationListResponse, _query: CompanyQueryList): z.output<TCompanyPaginatedListSchema>;
+    protected parseOrgContact(contact: HclWcsOrgContact, defaultNickName: string): Address;
+}