@reactionary/provider-commercetools 0.6.1 → 0.6.2

package/src/providers/order.provider.d.ts

@@ -1,12 +1,13 @@
-import type { RequestContext, Cache, Order, OrderQueryById, Result, NotFoundError } from '@reactionary/core';
+import type { RequestContext, Cache, OrderFactory, OrderFactoryOutput, OrderFactoryWithOutput, OrderQueryById, Result, NotFoundError } from '@reactionary/core';
 import { OrderProvider } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsOrderProvider extends OrderProvider {
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+export declare class CommercetoolsOrderProvider<TFactory extends OrderFactory = CommercetoolsOrderFactory> extends OrderProvider<OrderFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: OrderFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: OrderFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyMeOrdersRequestBuilder>;
-    getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>>;
-    protected parseSingle(_body: unknown): Order;
+    getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>>;
 }

package/src/providers/price.provider.d.ts

@@ -1,15 +1,18 @@
-import { PriceProvider } from '@reactionary/core';
-import type { RequestContext, Price, Cache, CustomerPriceQuery, ListPriceQuery, Result } from '@reactionary/core';
+import { PriceProvider, type PriceFactory, type PriceFactoryOutput, type PriceFactoryWithOutput } from '@reactionary/core';
+import type { RequestContext, Cache, CustomerPriceQuery, ListPriceQuery, Result } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsPriceProvider extends PriceProvider {
+import type { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
+export declare class CommercetoolsPriceProvider<TFactory extends PriceFactory = CommercetoolsPriceFactory> extends PriceProvider<PriceFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
-    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>>;
-    getListPrice(payload: ListPriceQuery): Promise<Result<Price>>;
+    protected factory: PriceFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: PriceFactoryWithOutput<TFactory>);
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
-    protected parseSingle(_body: unknown, options?: {
-        includeDiscounts: boolean;
-    }): Price;
+    protected getChannels(): Promise<{
+        offer: string;
+        list: string;
+    }>;
 }

package/src/providers/product-associations.provider.d.ts

@@ -1,24 +1,17 @@
-import { ProductAssociationsProvider } from '@reactionary/core';
-import type { ProductIdentifier, ProductAssociation, ProductSearchResultItem, ProductSearchResultItemVariant, ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery, Result, RequestContext, Cache } from '@reactionary/core';
-import type { ProductProjection, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import { type ProductAssociationsFactory, type ProductAssociationsFactoryOutput, type ProductAssociationsFactoryWithOutput, ProductAssociationsProvider } from '@reactionary/core';
+import type { ProductIdentifier, ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery, Result, RequestContext, Cache } from '@reactionary/core';
+import type { ProductProjection } from '@commercetools/platform-sdk';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsProductAssociationsProvider extends ProductAssociationsProvider {
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+export declare class CommercetoolsProductAssociationsProvider<TFactory extends ProductAssociationsFactory = CommercetoolsProductAssociationsFactory> extends ProductAssociationsProvider<ProductAssociationsFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: ProductAssociationsFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
-    protected fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]>;
-    protected parseSingle(body: ProductProjection): {
-        identifier: {
-            key: string;
-        };
-        name: string;
-        slug: string;
-        variants: ProductSearchResultItemVariant[];
-    };
-    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociation[]>>;
-    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociation[]>>;
-    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociation[]>>;
-    protected parseVariant(variant: CTProductVariant, product: ProductProjection): ProductSearchResultItemVariant;
+    protected fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductProjection[]>;
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
 }

package/src/providers/product-list.provider.d.ts

