@reactionary/source 0.6.1 → 0.6.3

package/packages/fake/src/core/initialize.types.ts

@@ -0,0 +1,164 @@
+import type {
+  CartFactory,
+  CategoryFactory,
+  CheckoutFactory,
+  ClientFromCapabilities,
+  IdentityFactory,
+  InventoryFactory,
+  OrderFactory,
+  OrderSearchFactory,
+  PriceFactory,
+  ProductAssociationsFactory,
+  ProductFactory,
+  ProductReviewsFactory,
+  ProductSearchFactory,
+  ProfileFactory,
+  StoreFactory,
+} from '@reactionary/core';
+import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+import type { FakeCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { FakeOrderFactory } from '../factories/order/order.factory.js';
+import type { FakeOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { FakePriceFactory } from '../factories/price/price.factory.js';
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { FakeProductFactory } from '../factories/product/product.factory.js';
+import type { FakeProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+import type { FakeCartCapability } from '../capabilities/cart.capability.js';
+import type { FakeCategoryCapability } from '../capabilities/category.capability.js';
+import type { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { FakeIdentityCapability } from '../capabilities/identity.capability.js';
+import type { FakeInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { FakeOrderCapability } from '../capabilities/order.capability.js';
+import type { FakeOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { FakePriceCapability } from '../capabilities/price.capability.js';
+import type { FakeProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import type { FakeProductCapability } from '../capabilities/product.capability.js';
+import type { FakeProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+import type { FakeProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { FakeProfileCapability } from '../capabilities/profile.capability.js';
+import type { FakeStoreCapability } from '../capabilities/store.capability.js';
+
+type FakeCapabilityKey = keyof FakeCapabilities;
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey]?: 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: unknown[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
+
+type FactoryContractMap = {
+  product: ProductFactory;
+  productSearch: ProductSearchFactory;
+  identity: IdentityFactory;
+  category: CategoryFactory;
+  cart: CartFactory;
+  inventory: InventoryFactory;
+  store: StoreFactory;
+  price: PriceFactory;
+  checkout: CheckoutFactory;
+  order: OrderFactory;
+  orderSearch: OrderSearchFactory;
+  profile: ProfileFactory;
+  productReviews: ProductReviewsFactory;
+  productAssociations: ProductAssociationsFactory;
+};
+
+type DefaultFactoryMap = {
+  product: FakeProductFactory;
+  productSearch: FakeProductSearchFactory;
+  identity: FakeIdentityFactory;
+  category: FakeCategoryFactory;
+  cart: FakeCartFactory;
+  inventory: FakeInventoryFactory;
+  store: FakeStoreFactory;
+  price: FakePriceFactory;
+  checkout: FakeCheckoutFactory;
+  order: FakeOrderFactory;
+  orderSearch: FakeOrderSearchFactory;
+  profile: FakeProfileFactory;
+  productReviews: FakeProductReviewsFactory;
+  productAssociations: FakeProductAssociationsFactory;
+};
+
+type ResolvedFactoryMap<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey]: ExtractCapabilityFactory<
+    T[K],
+    FactoryContractMap[K],
+    DefaultFactoryMap[K]
+  >;
+};
+
+type DefaultCapabilityMap<T extends FakeCapabilities> = {
+  product: FakeProductCapability<ResolvedFactoryMap<T>['product']>;
+  productSearch: FakeProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+  identity: FakeIdentityCapability<ResolvedFactoryMap<T>['identity']>;
+  category: FakeCategoryCapability<ResolvedFactoryMap<T>['category']>;
+  cart: FakeCartCapability<ResolvedFactoryMap<T>['cart']>;
+  inventory: FakeInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+  store: FakeStoreCapability<ResolvedFactoryMap<T>['store']>;
+  price: FakePriceCapability<ResolvedFactoryMap<T>['price']>;
+  checkout: FakeCheckoutCapability<ResolvedFactoryMap<T>['checkout']>;
+  order: FakeOrderCapability<ResolvedFactoryMap<T>['order']>;
+  orderSearch: FakeOrderSearchCapability<ResolvedFactoryMap<T>['orderSearch']>;
+  profile: FakeProfileCapability<ResolvedFactoryMap<T>['profile']>;
+  productReviews: FakeProductReviewsCapability<ResolvedFactoryMap<T>['productReviews']>;
+  productAssociations: FakeProductAssociationsCapability<
+    ResolvedFactoryMap<T>['productAssociations']
+  >;
+};
+
+type CapabilityImplementationMap<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap<T>[K]>;
+};
+
+type EnabledCapabilityOverrideMap<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey as T[K] extends { enabled: true } ? K : never]:
+    CapabilityImplementationMap<T>[K];
+};
+
+export type FakeClientFromCapabilities<T extends FakeCapabilities> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  FakeCapabilityKey
+> &
+  EnabledCapabilityOverrideMap<T>;
+
+export 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 {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+
+  return capabilityFactory(buildCapabilityArgs(factory));
+}

package/packages/fake/src/factories/cart/cart.factory.ts

@@ -0,0 +1,34 @@
+import type {
+  AnyCartIdentifierSchema,
+  AnyCartSchema,
+  CartFactory,
+  CartIdentifierSchema,
+  CartSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeCartFactory<
+  TCartSchema extends AnyCartSchema = typeof CartSchema,
+  TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema,
+> implements CartFactory<TCartSchema, TCartIdentifierSchema>
+{
+  public readonly cartSchema: TCartSchema;
+  public readonly cartIdentifierSchema: TCartIdentifierSchema;
+
+  constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+
+  public parseCart(_context: RequestContext, data: unknown): z.output<TCartSchema> {
+    return this.cartSchema.parse(data);
+  }
+
+  public parseCartIdentifier(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCartIdentifierSchema> {
+    return this.cartIdentifierSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/category/category.factory.ts

@@ -0,0 +1,40 @@
+import type {
+  AnyCategoryPaginatedResultSchema,
+  AnyCategorySchema,
+  CategoryFactory,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeCategoryFactory<
+  TCategorySchema extends AnyCategorySchema = typeof CategorySchema,
+  TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema,
+> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema>
+{
+  public readonly categorySchema: TCategorySchema;
+  public readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+
+  constructor(
+    categorySchema: TCategorySchema,
+    categoryPaginatedResultSchema: TCategoryPaginatedSchema,
+  ) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+
+  public parseCategory(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCategorySchema> {
+    return this.categorySchema.parse(data);
+  }
+
+  public parseCategoryPaginatedResult(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCategoryPaginatedSchema> {
+    return this.categoryPaginatedResultSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/checkout/checkout.factory.ts

@@ -0,0 +1,53 @@
+import type {
+  AnyCheckoutSchema,
+  AnyPaymentMethodSchema,
+  AnyShippingMethodSchema,
+  CheckoutFactory,
+  CheckoutSchema,
+  PaymentMethodSchema,
+  RequestContext,
+  ShippingMethodSchema,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeCheckoutFactory<
+  TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema,
+  TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema,
+  TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema,
+> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema>
+{
+  public readonly checkoutSchema: TCheckoutSchema;
+  public readonly shippingMethodSchema: TShippingMethodSchema;
+  public readonly paymentMethodSchema: TPaymentMethodSchema;
+
+  constructor(
+    checkoutSchema: TCheckoutSchema,
+    shippingMethodSchema: TShippingMethodSchema,
+    paymentMethodSchema: TPaymentMethodSchema,
+  ) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+
+  public parseCheckout(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCheckoutSchema> {
+    return this.checkoutSchema.parse(data);
+  }
+
+  public parseShippingMethod(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TShippingMethodSchema> {
+    return this.shippingMethodSchema.parse(data);
+  }
+
+  public parsePaymentMethod(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TPaymentMethodSchema> {
+    return this.paymentMethodSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/identity/identity.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyIdentitySchema,
+  IdentityFactory,
+  IdentitySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeIdentityFactory<
+  TIdentitySchema extends AnyIdentitySchema = typeof IdentitySchema,
+> implements IdentityFactory<TIdentitySchema>
+{
+  public readonly identitySchema: TIdentitySchema;
+
+  constructor(identitySchema: TIdentitySchema) {
+    this.identitySchema = identitySchema;
+  }
+
+  public parseIdentity(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TIdentitySchema> {
+    return this.identitySchema.parse(data);
+  }
+}

package/packages/fake/src/factories/index.ts

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

package/packages/fake/src/factories/inventory/inventory.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyInventorySchema,
+  InventoryFactory,
+  InventorySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeInventoryFactory<
+  TInventorySchema extends AnyInventorySchema = typeof InventorySchema,
+> implements InventoryFactory<TInventorySchema>
+{
+  public readonly inventorySchema: TInventorySchema;
+
+  constructor(inventorySchema: TInventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+
+  public parseInventory(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TInventorySchema> {
+    return this.inventorySchema.parse(data);
+  }
+}

package/packages/fake/src/factories/order/order.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyOrderSchema,
+  OrderFactory,
+  OrderSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeOrderFactory<
+  TOrderSchema extends AnyOrderSchema = typeof OrderSchema,
+> implements OrderFactory<TOrderSchema>
+{
+  public readonly orderSchema: TOrderSchema;
+
+  constructor(orderSchema: TOrderSchema) {
+    this.orderSchema = orderSchema;
+  }
+
+  public parseOrder(_context: RequestContext, data: unknown): z.output<TOrderSchema> {
+    return this.orderSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyOrderSearchResultSchema,
+  OrderSearchFactory,
+  OrderSearchQueryByTerm,
+  OrderSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/price/price.factory.ts

@@ -0,0 +1,26 @@
+import type {
+  AnyPriceSchema,
+  PriceFactory,
+  PriceSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakePriceFactory<
+  TPriceSchema extends AnyPriceSchema = typeof PriceSchema,
+> implements PriceFactory<TPriceSchema>
+{
+  public readonly priceSchema: TPriceSchema;
+
+  constructor(priceSchema: TPriceSchema) {
+    this.priceSchema = priceSchema;
+  }
+
+  public parsePrice(
+    _context: RequestContext,
+    data: unknown,
+    _options?: { includeDiscounts: boolean },
+  ): z.output<TPriceSchema> {
+    return this.priceSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/product/product.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyProductSchema,
+  ProductFactory,
+  ProductSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeProductFactory<
+  TProductSchema extends AnyProductSchema = typeof ProductSchema,
+> implements ProductFactory<TProductSchema>
+{
+  public readonly productSchema: TProductSchema;
+
+  constructor(productSchema: TProductSchema) {
+    this.productSchema = productSchema;
+  }
+
+  public parseProduct(_context: RequestContext, data: unknown): z.output<TProductSchema> {
+    return this.productSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/product-associations/product-associations.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyProductAssociationSchema,
+  ProductAssociationSchema,
+  ProductAssociationsFactory,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeProductAssociationsFactory<
+  TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema,
+> implements ProductAssociationsFactory<TProductAssociationSchema>
+{
+  public readonly productAssociationSchema: TProductAssociationSchema;
+
+  constructor(productAssociationSchema: TProductAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+
+  public parseAssociation(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TProductAssociationSchema> {
+    return this.productAssociationSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/product-reviews/product-reviews.factory.ts

@@ -0,0 +1,53 @@
+import type {
+  AnyProductRatingSummarySchema,
+  AnyProductReviewPaginatedSchema,
+  AnyProductReviewSchema,
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
+  ProductReviewsFactory,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeProductReviewsFactory<
+  TRatingSummarySchema extends AnyProductRatingSummarySchema = typeof ProductRatingSummarySchema,
+  TReviewSchema extends AnyProductReviewSchema = typeof ProductReviewSchema,
+  TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = typeof ProductReviewPaginatedResultSchema,
+> implements ProductReviewsFactory<TRatingSummarySchema, TReviewSchema, TReviewPaginatedSchema>
+{
+  public readonly ratingSummarySchema: TRatingSummarySchema;
+  public readonly reviewSchema: TReviewSchema;
+  public readonly reviewPaginatedSchema: TReviewPaginatedSchema;
+
+  constructor(
+    ratingSummarySchema: TRatingSummarySchema,
+    reviewSchema: TReviewSchema,
+    reviewPaginatedSchema: TReviewPaginatedSchema,
+  ) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+
+  public parseRatingSummary(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TRatingSummarySchema> {
+    return this.ratingSummarySchema.parse(data);
+  }
+
+  public parseReview(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TReviewSchema> {
+    return this.reviewSchema.parse(data);
+  }
+
+  public parseReviewPaginatedResult(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TReviewPaginatedSchema> {
+    return this.reviewPaginatedSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,27 @@
+import type {
+  AnyProductSearchResultSchema,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    _query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    return this.productSearchResultSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/profile/profile.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyProfileSchema,
+  ProfileFactory,
+  ProfileSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeProfileFactory<
+  TProfileSchema extends AnyProfileSchema = typeof ProfileSchema,
+> implements ProfileFactory<TProfileSchema>
+{
+  public readonly profileSchema: TProfileSchema;
+
+  constructor(profileSchema: TProfileSchema) {
+    this.profileSchema = profileSchema;
+  }
+
+  public parseProfile(_context: RequestContext, data: unknown): z.output<TProfileSchema> {
+    return this.profileSchema.parse(data);
+  }
+}

package/packages/fake/src/factories/store/store.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyStoreSchema,
+  RequestContext,
+  StoreFactory,
+  StoreSchema,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeStoreFactory<
+  TStoreSchema extends AnyStoreSchema = typeof StoreSchema,
+> implements StoreFactory<TStoreSchema>
+{
+  public readonly storeSchema: TStoreSchema;
+
+  constructor(storeSchema: TStoreSchema) {
+    this.storeSchema = storeSchema;
+  }
+
+  public parseStore(_context: RequestContext, data: unknown): z.output<TStoreSchema> {
+    return this.storeSchema.parse(data);
+  }
+}

package/{providers/algolia → packages/fake}/src/index.ts

@@ -1,6 +1,7 @@
 export * from './core/initialize.js';
-export * from './providers/product-search.provider.js';
-export * from './providers/product-recommendations.provider.js';
+export * from './core/initialize.types.js';
 
-export * from './schema/configuration.schema.js';
+export * from './capabilities/index.js'
+export * from './factories/index.js';
 export * from './schema/capabilities.schema.js';
+export * from './schema/configuration.schema.js';