@reactionary/medusa 0.6.3

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

@@ -0,0 +1,100 @@
+import type { Cache, CartItem, CartFactory, CartFactoryCartOutput, CartFactoryIdentifierOutput, CartFactoryWithOutput, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartQueryById, CostBreakDown, Currency, ItemCostBreakdown, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import { CartCapability } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { StoreAddCartLineItem, StoreCart, StoreCartAddPromotion, StoreCartLineItem, StoreCartRemovePromotion, StoreCreateCart, StoreUpdateCart, StoreUpdateCartLineItem } from '@medusajs/types';
+import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
+export declare class MedusaCartCapability<TFactory extends CartFactory = MedusaCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>, CartFactoryIdentifierOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: CartFactoryWithOutput<TFactory>;
+    /**
+     * This controls which fields are always included when fetching a cart
+     * You can override this in a subclass to add more fields as needed.
+     *
+     * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
+     */
+    protected includedFields: string;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CartFactoryWithOutput<TFactory>);
+    getById(payload: CartQueryById): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>>;
+    /**
+     * Extension point for the `add` operation to control the payload sent to Medusa when adding an item to the cart. By default, it only includes the variant ID and quantity, but you can override it to include more fields as needed.
+     *
+     * @param payload
+     * @param variantId
+     * @returns
+     */
+    protected addPayload(payload: CartMutationItemAdd, variantId: string): StoreAddCartLineItem;
+    add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    /**
+     * Extension point for the `changeQuantity` operation to control the payload sent to Medusa when changing the quantity of an item in the cart. By default, it only includes the new quantity, but you can override it to include more fields as needed.
+     * @param payload
+     * @returns
+     */
+    protected changeQuantityPayload(payload: CartMutationItemQuantityChange): StoreUpdateCartLineItem;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    getActiveCartId(): Promise<Result<CartFactoryIdentifierOutput<TFactory>, NotFoundError>>;
+    deleteCart(payload: CartMutationDeleteCart): Promise<Result<void>>;
+    /**
+     * Extension point to apply a coupon code to the cart. By default, it only includes the coupon code, but you can override it to include more fields as needed.
+     * @param payload
+     * @returns
+     */
+    protected applyCouponCodePayload(payload: CartMutationApplyCoupon): StoreCartAddPromotion;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    /**
+     * Extension point to remove a coupon code from the cart. By default, it only includes the coupon code to be removed, but you can override it to include more fields as needed.
+     * @param payload
+     * @returns
+     */
+    protected removeCouponCodePayload(payload: CartMutationRemoveCoupon): StoreCartRemovePromotion;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    /**
+     * Extension point to control the payload sent to Medusa when changing the currency of the cart. By default, it only includes the new region ID, but you can override it to include more fields as needed.
+     * @param payload
+     * @param newRegionId
+     * @returns
+     */
+    protected changeCurrencyPayload(payload: CartMutationChangeCurrency, newRegionId: string): StoreUpdateCart;
+    changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    /**
+     * Extension point to control the payload sent to Medusa when creating a cart. By default, it only includes the currency code, but you can override it to include more fields as needed.
+     * @param currency
+     * @returns
+     */
+    protected createCartPayload(currency?: string): StoreCreateCart;
+    protected createCart(currency?: string): Promise<CartFactoryIdentifierOutput<TFactory>>;
+    protected getClient(): Promise<{
+        client: import("@medusajs/js-sdk").Client;
+        admin: import("@medusajs/js-sdk").Admin;
+        store: import("@medusajs/js-sdk").Store;
+        auth: import("@medusajs/js-sdk").Auth;
+    }>;
+    /**
+     * Extension point to control the parsing of a single cart item price
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseItemPrice(remoteItem: StoreCartLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(remote: StoreCart): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single cart item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseCartItem(remoteItem: StoreCartLineItem, currency: Currency): CartItem;
+    /**
+     * Extension point to control the parsing of a single cart
+     * @param remote
+     * @returns
+     */
+    protected parseSingle(remote: StoreCart): CartFactoryCartOutput<TFactory>;
+}

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