@@ -1,22 +1,24 @@
 import type { ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
-import type { Cache, ProductList, ProductListIdentifier, ProductListItem, ProductListItemMutationCreate, ProductListItemMutationDelete, ProductListItemMutationUpdate, ProductListItemPaginatedResult, ProductListItemsQuery, ProductListMutationCreate, ProductListMutationDelete, ProductListMutationUpdate, ProductListPaginatedResult, ProductListQuery, ProductListQueryById, RequestContext, Result } from '@reactionary/core';
+import type { Cache, ProductListFactory, ProductListFactoryItemOutput, ProductListFactoryItemPaginatedOutput, ProductListFactoryListOutput, ProductListFactoryListPaginatedOutput, ProductListFactoryWithOutput, ProductList, ProductListIdentifier, ProductListItem, ProductListItemMutationCreate, ProductListItemMutationDelete, ProductListItemMutationUpdate, ProductListItemsQuery, ProductListMutationCreate, ProductListMutationDelete, ProductListMutationUpdate, ProductListQuery, ProductListQueryById, RequestContext, Result } from '@reactionary/core';
 import { ProductListProvider } from '@reactionary/core';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-export declare class CommercetoolsProductListProvider extends ProductListProvider {
+import type { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+export declare class CommercetoolsProductListProvider<TFactory extends ProductListFactory = CommercetoolsProductListFactory> extends ProductListProvider<ProductListFactoryListOutput<TFactory>, ProductListFactoryItemOutput<TFactory>, ProductListFactoryListPaginatedOutput<TFactory>, ProductListFactoryItemPaginatedOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: ProductListFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: ProductListFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyMeRequestBuilder>;
-    getById(payload: ProductListQueryById): Promise<Result<ProductList>>;
-    queryLists(payload: ProductListQuery): Promise<Result<ProductListPaginatedResult>>;
-    addList(mutation: ProductListMutationCreate): Promise<Result<ProductList>>;
-    updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductList>>;
+    getById(payload: ProductListQueryById): Promise<Result<ProductListFactoryListOutput<TFactory>>>;
+    queryLists(payload: 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<ProductListItemPaginatedResult>>;
-    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListItem>>;
+    queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListFactoryItemPaginatedOutput<TFactory>>>;
+    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
     deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
-    updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListItem>>;
+    updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
     /**
      * It is not clear to me, why i'd want my CUSTOMER defined resources to be localized, since that means, if he changes visual language,
      * the names of his lists will disappear, since they are not translated. But maybe there are usecases for this, so we should support it, but default to english.

package/src/providers/product-reviews.provider.d.ts

@@ -1,16 +1,18 @@
-import { ProductReviewsProvider } from '@reactionary/core';
-import type { ProductReview, ProductRatingSummary, ProductReviewPaginatedResult, ProductReviewsListQuery, ProductReviewsGetRatingSummaryQuery, ProductReviewMutationSubmit, Result, RequestContext, Cache } from '@reactionary/core';
+import { type ProductReviewsFactory, type ProductReviewsFactoryRatingOutput, type ProductReviewsFactoryReviewOutput, type ProductReviewsFactoryReviewPaginatedOutput, type ProductReviewsFactoryWithOutput, ProductReviewsProvider } from '@reactionary/core';
+import type { ProductReview, ProductReviewsListQuery, ProductReviewsGetRatingSummaryQuery, ProductReviewMutationSubmit, Result, RequestContext, Cache } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { Review as CTReview } from '@commercetools/platform-sdk';
-export declare class CommercetoolsProductReviewsProvider extends ProductReviewsProvider {
+import type { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+export declare class CommercetoolsProductReviewsProvider<TFactory extends ProductReviewsFactory = CommercetoolsProductReviewsFactory> extends ProductReviewsProvider<ProductReviewsFactoryRatingOutput<TFactory>, ProductReviewsFactoryReviewPaginatedOutput<TFactory>, ProductReviewsFactoryReviewOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: ProductReviewsFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: ProductReviewsFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
     protected getAdminClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
-    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductRatingSummary>>;
-    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewPaginatedResult>>;
-    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReview>>;
+    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>>;
+    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>>;
+    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>>;
     protected parseSingle(review: CTReview, productKey: string): ProductReview;
 }

package/src/providers/product-search.provider.d.ts

@@ -1,13 +1,15 @@
-import type { ProductSearchFacetResult as CTProductSearchFacetResult, ProductVariant as CTProductVariant, ProductPagedSearchResponse, ProductProjection, ProductSearchFacetExpression } from '@commercetools/platform-sdk';
-import type { Cache, FacetIdentifier, FacetValueIdentifier, ProductSearchQueryByTerm, ProductSearchQueryCreateNavigationFilter, ProductSearchResult, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItem, ProductSearchResultItemVariant, RequestContext, Result } from '@reactionary/core';
+import type { ProductSearchFacetExpression } from '@commercetools/platform-sdk';
+import type { Cache, FacetValueIdentifier, ProductSearchFactory, ProductSearchFactoryOutput, ProductSearchFactoryWithOutput, ProductSearchQueryByTerm, ProductSearchQueryCreateNavigationFilter, RequestContext, Result } from '@reactionary/core';
 import { ProductSearchProvider } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
 import { type CommercetoolsCategoryLookup, type CommercetoolsResolveCategoryQueryById, type CommercetoolsResolveCategoryQueryByKey } from '../schema/commercetools.schema.js';
-export declare class CommercetoolsSearchProvider extends ProductSearchProvider {
+import type { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class CommercetoolsSearchProvider<TFactory extends ProductSearchFactory = CommercetoolsProductSearchFactory> extends ProductSearchProvider<ProductSearchFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: ProductSearchFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyProductsRequestBuilder>;
     protected getFacetQuery(payload: ProductSearchQueryByTerm, selectedFacetValue: FacetValueIdentifier): Promise<{
         exact: {
@@ -75,51 +77,6 @@ export declare class CommercetoolsSearchProvider extends ProductSearchProvider {
     } | undefined>;
     protected getFacetsToReturn(payload: ProductSearchQueryByTerm): Promise<ProductSearchFacetExpression[]>;
     createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
-    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
-    protected patchCategoryFacetValues(result: ProductSearchResult): Promise<void>;
-    protected parseSingle(body: ProductProjection): {
-        identifier: {
-            key: string;
-        };
-        name: string;
-        slug: string;
-        variants: ProductSearchResultItemVariant[];
-    };
-    protected parsePaginatedResult(body: ProductPagedSearchResponse, query: ProductSearchQueryByTerm): {
-        identifier: {
-            term: string;
-            facets: {
-                facet: {
-                    key: string;
-                };
-                key: string;
-            }[];
-            filters: string[];
-            paginationOptions: {
-                pageNumber: number;
-                pageSize: number;
-            };
-            categoryFilter?: {
-                facet: {
-                    key: string;
-                };
-                key: string;
-            } | undefined;
-        };
-        pageNumber: number;
-        pageSize: number;
-        totalCount: number;
-        totalPages: number;
-        items: ProductSearchResultItem[];
-        facets: ProductSearchResultFacet[];
-    };
-    /**
-     * See version 0.0.81 for ProductProjection based facet parsing
-     * @param facetIdentifier
-     * @param facetValue
-     * @returns
-     */
-    protected parseFacet(facetIdentifier: FacetIdentifier, facet: CTProductSearchFacetResult): ProductSearchResultFacet;
-    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
-    protected parseVariant(variant: CTProductVariant, product: ProductProjection): ProductSearchResultItemVariant;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
+    protected patchCategoryFacetValues(result: ProductSearchFactoryOutput<TFactory>): Promise<void>;
 }

package/src/providers/product.provider.d.ts

@@ -1,26 +1,17 @@
-import { ProductProvider } from '@reactionary/core';
+import { ProductProvider, type ProductFactory, type ProductFactoryOutput, type ProductFactoryWithOutput } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { ProductProjection, ProductVariant as CTProductVariant, Attribute as CTAttribute } from '@commercetools/platform-sdk';
-import type { Product, ProductVariant, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext, ProductAttribute, ProductAttributeValue, Result } from '@reactionary/core';
+import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext, Result } from '@reactionary/core';
 import type { Cache } from '@reactionary/core';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { NotFoundError } from '@reactionary/core';
-export declare class CommercetoolsProductProvider extends ProductProvider {
+import type { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+export declare class CommercetoolsProductProvider<TFactory extends ProductFactory = CommercetoolsProductFactory> extends ProductProvider<ProductFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: ProductFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: CommercetoolsConfiguration, commercetools: CommercetoolsAPI, factory: ProductFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyProductProjectionsRequestBuilder>;
-    getById(payload: ProductQueryById): Promise<Result<Product>>;
-    getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;
-    getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>>;
-    protected parseSingle(data: ProductProjection): Product;
-    /**
-     * Return true, if the attribute is a defining attribute (ie an option)
-     * @param attr a variant attribute
-     * @returns true if the attribute is an option
-     */
-    protected isVariantAttributeAnOption(attr: CTAttribute): boolean;
-    protected parseVariant(variant: CTProductVariant, product: ProductProjection): ProductVariant;
-    protected parseAttribute(attr: CTAttribute): ProductAttribute;
-    protected parseAttributeValue(attr: CTAttribute): ProductAttributeValue;
+    getById(payload: ProductQueryById): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>>>;
 }

package/src/providers/profile.provider.d.ts

@@ -1,23 +1,23 @@
-import type { Profile, ProfileMutationAddShippingAddress, ProfileMutationMakeShippingAddressDefault, ProfileMutationRemoveShippingAddress, ProfileMutationSetBillingAddress, ProfileMutationUpdate, ProfileQuerySelf, RequestContext, Result, NotFoundError, Address, ProfileMutationUpdateShippingAddress } from '@reactionary/core';
+import type { ProfileFactory, ProfileFactoryOutput, ProfileFactoryWithOutput, ProfileMutationAddShippingAddress, ProfileMutationMakeShippingAddressDefault, ProfileMutationRemoveShippingAddress, ProfileMutationSetBillingAddress, ProfileMutationUpdate, ProfileQuerySelf, RequestContext, Result, NotFoundError, ProfileMutationUpdateShippingAddress, Address } from '@reactionary/core';
 import { ProfileProvider } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { Cache } from '@reactionary/core';
-import type { Customer, Address as CTAddress } from '@commercetools/platform-sdk';
+import type { Address as CTAddress } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsProfileProvider extends ProfileProvider {
+import type { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
+export declare class CommercetoolsProfileProvider<TFactory extends ProfileFactory = CommercetoolsProfileFactory> extends ProfileProvider<ProfileFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: ProfileFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: ProfileFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
-    getById(payload: ProfileQuerySelf): Promise<Result<Profile, NotFoundError>>;
-    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
-    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
-    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
-    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
-    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
-    update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
-    protected parseAddress(address: CTAddress): Address;
-    protected parseSingle(body: Customer): Profile;
+    getById(payload: ProfileQuerySelf): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    update(payload: ProfileMutationUpdate): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
     protected createCTAddressDraft(address: Address): CTAddress;
     /**
     * Checks if an address only contains phone information and lacks essential address fields.

package/src/providers/store.provider.d.ts

@@ -1,13 +1,13 @@
-import type { RequestContext, Cache, StoreQueryByProximity, Store, Result } from '@reactionary/core';
+import type { RequestContext, Cache, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StoreQueryByProximity, Result } from '@reactionary/core';
 import { StoreProvider } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { Channel } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsStoreProvider extends StoreProvider {
+import type { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+export declare class CommercetoolsStoreProvider<TFactory extends StoreFactory = CommercetoolsStoreFactory> extends StoreProvider<StoreFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: StoreFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: StoreFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
-    queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<Store>>>;
-    protected parseSingle(body: Channel): Store;
+    queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<StoreFactoryOutput<TFactory>>>>;
 }

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

@@ -1,19 +1,104 @@
-import type * as z from 'zod';
+import type { Cache, CartFactory, CartFactoryWithOutput, CartProvider, CategoryFactory, CategoryFactoryWithOutput, CategoryProvider, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutProvider, IdentityFactory, IdentityFactoryWithOutput, IdentityProvider, InventoryFactory, InventoryFactoryWithOutput, InventoryProvider, OrderFactory, OrderFactoryWithOutput, OrderProvider, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchProvider, PriceFactory, PriceFactoryWithOutput, PriceProvider, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsProvider, ProductFactory, ProductFactoryWithOutput, ProductListFactory, ProductListFactoryWithOutput, ProductListProvider, ProductProvider, ProductReviewsFactory, ProductReviewsFactoryWithOutput, ProductReviewsProvider, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchProvider, ProfileFactory, ProfileFactoryWithOutput, ProfileProvider, RequestContext, StoreFactory, StoreFactoryWithOutput, StoreProvider } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
 export declare const CommercetoolsCapabilitiesSchema: z.ZodObject<{
-    product: z.ZodOptional<z.ZodBoolean>;
-    price: z.ZodOptional<z.ZodBoolean>;
-    order: z.ZodOptional<z.ZodBoolean>;
-    cart: z.ZodOptional<z.ZodBoolean>;
-    checkout: z.ZodOptional<z.ZodBoolean>;
-    identity: z.ZodOptional<z.ZodBoolean>;
-    inventory: z.ZodOptional<z.ZodBoolean>;
-    category: z.ZodOptional<z.ZodBoolean>;
-    profile: z.ZodOptional<z.ZodBoolean>;
-    store: z.ZodOptional<z.ZodBoolean>;
-    productSearch: z.ZodOptional<z.ZodBoolean>;
-    productAssociations: z.ZodOptional<z.ZodBoolean>;
-    productReviews: z.ZodOptional<z.ZodBoolean>;
-    productList: z.ZodOptional<z.ZodBoolean>;
-    orderSearch: z.ZodOptional<z.ZodBoolean>;
+    productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    productAssociations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    productReviews: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    productList: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    identity: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    cart: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    order: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    orderSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    inventory: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    category: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    store: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    profile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, z.core.$loose>>>;
+    product: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        provider: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    checkout: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        provider: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
-export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+export interface CommercetoolsCapabilityProviderFactoryArgs<TFactory> {
+    cache: Cache;
+    context: RequestContext;
+    config: CommercetoolsConfiguration;
+    commercetoolsApi: CommercetoolsAPI;
+    factory: TFactory;
+}
+export interface CommercetoolsCapabilityConfig<TFactory, TProvider> {
+    factory?: TFactory;
+    provider?: (args: CommercetoolsCapabilityProviderFactoryArgs<TFactory>) => TProvider;
+}
+type EnabledCapabilityConfig<TFactory, TProvider> = {
+    enabled: boolean;
+} & CommercetoolsCapabilityConfig<TFactory, TProvider>;
+export type CommercetoolsProductCapabilityConfig<TFactory extends ProductFactory = ProductFactory, TProvider extends ProductProvider = ProductProvider> = CommercetoolsCapabilityConfig<ProductFactoryWithOutput<TFactory>, TProvider>;
+export type CommercetoolsCheckoutCapabilityConfig<TFactory extends CheckoutFactory = CheckoutFactory, TProvider extends CheckoutProvider = CheckoutProvider> = CommercetoolsCapabilityConfig<CheckoutFactoryWithOutput<TFactory>, TProvider>;
+export type CommercetoolsProductSearchCapabilityConfig = CommercetoolsCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchProvider>;
+export type CommercetoolsProductAssociationsCapabilityConfig = CommercetoolsCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsProvider>;
+export type CommercetoolsProductReviewsCapabilityConfig = CommercetoolsCapabilityConfig<ProductReviewsFactoryWithOutput<ProductReviewsFactory>, ProductReviewsProvider>;
+export type CommercetoolsProductListCapabilityConfig = CommercetoolsCapabilityConfig<ProductListFactoryWithOutput<ProductListFactory>, ProductListProvider>;
+export type CommercetoolsIdentityCapabilityConfig = CommercetoolsCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityProvider>;
+export type CommercetoolsCartCapabilityConfig = CommercetoolsCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartProvider>;
+export type CommercetoolsInventoryCapabilityConfig = CommercetoolsCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryProvider>;
+export type CommercetoolsPriceCapabilityConfig = CommercetoolsCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceProvider>;
+export type CommercetoolsCategoryCapabilityConfig = CommercetoolsCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryProvider>;
+export type CommercetoolsStoreCapabilityConfig = CommercetoolsCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreProvider>;
+export type CommercetoolsProfileCapabilityConfig = CommercetoolsCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileProvider>;
+export type CommercetoolsOrderCapabilityConfig = CommercetoolsCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderProvider>;
+export type CommercetoolsOrderSearchCapabilityConfig = CommercetoolsCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchProvider>;
+export type CommercetoolsCapabilityConfigMap<TProductFactory extends ProductFactory = ProductFactory, TProductProvider extends ProductProvider = ProductProvider, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutProvider extends CheckoutProvider = CheckoutProvider> = {
+    product: EnabledCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductProvider>;
+    checkout: EnabledCapabilityConfig<CheckoutFactoryWithOutput<TCheckoutFactory>, TCheckoutProvider>;
+    productSearch: EnabledCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchProvider>;
+    productAssociations: EnabledCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsProvider>;
+    productReviews: EnabledCapabilityConfig<ProductReviewsFactoryWithOutput<ProductReviewsFactory>, ProductReviewsProvider>;
+    productList: EnabledCapabilityConfig<ProductListFactoryWithOutput<ProductListFactory>, ProductListProvider>;
+    identity: EnabledCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityProvider>;
+    cart: EnabledCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartProvider>;
+    inventory: EnabledCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryProvider>;
+    price: EnabledCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceProvider>;
+    category: EnabledCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryProvider>;
+    store: EnabledCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreProvider>;
+    profile: EnabledCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileProvider>;
+    order: EnabledCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderProvider>;
+    orderSearch: EnabledCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchProvider>;
+};
+type CommercetoolsCapabilitiesBase = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+export type CommercetoolsCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductProvider extends ProductProvider = ProductProvider, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutProvider extends CheckoutProvider = CheckoutProvider> = Omit<CommercetoolsCapabilitiesBase, keyof CommercetoolsCapabilityConfigMap<TProductFactory, TProductProvider, TCheckoutFactory, TCheckoutProvider>> & Partial<CommercetoolsCapabilityConfigMap<TProductFactory, TProductProvider, TCheckoutFactory, TCheckoutProvider>>;
+export {};

package/src/test/client-builder-merge-extensions.example.d.ts

@@ -0,0 +1 @@
+export {};

package/test/client-builder-merge-extensions.example.js

@@ -0,0 +1,94 @@
+import {
+  ClientBuilder,
+  createInitialRequestContext,
+  NoOpCache,
+  ProductSchema,
+  StoreSchema
+} from "@reactionary/core";
+import * as z from "zod";
+import { withCommercetoolsCapabilities } from "../core/initialize.js";
+import { CommercetoolsProductFactory } from "../factories/product/product.factory.js";
+import { CommercetoolsStoreFactory } from "../factories/store/store.factory.js";
+import { assertNotAny, assertType } from "../factories/product/utils.example.js";
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedProductValue: z.string()
+});
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+  parseProduct(context, data) {
+    const base = super.parseProduct(context, data);
+    return this.productSchema.parse({
+      ...base,
+      extendedProductValue: "from-product-factory"
+    });
+  }
+}
+const ExtendedStoreSchema = StoreSchema.safeExtend({
+  extendedStoreValue: z.string()
+});
+class ExtendedCommercetoolsStoreFactory extends CommercetoolsStoreFactory {
+  constructor() {
+    super(ExtendedStoreSchema);
+  }
+  parseStore(context, data) {
+    const base = super.parseStore(context, data);
+    return this.storeSchema.parse({
+      ...base,
+      extendedStoreValue: "from-store-factory"
+    });
+  }
+}
+const config = {
+  apiUrl: "https://api.example.invalid",
+  authUrl: "https://auth.example.invalid",
+  clientId: "test-client",
+  clientSecret: "test-secret",
+  projectKey: "test-project",
+  scopes: [],
+  paymentMethods: [],
+  facetFieldsForSearch: []
+};
+function createMergedClientExample() {
+  const cache = new NoOpCache();
+  const context = createInitialRequestContext();
+  const withProduct = withCommercetoolsCapabilities(config, {
+    product: {
+      enabled: true,
+      factory: new ExtendedCommercetoolsProductFactory()
+    }
+  });
+  const withStore = withCommercetoolsCapabilities(config, {
+    store: {
+      enabled: true,
+      factory: new ExtendedCommercetoolsStoreFactory()
+    }
+  });
+  const client = new ClientBuilder(context).withCache(cache).withCapability(withProduct).withCapability(withStore).build();
+  client.product.getById({
+    identifier: { key: "p-1" }
+  }).then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      assertNotAny(result.value);
+      assertNotAny(result.value.extendedProductValue);
+      assertType(result.value.extendedProductValue);
+    }
+  });
+  client.store.queryByProximity({
+    longitude: 10,
+    latitude: 56,
+    distance: 50,
+    limit: 5
+  }).then((result) => {
+    assertNotAny(result);
+    if (result.success) {
+      const first = result.value[0];
+      assertNotAny(first);
+      assertNotAny(first.extendedStoreValue);
+      assertType(first.extendedStoreValue);
+    }
+  });
+  return client;
+}