@reactionary/fake 0.6.3

package/factories/category/category.factory.js

@@ -0,0 +1,17 @@
+class FakeCategoryFactory {
+  categorySchema;
+  categoryPaginatedResultSchema;
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(_context, data) {
+    return this.categorySchema.parse(data);
+  }
+  parseCategoryPaginatedResult(_context, data) {
+    return this.categoryPaginatedResultSchema.parse(data);
+  }
+}
+export {
+  FakeCategoryFactory
+};

package/factories/checkout/checkout.factory.js

@@ -0,0 +1,22 @@
+class FakeCheckoutFactory {
+  checkoutSchema;
+  shippingMethodSchema;
+  paymentMethodSchema;
+  constructor(checkoutSchema, shippingMethodSchema, paymentMethodSchema) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+  parseCheckout(_context, data) {
+    return this.checkoutSchema.parse(data);
+  }
+  parseShippingMethod(_context, data) {
+    return this.shippingMethodSchema.parse(data);
+  }
+  parsePaymentMethod(_context, data) {
+    return this.paymentMethodSchema.parse(data);
+  }
+}
+export {
+  FakeCheckoutFactory
+};

package/factories/identity/identity.factory.js

@@ -0,0 +1,12 @@
+class FakeIdentityFactory {
+  identitySchema;
+  constructor(identitySchema) {
+    this.identitySchema = identitySchema;
+  }
+  parseIdentity(_context, data) {
+    return this.identitySchema.parse(data);
+  }
+}
+export {
+  FakeIdentityFactory
+};

package/factories/index.js

@@ -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/factories/inventory/inventory.factory.js

