@reactionary/commercetools 0.6.3

package/schema/session.schema.js

@@ -0,0 +1,9 @@
+import * as z from "zod";
+const CommercetoolsSessionSchema = z.looseObject({
+  token: z.string().default(""),
+  refreshToken: z.string().optional(),
+  expirationTime: z.number().default(0)
+});
+export {
+  CommercetoolsSessionSchema
+};

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

@@ -0,0 +1,34 @@
+import { type CartFactory, type CartFactoryCartOutput, type CartFactoryWithOutput, CartCapability } 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 { MyCartUpdateAction } from '@commercetools/platform-sdk';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsCartFactory } from '../factories/cart/cart.factory.js';
+export declare class CommercetoolsCartCapability<TFactory extends CartFactory = CommercetoolsCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>, CartIdentifier> {
+    protected config: CommercetoolsConfiguration;
+    protected commercetools: CommercetoolsAPI;
+    protected expandedCartFields: string[];
+    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<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<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.
+     * In the future, maybe we can delay this upgrade until we actually need it.
+     */
+    protected getClient(): Promise<{
+        carts: import("@commercetools/platform-sdk").ByProjectKeyMeCartsRequestBuilder;
+        activeCart: import("@commercetools/platform-sdk").ByProjectKeyMeActiveCartRequestBuilder;
+        orders: import("@commercetools/platform-sdk").ByProjectKeyMeOrdersRequestBuilder;
+    }>;
+}

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

@@ -0,0 +1,47 @@
+import { type CategoryFactory, type CategoryFactoryCategoryOutput, type CategoryFactoryWithOutput, CategoryCapability } 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';
+import type { CommercetoolsCategoryFactory } from '../factories/category/category.factory.js';
+export declare class CommercetoolsCategoryCapability<TFactory extends CategoryFactory = CommercetoolsCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryPaginatedResult> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    /**
+     * Resolve the category by slug, in the users current locale.
+     */
+    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<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.
+     * If you expect your frontend will load many many categories, consider adding a "load more" button, or lazy load the next page.
+     *
+     * This is cached by ID + page number + page size + locale + store
+     */
+    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;
+    }>>;
+    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;
+    }>>;
+}

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

@@ -0,0 +1,39 @@
+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 { CheckoutCapability } 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 CommercetoolsCheckoutCapability<TFactory extends CheckoutFactory = CommercetoolsCheckoutFactory> extends CheckoutCapability<CheckoutFactoryCheckoutOutput<TFactory>, CheckoutFactoryShippingMethodOutput<TFactory>, CheckoutFactoryPaymentMethodOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<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.
+     *
+     * Usecase: Override this, if you need to change the payment options based on the request context.
+     * @returns
+     */
+    protected getStaticPaymentMethods(_checkout: CheckoutIdentifier): PaymentMethod[];
+}

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

@@ -0,0 +1,14 @@
+import { type IdentityFactory, type IdentityFactoryOutput, type IdentityFactoryWithOutput, type IdentityMutationLogin, type IdentityQuerySelf, type RequestContext, type Cache, IdentityCapability, type IdentityMutationRegister, type Result } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
+export declare class CommercetoolsIdentityCapability<TFactory extends IdentityFactory = CommercetoolsIdentityFactory> extends IdentityCapability<IdentityFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected commercetools: CommercetoolsAPI;
+    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/capabilities/index.d.ts

@@ -0,0 +1,15 @@
+export * from './cart.capability.js';
+export * from './category.capability.js';
+export * from './identity.capability.js';
+export * from './inventory.capability.js';
+export * from './order-search.capability.js';
+export * from './price.capability.js';
+export * from './product-associations.capability.js';
+export * from './product-list.capability.js';
+export * from './product.capability.js';
+export * from './product-reviews.capability.js';
+export * from './profile.capability.js';
+export * from './product-search.capability.js';
+export * from './store.capability.js';
+export * from './order.capability.js';
+export * from './checkout.capability.js';

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