@@ -0,0 +1,36 @@
+import type { StoreProductCategory, StoreProductCategoryListResponse } from '@medusajs/types';
+import type { Cache, CategoryFactory, CategoryFactoryCategoryOutput, CategoryFactoryPaginatedOutput, CategoryFactoryWithOutput } from '@reactionary/core';
+import { CategoryCapability, type Result, type NotFoundError, type CategoryQueryById, type CategoryQueryBySlug, type CategoryQueryForBreadcrumb, type CategoryQueryForChildCategories, type CategoryQueryForTopCategories, type RequestContext } from '@reactionary/core';
+import type { MedusaAPI, MedusaConfiguration } from '../index.js';
+import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
+export declare class MedusaCategoryCapability<TFactory extends CategoryFactory = MedusaCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: CategoryFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CategoryFactoryWithOutput<TFactory>);
+    protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
+    getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    protected getBySlugPayload(payload: CategoryQueryBySlug): {
+        handle: string;
+        limit: number;
+        offset: number;
+    };
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>>;
+    protected findChildCategoriesPayload(payload: CategoryQueryForChildCategories, actualParent: StoreProductCategory): {
+        fields: string;
+        parent_category_id: string;
+        limit: number;
+        offset: number;
+    };
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<CategoryFactoryPaginatedOutput<TFactory>>>;
+    protected findTopCategoriesPayload(payload: CategoryQueryForTopCategories): {
+        fields: string;
+        parent_category_id: string;
+        limit: number;
+        offset: number;
+    };
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<import("@reactionary/core").Ok<CategoryFactoryPaginatedOutput<TFactory>>>;
+    protected parseSingle(_body: StoreProductCategory): CategoryFactoryCategoryOutput<TFactory>;
+    protected parsePaginatedResult(body: StoreProductCategoryListResponse): CategoryFactoryPaginatedOutput<TFactory>;
+}

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

@@ -0,0 +1,88 @@
+import type { StoreAddCartShippingMethods, StoreCart, StoreCartAddress, StoreCartLineItem, StoreInitializePaymentSession, StoreUpdateCart } from '@medusajs/types';
+import type { Address, Cache, CheckoutIdentifier, CheckoutItem, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutFactory, CheckoutFactoryCheckoutOutput, CheckoutFactoryPaymentMethodOutput, CheckoutFactoryShippingMethodOutput, CheckoutFactoryWithOutput, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, CostBreakDown, Currency, ItemCostBreakdown, RequestContext, Result, NotFoundError } from '@reactionary/core';
+import { CheckoutCapability } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+export declare class CheckoutNotReadyForFinalizationError extends Error {
+    checkoutIdentifier: CheckoutIdentifier;
+    constructor(checkoutIdentifier: CheckoutIdentifier);
+}
+export declare class MedusaCheckoutCapability<TFactory extends CheckoutFactory = MedusaCheckoutFactory> extends CheckoutCapability<CheckoutFactoryCheckoutOutput<TFactory>, CheckoutFactoryShippingMethodOutput<TFactory>, CheckoutFactoryPaymentMethodOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: CheckoutFactoryWithOutput<TFactory>;
+    /**
+     * This controls which fields are always included when fetching a cart
+     * You can override this in a subclass to add more fields as needed.
+     *
+     * example: this.includedFields = [includedFields, '+discounts.*'].join(',');
+     */
+    protected includedFields: string;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CheckoutFactoryWithOutput<TFactory>);
+    protected initiateCheckoutForCartPayload(payload: CheckoutMutationInitiateCheckout): StoreUpdateCart;
+    initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    getById(payload: CheckoutQueryById): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>>;
+    protected setShippingAddressPayload(payload: CheckoutMutationSetShippingAddress): StoreUpdateCart;
+    setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    protected getAvailableShippingMethodsPayload(payload: CheckoutQueryForAvailableShippingMethods): {
+        cart_id: string;
+    };
+    getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>>;
+    protected getAvailablePaymentMethodsPayload(payload: CheckoutQueryForAvailablePaymentMethods, regionId: string): {
+        region_id: string;
+    };
+    getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<CheckoutFactoryPaymentMethodOutput<TFactory>[]>>;
+    protected addPaymentInstructionPayload(payload: CheckoutMutationAddPaymentInstruction): StoreInitializePaymentSession;
+    addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    protected setShippingInstructionPayload(payload: CheckoutMutationSetShippingInstruction): StoreAddCartShippingMethods;
+    setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
+    /**
+     * Extension point to map an Address to a Store Address
+     * @param address
+     * @returns
+     */
+    protected mapAddressToStoreAddress(address: Partial<Address>): {
+        first_name: string | undefined;
+        last_name: string | undefined;
+        address_1: string | undefined;
+        address_2: string;
+        city: string | undefined;
+        postal_code: string | undefined;
+        country_code: string | undefined;
+    };
+    /**
+     * Extension point to control the parsing of an address from a store cart address
+     * @param storeAddress
+     * @returns
+     */
+    protected composeAddressFromStoreAddress(storeAddress: StoreCartAddress): Address;
+    /**
+     * Extension point to control the parsing of a single cart item price
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseItemPrice(remoteItem: StoreCartLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(remote: StoreCart): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single checkout item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseCheckoutItem(remoteItem: StoreCartLineItem, currency: Currency): CheckoutItem;
+    /**
+     * Extension point to control the parsing of the Checkout object
+     * @param remote
+     * @returns
+     */
+    protected parseSingle(remote: StoreCart): CheckoutFactoryCheckoutOutput<TFactory>;
+}

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