@@ -0,0 +1,12 @@
+class FakeInventoryFactory {
+  inventorySchema;
+  constructor(inventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+  parseInventory(_context, data) {
+    return this.inventorySchema.parse(data);
+  }
+}
+export {
+  FakeInventoryFactory
+};

package/factories/order/order.factory.js

@@ -0,0 +1,12 @@
+class FakeOrderFactory {
+  orderSchema;
+  constructor(orderSchema) {
+    this.orderSchema = orderSchema;
+  }
+  parseOrder(_context, data) {
+    return this.orderSchema.parse(data);
+  }
+}
+export {
+  FakeOrderFactory
+};

package/factories/order-search/order-search.factory.js

@@ -0,0 +1,12 @@
+class FakeOrderSearchFactory {
+  orderSearchResultSchema;
+  constructor(orderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+  parseOrderSearchResult(_context, data, _query) {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}
+export {
+  FakeOrderSearchFactory
+};

package/factories/price/price.factory.js

@@ -0,0 +1,12 @@
+class FakePriceFactory {
+  priceSchema;
+  constructor(priceSchema) {
+    this.priceSchema = priceSchema;
+  }
+  parsePrice(_context, data, _options) {
+    return this.priceSchema.parse(data);
+  }
+}
+export {
+  FakePriceFactory
+};

package/factories/product/product.factory.js

@@ -0,0 +1,12 @@
+class FakeProductFactory {
+  productSchema;
+  constructor(productSchema) {
+    this.productSchema = productSchema;
+  }
+  parseProduct(_context, data) {
+    return this.productSchema.parse(data);
+  }
+}
+export {
+  FakeProductFactory
+};

package/factories/product-associations/product-associations.factory.js

@@ -0,0 +1,12 @@
+class FakeProductAssociationsFactory {
+  productAssociationSchema;
+  constructor(productAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+  parseAssociation(_context, data) {
+    return this.productAssociationSchema.parse(data);
+  }
+}
+export {
+  FakeProductAssociationsFactory
+};

package/factories/product-reviews/product-reviews.factory.js

@@ -0,0 +1,22 @@
+class FakeProductReviewsFactory {
+  ratingSummarySchema;
+  reviewSchema;
+  reviewPaginatedSchema;
+  constructor(ratingSummarySchema, reviewSchema, reviewPaginatedSchema) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+  parseRatingSummary(_context, data) {
+    return this.ratingSummarySchema.parse(data);
+  }
+  parseReview(_context, data) {
+    return this.reviewSchema.parse(data);
+  }
+  parseReviewPaginatedResult(_context, data) {
+    return this.reviewPaginatedSchema.parse(data);
+  }
+}
+export {
+  FakeProductReviewsFactory
+};

package/factories/product-search/product-search.factory.js

@@ -0,0 +1,12 @@
+class FakeProductSearchFactory {
+  productSearchResultSchema;
+  constructor(productSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  parseSearchResult(_context, data, _query) {
+    return this.productSearchResultSchema.parse(data);
+  }
+}
+export {
+  FakeProductSearchFactory
+};

package/factories/profile/profile.factory.js

@@ -0,0 +1,12 @@
+class FakeProfileFactory {
+  profileSchema;
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(_context, data) {
+    return this.profileSchema.parse(data);
+  }
+}
+export {
+  FakeProfileFactory
+};

package/factories/store/store.factory.js

@@ -0,0 +1,12 @@
+class FakeStoreFactory {
+  storeSchema;
+  constructor(storeSchema) {
+    this.storeSchema = storeSchema;
+  }
+  parseStore(_context, data) {
+    return this.storeSchema.parse(data);
+  }
+}
+export {
+  FakeStoreFactory
+};

package/index.js

@@ -0,0 +1,6 @@
+export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
+export * from "./capabilities/index.js";
+export * from "./factories/index.js";
+export * from "./schema/capabilities.schema.js";
+export * from "./schema/configuration.schema.js";

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@reactionary/fake",
+  "version": "0.6.3",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5",
+    "@reactionary/core": "0.6.3",
+    "zod": "4.1.9",
+    "@faker-js/faker": "^9.8.0"
+  },
+  "sideEffects": false
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,41 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  productSearch: true,
+  identity: true,
+  category: true,
+  cart: true,
+  inventory: true,
+  store: true,
+  price: true,
+  checkout: true,
+  order: true,
+  orderSearch: true,
+  profile: true,
+  productReviews: true,
+  productAssociations: true
+}).extend({
+  product: OverridableCapabilitySchema.optional(),
+  productSearch: OverridableCapabilitySchema.optional(),
+  identity: OverridableCapabilitySchema.optional(),
+  category: OverridableCapabilitySchema.optional(),
+  cart: OverridableCapabilitySchema.optional(),
+  inventory: OverridableCapabilitySchema.optional(),
+  store: OverridableCapabilitySchema.optional(),
+  price: OverridableCapabilitySchema.optional(),
+  checkout: OverridableCapabilitySchema.optional(),
+  order: OverridableCapabilitySchema.optional(),
+  orderSearch: OverridableCapabilitySchema.optional(),
+  profile: OverridableCapabilitySchema.optional(),
+  productReviews: OverridableCapabilitySchema.optional(),
+  productAssociations: OverridableCapabilitySchema.optional()
+}).partial();
+export {
+  FakeCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,18 @@
+import * as z from "zod";
+const FakeConfigurationSchema = z.looseObject({
+  jitter: z.looseObject({
+    mean: z.number().min(0).max(1e4),
+    deviation: z.number().min(0).max(5e3)
+  }).default({
+    mean: 0,
+    deviation: 0
+  }),
+  seeds: z.looseObject({
+    product: z.number().min(0).max(1e4).default(1),
+    search: z.number().min(0).max(1e4).default(1),
+    category: z.number().min(0).max(1e4).default(1)
+  })
+});
+export {
+  FakeConfigurationSchema
+};

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

@@ -0,0 +1,8 @@
+import type { AnalyticsMutation, Cache, RequestContext } from '@reactionary/core';
+import { AnalyticsCapability } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+export declare class FakeAnalyticsCapability extends AnalyticsCapability {
+    protected config: FakeConfiguration;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext);
+    track(event: AnalyticsMutation): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+import type { Cart, CartFactory, CartFactoryCartOutput, CartFactoryWithOutput, CartQueryById, CartMutationItemAdd, CartMutationItemRemove, CartMutationItemQuantityChange, RequestContext, Cache, CartIdentifier, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationRemoveCoupon, Result, NotFoundError } from '@reactionary/core';
+import { CartCapability } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
+export declare class FakeCartCapability<TFactory extends CartFactory = FakeCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>, CartIdentifier> {
+    protected config: FakeConfiguration;
+    protected factory: CartFactoryWithOutput<TFactory>;
+    private carts;
+    private generator;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, 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 recalculateCart(cart: Cart): void;
+    protected createEmptyCart(): Cart;
+}

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

@@ -0,0 +1,20 @@
+import type { Cache, Category, CategoryFactory, CategoryFactoryCategoryOutput, CategoryFactoryPaginatedOutput, CategoryFactoryWithOutput, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import { CategoryCapability } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker } from '@faker-js/faker';
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+export declare class FakeCategoryCapability<TFactory extends CategoryFactory = FakeCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: CategoryFactoryWithOutput<TFactory>;
+    protected topCategories: Category[];
+    protected childCategories: Map<string, Category[]>;
+    protected allCategories: Map<string, Category>;
+    protected categoryGenerator: Faker;
+    protected generateFakeCategory(parent: Category | undefined, index: number): Category;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: CategoryFactoryWithOutput<TFactory>);
+    getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>>;
+    findTopCategories(_payload: CategoryQueryForTopCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+}

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

@@ -0,0 +1,56 @@
+import { CheckoutCapability, type CheckoutMutationAddPaymentInstruction, type CheckoutMutationFinalizeCheckout, type CheckoutMutationInitiateCheckout, type CheckoutMutationRemovePaymentInstruction, type CheckoutMutationSetShippingAddress, type CheckoutMutationSetShippingInstruction, type CheckoutQueryById, type CheckoutQueryForAvailablePaymentMethods, type CheckoutQueryForAvailableShippingMethods, type NotFoundError, type RequestContext, type Result, type Cache, type CheckoutIdentifier, type CheckoutFactory, type CheckoutFactoryCheckoutOutput, type CheckoutFactoryPaymentMethodOutput, type CheckoutFactoryShippingMethodOutput, type CheckoutFactoryWithOutput } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker } from '@faker-js/faker';
+import type { FakeCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+export declare class FakeCheckoutCapability<TFactory extends CheckoutFactory = FakeCheckoutFactory> extends CheckoutCapability<CheckoutFactoryCheckoutOutput<TFactory>, CheckoutFactoryShippingMethodOutput<TFactory>, CheckoutFactoryPaymentMethodOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected generator: Faker;
+    protected factory: CheckoutFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: CheckoutFactoryWithOutput<TFactory>);
+    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 composeBaseCheckout(identifier?: CheckoutIdentifier): {
+        description: string;
+        identifier: CheckoutIdentifier;
+        items: never[];
+        name: string;
+        originalCartReference: {
+            key: string;
+        };
+        paymentInstructions: never[];
+        price: {
+            grandTotal: {
+                currency: "USD";
+                value: number;
+            };
+            totalDiscount: {
+                currency: "USD";
+                value: number;
+            };
+            totalProductPrice: {
+                currency: "USD";
+                value: number;
+            };
+            totalShipping: {
+                currency: "USD";
+                value: number;
+            };
+            totalSurcharge: {
+                currency: "USD";
+                value: number;
+            };
+            totalTax: {
+                currency: "USD";
+                value: number;
+            };
+        };
+        readyForFinalization: false;
+    };
+}

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