@@ -0,0 +1,13 @@
+import type { InventoryFactory, InventoryFactoryOutput, InventoryFactoryWithOutput, RequestContext, Cache, InventoryQueryBySKU, Result, NotFoundError } from '@reactionary/core';
+import { InventoryCapability } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class CommercetoolsInventoryCapability<TFactory extends InventoryFactory = CommercetoolsInventoryFactory> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<InventoryFactoryOutput<TFactory>, NotFoundError>>;
+}

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

@@ -0,0 +1,13 @@
+import type { RequestContext, Cache, OrderSearchFactory, OrderSearchFactoryOutput, OrderSearchFactoryWithOutput, OrderSearchQueryByTerm, Result } from '@reactionary/core';
+import { OrderSearchCapability } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+export declare class CommercetoolsOrderSearchCapability<TFactory extends OrderSearchFactory = CommercetoolsOrderSearchFactory> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<OrderSearchFactoryOutput<TFactory>>>;
+}

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

@@ -0,0 +1,13 @@
+import type { RequestContext, Cache, OrderFactory, OrderFactoryOutput, OrderFactoryWithOutput, OrderQueryById, Result, NotFoundError } from '@reactionary/core';
+import { OrderCapability } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsOrderFactory } from '../factories/order/order.factory.js';
+export declare class CommercetoolsOrderCapability<TFactory extends OrderFactory = CommercetoolsOrderFactory> extends OrderCapability<OrderFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<OrderFactoryOutput<TFactory>, NotFoundError>>;
+}

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

@@ -0,0 +1,18 @@
+import { PriceCapability, 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';
+import type { CommercetoolsPriceFactory } from '../factories/price/price.factory.js';
+export declare class CommercetoolsPriceCapability<TFactory extends PriceFactory = CommercetoolsPriceFactory> extends PriceCapability<PriceFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected commercetools: CommercetoolsAPI;
+    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 getChannels(): Promise<{
+        offer: string;
+        list: string;
+    }>;
+}

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

@@ -0,0 +1,17 @@
+import { type ProductAssociationsFactory, type ProductAssociationsFactoryOutput, type ProductAssociationsFactoryWithOutput, ProductAssociationsCapability } 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';
+import type { CommercetoolsProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+export declare class CommercetoolsProductAssociationsCapability<TFactory extends ProductAssociationsFactory = CommercetoolsProductAssociationsFactory> extends ProductAssociationsCapability<ProductAssociationsFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<ProductProjection[]>;
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+}

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

@@ -0,0 +1,29 @@
+import type { ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
+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 { ProductListCapability } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsProductListFactory } from '../factories/product-list/product-list.factory.js';
+export declare class CommercetoolsProductListCapability<TFactory extends ProductListFactory = CommercetoolsProductListFactory> extends ProductListCapability<ProductListFactoryListOutput<TFactory>, ProductListFactoryItemOutput<TFactory>, ProductListFactoryListPaginatedOutput<TFactory>, ProductListFactoryItemPaginatedOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<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<ProductListFactoryItemPaginatedOutput<TFactory>>>;
+    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListFactoryItemOutput<TFactory>>>;
+    deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
+    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.
+     **/
+    protected getLocaleString(): string;
+    protected parseSingle(list: ShoppingList): ProductList;
+    protected parseProductListItem(listIdentifier: ProductListIdentifier, lineItem: ShoppingListLineItem): ProductListItem;
+}

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

