@reactionary/commercetools 0.6.3

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

@@ -0,0 +1,118 @@
+import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, IdentityFactory, InventoryFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductListFactory, ProductReviewsFactory, ProductSearchFactory, ProfileFactory, StoreFactory } from '@reactionary/core';
+import type { CommercetoolsCapabilities } from '../schema/capabilities.schema.js';
+import type { OverridableCapabilityKey } from './capability-descriptors.js';
+import type { CommercetoolsCartFactory } from '../factories/cart/cart.factory.js';
+import type { CommercetoolsCategoryFactory } from '../factories/category/category.factory.js';
+import type { CommercetoolsCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
+import type { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+import type { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+import type { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+import type { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
+import type { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+import type { CommercetoolsCartCapability } from '../capabilities/cart.capability.js';
+import type { CommercetoolsCategoryCapability } from '../capabilities/category.capability.js';
+import type { CommercetoolsCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { CommercetoolsIdentityCapability } from '../capabilities/identity.capability.js';
+import type { CommercetoolsInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { CommercetoolsOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { CommercetoolsOrderCapability } from '../capabilities/order.capability.js';
+import type { CommercetoolsPriceCapability } from '../capabilities/price.capability.js';
+import type { CommercetoolsProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import type { CommercetoolsProductListCapability } from '../capabilities/product-list.capability.js';
+import type { CommercetoolsProductCapability } from '../capabilities/product.capability.js';
+import type { CommercetoolsProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import type { CommercetoolsProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { CommercetoolsProfileCapability } from '../capabilities/profile.capability.js';
+import type { CommercetoolsStoreCapability } from '../capabilities/store.capability.js';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends CommercetoolsCapabilities> = Omit<T, OverridableCapabilityKey> & {
+    [K in OverridableCapabilityKey]?: EnabledCapability<T[K]>;
+};
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends TContract ? TFactory : TDefaultFactory : TDefaultFactory;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: any[]) => infer TResolvedCapability ? TResolvedCapability : TDefaultCapability : TDefaultCapability;
+type FactoryContractMap = {
+    product: ProductFactory;
+    productSearch: ProductSearchFactory;
+    productAssociations: ProductAssociationsFactory;
+    productReviews: ProductReviewsFactory;
+    productList: ProductListFactory;
+    identity: IdentityFactory;
+    cart: CartFactory;
+    checkout: CheckoutFactory;
+    order: OrderFactory;
+    orderSearch: OrderSearchFactory;
+    inventory: InventoryFactory;
+    price: PriceFactory;
+    category: CategoryFactory;
+    store: StoreFactory;
+    profile: ProfileFactory;
+};
+type DefaultFactoryMap = {
+    product: CommercetoolsProductFactory;
+    productSearch: CommercetoolsProductSearchFactory;
+    productAssociations: CommercetoolsProductAssociationsFactory;
+    productReviews: CommercetoolsProductReviewsFactory;
+    productList: CommercetoolsProductListFactory;
+    identity: CommercetoolsIdentityFactory;
+    cart: CommercetoolsCartFactory;
+    checkout: CommercetoolsCheckoutFactory;
+    order: CommercetoolsOrderFactory;
+    orderSearch: CommercetoolsOrderSearchFactory;
+    inventory: CommercetoolsInventoryFactory;
+    price: CommercetoolsPriceFactory;
+    category: CommercetoolsCategoryFactory;
+    store: CommercetoolsStoreFactory;
+    profile: CommercetoolsProfileFactory;
+};
+type ResolvedFactoryMap<T extends CommercetoolsCapabilities> = {
+    [K in OverridableCapabilityKey]: ExtractCapabilityFactory<T[K], FactoryContractMap[K], DefaultFactoryMap[K]>;
+};
+type DefaultCapabilityMap<T extends CommercetoolsCapabilities> = {
+    product: CommercetoolsProductCapability<ResolvedFactoryMap<T>['product']>;
+    productSearch: CommercetoolsProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+    productAssociations: CommercetoolsProductAssociationsCapability<ResolvedFactoryMap<T>['productAssociations']>;
+    productReviews: CommercetoolsProductReviewsCapability<ResolvedFactoryMap<T>['productReviews']>;
+    productList: CommercetoolsProductListCapability<ResolvedFactoryMap<T>['productList']>;
+    identity: CommercetoolsIdentityCapability<ResolvedFactoryMap<T>['identity']>;
+    cart: CommercetoolsCartCapability<ResolvedFactoryMap<T>['cart']>;
+    checkout: CommercetoolsCheckoutCapability<ResolvedFactoryMap<T>['checkout']>;
+    order: CommercetoolsOrderCapability<ResolvedFactoryMap<T>['order']>;
+    orderSearch: CommercetoolsOrderSearchCapability<ResolvedFactoryMap<T>['orderSearch']>;
+    inventory: CommercetoolsInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+    price: CommercetoolsPriceCapability<ResolvedFactoryMap<T>['price']>;
+    category: CommercetoolsCategoryCapability<ResolvedFactoryMap<T>['category']>;
+    store: CommercetoolsStoreCapability<ResolvedFactoryMap<T>['store']>;
+    profile: CommercetoolsProfileCapability<ResolvedFactoryMap<T>['profile']>;
+};
+type CapabilityImplementationMap<T extends CommercetoolsCapabilities> = {
+    [K in OverridableCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap<T>[K]>;
+};
+type EnabledCapabilityOverrideMap<T extends CommercetoolsCapabilities> = {
+    [K in OverridableCapabilityKey as T[K] extends {
+        enabled: true;
+    } ? K : never]: CapabilityImplementationMap<T>[K];
+};
+export type CommercetoolsClientFromCapabilities<T extends CommercetoolsCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, OverridableCapabilityKey> & EnabledCapabilityOverrideMap<T>;
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+}, buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs): TResolvedCapability;
+export {};

package/src/core/token-cache.d.ts

@@ -0,0 +1,9 @@
+import type { TokenCache, TokenCacheOptions, TokenStore } from "@commercetools/ts-client";
+import type { RequestContext } from "@reactionary/core";
+export declare class RequestContextTokenCache implements TokenCache {
+    protected context: RequestContext;
+    protected sessionProviderKey: string;
+    constructor(context: RequestContext, sessionProviderKey: string);
+    get(tokenCacheOptions?: TokenCacheOptions): Promise<TokenStore | undefined>;
+    set(cache: TokenStore, tokenCacheOptions?: TokenCacheOptions): Promise<void>;
+}

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-capability-custom-method-only.example.d.ts

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

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

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

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.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

@@ -0,0 +1,28 @@
+export * from './core/client.js';
+export * from './core/initialize.js';
+export * from './capabilities/cart.capability.js';
+export * from './capabilities/identity.capability.js';
+export * from './capabilities/inventory.capability.js';
+export * from './capabilities/order-search.capability.js';
+export * from './capabilities/price.capability.js';
+export * from './capabilities/product-associations.capability.js';
+export * from './capabilities/product.capability.js';
+export * from './capabilities/product-reviews.capability.js';
+export * from './capabilities/product-search.capability.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/schema/capabilities.schema.d.ts

@@ -0,0 +1,104 @@
+import type { Cache, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductListFactory, ProductListFactoryWithOutput, ProductListCapability, ProductCapability, ProductReviewsFactory, ProductReviewsFactoryWithOutput, ProductReviewsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, StoreFactory, StoreFactoryWithOutput, StoreCapability } 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<{
+    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>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    checkout: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export interface CommercetoolsCapabilityFactoryArgs<TFactory> {
+    cache: Cache;
+    context: RequestContext;
+    config: CommercetoolsConfiguration;
+    commercetoolsApi: CommercetoolsAPI;
+    factory: TFactory;
+}
+export interface CommercetoolsCapabilityConfig<TFactory, TCapability> {
+    factory?: TFactory;
+    capability?: (args: CommercetoolsCapabilityFactoryArgs<TFactory>) => TCapability;
+}
+type EnabledCapabilityConfig<TFactory, TCapability> = {
+    enabled: boolean;
+} & CommercetoolsCapabilityConfig<TFactory, TCapability>;
+export type CommercetoolsProductCapabilityConfig<TFactory extends ProductFactory = ProductFactory, TCapability extends ProductCapability = ProductCapability> = CommercetoolsCapabilityConfig<ProductFactoryWithOutput<TFactory>, TCapability>;
+export type CommercetoolsCheckoutCapabilityConfig<TFactory extends CheckoutFactory = CheckoutFactory, TCapability extends CheckoutCapability = CheckoutCapability> = CommercetoolsCapabilityConfig<CheckoutFactoryWithOutput<TFactory>, TCapability>;
+export type CommercetoolsProductSearchCapabilityConfig = CommercetoolsCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
+export type CommercetoolsProductAssociationsCapabilityConfig = CommercetoolsCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
+export type CommercetoolsProductReviewsCapabilityConfig = CommercetoolsCapabilityConfig<ProductReviewsFactoryWithOutput<ProductReviewsFactory>, ProductReviewsCapability>;
+export type CommercetoolsProductListCapabilityConfig = CommercetoolsCapabilityConfig<ProductListFactoryWithOutput<ProductListFactory>, ProductListCapability>;
+export type CommercetoolsIdentityCapabilityConfig = CommercetoolsCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityCapability>;
+export type CommercetoolsCartCapabilityConfig = CommercetoolsCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+export type CommercetoolsInventoryCapabilityConfig = CommercetoolsCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryCapability>;
+export type CommercetoolsPriceCapabilityConfig = CommercetoolsCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+export type CommercetoolsCategoryCapabilityConfig = CommercetoolsCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
+export type CommercetoolsStoreCapabilityConfig = CommercetoolsCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
+export type CommercetoolsProfileCapabilityConfig = CommercetoolsCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
+export type CommercetoolsOrderCapabilityConfig = CommercetoolsCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
+export type CommercetoolsOrderSearchCapabilityConfig = CommercetoolsCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchCapability>;
+export type CommercetoolsCapabilityConfigMap<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability> = {
+    product: EnabledCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
+    checkout: EnabledCapabilityConfig<CheckoutFactoryWithOutput<TCheckoutFactory>, TCheckoutCapability>;
+    productSearch: EnabledCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
+    productAssociations: EnabledCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
+    productReviews: EnabledCapabilityConfig<ProductReviewsFactoryWithOutput<ProductReviewsFactory>, ProductReviewsCapability>;
+    productList: EnabledCapabilityConfig<ProductListFactoryWithOutput<ProductListFactory>, ProductListCapability>;
+    identity: EnabledCapabilityConfig<IdentityFactoryWithOutput<IdentityFactory>, IdentityCapability>;
+    cart: EnabledCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+    inventory: EnabledCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryCapability>;
+    price: EnabledCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+    category: EnabledCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
+    store: EnabledCapabilityConfig<StoreFactoryWithOutput<StoreFactory>, StoreCapability>;
+    profile: EnabledCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
+    order: EnabledCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
+    orderSearch: EnabledCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchCapability>;
+};
+type CommercetoolsCapabilitiesBase = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+export type CommercetoolsCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability> = Omit<CommercetoolsCapabilitiesBase, keyof CommercetoolsCapabilityConfigMap<TProductFactory, TProductCapability, TCheckoutFactory, TCheckoutCapability>> & Partial<CommercetoolsCapabilityConfigMap<TProductFactory, TProductCapability, TCheckoutFactory, TCheckoutCapability>>;
+export {};

package/src/schema/commercetools.schema.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod";
+export declare const CommercetoolsCartIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const CommercetoolsOrderIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const CommercetoolsCheckoutIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const CommercetoolsResolveCategoryQueryByKeySchema: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+export declare const CommercetoolsResolveCategoryQueryByIdSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const CommercetoolsCategoryLookupSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    name: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$loose>;
+export type CommercetoolsCheckoutIdentifier = z.infer<typeof CommercetoolsCheckoutIdentifierSchema>;
+export type CommercetoolsCartIdentifier = z.infer<typeof CommercetoolsCartIdentifierSchema>;
+export type CommercetoolsOrderIdentifier = z.infer<typeof CommercetoolsOrderIdentifierSchema>;
+export type CommercetoolsResolveCategoryQueryByKey = z.infer<typeof CommercetoolsResolveCategoryQueryByKeySchema>;
+export type CommercetoolsResolveCategoryQueryById = z.infer<typeof CommercetoolsResolveCategoryQueryByIdSchema>;
+export type CommercetoolsCategoryLookup = z.infer<typeof CommercetoolsCategoryLookupSchema>;

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

@@ -0,0 +1,30 @@
+import * as z from 'zod';
+export declare const CommercetoolsConfigurationSchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    authUrl: z.ZodString;
+    apiUrl: z.ZodString;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    adminClientId: z.ZodOptional<z.ZodString>;
+    adminClientSecret: z.ZodOptional<z.ZodString>;
+    paymentMethods: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        identifier: z.ZodObject<{
+            method: z.ZodString;
+            name: z.ZodString;
+            paymentProcessor: z.ZodString;
+        }, z.core.$loose>;
+        logo: z.ZodOptional<z.ZodObject<{
+            sourceUrl: z.ZodDefault<z.ZodString>;
+            altText: z.ZodDefault<z.ZodString>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        description: z.ZodString;
+        isPunchOut: z.ZodBoolean;
+    }, z.core.$loose>>>>;
+    facetFieldsForSearch: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    listPriceChannelKey: z.ZodOptional<z.ZodString>;
+    customerPriceChannelKey: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;

package/src/schema/session.schema.d.ts

@@ -0,0 +1,7 @@
+import * as z from 'zod';
+export declare const CommercetoolsSessionSchema: z.ZodObject<{
+    token: z.ZodDefault<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expirationTime: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export type CommercetoolsSession = z.infer<typeof CommercetoolsSessionSchema>;

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

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

package/src/test/test-utils.d.ts

@@ -0,0 +1,27 @@
+export declare function getCommercetoolsTestConfiguration(): {
+    apiUrl: string;
+    authUrl: string;
+    clientId: string;
+    clientSecret: string;
+    projectKey: string;
+    scopes: string[];
+    paymentMethods: {
+        [x: string]: unknown;
+        identifier: {
+            [x: string]: unknown;
+            method: string;
+            name: string;
+            paymentProcessor: string;
+        };
+        description: string;
+        isPunchOut: boolean;
+        logo?: {
+            [x: string]: unknown;
+            sourceUrl: string;
+            altText: string;
+            width?: number | undefined;
+            height?: number | undefined;
+        } | undefined;
+    }[];
+    facetFieldsForSearch: never[];
+};