@@ -0,0 +1,13 @@
+import { type Cache, type IdentityFactory, type IdentityFactoryOutput, type IdentityFactoryWithOutput, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, IdentityCapability, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
+export declare class FakeIdentityCapability<TFactory extends IdentityFactory = FakeIdentityFactory> extends IdentityCapability<IdentityFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: IdentityFactoryWithOutput<TFactory>;
+    private currentIdentity;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: IdentityFactoryWithOutput<TFactory>);
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    login(_payload: IdentityMutationLogin): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+    register(_payload: IdentityMutationRegister): Promise<Result<IdentityFactoryOutput<TFactory>>>;
+}

package/src/capabilities/index.d.ts

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

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

@@ -0,0 +1,10 @@
+import type { Cache, InventoryFactory, InventoryFactoryOutput, InventoryFactoryWithOutput, InventoryQueryBySKU, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import { InventoryCapability } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class FakeInventoryCapability<TFactory extends InventoryFactory = FakeInventoryFactory> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: InventoryFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: InventoryFactoryWithOutput<TFactory>);
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>>;
+}

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

@@ -0,0 +1,11 @@
+import { OrderSearchCapability, type Cache, type OrderSearchFactory, type OrderSearchFactoryOutput, type OrderSearchFactoryWithOutput, type OrderSearchQueryByTerm, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker } from '@faker-js/faker';
+import type { FakeOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+export declare class FakeOrderSearchCapability<TFactory extends OrderSearchFactory = FakeOrderSearchFactory> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected generator: Faker;
+    protected factory: OrderSearchFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: OrderSearchFactoryWithOutput<TFactory>);
+    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>>;
+}

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

@@ -0,0 +1,11 @@
+import { OrderCapability, type Cache, type NotFoundError, type OrderFactory, type OrderFactoryOutput, type OrderFactoryWithOutput, type OrderQueryById, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker } from '@faker-js/faker';
+import type { FakeOrderFactory } from '../factories/order/order.factory.js';
+export declare class FakeOrderCapability<TFactory extends OrderFactory = FakeOrderFactory> extends OrderCapability<OrderFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected generator: Faker;
+    protected factory: OrderFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: OrderFactoryWithOutput<TFactory>);
+    getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>>;
+}

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

@@ -0,0 +1,13 @@
+import { PriceCapability, type Cache, type CustomerPriceQuery, type ListPriceQuery, type Price, type PriceFactory, type PriceFactoryOutput, type PriceFactoryWithOutput, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker } from '@faker-js/faker';
+import type { FakePriceFactory } from '../factories/price/price.factory.js';
+export declare class FakePriceCapability<TFactory extends PriceFactory = FakePriceFactory> extends PriceCapability<PriceFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected faker: Faker;
+    protected factory: PriceFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: PriceFactoryWithOutput<TFactory>);
+    protected createPrice(variantSku: string, mode: 'list' | 'customer'): Price;
+    getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+}

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