@@ -0,0 +1,18 @@
+import { type ProductReviewsFactory, type ProductReviewsFactoryRatingOutput, type ProductReviewsFactoryReviewOutput, type ProductReviewsFactoryReviewPaginatedOutput, type ProductReviewsFactoryWithOutput, ProductReviewsCapability } 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';
+import type { CommercetoolsProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+export declare class CommercetoolsProductReviewsCapability<TFactory extends ProductReviewsFactory = CommercetoolsProductReviewsFactory> extends ProductReviewsCapability<ProductReviewsFactoryRatingOutput<TFactory>, ProductReviewsFactoryReviewPaginatedOutput<TFactory>, ProductReviewsFactoryReviewOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<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/capabilities/product-search.capability.d.ts

@@ -0,0 +1,82 @@
+import type { ProductSearchFacetExpression } from '@commercetools/platform-sdk';
+import type { Cache, FacetValueIdentifier, ProductSearchFactory, ProductSearchFactoryOutput, ProductSearchFactoryWithOutput, ProductSearchQueryByTerm, ProductSearchQueryCreateNavigationFilter, RequestContext, Result } from '@reactionary/core';
+import { ProductSearchCapability } 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';
+import type { CommercetoolsProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class CommercetoolsProductSearchCapability<TFactory extends ProductSearchFactory = CommercetoolsProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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: {
+            field: string;
+            values: string[];
+            fieldType: string;
+            value?: undefined;
+        };
+    } | {
+        exact: {
+            field: string;
+            fieldType: string;
+            value: string;
+            values?: undefined;
+        };
+    }>;
+    protected resolveCategoryFromId(payload: CommercetoolsResolveCategoryQueryById): Promise<CommercetoolsCategoryLookup>;
+    protected resolveCategoryFromKey(payload: CommercetoolsResolveCategoryQueryByKey): Promise<CommercetoolsCategoryLookup>;
+    protected getCategoryFilterExpression(payload: ProductSearchQueryByTerm): Promise<{
+        exact: {
+            field: string;
+            values: string[];
+            fieldType: string;
+        };
+    } | undefined>;
+    protected getSearchTermExpression(payload: ProductSearchQueryByTerm): Promise<{
+        or: {
+            fullText: {
+                field: string;
+                language: string;
+                value: string;
+            };
+        }[];
+    } | undefined>;
+    protected getFacetsQuery(payload: ProductSearchQueryByTerm): Promise<{
+        exact: {
+            field: string;
+            values: string[];
+            fieldType: string;
+            value?: undefined;
+        };
+    } | {
+        exact: {
+            field: string;
+            fieldType: string;
+            value: string;
+            values?: undefined;
+        };
+    } | {
+        and: ({
+            exact: {
+                field: string;
+                values: string[];
+                fieldType: string;
+                value?: undefined;
+            };
+        } | {
+            exact: {
+                field: string;
+                fieldType: string;
+                value: string;
+                values?: undefined;
+            };
+        })[];
+    } | undefined>;
+    protected getFacetsToReturn(payload: ProductSearchQueryByTerm): Promise<ProductSearchFacetExpression[]>;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
+    protected patchCategoryFacetValues(result: ProductSearchFactoryOutput<TFactory>): Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import { ProductCapability, type ProductFactory, type ProductFactoryOutput, type ProductFactoryWithOutput } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+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';
+import type { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+export declare class CommercetoolsProductCapability<TFactory extends ProductFactory = CommercetoolsProductFactory> extends ProductCapability<ProductFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<ProductFactoryOutput<TFactory>>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>>>;
+}

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

@@ -0,0 +1,30 @@
+import type { ProfileFactory, ProfileFactoryOutput, ProfileFactoryWithOutput, ProfileMutationAddShippingAddress, ProfileMutationMakeShippingAddressDefault, ProfileMutationRemoveShippingAddress, ProfileMutationSetBillingAddress, ProfileMutationUpdate, ProfileQuerySelf, RequestContext, Result, NotFoundError, ProfileMutationUpdateShippingAddress, Address } from '@reactionary/core';
+import { ProfileCapability } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { Cache } from '@reactionary/core';
+import type { Address as CTAddress } from '@commercetools/platform-sdk';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsProfileFactory } from '../factories/profile/profile.factory.js';
+export declare class CommercetoolsProfileCapability<TFactory extends ProfileFactory = CommercetoolsProfileFactory> extends ProfileCapability<ProfileFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<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.
+    * An address is considered incomplete if it exists but has no firstName, lastName, streetName,
+    * streetNumber, or city.
+    * @param address - The address to check, or undefined
+    * @returns true if the address exists but lacks essential fields, false otherwise (including when address is undefined)
+    */
+    protected isIncompleteAddress(address: CTAddress | undefined): boolean;
+}

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