@@ -0,0 +1,13 @@
+import { type Identity, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, type RequestContext, type Cache, IdentityCapability, type AnonymousIdentity, type Result } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+export declare class MedusaIdentityCapability extends IdentityCapability {
+    protected config: MedusaConfiguration;
+    protected medusaApi: MedusaAPI;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
+    protected createAnonymousIdentity(): AnonymousIdentity;
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<Identity>>;
+    login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<Identity>>;
+    register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
+}

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

@@ -0,0 +1,21 @@
+import { type InventoryQueryBySKU, type RequestContext, type Cache, InventoryCapability, type InventoryFactory, type InventoryFactoryOutput, type InventoryFactoryWithOutput, type NotFoundError, type Result } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import { type MedusaAPI } from '../core/client.js';
+import type { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class MedusaInventoryCapability<TFactory extends InventoryFactory = MedusaInventoryFactory> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: InventoryFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: InventoryFactoryWithOutput<TFactory>);
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>>;
+    protected parseSingle(_body: unknown): InventoryFactoryOutput<TFactory>;
+    /**
+     * Utility function to create an empty inventory result.
+     * This is used when no inventory is found for a given SKU + fulfillment center combination.
+     * @param sku
+     * @param fulfillmentCenterKey
+     * @returns
+     */
+    protected createEmptyInventoryResult(sku: string, fulfillmentCenterKey: string): InventoryFactoryOutput<TFactory>;
+    protected getResourceName(): string;
+}

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