@@ -0,0 +1,15 @@
+import { ProductAssociationsCapability, type ProductAssociationsGetAccessoriesQuery, type ProductAssociationsGetSparepartsQuery, type ProductAssociationsGetReplacementsQuery, type Result, type Cache, type RequestContext } from '@reactionary/core';
+import type { ProductAssociationsFactory, ProductAssociationsFactoryOutput, ProductAssociationsFactoryWithOutput } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import { Faker } from '@faker-js/faker';
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+export declare class FakeProductAssociationsCapability<TFactory extends ProductAssociationsFactory = FakeProductAssociationsFactory> extends ProductAssociationsCapability<ProductAssociationsFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
+    protected faker: Faker;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductAssociationsFactoryWithOutput<TFactory>);
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    private generateFakeAssociatedProducts;
+}

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

@@ -0,0 +1,13 @@
+import { ProductReviewsCapability, type Cache, type ProductIdentifier, type ProductReviewsFactory, type ProductReviewsFactoryRatingOutput, type ProductReviewsFactoryReviewOutput, type ProductReviewsFactoryReviewPaginatedOutput, type ProductReviewsFactoryWithOutput, type ProductReviewsGetRatingSummaryQuery, type ProductReviewsListQuery, type ProductReview, type ProductReviewMutationSubmit, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+export declare class FakeProductReviewsCapability<TFactory extends ProductReviewsFactory = FakeProductReviewsFactory> extends ProductReviewsCapability<ProductReviewsFactoryRatingOutput<TFactory>, ProductReviewsFactoryReviewPaginatedOutput<TFactory>, ProductReviewsFactoryReviewOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: ProductReviewsFactoryWithOutput<TFactory>;
+    private faker;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductReviewsFactoryWithOutput<TFactory>);
+    protected createReviewsForProduct(productIdentifier: ProductIdentifier): ProductReview[];
+    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>>;
+    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>>;
+    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>>;
+}

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

@@ -0,0 +1,10 @@
+import { ProductSearchCapability, type Cache, type FacetValueIdentifier, type ProductSearchFactory, type ProductSearchFactoryOutput, type ProductSearchFactoryWithOutput, type ProductSearchQueryByTerm, type ProductSearchQueryCreateNavigationFilter, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class FakeProductSearchCapability<TFactory extends ProductSearchFactory = FakeProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductSearchFactoryWithOutput<TFactory>);
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+}

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

@@ -0,0 +1,12 @@
+import { type Cache, type NotFoundError, type ProductFactory, type ProductFactoryOutput, type ProductFactoryWithOutput, type ProductQueryById, type ProductQueryBySKU, type ProductQueryBySlug, ProductCapability, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeProductFactory } from '../factories/product/product.factory.js';
+export declare class FakeProductCapability<TFactory extends ProductFactory = FakeProductFactory> extends ProductCapability<ProductFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: ProductFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProductFactoryWithOutput<TFactory>);
+    getById(payload: ProductQueryById): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    protected composeSingle(body: string): ProductFactoryOutput<TFactory>;
+}

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

@@ -0,0 +1,18 @@
+import { ProfileCapability, type Cache, type Address, type IdentityIdentifier, type NotFoundError, type ProfileFactory, type ProfileFactoryOutput, type ProfileFactoryWithOutput, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf, type RequestContext, type Result } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
+export declare class FakeProfileCapability<TFactory extends ProfileFactory = FakeProfileFactory> extends ProfileCapability<ProfileFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: ProfileFactoryWithOutput<TFactory>;
+    private generator;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: ProfileFactoryWithOutput<TFactory>);
+    getById(payload: ProfileQuerySelf): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    update(payload: ProfileMutationUpdate): 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>>;
+    protected composeProfile(identifier: IdentityIdentifier): ProfileFactoryOutput<TFactory>;
+    protected createEmptyAddress(): Address;
+}

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

@@ -0,0 +1,10 @@
+import type { Cache, RequestContext, Result, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StoreQueryByProximity } from '@reactionary/core';
+import { StoreCapability } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+export declare class FakeStoreCapability<TFactory extends StoreFactory = FakeStoreFactory> extends StoreCapability<StoreFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: StoreFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: StoreFactoryWithOutput<TFactory>);
+    queryByProximity(payload: StoreQueryByProximity): Promise<Result<StoreFactoryOutput<TFactory>[]>>;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { Cache as ReactinaryCache, RequestContext } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import { type FakeClientFromCapabilities } from './initialize.types.js';
+export declare function withFakeCapabilities<T extends FakeCapabilities>(configuration: FakeConfiguration, capabilities: T): (cache: ReactinaryCache, context: RequestContext) => FakeClientFromCapabilities<T>;