@reactionary/provider-commercetools 0.3.18 → 0.6.2

package/providers/product-search.provider.js

@@ -10,19 +10,11 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
-  FacetIdentifierSchema,
   FacetValueIdentifierSchema,
-  ImageSchema,
-  ProductOptionIdentifierSchema,
   ProductSearchProvider,
   ProductSearchQueryByTermSchema,
   ProductSearchQueryCreateNavigationFilterSchema,
-  ProductSearchResultFacetSchema,
-  ProductSearchResultFacetValueSchema,
-  ProductSearchResultItemVariantSchema,
   ProductSearchResultSchema,
-  ProductVariantIdentifierSchema,
-  ProductVariantOptionSchema,
   Reactionary,
   success
 } from "@reactionary/core";
@@ -30,10 +22,11 @@ import createDebug from "debug";
 import { CommercetoolsCategoryLookupSchema, CommercetoolsResolveCategoryQueryByKeySchema } from "../schema/commercetools.schema.js";
 const debug = createDebug("reactionary:commercetools:search");
 class CommercetoolsSearchProvider extends ProductSearchProvider {
-  constructor(config, cache, context, commercetools) {
+  constructor(config, cache, context, commercetools, factory) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
   async getClient() {
     const client = await this.commercetools.getClient();
@@ -228,7 +221,8 @@ class CommercetoolsSearchProvider extends ProductSearchProvider {
       }
     }).execute();
     const responseBody = response.body;
-    const result = this.parsePaginatedResult(
+    const result = this.factory.parseSearchResult(
+      this.context,
       responseBody,
       payload
     );
@@ -272,108 +266,6 @@ class CommercetoolsSearchProvider extends ProductSearchProvider {
       }
     }
   }