@@ -0,0 +1,53 @@
+import type { RequestContext, Cache, OrderSearchQueryByTerm, Result, Address, IdentityIdentifier, MonetaryAmount, OrderSearchResultItem, OrderSearchFactory, OrderSearchFactoryOutput, OrderSearchFactoryWithOutput } from '@reactionary/core';
+import { OrderSearchCapability } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import type { StoreOrder, StoreOrderAddress, StoreOrderListResponse } from '@medusajs/types';
+import type { MedusaOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+export declare class MedusaOrderSearchCapability<TFactory extends OrderSearchFactory = MedusaOrderSearchFactory> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: OrderSearchFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: OrderSearchFactoryWithOutput<TFactory>);
+    protected queryByTermPayload(payload: OrderSearchQueryByTerm): any;
+    queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchFactoryOutput<TFactory>>>;
+    protected composeAddressFromStoreAddress(storeAddress: StoreOrderAddress): Address;
+    protected parseSingle(body: StoreOrder): {
+        identifier: {
+            key: string;
+        };
+        userId: IdentityIdentifier;
+        customerName: string;
+        shippingAddress: Address;
+        orderDate: string;
+        orderStatus: "AwaitingPayment" | "ReleasedToFulfillment" | "Shipped" | "Cancelled";
+        inventoryStatus: ("NotAllocated" & {
+            _?: never;
+        }) | ("Allocated" & {
+            _?: never;
+        });
+        totalAmount: MonetaryAmount;
+    };
+    protected parsePaginatedResult(body: StoreOrderListResponse, query: OrderSearchQueryByTerm): {
+        identifier: {
+            term: string;
+            filters: string[];
+            paginationOptions: {
+                pageNumber: number;
+                pageSize: number;
+            };
+            partNumber?: string[] | undefined;
+            orderStatus?: ("AwaitingPayment" | "ReleasedToFulfillment" | "Shipped" | "Cancelled")[] | undefined;
+            user?: {
+                userId: string;
+            } | undefined;
+            startDate?: string | undefined;
+            endDate?: string | undefined;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: OrderSearchResultItem[];
+    };
+}

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

