@reactionary/medusa 0.6.3 → 0.6.5

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

@@ -1,8 +1,8 @@
-import type { StoreProductCategory, StoreProductCategoryListResponse } from '@medusajs/types';
+import type { StoreProductCategory } 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 { CategoryCapability, type CategoryQueryById, type CategoryQueryBySlug, type CategoryQueryForBreadcrumb, type CategoryQueryForChildCategories, type CategoryQueryForTopCategories, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
 import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
+import type { MedusaAPI, MedusaConfiguration } from '../index.js';
 export declare class MedusaCategoryCapability<TFactory extends CategoryFactory = MedusaCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
@@ -23,14 +23,12 @@ export declare class MedusaCategoryCapability<TFactory extends CategoryFactory =
         limit: number;
         offset: number;
     };
-    findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<CategoryFactoryPaginatedOutput<TFactory>>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<import("@reactionary/core").Ok<ReturnType<TFactory["parseCategoryPaginatedResult"]>>>;
     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>;
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<import("@reactionary/core").Ok<ReturnType<TFactory["parseCategoryPaginatedResult"]>>>;
 }

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

@@ -1,9 +1,9 @@
-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 type { StoreAddCartShippingMethods, StoreInitializePaymentSession, StoreUpdateCart } from '@medusajs/types';
+import type { Address, Cache, CheckoutFactory, CheckoutFactoryCheckoutOutput, CheckoutFactoryPaymentMethodOutput, CheckoutFactoryShippingMethodOutput, CheckoutFactoryWithOutput, CheckoutIdentifier, CheckoutMutationAddPaymentInstruction, CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingAddress, CheckoutMutationSetShippingInstruction, CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods, NotFoundError, RequestContext, Result } 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';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 export declare class CheckoutNotReadyForFinalizationError extends Error {
     checkoutIdentifier: CheckoutIdentifier;
     constructor(checkoutIdentifier: CheckoutIdentifier);
@@ -53,36 +53,4 @@ export declare class MedusaCheckoutCapability<TFactory extends CheckoutFactory =
         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/inventory.capability.d.ts

@@ -1,21 +1,11 @@
-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 Cache, InventoryCapability, type InventoryFactory, type InventoryFactoryOutput, type InventoryFactoryWithOutput, type InventoryQueryBySKU, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
 import { type MedusaAPI } from '../core/client.js';
 import type { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.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

@@ -1,9 +1,8 @@
-import type { RequestContext, Cache, OrderSearchQueryByTerm, Result, Address, IdentityIdentifier, MonetaryAmount, OrderSearchResultItem, OrderSearchFactory, OrderSearchFactoryOutput, OrderSearchFactoryWithOutput } from '@reactionary/core';
+import type { Cache, OrderSearchFactory, OrderSearchFactoryOutput, OrderSearchFactoryWithOutput, OrderSearchQueryByTerm, RequestContext, Result } 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';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 export declare class MedusaOrderSearchCapability<TFactory extends OrderSearchFactory = MedusaOrderSearchFactory> extends OrderSearchCapability<OrderSearchFactoryOutput<TFactory>> {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
@@ -11,43 +10,4 @@ export declare class MedusaOrderSearchCapability<TFactory extends OrderSearchFac
     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

@@ -1,49 +1,12 @@
-import type { Cache, OrderQueryById, RequestContext, Result, NotFoundError, CostBreakDown, Currency, OrderItem, ItemCostBreakdown, PaymentMethodIdentifier, OrderFactory, OrderFactoryOutput, OrderFactoryWithOutput } from '@reactionary/core';
+import type { Cache, NotFoundError, OrderFactory, OrderFactoryOutput, OrderFactoryWithOutput, OrderQueryById, RequestContext, Result } 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';
+import type { MedusaConfiguration } from '../schema/configuration.schema.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

@@ -1,8 +1,7 @@
-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';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 export declare class MedusaPriceCapability<TFactory extends PriceFactory = MedusaPriceFactory> extends PriceCapability<PriceFactoryOutput<TFactory>> {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
@@ -11,6 +10,4 @@ export declare class MedusaPriceCapability<TFactory extends PriceFactory = Medus
     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

@@ -1,19 +1,15 @@
+import type { Cache, ProductAssociationsFactory, ProductAssociationsFactoryOutput, ProductAssociationsFactoryWithOutput, ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetReplacementsQuery, ProductAssociationsGetSparepartsQuery, ProductIdentifier, RequestContext, Result } from '@reactionary/core';
 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';
+import type { MedusaConfiguration } from '../schema/configuration.schema.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[]>;
+    protected fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<import("@medusajs/types").StoreProduct[]>;
     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-search.capability.d.ts

@@ -1,8 +1,8 @@
-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 { StoreProductCategory } from '@medusajs/types';
+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 { 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';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 export declare class MedusaProductSearchCapability<TFactory extends ProductSearchFactory = MedusaProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
@@ -10,36 +10,6 @@ export declare class MedusaProductSearchCapability<TFactory extends ProductSearc
     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>>;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
 }

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

@@ -1,8 +1,7 @@
-import type { Cache, NotFoundError, ProductAttribute, ProductFactory, ProductFactoryOutput, ProductFactoryWithOutput, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, ProductVariant, RequestContext, Result } from '@reactionary/core';
+import type { Cache, NotFoundError, ProductFactory, ProductFactoryOutput, ProductFactoryWithOutput, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, 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;
@@ -25,8 +24,4 @@ export declare class MedusaProductCapability<TFactory extends ProductFactory = M
     };
     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

@@ -1,8 +1,8 @@
-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 { StoreCreateCustomerAddress } from '@medusajs/types';
+import { type Address, type Cache, type NotFoundError, ProfileCapability, type ProfileFactory, type ProfileFactoryOutput, type ProfileFactoryWithOutput, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf as ProfileQueryById, type RequestContext, type Result } from '@reactionary/core';
 import type { MedusaAPI } from '../core/client.js';
-import type { StoreCreateCustomerAddress, StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
 import type { MedusaProfileFactory } from '../factories/profile/profile.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
 /**
  * Medusa Profile Capability
  *
@@ -34,6 +34,4 @@ export declare class MedusaProfileCapability<TFactory extends ProfileFactory = M
     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>;
 }

package/src/factories/cart/cart.factory.d.ts

@@ -1,9 +1,30 @@
-import type { AnyCartIdentifierSchema, AnyCartSchema, CartFactory, CartIdentifierSchema, CartSchema, RequestContext } from '@reactionary/core';
+import type { StoreCart, StoreCartLineItem } from '@medusajs/types';
+import { type AnyCartIdentifierSchema, type AnyCartSchema, type CartFactory, type CartIdentifierSchema, type CartItem, type CartSchema, type CostBreakDown, type Currency, type ItemCostBreakdown, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema> {
     readonly cartSchema: TCartSchema;
     readonly cartIdentifierSchema: TCartIdentifierSchema;
     constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema);
-    parseCart(_context: RequestContext, data: unknown): z.output<TCartSchema>;
+    parseCart(context: RequestContext, data: StoreCart): z.output<TCartSchema>;
     parseCartIdentifier(_context: RequestContext, data: unknown): z.output<TCartIdentifierSchema>;
+    /**
+   * Extension point to control the parsing of a single cart item price
+   * @param remoteItem
+   * @param currency
+   * @returns
+   */
+    protected parseItemPrice(_context: RequestContext, remoteItem: StoreCartLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(_context: RequestContext, remote: StoreCart): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single cart item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseCartItem(context: RequestContext, remoteItem: StoreCartLineItem, currency: Currency): CartItem;
 }

package/src/factories/category/category.factory.d.ts

@@ -1,9 +1,10 @@
-import type { AnyCategoryPaginatedResultSchema, AnyCategorySchema, CategoryFactory, CategoryPaginatedResultSchema, CategorySchema, RequestContext } from '@reactionary/core';
+import type { StoreProductCategory, StoreProductCategoryListResponse } from '@medusajs/types';
+import { type AnyCategoryPaginatedResultSchema, type AnyCategorySchema, type CategoryFactory, type CategoryPaginatedResultSchema, type CategorySchema, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaCategoryFactory<TCategorySchema extends AnyCategorySchema = typeof CategorySchema, TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema> {
     readonly categorySchema: TCategorySchema;
     readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
     constructor(categorySchema: TCategorySchema, categoryPaginatedResultSchema: TCategoryPaginatedSchema);
-    parseCategory(_context: RequestContext, data: unknown): z.output<TCategorySchema>;
-    parseCategoryPaginatedResult(_context: RequestContext, data: unknown): z.output<TCategoryPaginatedSchema>;
+    parseCategory(_context: RequestContext, data: StoreProductCategory): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(context: RequestContext, data: StoreProductCategoryListResponse): z.output<TCategoryPaginatedSchema>;
 }

package/src/factories/checkout/checkout.factory.d.ts

@@ -1,11 +1,38 @@
-import type { AnyCheckoutSchema, AnyPaymentMethodSchema, AnyShippingMethodSchema, CheckoutFactory, CheckoutSchema, PaymentMethodSchema, RequestContext, ShippingMethodSchema } from '@reactionary/core';
+import type { StoreCart, StoreCartAddress, StoreCartLineItem, StoreCartShippingOptionWithServiceZone, StorePaymentProvider } from '@medusajs/types';
+import { type Address, type AnyCheckoutSchema, type AnyPaymentMethodSchema, type AnyShippingMethodSchema, type CheckoutFactory, type CheckoutItem, type CheckoutSchema, type CostBreakDown, type Currency, type ItemCostBreakdown, type PaymentMethodSchema, type RequestContext, type ShippingMethodSchema } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaCheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema> {
     readonly checkoutSchema: TCheckoutSchema;
     readonly shippingMethodSchema: TShippingMethodSchema;
     readonly paymentMethodSchema: TPaymentMethodSchema;
     constructor(checkoutSchema: TCheckoutSchema, shippingMethodSchema: TShippingMethodSchema, paymentMethodSchema: TPaymentMethodSchema);
-    parseCheckout(_context: RequestContext, data: unknown): z.output<TCheckoutSchema>;
-    parseShippingMethod(_context: RequestContext, data: unknown): z.output<TShippingMethodSchema>;
-    parsePaymentMethod(_context: RequestContext, data: unknown): z.output<TPaymentMethodSchema>;
+    /**
+     * Extension point to control the parsing of a single cart item price
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseItemPrice(_context: RequestContext, remoteItem: StoreCartLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(_context: RequestContext, remote: StoreCart): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single checkout item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseCheckoutItem(context: RequestContext, remoteItem: StoreCartLineItem, currency: Currency): CheckoutItem;
+    /**
+     * Extension point to control the parsing of an address from a store cart address
+     * @param storeAddress
+     * @returns
+     */
+    protected parseAddress(_context: RequestContext, storeAddress: StoreCartAddress): Address;
+    parseCheckout(context: RequestContext, data: StoreCart): z.output<TCheckoutSchema>;
+    parseShippingMethod(_context: RequestContext, data: StoreCartShippingOptionWithServiceZone): z.output<TShippingMethodSchema>;
+    parsePaymentMethod(_context: RequestContext, data: StorePaymentProvider): z.output<TPaymentMethodSchema>;
 }

package/src/factories/inventory/inventory.factory.d.ts

@@ -1,7 +1,13 @@
 import type { AnyInventorySchema, InventoryFactory, InventorySchema, RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
+export interface MedusaInventoryParseInput {
+    sku: string;
+    fulfillmentCenterKey: string;
+    quantity: number;
+    inventoryItemId: string;
+}
 export declare class MedusaInventoryFactory<TInventorySchema extends AnyInventorySchema = typeof InventorySchema> implements InventoryFactory<TInventorySchema> {
     readonly inventorySchema: TInventorySchema;
     constructor(inventorySchema: TInventorySchema);
-    parseInventory(_context: RequestContext, data: unknown): z.output<TInventorySchema>;
+    parseInventory(_context: RequestContext, data: MedusaInventoryParseInput): z.output<TInventorySchema>;
 }

package/src/factories/order/order.factory.d.ts

@@ -1,7 +1,43 @@
-import type { AnyOrderSchema, OrderFactory, OrderSchema, RequestContext } from '@reactionary/core';
+import type { StoreOrder, StoreOrderLineItem, StorePaymentCollection } from '@medusajs/types';
+import { type AnyOrderSchema, type CostBreakDown, type Currency, type ItemCostBreakdown, type OrderFactory, type OrderItem, type OrderSchema, type PaymentMethodIdentifier, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaOrderFactory<TOrderSchema extends AnyOrderSchema = typeof OrderSchema> implements OrderFactory<TOrderSchema> {
     readonly orderSchema: TOrderSchema;
     constructor(orderSchema: TOrderSchema);
-    parseOrder(_context: RequestContext, data: unknown): z.output<TOrderSchema>;
+    parseOrder(context: RequestContext, data: StoreOrder): z.output<TOrderSchema>;
+    /**
+     * Extension point to control the parsing of a single cart item price
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseItemPrice(context: RequestContext, remoteItem: StoreOrderLineItem, currency: Currency): ItemCostBreakdown;
+    /**
+     * Extension point to control the parsing of the cost breakdown of a cart
+     * @param remote
+     * @returns
+     */
+    protected parseCostBreakdown(_context: RequestContext, remote: StoreOrder): CostBreakDown;
+    /**
+     * Extension point to control the parsing of a single cart item
+     * @param remoteItem
+     * @param currency
+     * @returns
+     */
+    protected parseOrderItem(context: RequestContext, remoteItem: StoreOrderLineItem, currency: Currency): OrderItem;
+    protected parsePaymentInstruction(_context: RequestContext, remotePayment: StorePaymentCollection, order: StoreOrder): {
+        identifier: {
+            key: string;
+        };
+        amount: {
+            value: number;
+            currency: Currency;
+        };
+        paymentMethod: PaymentMethodIdentifier;
+        protocolData: {
+            key: string;
+            value: string;
+        }[];
+        status: "pending" | "authorized" | "canceled" | "capture";
+    };
 }

package/src/factories/order-search/order-search.factory.d.ts

@@ -1,7 +1,25 @@
-import type { AnyOrderSearchResultSchema, OrderSearchFactory, OrderSearchQueryByTerm, OrderSearchResultSchema, RequestContext } from '@reactionary/core';
+import type { StoreOrder, StoreOrderAddress, StoreOrderListResponse } from '@medusajs/types';
+import { type Address, type AnyOrderSearchResultSchema, type IdentityIdentifier, type MonetaryAmount, type OrderSearchFactory, type OrderSearchQueryByTerm, type OrderSearchResultSchema, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaOrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema> implements OrderSearchFactory<TOrderSearchResultSchema> {
     readonly orderSearchResultSchema: TOrderSearchResultSchema;
     constructor(orderSearchResultSchema: TOrderSearchResultSchema);
-    parseOrderSearchResult(_context: RequestContext, data: unknown, _query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+    protected parseOrderSearchResultItem(context: RequestContext, 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 parseAddress(_context: RequestContext, storeAddress: StoreOrderAddress): Address;
+    parseOrderSearchResult(_context: RequestContext, data: StoreOrderListResponse, query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
 }

package/src/factories/price/price.factory.d.ts

@@ -1,9 +1,14 @@
+import type { StoreProductVariant } from '@medusajs/types';
 import type { AnyPriceSchema, PriceFactory, PriceSchema, RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
+export interface MedusaPriceFactoryParseInput {
+    variant: StoreProductVariant;
+    mode: 'list' | 'customer';
+}
 export declare class MedusaPriceFactory<TPriceSchema extends AnyPriceSchema = typeof PriceSchema> implements PriceFactory<TPriceSchema> {
     readonly priceSchema: TPriceSchema;
     constructor(priceSchema: TPriceSchema);
-    parsePrice(_context: RequestContext, data: unknown, _options?: {
+    parsePrice(context: RequestContext, data: MedusaPriceFactoryParseInput, _options?: {
         includeDiscounts: boolean;
     }): z.output<TPriceSchema>;
 }

package/src/factories/product/product.factory.d.ts

@@ -1,7 +1,11 @@
-import type { AnyProductSchema, ProductFactory, ProductSchema, RequestContext } from '@reactionary/core';
+import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import { type AnyProductSchema, type ProductAttribute, type ProductFactory, type ProductSchema, type ProductVariant, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaProductFactory<TProductSchema extends AnyProductSchema = typeof ProductSchema> implements ProductFactory<TProductSchema> {
     readonly productSchema: TProductSchema;
     constructor(productSchema: TProductSchema);
-    parseProduct(_context: RequestContext, data: unknown): z.output<TProductSchema>;
+    protected parseVariant(_context: RequestContext, variant: StoreProductVariant, product: StoreProduct): ProductVariant;
+    protected createSynthAttribute(key: string, name: string, value: string): ProductAttribute;
+    protected parseAttributes(_context: RequestContext, _body: StoreProduct): Array<ProductAttribute>;
+    parseProduct(context: RequestContext, data: StoreProduct): z.output<TProductSchema>;
 }

package/src/factories/product-associations/product-associations.factory.d.ts

@@ -1,7 +1,13 @@
-import type { AnyProductAssociationSchema, ProductAssociationSchema, ProductAssociationsFactory, RequestContext } from '@reactionary/core';
+import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+import { type AnyProductAssociationSchema, type ProductAssociationSchema, type ProductAssociationsFactory, type ProductAssociationsIdentifier, type ProductSearchResultItemVariant, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
+export interface MedusaProductAssociationFactoryInput {
+    product: StoreProduct;
+    identifier: ProductAssociationsIdentifier;
+}
 export declare class MedusaProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema> implements ProductAssociationsFactory<TProductAssociationSchema> {
     readonly productAssociationSchema: TProductAssociationSchema;
     constructor(productAssociationSchema: TProductAssociationSchema);
-    parseAssociation(_context: RequestContext, data: unknown): z.output<TProductAssociationSchema>;
+    parseAssociation(context: RequestContext, data: MedusaProductAssociationFactoryInput): z.output<TProductAssociationSchema>;
+    protected parseVariant(_context: RequestContext, variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
 }

package/src/factories/product-search/product-search.factory.d.ts

@@ -1,7 +1,10 @@
-import type { AnyProductSearchResultSchema, ProductSearchFactory, ProductSearchQueryByTerm, ProductSearchResultSchema, RequestContext } from '@reactionary/core';
+import type { StoreProduct, StoreProductListResponse, StoreProductVariant } from '@medusajs/types';
+import { type AnyProductSearchResultSchema, type ProductSearchFactory, type ProductSearchQueryByTerm, type ProductSearchResultItem, type ProductSearchResultItemVariant, type ProductSearchResultSchema, type RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
     readonly productSearchResultSchema: TProductSearchResultSchema;
     constructor(productSearchResultSchema: TProductSearchResultSchema);
-    parseSearchResult(_context: RequestContext, data: unknown, _query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+    parseSearchResult(context: RequestContext, remote: StoreProductListResponse, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+    protected parseProductSearchResultItem(context: RequestContext, data: StoreProduct): ProductSearchResultItem;
+    protected parseVariant(_context: RequestContext, variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
 }

package/src/factories/profile/profile.factory.d.ts

@@ -1,7 +1,9 @@
-import type { AnyProfileSchema, ProfileFactory, ProfileSchema, RequestContext } from '@reactionary/core';
+import type { StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
+import type { Address, AnyProfileSchema, ProfileFactory, ProfileSchema, RequestContext } from '@reactionary/core';
 import type * as z from 'zod';
 export declare class MedusaProfileFactory<TProfileSchema extends AnyProfileSchema = typeof ProfileSchema> implements ProfileFactory<TProfileSchema> {
     readonly profileSchema: TProfileSchema;
     constructor(profileSchema: TProfileSchema);
-    parseProfile(_context: RequestContext, data: unknown): z.output<TProfileSchema>;
+    parseProfile(context: RequestContext, data: StoreCustomer): z.output<TProfileSchema>;
+    protected parseAddress(context: RequestContext, address: StoreCustomerAddress): Address;
 }