@reactionary/provider-commercetools 0.6.1 → 0.6.2

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

@@ -0,0 +1,14 @@
+import type { Cart as CTCart, LineItem } from '@commercetools/platform-sdk';
+import type { CartIdentifierSchema, CartSchema } from '@reactionary/core';
+import { type AnyCartIdentifierSchema, type AnyCartSchema, type CartFactory, type CartItem, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema> {
+    readonly cartSchema: TCartSchema;
+    readonly cartIdentifierSchema: TCartIdentifierSchema;
+    constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema);
+    parseCartIdentifier(_context: RequestContext, data: {
+        key?: string;
+    }): z.output<TCartIdentifierSchema>;
+    parseCart(context: RequestContext, data: CTCart): z.output<TCartSchema>;
+    protected parseCartItem(lineItem: LineItem): CartItem;
+}

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

@@ -0,0 +1,11 @@
+import type { Category as CTCategory, CategoryPagedQueryResponse } from '@commercetools/platform-sdk';
+import type { CategoryPaginatedResultSchema, CategorySchema } from '@reactionary/core';
+import { type AnyCategoryPaginatedResultSchema, type AnyCategorySchema, type CategoryFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsCategoryFactory<TCategorySchema extends AnyCategorySchema = typeof CategorySchema, TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema> {
+    readonly categorySchema: TCategorySchema;
+    readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+    constructor(categorySchema: TCategorySchema, categoryPaginatedResultSchema: TCategoryPaginatedSchema);
+    parseCategory(context: RequestContext, data: CTCategory): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(context: RequestContext, data: CategoryPagedQueryResponse): z.output<TCategoryPaginatedSchema>;
+}

package/src/factories/checkout/checkout-initializer-overrides.example.d.ts

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

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

@@ -0,0 +1,18 @@
+import type { Address as CTAddress, Cart as CTCart, LineItem, Payment as CTPayment, ShippingMethod as CTShippingMethod } from '@commercetools/platform-sdk';
+import type { CheckoutSchema, PaymentMethodSchema, ShippingMethodSchema } from '@reactionary/core';
+import { type Address, type AnyCheckoutSchema, type AnyPaymentMethodSchema, type AnyShippingMethodSchema, type CheckoutFactory, type CheckoutItem, type CostBreakDown, type PaymentInstruction, type PaymentMethod, type RequestContext, type ShippingInstruction } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsCheckoutFactory<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: CTCart): z.output<TCheckoutSchema>;
+    parseShippingMethod(context: RequestContext, data: CTShippingMethod): z.output<TShippingMethodSchema>;
+    parsePaymentMethod(_context: RequestContext, data: PaymentMethod): z.output<TPaymentMethodSchema>;
+    protected parseCheckoutItem(remoteItem: LineItem): CheckoutItem;
+    protected isReadyForFinalization(price: CostBreakDown, paymentInstructions: PaymentInstruction[], billingAddress?: Address, shippingAddress?: Address, shippingInstruction?: ShippingInstruction): boolean;
+    protected parsePaymentInstruction(context: RequestContext, data: CTPayment): PaymentInstruction;
+    protected parseAddress(data: CTAddress): Address;
+    protected parseShippingInstruction(data: CTCart): ShippingInstruction | undefined;
+}

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