@@ -0,0 +1,49 @@
+import type { Cache, OrderQueryById, RequestContext, Result, NotFoundError, CostBreakDown, Currency, OrderItem, ItemCostBreakdown, PaymentMethodIdentifier, OrderFactory, OrderFactoryOutput, OrderFactoryWithOutput } from '@reactionary/core';
+import { OrderCapability } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { StoreOrder, StoreOrderLineItem, StorePaymentCollection } from '@medusajs/types';
+import type { MedusaOrderFactory } from '../factories/order/order.factory.js';
+export declare class MedusaOrderCapability<TFactory extends OrderFactory = MedusaOrderFactory> extends OrderCapability<OrderFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: OrderFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: OrderFactoryWithOutput<TFactory>);
+    getById(payload: OrderQueryById): Promise<Result<OrderFactoryOutput<TFactory>, NotFoundError>>;
+    /**
+     * Extension point to control the parsing of a single cart item price
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseItemPrice(remoteItem: StoreOrderLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(remote: StoreOrder): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single cart item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseOrderItem(remoteItem: StoreOrderLineItem, currency: Currency): OrderItem;
+    protected parsePaymentInstruction(remotePayment: StorePaymentCollection, order: StoreOrder): {
+        identifier: {
+            key: string;
+        };
+        amount: {
+            value: number;
+            currency: Currency;
+        };
+        paymentMethod: PaymentMethodIdentifier;
+        protocolData: {
+            key: string;
+            value: string;
+        }[];
+        status: "pending" | "authorized" | "canceled" | "capture";
+    };
+    protected parseSingle(body: StoreOrder): OrderFactoryOutput<TFactory>;
+}

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

@@ -0,0 +1,16 @@
+import type { StoreProductVariant } from '@medusajs/types';
+import { PriceCapability, type Cache, type CustomerPriceQuery, type ListPriceQuery, type PriceFactory, type PriceFactoryOutput, type PriceFactoryWithOutput, type RequestContext, type Result } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaPriceFactory } from '../factories/price/price.factory.js';
+export declare class MedusaPriceCapability<TFactory extends PriceFactory = MedusaPriceFactory> extends PriceCapability<PriceFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: PriceFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: PriceFactoryWithOutput<TFactory>);
+    getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    protected getBySKU(payload: ListPriceQuery | CustomerPriceQuery, mode: 'list' | 'customer'): Promise<PriceFactoryOutput<TFactory>>;
+    protected parseSingle(variant: StoreProductVariant, mode: 'list' | 'customer'): PriceFactoryOutput<TFactory>;
+    protected getResourceName(): string;
+}

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

@@ -0,0 +1,19 @@
+import { ProductAssociationsCapability } from '@reactionary/core';
+import type { ProductAssociationsFactory, ProductAssociationsFactoryOutput, ProductAssociationsFactoryWithOutput } from '@reactionary/core';
+import type { ProductIdentifier, ProductSearchResultItem, ProductSearchResultItemVariant, ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery, Result, RequestContext, Cache } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import type { MedusaProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+export declare class MedusaProductAssociationsCapability<TFactory extends ProductAssociationsFactory = MedusaProductAssociationsFactory> extends ProductAssociationsCapability<ProductAssociationsFactoryOutput<TFactory>> {
+    protected config: MedusaConfiguration;
+    protected medusa: MedusaAPI;
+    protected factory: ProductAssociationsFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusa: MedusaAPI, factory: ProductAssociationsFactoryWithOutput<TFactory>);
+    protected fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]>;
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociationsFactoryOutput<TFactory>[]>>;
+    protected parseSingle(_body: StoreProduct): ProductSearchResultItem;
+    protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
+}

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

@@ -0,0 +1,41 @@
+import type { StoreCollection, StoreProduct, StoreProductVariant } from '@medusajs/types';
+import { ProductRecommendationsCapability, type Cache, type ProductRecommendation, type ProductRecommendationsByCollectionQuery, type ProductSearchResultItemVariant, type RequestContext, type Result } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+/**
+ * MedusaProductRecommendationsCapability
+ *
+ * Provides product recommendations using Medusa's collection-based product grouping.
+ * Only overrides the getCollection method to fetch products from Medusa collections.
+ *
+ * Note: This implementation leverages Medusa's product collections feature to provide
+ * curated product recommendations. Collections are typically manually managed or
+ * created through Medusa's admin panel or API.
+ */
+export declare class MedusaProductRecommendationsCapability extends ProductRecommendationsCapability {
+    protected config: MedusaConfiguration;
+    protected medusaApi: MedusaAPI;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
+    protected getCollectionPayload(query: ProductRecommendationsByCollectionQuery, collection: StoreCollection): {
+        collection_id: string[];
+        limit: number;
+        fields: string;
+    };
+    /**
+     * Get product recommendations from a Medusa collection
+     *
+     * This method fetches products from a specific Medusa collection by name or handle.
+     * It's useful for displaying curated product lists like "Featured Products",
+     * "New Arrivals", "Best Sellers", etc.
+     */
+    getCollection(query: ProductRecommendationsByCollectionQuery): Promise<Result<ProductRecommendation[]>>;
+    protected parseSearchResultItem(_body: StoreProduct): {
+        identifier: {
+            key: string;
+        };
+        name: string;
+        slug: string;
+        variants: ProductSearchResultItemVariant[];
+    };
+    protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
+}

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

@@ -0,0 +1,45 @@
+import { ProductSearchCapability, type Cache, type RequestContext, type ProductSearchQueryByTerm, type ProductSearchResultItem, type ProductSearchResultItemVariant, type FacetValueIdentifier, type ProductSearchFactory, type ProductSearchFactoryOutput, type ProductSearchFactoryWithOutput, type ProductSearchQueryCreateNavigationFilter, type Result } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import type { StoreProduct, StoreProductCategory, StoreProductListResponse, StoreProductVariant } from '@medusajs/types';
+import type { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class MedusaProductSearchCapability<TFactory extends ProductSearchFactory = MedusaProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: ProductSearchFactoryWithOutput<TFactory>);
+    protected resolveCategoryIdByExternalId(externalId: string): Promise<StoreProductCategory | null>;
+    protected queryByTermPayload(payload: ProductSearchQueryByTerm, categoryIdToFind: string | null): any;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
+    protected parsePaginatedResult(remote: StoreProductListResponse, query: ProductSearchQueryByTerm): {
+        identifier: {
+            term: string;
+            facets: {
+                facet: {
+                    key: string;
+                };
+                key: string;
+            }[];
+            filters: string[];
+            paginationOptions: {
+                pageNumber: number;
+                pageSize: number;
+            };
+            categoryFilter?: {
+                facet: {
+                    key: string;
+                };
+                key: string;
+            } | undefined;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: ProductSearchResultItem[];
+        facets: never[];
+    };
+    protected parseSingle(_body: StoreProduct): ProductSearchResultItem;
+    protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+}

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