-  parseSingle(body) {
-    const identifier = { key: body.id };
-    const name = body.name[this.context.languageContext.locale] || body.id;
-    const slug = body.slug?.[this.context.languageContext.locale] || body.id;
-    const variants = [body.masterVariant, ...body.variants].map(
-      (variant) => this.parseVariant(variant, body)
-    );
-    const product = {
-      identifier,
-      name,
-      slug,
-      variants
-    };
-    return product;
-  }
-  parsePaginatedResult(body, query) {
-    const identifier = {
-      ...query.search
-    };
-    const products = body.results.map(
-      (p) => this.parseSingle(p.productProjection)
-    );
-    const facets = [];
-    for (const facet of body.facets) {
-      const facetIdentifier = FacetIdentifierSchema.parse({
-        key: facet.name
-      });
-      const candidateFacet = this.parseFacet(facetIdentifier, facet);
-      if (candidateFacet.values.length > 0) {
-        facets.push(candidateFacet);
-      }
-    }
-    const result = {
-      identifier,
-      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
-      pageSize: body.limit,
-      totalCount: body.total || 0,
-      totalPages: Math.ceil((body.total || 0) / body.limit || 0) + 1,
-      items: products,
-      facets
-    };
-    return result;
-  }
-  /**
-   * See version 0.0.81 for ProductProjection based facet parsing
-   * @param facetIdentifier
-   * @param facetValue
-   * @returns
-   */
-  parseFacet(facetIdentifier, facet) {
-    const result = ProductSearchResultFacetSchema.parse({
-      identifier: facetIdentifier,
-      name: facet.name,
-      values: []
-    });
-    const distinctFacet = facet;
-    if (distinctFacet) {
-      distinctFacet.buckets.forEach((bucket) => {
-        const facetValueIdentifier = FacetValueIdentifierSchema.parse({
-          facet: facetIdentifier,
-          key: bucket.key
-        });
-        result.values.push(
-          this.parseFacetValue(facetValueIdentifier, bucket.key, bucket.count)
-        );
-      });
-    }
-    return result;
-  }
-  parseFacetValue(facetValueIdentifier, label, count) {
-    return ProductSearchResultFacetValueSchema.parse({
-      identifier: facetValueIdentifier,
-      name: label,
-      count,
-      active: false
-    });
-  }
-  parseVariant(variant, product) {
-    const sourceImage = variant.images?.[0];
-    const img = ImageSchema.parse({
-      sourceUrl: sourceImage?.url || "",
-      height: sourceImage?.dimensions.h || void 0,
-      width: sourceImage?.dimensions.w || void 0,
-      altText: sourceImage?.label || product.name[this.context.languageContext.locale] || void 0
-    });
-    const mappedOptions = variant.attributes?.filter((x) => x.name === "Color").map(
-      (opt) => ProductVariantOptionSchema.parse({
-        identifier: ProductOptionIdentifierSchema.parse({
-          key: opt.name
-        }),
-        name: opt.value || ""
-      })
-    ) || [];
-    const mappedOption = mappedOptions?.[0];
-    return ProductSearchResultItemVariantSchema.parse({
-      variant: ProductVariantIdentifierSchema.parse({
-        sku: variant.sku || ""
-      }),
-      image: img,
-      options: mappedOption
-    });
-  }
 }
 __decorateClass([
   Reactionary({

package/providers/product.provider.js

@@ -10,11 +10,6 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import {
-  ImageSchema,
-  ProductAttributeIdentifierSchema,
-  ProductAttributeSchema,
-  ProductAttributeValueIdentifierSchema,
-  ProductAttributeValueSchema,
   ProductProvider,
   ProductQueryByIdSchema,
   ProductQueryBySKUSchema,
@@ -25,10 +20,11 @@ import {
   error
 } from "@reactionary/core";
 class CommercetoolsProductProvider extends ProductProvider {
-  constructor(config, cache, context, commercetools) {
+  constructor(cache, context, config, commercetools, factory) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
   async getClient() {
     const client = await this.commercetools.getClient();
@@ -37,7 +33,7 @@ class CommercetoolsProductProvider extends ProductProvider {
   async getById(payload) {
     const client = await this.getClient();
     const remote = await client.withKey({ key: payload.identifier.key }).get().execute();
-    const value = this.parseSingle(remote.body);
+    const value = this.factory.parseProduct(this.context, remote.body);
     return success(value);
   }
   async getBySlug(payload) {
@@ -55,7 +51,7 @@ class CommercetoolsProductProvider extends ProductProvider {
         identifier: payload.slug
       });
     }
-    const result = this.parseSingle(remote.body.results[0]);
+    const result = this.factory.parseProduct(this.context, remote.body.results[0]);
     return success(result);
   }
   async getBySKU(payload) {
@@ -68,139 +64,9 @@ class CommercetoolsProductProvider extends ProductProvider {
         "var.skus": [payload].map((p) => p.variant.sku)
       }
     }).execute();
-    const result = this.parseSingle(remote.body.results[0]);
+    const result = this.factory.parseProduct(this.context, remote.body.results[0]);
     return success(result);
   }
-  parseSingle(data) {
-    const identifier = { key: data.key || data.id };
-    const name = data.name[this.context.languageContext.locale];
-    const slug = data.slug[this.context.languageContext.locale];
-    let description = "";
-    if (data.description) {
-      description = data.description[this.context.languageContext.locale];
-    }
-    const variantLevelAttributes = data.masterVariant.attributes?.map((x) => this.parseAttribute(x)) || [];
-    const specialAttributes = [
-      "reactionaryaccessories",
-      "reactionaryspareparts",
-      "reactionaryreplacements"
-    ];
-    const productLevelAttributes = data.attributes.filter((x) => !specialAttributes.includes(x.name)).map((x) => this.parseAttribute(x)) || [];
-    const sharedAttributes = [
-      ...productLevelAttributes,
-      ...variantLevelAttributes
-    ];
-    const mainVariant = this.parseVariant(data.masterVariant, data);
-    const otherVariants = [];
-    for (const variant of data.variants || []) {
-      if (variant.id !== data.masterVariant.id) {
-        otherVariants.push(this.parseVariant(variant, data));
-      }
-    }
-    const result = {
-      identifier,
-      name,
-      slug,
-      description,
-      sharedAttributes,
-      mainVariant,
-      brand: "",
-      longDescription: "",
-      manufacturer: "",
-      options: [],
-      parentCategories: [],
-      published: true,
-      variants: otherVariants
-    };
-    return result;
-  }
-  /**
-   * 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
-   */
-  isVariantAttributeAnOption(attr) {
-    return true;
-  }
-  parseVariant(variant, product) {
-    const identifier = {
-      sku: variant.sku
-    };
-    const images = [
-      ...(variant.images || []).map(
-        (img) => ImageSchema.parse({
-          sourceUrl: img.url,
-          altText: img.label || "",
-          width: img.dimensions?.w,
-          height: img.dimensions?.h
-        })
-      )
-    ];
-    const options = (variant.attributes ?? []).filter((attr) => this.isVariantAttributeAnOption(attr)).map((attr) => {
-      const attrVal = this.parseAttributeValue(attr);
-      const optionIdentifier = {
-        key: attr.name
-      };
-      const option = {
-        identifier: optionIdentifier,
-        name: attr.name,
-        value: {
-          identifier: {
-            key: attrVal.value,
-            option: optionIdentifier
-          },
-          label: attrVal.label
-        }
-      };
-      return option;
-    }) || [];
-    const result = {
-      identifier,
-      images,
-      barcode: "",
-      ean: "",
-      gtin: "",
-      name: product.name[this.context.languageContext.locale],
-      options,
-      upc: ""
-    };
-    return result;
-  }
-  parseAttribute(attr) {
-    const result = ProductAttributeSchema.parse({
-      identifier: ProductAttributeIdentifierSchema.parse({
-        key: attr.name
-      }),
-      group: "",
-      name: attr.name,
-      values: [this.parseAttributeValue(attr)]
-    });
-    return result;
-  }
-  parseAttributeValue(attr) {
-    let attrValue = "";
-    if (attr.value && Array.isArray(attr.value)) {
-      attrValue = attr.value[0];
-    }
-    if (attr.value && typeof attr.value === "object") {
-      if (this.context.languageContext.locale in attr.value) {
-        attrValue = attr.value[this.context.languageContext.locale];
-      } else {
-        attrValue = "-";
-      }
-    }
-    if (typeof attr.value === "string") {
-      attrValue = attr.value;
-    }
-    const attrVal = ProductAttributeValueSchema.parse({
-      identifier: ProductAttributeValueIdentifierSchema.parse({
-        key: attrValue
-      }),
-      value: String(attrValue),
-      label: String(attrValue)
-    });
-    return attrVal;
-  }
 }
 __decorateClass([
   Reactionary({

package/providers/profile.provider.js

@@ -21,10 +21,11 @@ import {
   ProfileMutationAddShippingAddressSchema
 } from "@reactionary/core";
 class CommercetoolsProfileProvider extends ProfileProvider {
-  constructor(config, cache, context, commercetools) {
+  constructor(config, cache, context, commercetools, factory) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
   async getClient() {
     const client = await this.commercetools.getClient();
@@ -39,7 +40,7 @@ class CommercetoolsProfileProvider extends ProfileProvider {
         identifier: payload.identifier
       });
     }
-    const model = this.parseSingle(remote.body);
+    const model = this.factory.parseProfile(this.context, remote.body);
     return success(model);
   }
   async addShippingAddress(payload) {
@@ -64,7 +65,7 @@ class CommercetoolsProfileProvider extends ProfileProvider {
       }
     }).execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
   async updateShippingAddress(payload) {
@@ -97,7 +98,7 @@ class CommercetoolsProfileProvider extends ProfileProvider {
       }
     }).execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
   async removeShippingAddress(payload) {
@@ -140,7 +141,7 @@ class CommercetoolsProfileProvider extends ProfileProvider {
       }
     }).execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
   async makeShippingAddressDefault(payload) {
@@ -178,7 +179,7 @@ class CommercetoolsProfileProvider extends ProfileProvider {
       }
     }).execute();
     customer = updateResponse.body;
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
   async setBillingAddress(payload) {
@@ -219,7 +220,7 @@ class CommercetoolsProfileProvider extends ProfileProvider {
       }).execute();
       customer = updateResponse.body;
     }
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
   async update(payload) {
@@ -274,53 +275,9 @@ class CommercetoolsProfileProvider extends ProfileProvider {
       }).execute();
       customer = updateResponse.body;
     }
-    const model = this.parseSingle(customer);
+    const model = this.factory.parseProfile(this.context, customer);
     return success(model);
   }
-  parseAddress(address) {
-    const result = {
-      identifier: {
-        nickName: address.key || ""
-      },
-      firstName: address.firstName || "",
-      lastName: address.lastName || "",
-      streetAddress: address.streetName || "",
-      streetNumber: address.streetNumber || "",
-      city: address.city || "",
-      region: address.region || "",
-      postalCode: address.postalCode || "",
-      countryCode: address.country
-    };
-    return result;
-  }
-  parseSingle(body) {
-    const email = body.email;
-    const emailVerified = body.isEmailVerified;
-    let defaultCTBillingAddress = body.addresses.find((addr) => addr.id === body.defaultBillingAddressId);
-    const phone = defaultCTBillingAddress?.phone ?? "";
-    if (this.isIncompleteAddress(defaultCTBillingAddress)) {
-      defaultCTBillingAddress = void 0;
-    }
-    const defaultCTShippingAddress = body.addresses.find((addr) => addr.id === body.defaultShippingAddressId);
-    const alternateShippingAddresses = body.addresses.filter((x) => x.id !== body.defaultBillingAddressId && x.id !== body.defaultShippingAddressId).map((addr) => this.parseAddress(addr));
-    const billingAddress = defaultCTBillingAddress ? this.parseAddress(defaultCTBillingAddress) : void 0;
-    const shippingAddress = defaultCTShippingAddress ? this.parseAddress(defaultCTShippingAddress) : void 0;
-    const result = {
-      identifier: {
-        userId: body.id
-      },
-      email,
-      emailVerified,
-      alternateShippingAddresses,
-      billingAddress,
-      shippingAddress,
-      createdAt: body.createdAt,
-      phone,
-      phoneVerified: false,
-      updatedAt: body.lastModifiedAt
-    };
-    return result;
-  }
   createCTAddressDraft(address) {
     return {
       key: address.identifier.nickName,

package/providers/store.provider.js

@@ -12,10 +12,11 @@ var __decorateClass = (decorators, target, key, kind) => {
 import { Reactionary, StoreProvider, StoreQueryByProximitySchema, StoreSchema, success, error } from "@reactionary/core";
 import * as z from "zod";
 class CommercetoolsStoreProvider extends StoreProvider {
-  constructor(config, cache, context, commercetools) {
+  constructor(config, cache, context, commercetools, factory) {
     super(cache, context);
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
   async getClient() {
     const client = await this.commercetools.getClient();
@@ -31,28 +32,10 @@ class CommercetoolsStoreProvider extends StoreProvider {
     }).execute();
     const results = [];
     for (const r of remote.body.results) {
-      results.push(this.parseSingle(r));
+      results.push(this.factory.parseStore(this.context, r));
     }
     return success(results);
   }
-  parseSingle(body) {
-    let name = "";
-    if (body.name && body.name["la"]) {
-      name = body.name["la"];
-    }
-    const identifier = {
-      key: body.key
-    };
-    const fulfillmentCenter = {
-      key: body.key
-    };
-    const result = {
-      identifier,
-      fulfillmentCenter,
-      name
-    };
-    return result;
-  }
 }
 __decorateClass([
   Reactionary({

package/schema/capabilities.schema.js

@@ -1,4 +1,13 @@
 import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const EnabledCapabilitySchema = z.looseObject({
+  enabled: z.boolean()
+});
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  provider: z.unknown().optional()
+});
 const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
   productSearch: true,
@@ -15,6 +24,22 @@ const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   category: true,
   store: true,
   profile: true
+}).extend({
+  productSearch: EnabledCapabilitySchema.optional(),
+  productAssociations: EnabledCapabilitySchema.optional(),
+  productReviews: EnabledCapabilitySchema.optional(),
+  productList: EnabledCapabilitySchema.optional(),
+  identity: EnabledCapabilitySchema.optional(),
+  cart: EnabledCapabilitySchema.optional(),
+  order: EnabledCapabilitySchema.optional(),
+  orderSearch: EnabledCapabilitySchema.optional(),
+  inventory: EnabledCapabilitySchema.optional(),
+  price: EnabledCapabilitySchema.optional(),
+  category: EnabledCapabilitySchema.optional(),
+  store: EnabledCapabilitySchema.optional(),
+  profile: EnabledCapabilitySchema.optional(),
+  product: OverridableCapabilitySchema.optional(),
+  checkout: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   CommercetoolsCapabilitiesSchema

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;
+        provider?: (args: any) => any;
+    } | undefined;
+    createDefaultFactory: () => any;
+    createDefaultProvider: (args: any) => any;
+};
+export declare const capabilityDescriptors: Record<OverridableCapabilityKey, CapabilityDescriptor>;
+export {};

package/src/core/initialize.d.ts

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

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 { CommercetoolsCartProvider } from '../providers/cart.provider.js';
+import type { CommercetoolsCategoryProvider } from '../providers/category.provider.js';
+import type { CommercetoolsCheckoutProvider } from '../providers/checkout.provider.js';
+import type { CommercetoolsIdentityProvider } from '../providers/identity.provider.js';
+import type { CommercetoolsInventoryProvider } from '../providers/inventory.provider.js';
+import type { CommercetoolsOrderSearchProvider } from '../providers/order-search.provider.js';
+import type { CommercetoolsOrderProvider } from '../providers/order.provider.js';
+import type { CommercetoolsPriceProvider } from '../providers/price.provider.js';
+import type { CommercetoolsProductAssociationsProvider } from '../providers/product-associations.provider.js';
+import type { CommercetoolsProductListProvider } from '../providers/product-list.provider.js';
+import type { CommercetoolsProductProvider } from '../providers/product.provider.js';
+import type { CommercetoolsProductReviewsProvider } from '../providers/product-reviews.provider.js';
+import type { CommercetoolsSearchProvider } from '../providers/product-search.provider.js';
+import type { CommercetoolsProfileProvider } from '../providers/profile.provider.js';
+import type { CommercetoolsStoreProvider } from '../providers/store.provider.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 ExtractCapabilityProvider<TCapability, TDefaultProvider> = TCapability extends {
+    enabled: true;
+    provider?: infer TProviderFactory;
+} ? TProviderFactory extends (...args: any[]) => infer TProvider ? TProvider : TDefaultProvider : TDefaultProvider;
+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 DefaultProviderMap<T extends CommercetoolsCapabilities> = {
+    product: CommercetoolsProductProvider<ResolvedFactoryMap<T>['product']>;
+    productSearch: CommercetoolsSearchProvider<ResolvedFactoryMap<T>['productSearch']>;
+    productAssociations: CommercetoolsProductAssociationsProvider<ResolvedFactoryMap<T>['productAssociations']>;
+    productReviews: CommercetoolsProductReviewsProvider<ResolvedFactoryMap<T>['productReviews']>;
+    productList: CommercetoolsProductListProvider<ResolvedFactoryMap<T>['productList']>;
+    identity: CommercetoolsIdentityProvider<ResolvedFactoryMap<T>['identity']>;
+    cart: CommercetoolsCartProvider<ResolvedFactoryMap<T>['cart']>;
+    checkout: CommercetoolsCheckoutProvider<ResolvedFactoryMap<T>['checkout']>;
+    order: CommercetoolsOrderProvider<ResolvedFactoryMap<T>['order']>;
+    orderSearch: CommercetoolsOrderSearchProvider<ResolvedFactoryMap<T>['orderSearch']>;
+    inventory: CommercetoolsInventoryProvider<ResolvedFactoryMap<T>['inventory']>;
+    price: CommercetoolsPriceProvider<ResolvedFactoryMap<T>['price']>;
+    category: CommercetoolsCategoryProvider<ResolvedFactoryMap<T>['category']>;
+    store: CommercetoolsStoreProvider<ResolvedFactoryMap<T>['store']>;
+    profile: CommercetoolsProfileProvider<ResolvedFactoryMap<T>['profile']>;
+};
+type CapabilityProviderTypeMap<T extends CommercetoolsCapabilities> = {
+    [K in OverridableCapabilityKey]: ExtractCapabilityProvider<T[K], DefaultProviderMap<T>[K]>;
+};
+type EnabledCapabilityOverrideMap<T extends CommercetoolsCapabilities> = {
+    [K in OverridableCapabilityKey as T[K] extends {
+        enabled: true;
+    } ? K : never]: CapabilityProviderTypeMap<T>[K];
+};
+export type CommercetoolsClientFromCapabilities<T extends CommercetoolsCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, OverridableCapabilityKey> & EnabledCapabilityOverrideMap<T>;
+export declare function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(capability: {
+    factory?: TFactory;
+    provider?: (args: TProviderArgs) => TProvider;
+} | undefined, defaults: {
+    factory: TFactory;
+    provider: (args: TProviderArgs) => TProvider;
+}, buildProviderArgs: (factory: TFactory) => TProviderArgs): TProvider;
+export {};