@@ -0,0 +1,8 @@
+import type { IdentitySchema } from '@reactionary/core';
+import { type AnyIdentitySchema, type IdentityFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsIdentityFactory<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/inventory/inventory.factory.d.ts

@@ -0,0 +1,9 @@
+import type { InventoryEntry } from '@commercetools/platform-sdk';
+import type { InventorySchema } from '@reactionary/core';
+import { type AnyInventorySchema, type InventoryFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsInventoryFactory<TInventorySchema extends AnyInventorySchema = typeof InventorySchema> implements InventoryFactory<TInventorySchema> {
+    readonly inventorySchema: TInventorySchema;
+    constructor(inventorySchema: TInventorySchema);
+    parseInventory(_context: RequestContext, data: InventoryEntry): z.output<TInventorySchema>;
+}

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

@@ -0,0 +1,9 @@
+import type { Order as CTOrder } from '@commercetools/platform-sdk';
+import type { OrderSchema } from '@reactionary/core';
+import { type AnyOrderSchema, type OrderFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsOrderFactory<TOrderSchema extends AnyOrderSchema = typeof OrderSchema> implements OrderFactory<TOrderSchema> {
+    readonly orderSchema: TOrderSchema;
+    constructor(orderSchema: TOrderSchema);
+    parseOrder(_context: RequestContext, data: CTOrder): z.output<TOrderSchema>;
+}

package/src/factories/order-search/order-search.factory.d.ts

@@ -0,0 +1,11 @@
+import type { Address as CTAddress, Order as CTOrder, OrderPagedQueryResponse } from '@commercetools/platform-sdk';
+import type { OrderSearchResultSchema } from '@reactionary/core';
+import { type Address, type AnyOrderSearchResultSchema, type OrderSearchFactory, type OrderSearchQueryByTerm, type OrderSearchResultItem, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsOrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema> implements OrderSearchFactory<TOrderSearchResultSchema> {
+    readonly orderSearchResultSchema: TOrderSearchResultSchema;
+    constructor(orderSearchResultSchema: TOrderSearchResultSchema);
+    parseOrderSearchResult(context: RequestContext, data: OrderPagedQueryResponse, query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+    protected parseAddress(data: CTAddress): Address;
+    protected parseOrderSearchItem(context: RequestContext, data: CTOrder): OrderSearchResultItem;
+}

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

@@ -0,0 +1,11 @@
+import type { ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type { PriceSchema } from '@reactionary/core';
+import { type AnyPriceSchema, type PriceFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsPriceFactory<TPriceSchema extends AnyPriceSchema = typeof PriceSchema> implements PriceFactory<TPriceSchema> {
+    readonly priceSchema: TPriceSchema;
+    constructor(priceSchema: TPriceSchema);
+    parsePrice(context: RequestContext, data: CTProductVariant, options?: {
+        includeDiscounts: boolean;
+    }): z.output<TPriceSchema>;
+}

package/src/factories/product/product-factory-baseline.example.d.ts

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

package/src/factories/product/product-factory-schema-and-parse-extension.example.d.ts

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

package/src/factories/product/product-factory-schema-extension.example.d.ts

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

package/src/factories/product/product-initializer-factory-extension.example.d.ts

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

package/src/factories/product/product-provider-custom-method-only.example.d.ts

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

package/src/factories/product/product-provider-schema-signature-extension.example.d.ts

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

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

@@ -0,0 +1,18 @@
+import { type AnyProductSchema, type ProductFactory, type ProductVariant, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { ProductProjection, ProductVariant as CTProductVariant, Attribute as CTAttribute } from '@commercetools/platform-sdk';
+import type { ProductAttribute, ProductAttributeValue, ProductSchema } from '@reactionary/core';
+export declare class CommercetoolsProductFactory<TProductSchema extends AnyProductSchema = typeof ProductSchema> implements ProductFactory<TProductSchema> {
+    readonly productSchema: TProductSchema;
+    constructor(productSchema: TProductSchema);
+    parseProduct(context: RequestContext, data: ProductProjection): z.output<TProductSchema>;
+    /**
+     * 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(context: RequestContext, variant: CTProductVariant, product: ProductProjection): ProductVariant;
+    protected parseAttribute(context: RequestContext, attr: CTAttribute): ProductAttribute;
+    protected parseAttributeValue(context: RequestContext, attr: CTAttribute): ProductAttributeValue;
+}

package/src/factories/product/utils.example.d.ts

@@ -0,0 +1,4 @@
+export declare const assertType: <T>(_value: T) => void;
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+export declare const assertNotAny: <T>(_value: IsAny<T> extends true ? never : T) => void;
+export {};

package/src/factories/product-associations/product-associations.factory.d.ts

@@ -0,0 +1,15 @@
+import type { ProductProjection, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type { ProductAssociationSchema } from '@reactionary/core';
+import { type AnyProductAssociationSchema, type ProductAssociationsFactory, type ProductSearchResultItem, type ProductSearchResultItemVariant, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema> implements ProductAssociationsFactory<TProductAssociationSchema> {
+    readonly productAssociationSchema: TProductAssociationSchema;
+    constructor(productAssociationSchema: TProductAssociationSchema);
+    parseAssociation(context: RequestContext, data: {
+        sourceProductKey: string;
+        relation: 'accessory' | 'sparepart' | 'replacement';
+        product: ProductProjection;
+    }): z.output<TProductAssociationSchema>;
+    protected parseSearchResultItem(context: RequestContext, data: ProductProjection): ProductSearchResultItem;
+    protected parseVariant(context: RequestContext, variant: CTProductVariant, product: ProductProjection): ProductSearchResultItemVariant;
+}

package/src/factories/product-list/product-list.factory.d.ts

@@ -0,0 +1,17 @@
+import type { ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
+import type { ProductListItemPaginatedResultsSchema, ProductListItemSchema, ProductListPaginatedResultsSchema, ProductListSchema } from '@reactionary/core';
+import { type AnyProductListItemPaginatedSchema, type AnyProductListItemSchema, type AnyProductListPaginatedSchema, type AnyProductListSchema, type ProductList, type ProductListFactory, type ProductListIdentifier, type ProductListItem, type ProductListItemPaginatedResult, type ProductListPaginatedResult, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsProductListFactory<TProductListSchema extends AnyProductListSchema = typeof ProductListSchema, TProductListItemSchema extends AnyProductListItemSchema = typeof ProductListItemSchema, TProductListPaginatedSchema extends AnyProductListPaginatedSchema = typeof ProductListPaginatedResultsSchema, TProductListItemPaginatedSchema extends AnyProductListItemPaginatedSchema = typeof ProductListItemPaginatedResultsSchema> implements ProductListFactory<TProductListSchema, TProductListItemSchema, TProductListPaginatedSchema, TProductListItemPaginatedSchema> {
+    readonly productListSchema: TProductListSchema;
+    readonly productListItemSchema: TProductListItemSchema;
+    readonly productListPaginatedSchema: TProductListPaginatedSchema;
+    readonly productListItemPaginatedSchema: TProductListItemPaginatedSchema;
+    constructor(productListSchema: TProductListSchema, productListItemSchema: TProductListItemSchema, productListPaginatedSchema: TProductListPaginatedSchema, productListItemPaginatedSchema: TProductListItemPaginatedSchema);
+    parseProductList(_context: RequestContext, data: ProductList): z.output<TProductListSchema>;
+    parseProductListItem(_context: RequestContext, data: ProductListItem): z.output<TProductListItemSchema>;
+    parseProductListPaginatedResult(_context: RequestContext, data: ProductListPaginatedResult): z.output<TProductListPaginatedSchema>;
+    parseProductListItemPaginatedResult(_context: RequestContext, data: ProductListItemPaginatedResult): z.output<TProductListItemPaginatedSchema>;
+    parseListFromCommercetools(list: ShoppingList): z.output<TProductListSchema>;
+    parseListItemFromCommercetools(listIdentifier: ProductListIdentifier, lineItem: ShoppingListLineItem): z.output<TProductListItemSchema>;
+}

package/src/factories/product-reviews/product-reviews.factory.d.ts

@@ -0,0 +1,14 @@
+import type { Review as CTReview } from '@commercetools/platform-sdk';
+import type { ProductRatingSummarySchema, ProductReviewPaginatedResultSchema, ProductReviewSchema } from '@reactionary/core';
+import { type AnyProductRatingSummarySchema, type AnyProductReviewPaginatedSchema, type AnyProductReviewSchema, type ProductRatingSummary, type ProductReview, type ProductReviewPaginatedResult, type ProductReviewsFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsProductReviewsFactory<TRatingSummarySchema extends AnyProductRatingSummarySchema = typeof ProductRatingSummarySchema, TReviewSchema extends AnyProductReviewSchema = typeof ProductReviewSchema, TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = typeof ProductReviewPaginatedResultSchema> implements ProductReviewsFactory<TRatingSummarySchema, TReviewSchema, TReviewPaginatedSchema> {
+    readonly ratingSummarySchema: TRatingSummarySchema;
+    readonly reviewSchema: TReviewSchema;
+    readonly reviewPaginatedSchema: TReviewPaginatedSchema;
+    constructor(ratingSummarySchema: TRatingSummarySchema, reviewSchema: TReviewSchema, reviewPaginatedSchema: TReviewPaginatedSchema);
+    parseRatingSummary(_context: RequestContext, data: ProductRatingSummary): z.output<TRatingSummarySchema>;
+    parseReview(_context: RequestContext, data: ProductReview): z.output<TReviewSchema>;
+    parseReviewPaginatedResult(_context: RequestContext, data: ProductReviewPaginatedResult): z.output<TReviewPaginatedSchema>;
+    parseReviewFromCommercetools(_context: RequestContext, review: CTReview, productKey: string): z.output<TReviewSchema>;
+}

package/src/factories/product-search/product-search.factory.d.ts

@@ -0,0 +1,13 @@
+import type { ProductPagedSearchResponse, ProductProjection, ProductSearchFacetResult as CTProductSearchFacetResult, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type { ProductSearchResultSchema } from '@reactionary/core';
+import { type AnyProductSearchResultSchema, type FacetIdentifier, type FacetValueIdentifier, type ProductSearchFactory, type ProductSearchQueryByTerm, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type ProductSearchResultItem, type ProductSearchResultItemVariant, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
+    readonly productSearchResultSchema: TProductSearchResultSchema;
+    constructor(productSearchResultSchema: TProductSearchResultSchema);
+    parseSearchResult(context: RequestContext, data: ProductPagedSearchResponse, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+    protected parseSingle(context: RequestContext, data: ProductProjection): ProductSearchResultItem;
+    protected parseFacet(facetIdentifier: FacetIdentifier, facet: CTProductSearchFacetResult): ProductSearchResultFacet;
+    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
+    protected parseVariant(context: RequestContext, variant: CTProductVariant, product: ProductProjection): ProductSearchResultItemVariant;
+}

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

@@ -0,0 +1,11 @@
+import type { Address as CTAddress, Customer } from '@commercetools/platform-sdk';
+import type { ProfileSchema } from '@reactionary/core';
+import { type Address, type AnyProfileSchema, type ProfileFactory, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsProfileFactory<TProfileSchema extends AnyProfileSchema = typeof ProfileSchema> implements ProfileFactory<TProfileSchema> {
+    readonly profileSchema: TProfileSchema;
+    constructor(profileSchema: TProfileSchema);
+    parseProfile(_context: RequestContext, data: Customer): z.output<TProfileSchema>;
+    protected parseAddress(address: CTAddress): Address;
+    protected isIncompleteAddress(address: CTAddress | undefined): boolean;
+}

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

@@ -0,0 +1,9 @@
+import type { Channel } from '@commercetools/platform-sdk';
+import type { StoreSchema } from '@reactionary/core';
+import { type AnyStoreSchema, type RequestContext, type StoreFactory } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class CommercetoolsStoreFactory<TStoreSchema extends AnyStoreSchema = typeof StoreSchema> implements StoreFactory<TStoreSchema> {
+    readonly storeSchema: TStoreSchema;
+    constructor(storeSchema: TStoreSchema);
+    parseStore(_context: RequestContext, data: Channel): z.output<TStoreSchema>;
+}

package/src/index.d.ts

@@ -9,5 +9,20 @@ export * from './providers/product-associations.provider.js';
 export * from './providers/product.provider.js';
 export * from './providers/product-reviews.provider.js';
 export * from './providers/product-search.provider.js';
+export * from './factories/product/product.factory.js';
+export * from './factories/checkout/checkout.factory.js';
+export * from './factories/product-search/product-search.factory.js';
+export * from './factories/inventory/inventory.factory.js';
+export * from './factories/price/price.factory.js';
+export * from './factories/store/store.factory.js';
+export * from './factories/order/order.factory.js';
+export * from './factories/category/category.factory.js';
+export * from './factories/cart/cart.factory.js';
+export * from './factories/profile/profile.factory.js';
+export * from './factories/order-search/order-search.factory.js';
+export * from './factories/product-associations/product-associations.factory.js';
+export * from './factories/product-reviews/product-reviews.factory.js';
+export * from './factories/product-list/product-list.factory.js';
+export * from './factories/identity/identity.factory.js';
 export * from './schema/capabilities.schema.js';
 export * from './schema/configuration.schema.js';

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

@@ -1,24 +1,26 @@
-import { CartProvider } from '@reactionary/core';
-import type { CartItem, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartQueryById, CartIdentifier, CartMutationApplyCoupon, CartMutationDeleteCart, CartMutationRemoveCoupon, CartMutationChangeCurrency, RequestContext, Cart, Cache, Result, NotFoundError } from '@reactionary/core';
+import { type CartFactory, type CartFactoryCartOutput, type CartFactoryWithOutput, CartProvider } from '@reactionary/core';
+import type { CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartQueryById, CartMutationApplyCoupon, CartMutationDeleteCart, CartMutationRemoveCoupon, CartMutationChangeCurrency, RequestContext, CartIdentifier, Cache, Result, NotFoundError } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { Cart as CTCart, LineItem, MyCartUpdateAction } from '@commercetools/platform-sdk';
+import type { MyCartUpdateAction } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsCartProvider extends CartProvider {
+import type { CommercetoolsCartFactory } from '../factories/cart/cart.factory.js';
+export declare class CommercetoolsCartProvider<TFactory extends CartFactory = CommercetoolsCartFactory> extends CartProvider<CartFactoryCartOutput<TFactory>, CartIdentifier> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
     protected expandedCartFields: string[];
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
-    getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
-    add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
-    remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
-    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
+    protected factory: CartFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: CartFactoryWithOutput<TFactory>);
+    getById(payload: CartQueryById): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>>;
+    add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<CartFactoryCartOutput<TFactory>>>;
     getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
     deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
-    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
-    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
-    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<CartFactoryCartOutput<TFactory>>>;
     protected createCart(): Promise<CartIdentifier>;
-    protected applyActions(cart: CartIdentifier, actions: MyCartUpdateAction[]): Promise<Cart>;
+    protected applyActions(cart: CartIdentifier, actions: MyCartUpdateAction[]): Promise<CartFactoryCartOutput<TFactory>>;
     /**
      * Creates a new Commercetools client, optionally upgrading it from Anonymous mode to Guest mode.
      * For now, any Query or Mutation will require an upgrade to Guest mode.
@@ -29,6 +31,4 @@ export declare class CommercetoolsCartProvider extends CartProvider {
         activeCart: import("@commercetools/platform-sdk").ByProjectKeyMeActiveCartRequestBuilder;
         orders: import("@commercetools/platform-sdk").ByProjectKeyMeOrdersRequestBuilder;
     }>;
-    protected parseCartItem(remoteItem: LineItem): CartItem;
-    protected parseSingle(remote: CTCart): Cart;
 }

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

@@ -1,26 +1,28 @@
-import { CategoryProvider } from '@reactionary/core';
-import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext, Cache, Category, Result, NotFoundError } from '@reactionary/core';
+import { type CategoryFactory, type CategoryFactoryCategoryOutput, type CategoryFactoryWithOutput, CategoryProvider } from '@reactionary/core';
+import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext, Cache, CategoryPaginatedResult, Result, NotFoundError } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { ByProjectKeyCategoriesRequestBuilder } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsCategoryProvider extends CategoryProvider {
+import type { CommercetoolsCategoryFactory } from '../factories/category/category.factory.js';
+export declare class CommercetoolsCategoryProvider<TFactory extends CategoryFactory = CommercetoolsCategoryFactory> extends CategoryProvider<CategoryFactoryCategoryOutput<TFactory>, CategoryPaginatedResult> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: CategoryFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: CategoryFactoryWithOutput<TFactory>);
     protected getClient(): Promise<ByProjectKeyCategoriesRequestBuilder>;
     /**
      * Look it up by the category ID (key in commercetools), and if not there, return a placeholder.
      */
-    getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
+    getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
     /**
      * Resolve the category by slug, in the users current locale.
      */
-    getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
     /**
      * Returns the breadcrumb path to the category, i.e. all parents up to the root.
      * The returned order is from root to leaf.
      */
-    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Array<CategoryFactoryCategoryOutput<TFactory>>>>;
     /**
      * Returns a page of child categories for the given parent category ID.
      * You must provide the pagination options to control the size of the result set.
@@ -28,30 +30,18 @@ export declare class CommercetoolsCategoryProvider extends CategoryProvider {
      *
      * This is cached by ID + page number + page size + locale + store
      */
-    findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<{
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<ReturnType<TFactory["parseCategoryPaginatedResult"]>> | import("@reactionary/core").Ok<{
+        items: never[];
         pageNumber: number;
         pageSize: number;
         totalCount: number;
         totalPages: number;
-        items: Category[];
     }>>;
-    findTopCategories(payload: CategoryQueryForTopCategories): Promise<import("@reactionary/core").Ok<{
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<import("@reactionary/core").Ok<ReturnType<TFactory["parseCategoryPaginatedResult"]>> | import("@reactionary/core").Ok<{
+        items: never[];
         pageNumber: number;
         pageSize: number;
         totalCount: number;
         totalPages: number;
-        items: Category[];
     }>>;
-    /**
-     * Handler for parsing a response from a remote provider and converting it
-     * into the typed domain model.
-     */
-    protected parseSingle(_body: unknown): Category;
-    protected parsePaginatedResult(_body: unknown): {
-        pageNumber: number;
-        pageSize: number;
-        totalCount: number;
-        totalPages: number;
-        items: Category[];
-    };
 }

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

@@ -1,32 +1,34 @@
-import type { Address as CTAddress, Cart as CTCart, Payment as CTPayment, LineItem, MyCartUpdateAction } from '@commercetools/platform-sdk';
-import type { Address, Cache, Checkout, CheckoutIdentifier, CheckoutItem, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, CostBreakDown, NotFoundError, PaymentInstruction, PaymentMethod, RequestContext, Result, ShippingInstruction, ShippingMethod } from '@reactionary/core';
+import type { MyCartUpdateAction } from '@commercetools/platform-sdk';
+import type { Cache, CheckoutFactory, CheckoutFactoryCheckoutOutput, CheckoutFactoryPaymentMethodOutput, CheckoutFactoryShippingMethodOutput, CheckoutFactoryWithOutput, CheckoutIdentifier, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, NotFoundError, PaymentMethod, RequestContext, Result } from '@reactionary/core';
 import { CheckoutProvider } from '@reactionary/core';
 import type { CommercetoolsAPI } from '../core/client.js';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsCheckoutFactory } from '../factories/checkout/checkout.factory.js';
 export declare class CheckoutNotReadyForFinalizationError extends Error {
     checkoutIdentifier: CheckoutIdentifier;
     constructor(checkoutIdentifier: CheckoutIdentifier);
 }
-export declare class CommercetoolsCheckoutProvider extends CheckoutProvider {
+export declare class CommercetoolsCheckoutProvider<TFactory extends CheckoutFactory = CommercetoolsCheckoutFactory> extends CheckoutProvider<CheckoutFactoryCheckoutOutput<TFactory>, CheckoutFactoryShippingMethodOutput<TFactory>, CheckoutFactoryPaymentMethodOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: CheckoutFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: CheckoutFactoryWithOutput<TFactory>);
     protected getClient(): Promise<{
         payments: import("@commercetools/platform-sdk").ByProjectKeyMePaymentsRequestBuilder;
         carts: import("@commercetools/platform-sdk").ByProjectKeyMeCartsRequestBuilder;
         shippingMethods: import("@commercetools/platform-sdk").ByProjectKeyShippingMethodsRequestBuilder;
         orders: import("@commercetools/platform-sdk").ByProjectKeyMeOrdersRequestBuilder;
     }>;
-    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<Checkout>>;
-    getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>>;
-    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<Checkout>>;
-    getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<ShippingMethod[]>>;
-    getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<PaymentMethod[]>>;
-    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<Checkout>>;
-    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<Checkout>>;
-    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<Checkout>>;
-    finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<Checkout>>;
-    protected applyActions(checkout: CheckoutIdentifier, actions: MyCartUpdateAction[]): Promise<Checkout>;
+    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>>>;
+    protected applyActions(checkout: CheckoutIdentifier, actions: MyCartUpdateAction[]): Promise<CheckoutFactoryCheckoutOutput<TFactory>>;
     /**
      * Extension point, to allow filtering the options, or adding new ones, like invoicing for b2b.
      *
@@ -34,22 +36,4 @@ export declare class CommercetoolsCheckoutProvider extends CheckoutProvider {
      * @returns
      */
     protected getStaticPaymentMethods(_checkout: CheckoutIdentifier): PaymentMethod[];
-    protected parseCheckoutItem(remoteItem: LineItem): CheckoutItem;
-    protected parseSingle(remote: CTCart): Checkout;
-    protected isReadyForFinalization(price: CostBreakDown, paymentInstructions: Array<PaymentInstruction>, billingAddress?: Address, shippingAddress?: Address, shippingInstruction?: ShippingInstruction): boolean;
-    protected parsePaymentInstruction(remote: CTPayment): PaymentInstruction;
-    protected parseAddress(remote: CTAddress): {
-        countryCode: string;
-        firstName: string;
-        lastName: string;
-        streetAddress: string;
-        streetNumber: string;
-        postalCode: string;
-        city: string;
-        identifier: {
-            nickName: string;
-        };
-        region: string;
-    };
-    protected parseShippingInstruction(remote: CTCart): ShippingInstruction | undefined;
 }

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

@@ -1,12 +1,14 @@
-import { type Identity, type IdentityMutationLogin, type IdentityQuerySelf, type RequestContext, type Cache, IdentityProvider, type IdentityMutationRegister, type Result } from '@reactionary/core';
+import { type IdentityFactory, type IdentityFactoryOutput, type IdentityFactoryWithOutput, type IdentityMutationLogin, type IdentityQuerySelf, type RequestContext, type Cache, IdentityProvider, type IdentityMutationRegister, type Result } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsIdentityProvider extends IdentityProvider {
+import type { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
+export declare class CommercetoolsIdentityProvider<TFactory extends IdentityFactory = CommercetoolsIdentityFactory> extends IdentityProvider<IdentityFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
-    getSelf(payload: IdentityQuerySelf): Promise<Result<Identity>>;
-    login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
-    logout(payload: Record<string, never>): Promise<Result<Identity>>;
-    register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
+    protected factory: IdentityFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: IdentityFactoryWithOutput<TFactory>);
+    getSelf(payload: IdentityQuerySelf): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    login(payload: IdentityMutationLogin): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    logout(payload: Record<string, never>): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    register(payload: IdentityMutationRegister): Promise<Result<IdentityFactoryOutput<TFactory>>>;
 }

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

@@ -1,13 +1,13 @@
-import type { Inventory, RequestContext, Cache, InventoryQueryBySKU, Result, NotFoundError } from '@reactionary/core';
+import type { InventoryFactory, InventoryFactoryOutput, InventoryFactoryWithOutput, RequestContext, Cache, InventoryQueryBySKU, Result, NotFoundError } from '@reactionary/core';
 import { InventoryProvider } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { InventoryEntry } from '@commercetools/platform-sdk';
 import type { CommercetoolsAPI } from '../core/client.js';
-export declare class CommercetoolsInventoryProvider extends InventoryProvider {
+import type { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class CommercetoolsInventoryProvider<TFactory extends InventoryFactory = CommercetoolsInventoryFactory> extends InventoryProvider<InventoryFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: InventoryFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: InventoryFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
-    getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>>;
-    protected parseSingle(body: InventoryEntry): Inventory;
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>>;
 }

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

@@ -1,71 +1,13 @@
-import type { RequestContext, Cache, OrderSearchQueryByTerm, OrderSearchResult, Result, MonetaryAmount, IdentityIdentifier } from '@reactionary/core';
-import { OrderSearchProvider, type OrderSearchResultItem } from '@reactionary/core';
+import type { RequestContext, Cache, OrderSearchFactory, OrderSearchFactoryOutput, OrderSearchFactoryWithOutput, OrderSearchQueryByTerm, Result } from '@reactionary/core';
+import { OrderSearchProvider } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
-import type { Order as CTOrder, Address as CTAddress, OrderPagedQueryResponse } from '@commercetools/platform-sdk';
-export declare class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
+import type { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+export declare class CommercetoolsOrderSearchProvider<TFactory extends OrderSearchFactory = CommercetoolsOrderSearchFactory> extends OrderSearchProvider<OrderSearchFactoryOutput<TFactory>> {
     protected config: CommercetoolsConfiguration;
     protected commercetools: CommercetoolsAPI;
-    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected factory: OrderSearchFactoryWithOutput<TFactory>;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: OrderSearchFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyMeOrdersRequestBuilder>;
-    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>>;
-    protected parseAddress(remote: CTAddress): {
-        countryCode: string;
-        firstName: string;
-        lastName: string;
-        streetAddress: string;
-        streetNumber: string;
-        postalCode: string;
-        city: string;
-        identifier: {
-            nickName: string;
-        };
-        region: string;
-    };
-    protected parseSingle(body: CTOrder): {
-        identifier: {
-            key: string;
-        };
-        userId: IdentityIdentifier;
-        customerName: string;
-        shippingAddress: {
-            countryCode: string;
-            firstName: string;
-            lastName: string;
-            streetAddress: string;
-            streetNumber: string;
-            postalCode: string;
-            city: string;
-            identifier: {
-                nickName: string;
-            };
-            region: string;
-        };
-        orderDate: string;
-        orderStatus: "AwaitingPayment" | "ReleasedToFulfillment" | "Shipped";
-        inventoryStatus: "NotAllocated" | "Allocated";
-        totalAmount: MonetaryAmount;
-    };
-    protected parsePaginatedResult(body: OrderPagedQueryResponse, query: OrderSearchQueryByTerm): {
-        identifier: {
-            term: string;
-            filters: string[];
-            paginationOptions: {
-                pageNumber: number;
-                pageSize: number;
-            };
-            partNumber?: string[] | undefined;
-            orderStatus?: ("AwaitingPayment" | "ReleasedToFulfillment" | "Shipped" | "Cancelled")[] | undefined;
-            user?: {
-                userId: string;
-            } | undefined;
-            startDate?: string | undefined;
-            endDate?: string | undefined;
-        };
-        pageNumber: number;
-        pageSize: number;
-        totalCount: number;
-        totalPages: number;
-        items: OrderSearchResultItem[];
-    };
+    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>>;
 }