@@ -0,0 +1,32 @@
+import type { Cache, NotFoundError, ProductAttribute, ProductFactory, ProductFactoryOutput, ProductFactoryWithOutput, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, ProductVariant, RequestContext, Result } from '@reactionary/core';
+import { ProductCapability } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import type { MedusaProductFactory } from '../factories/product/product.factory.js';
+export declare class MedusaProductCapability<TFactory extends ProductFactory = MedusaProductFactory> extends ProductCapability<ProductFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected alwaysIncludedFields: string[];
+    protected factory: ProductFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: ProductFactoryWithOutput<TFactory>);
+    protected getByIdPayload(payload: ProductQueryById): {
+        external_id: string;
+        limit: number;
+        offset: number;
+        fields: string;
+    };
+    getById(payload: ProductQueryById): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    protected getBySlugPayload(payload: ProductQueryBySlug): {
+        handle: string;
+        limit: number;
+        offset: number;
+        fields: string;
+    };
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    protected parseSingle(_body: StoreProduct): ProductFactoryOutput<TFactory>;
+    protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductVariant;
+    protected createSynthAttribute(key: string, name: string, value: string): ProductAttribute;
+    protected parseAttributes(_body: StoreProduct): Array<ProductAttribute>;
+}

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

@@ -0,0 +1,39 @@
+import { type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf as ProfileQueryById, type RequestContext, type Cache, type Result, type NotFoundError, ProfileCapability, type Address, type ProfileFactory, type ProfileFactoryOutput, type ProfileFactoryWithOutput } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import type { StoreCreateCustomerAddress, StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
+import type { MedusaProfileFactory } from '../factories/profile/profile.factory.js';
+/**
+ * Medusa Profile Capability
+ *
+ * Implements profile management using Medusa's customer APIs.
+ *
+ * TODO:
+ * - handle email and phone verification status properly using metadata or other means.
+ * - handle guest user scenarios (if applicable).
+ * - improve error handling and edge cases.
+ */
+export declare class MedusaProfileCapability<TFactory extends ProfileFactory = MedusaProfileFactory> extends ProfileCapability<ProfileFactoryOutput<TFactory>> {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected includedFields: string[];
+    protected factory: ProfileFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: ProfileFactoryWithOutput<TFactory>);
+    getById(payload: ProfileQueryById): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected updatePayload(payload: ProfileMutationUpdate): any;
+    update(payload: ProfileMutationUpdate): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected addShippingAddressPayload(payload: ProfileMutationAddShippingAddress): StoreCreateCustomerAddress;
+    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected updateShippingAddressPayload(payload: ProfileMutationUpdateShippingAddress): StoreCreateCustomerAddress;
+    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected makeShippingAddressDefaultPayload(payload: ProfileMutationMakeShippingAddressDefault): {
+        is_default_shipping: boolean;
+    };
+    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected setBillingAddressPayload(payload: ProfileMutationSetBillingAddress): StoreCreateCustomerAddress;
+    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<ProfileFactoryOutput<TFactory>, NotFoundError>>;
+    protected createMedusaAddress(address: Address): StoreCreateCustomerAddress;
+    protected parseAddress(address: StoreCustomerAddress): Address;
+    protected parseSingle(customer: StoreCustomer): ProfileFactoryOutput<TFactory>;
+}