@@ -0,0 +1,13 @@
+import type { RequestContext, Cache, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StoreQueryByProximity, Result } from '@reactionary/core';
+import { StoreCapability } from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+export declare class CommercetoolsStoreCapability<TFactory extends StoreFactory = CommercetoolsStoreFactory> extends StoreCapability<StoreFactoryOutput<TFactory>> {
+    protected config: CommercetoolsConfiguration;
+    protected 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<StoreFactoryOutput<TFactory>>>>;
+}

package/src/core/capability-descriptors.d.ts

@@ -0,0 +1,16 @@
+import type * as z from 'zod';
+import { type CommercetoolsCapabilities, type CommercetoolsCapabilitiesSchema } from '../schema/capabilities.schema.js';
+export declare const capabilityKeys: readonly ["product", "profile", "productSearch", "productAssociations", "productList", "productReviews", "identity", "cart", "inventory", "price", "category", "checkout", "store", "order", "orderSearch"];
+export type OverridableCapabilityKey = (typeof capabilityKeys)[number];
+type ParsedCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;
+export type CapabilityDescriptor = {
+    isEnabled: (caps: ParsedCapabilities) => boolean | undefined;
+    getOverride: (caps: CommercetoolsCapabilities) => {
+        factory?: any;
+        capability?: (args: any) => any;
+    } | undefined;
+    createDefaultFactory: () => any;
+    createDefaultCapability: (args: any) => any;
+};
+export declare const capabilityDescriptors: Record<OverridableCapabilityKey, CapabilityDescriptor>;
+export {};

package/src/core/client.d.ts

@@ -0,0 +1,55 @@
+import { ClientBuilder } from '@commercetools/ts-client';
+import { type ApiRoot } from '@commercetools/platform-sdk';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import { type AnonymousIdentity, type GuestIdentity, type RegisteredIdentity, type RequestContext } from '@reactionary/core';
+import { RequestContextTokenCache } from './token-cache.js';
+import { type CommercetoolsSession } from '../schema/session.schema.js';
+export declare const PROVIDER_SESSION_KEY = "COMMERCETOOLS_PROVIDER";
+export declare class CommercetoolsAPI {
+    protected config: CommercetoolsConfiguration;
+    protected context: RequestContext;
+    protected tokenCache: RequestContextTokenCache;
+    protected client: Promise<ApiRoot> | undefined;
+    protected adminClient: Promise<ApiRoot> | undefined;
+    constructor(config: CommercetoolsConfiguration, context: RequestContext);
+    getClient(): Promise<ApiRoot>;
+    getAdminClient(): Promise<ApiRoot>;
+    getSessionData(): CommercetoolsSession;
+    setSessionData(sessionData: Partial<CommercetoolsSession>): void;
+    /**
+     * Only caches it pr session for now...... but still better than every call
+     * @param key
+     * @returns
+     */
+    resolveChannelIdByKey(key: string): Promise<string>;
+    /**
+     * Only caches it pr session for now...... but still better than every call
+     * @param key
+     * @returns
+     */
+    resolveChannelIdByRole(role: string): Promise<string>;
+    protected createAdminClient(): Promise<ApiRoot>;
+    protected createClient(): Promise<ApiRoot>;
+    register(username: string, password: string): Promise<{
+        [x: string]: unknown;
+        id: {
+            [x: string]: unknown;
+            userId: string;
+        };
+        type: "Registered";
+    }>;
+    login(username: string, password: string): Promise<{
+        [x: string]: unknown;
+        id: {
+            [x: string]: unknown;
+            userId: string;
+        };
+        type: "Registered";
+    }>;
+    logout(): Promise<{
+        type: "Anonymous";
+    }>;
+    introspect(): Promise<AnonymousIdentity | GuestIdentity | RegisteredIdentity>;
+    protected becomeGuest(): Promise<void>;
+    protected createBaseClientBuilder(): ClientBuilder;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import { type CommercetoolsCapabilities } from '../schema/capabilities.schema.js';
+import { type CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import { type CommercetoolsClientFromCapabilities } from './initialize.types.js';
+export declare function withCommercetoolsCapabilities<T extends CommercetoolsCapabilities>(configuration: CommercetoolsConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => CommercetoolsClientFromCapabilities<T>;