@reactionary/magento 0.0.1

package/src/core/initialize.types.d.ts

@@ -0,0 +1,80 @@
+import type { CartFactory, CategoryFactory, ClientFromCapabilities, InventoryFactory, PriceFactory, ProductFactory, ProductSearchFactory } from '@reactionary/core';
+import type { MagentoCapabilities } from '../schema/capabilities.schema.js';
+import type { MagentoCartFactory } from '../factories/cart/cart.factory.js';
+import type { MagentoCategoryFactory } from '../factories/category/category.factory.js';
+import type { MagentoInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { MagentoPriceFactory } from '../factories/price/price.factory.js';
+import type { MagentoProductFactory } from '../factories/product/product.factory.js';
+import type { MagentoProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { MagentoCartCapability } from '../capabilities/cart.capability.js';
+import type { MagentoCategoryCapability } from '../capabilities/category.capability.js';
+import type { MagentoIdentityCapability } from '../capabilities/identity.capability.js';
+import type { MagentoInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { MagentoPriceCapability } from '../capabilities/price.capability.js';
+import type { MagentoProductCapability } from '../capabilities/product.capability.js';
+import type { MagentoProductSearchCapability } from '../capabilities/product-search.capability.js';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'category' | 'price' | 'inventory';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends MagentoCapabilities> = Omit<T, OverridableCapabilityKey | 'identity'> & {
+    [K in OverridableCapabilityKey]?: EnabledCapability<T[K]>;
+} & {
+    identity?: EnabledCapability<T['identity']>;
+};
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends TContract ? TFactory : TDefaultFactory : TDefaultFactory;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability ? TResolvedCapability : TDefaultCapability : TDefaultCapability;
+type FactoryContractMap = {
+    product: ProductFactory;
+    productSearch: ProductSearchFactory;
+    cart: CartFactory;
+    category: CategoryFactory;
+    price: PriceFactory;
+    inventory: InventoryFactory;
+};
+type DefaultFactoryMap = {
+    product: MagentoProductFactory;
+    productSearch: MagentoProductSearchFactory;
+    cart: MagentoCartFactory;
+    category: MagentoCategoryFactory;
+    price: MagentoPriceFactory;
+    inventory: MagentoInventoryFactory;
+};
+type ResolvedFactoryMap<T extends MagentoCapabilities> = {
+    [K in OverridableCapabilityKey]: ExtractCapabilityFactory<T[K], FactoryContractMap[K], DefaultFactoryMap[K]>;
+};
+type DefaultCapabilityMap<T extends MagentoCapabilities> = {
+    product: MagentoProductCapability<ResolvedFactoryMap<T>['product']>;
+    productSearch: MagentoProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+    cart: MagentoCartCapability<ResolvedFactoryMap<T>['cart']>;
+    category: MagentoCategoryCapability<ResolvedFactoryMap<T>['category']>;
+    price: MagentoPriceCapability<ResolvedFactoryMap<T>['price']>;
+    inventory: MagentoInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+    identity: MagentoIdentityCapability;
+};
+type CapabilityImplementationMap<T extends MagentoCapabilities> = {
+    [K in OverridableCapabilityKey | 'identity']: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap<T>[K]>;
+};
+type EnabledCapabilityOverrideMap<T extends MagentoCapabilities> = {
+    [K in OverridableCapabilityKey | 'identity' as T[K] extends {
+        enabled: true;
+    } ? K : never]: CapabilityImplementationMap<T>[K];
+};
+export type MagentoClientFromCapabilities<T extends MagentoCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, OverridableCapabilityKey | 'identity'> & EnabledCapabilityOverrideMap<T>;
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+}, buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs): TResolvedCapability;
+export declare function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(capability: {
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaultCapability: (args: TCapabilityArgs) => TResolvedCapability, args: TCapabilityArgs): TResolvedCapability;
+export {};

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

@@ -0,0 +1,20 @@
+import { type AnyCartIdentifierSchema, type AnyCartPaginatedSearchResult, type AnyCartSchema, type CartFactory, type CartIdentifierSchema, type CartItem, type CartPaginatedSearchResultSchema, type CartQueryList, type CartSchema, type CartSearchResultItem, type CostBreakDown, type Currency, type ItemCostBreakdown, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { MagentoCart, MagentoCartItem } from '../../schema/magento.types.js';
+export interface MagentoCartFactoryPaginatedSearchResultInput {
+    items: MagentoCart[];
+    totalCount: number;
+}
+export declare class MagentoCartFactory<TCartSchema extends AnyCartSchema = typeof CartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema, TCartPaginatedSearchResult extends AnyCartPaginatedSearchResult = typeof CartPaginatedSearchResultSchema> implements CartFactory<TCartSchema, TCartIdentifierSchema, TCartPaginatedSearchResult> {
+    readonly cartSchema: TCartSchema;
+    readonly cartIdentifierSchema: TCartIdentifierSchema;
+    readonly cartPaginatedSearchResultSchema: TCartPaginatedSearchResult;
+    constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema, cartPaginatedSearchResultSchema: TCartPaginatedSearchResult);
+    parseCart(_context: RequestContext, data: MagentoCart): z.output<TCartSchema>;
+    parseCartIdentifier(_context: RequestContext, data: MagentoCart): z.output<TCartIdentifierSchema>;
+    parseCartPaginatedSearchResult(_context: RequestContext, data: MagentoCartFactoryPaginatedSearchResultInput, query: CartQueryList): z.output<TCartPaginatedSearchResult>;
+    protected parseCartSearchResultItem(context: RequestContext, data: MagentoCart): CartSearchResultItem;
+    protected parseCostBreakdown(cart: MagentoCart, currency: Currency): CostBreakDown;
+    protected parseItemPrice(item: MagentoCartItem, currency: Currency): ItemCostBreakdown;
+    protected parseCartItem(item: MagentoCartItem, currency: Currency): CartItem;
+}

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

@@ -0,0 +1,14 @@
+import { type AnyCategoryPaginatedResultSchema, type AnyCategorySchema, type CategoryFactory, type CategoryPaginatedResultSchema, type CategorySchema, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { MagentoCategory, MagentoCategorySearchResult } from '../../schema/magento.types.js';
+export interface MagentoCategoryPaginatedInput extends MagentoCategorySearchResult {
+    pageSize: number;
+    currentPage: number;
+}
+export declare class MagentoCategoryFactory<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: MagentoCategory): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(context: RequestContext, data: MagentoCategoryPaginatedInput): z.output<TCategoryPaginatedSchema>;
+}

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

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

package/src/factories/index.d.ts

@@ -0,0 +1,7 @@
+export * from './cart/cart.factory.js';
+export * from './category/category.factory.js';
+export * from './identity/identity.factory.js';
+export * from './inventory/inventory.factory.js';
+export * from './price/price.factory.js';
+export * from './product/product.factory.js';
+export * from './product-search/product-search.factory.js';

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

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

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

@@ -0,0 +1,15 @@
+import type { AnyPriceSchema, PriceFactory, PriceSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { MagentoProduct } from '../../schema/magento.types.js';
+export interface MagentoPriceParseInput {
+    product: MagentoProduct;
+    sku: string;
+    mode: 'list' | 'customer';
+}
+export declare class MagentoPriceFactory<TPriceSchema extends AnyPriceSchema = typeof PriceSchema> implements PriceFactory<TPriceSchema> {
+    readonly priceSchema: TPriceSchema;
+    constructor(priceSchema: TPriceSchema);
+    parsePrice(context: RequestContext, data: unknown, _options?: {
+        includeDiscounts: boolean;
+    }): z.output<TPriceSchema>;
+}

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

@@ -0,0 +1,13 @@
+import { type AnyProductSchema, type ProductAttribute, type ProductFactory, type ProductSchema, type ProductVariant, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { MagentoConfiguration } from '../../schema/configuration.schema.js';
+import type { MagentoProduct } from '../../schema/magento.types.js';
+export declare class MagentoProductFactory<TProductSchema extends AnyProductSchema = typeof ProductSchema> implements ProductFactory<TProductSchema> {
+    protected config: MagentoConfiguration;
+    readonly productSchema: TProductSchema;
+    constructor(productSchema: TProductSchema, config: MagentoConfiguration);
+    parseProduct(_context: RequestContext, data: MagentoProduct): z.output<TProductSchema>;
+    protected parseVariant(product: MagentoProduct): ProductVariant;
+    protected createSynthAttribute(key: string, name: string, value: string): ProductAttribute;
+    protected parseAttributes(product: MagentoProduct): Array<ProductAttribute>;
+}

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

@@ -0,0 +1,12 @@
+import { type AnyProductSearchResultSchema, type ProductSearchFactory, type ProductSearchQueryByTerm, type ProductSearchResultItem, type ProductSearchResultItemVariant, type ProductSearchResultSchema, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { MagentoConfiguration } from '../../schema/configuration.schema.js';
+import type { MagentoProduct, MagentoProductSearchResult } from '../../schema/magento.types.js';
+export declare class MagentoProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
+    protected config: MagentoConfiguration;
+    readonly productSearchResultSchema: TProductSearchResultSchema;
+    constructor(productSearchResultSchema: TProductSearchResultSchema, config: MagentoConfiguration);
+    parseSearchResult(context: RequestContext, data: MagentoProductSearchResult, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+    protected parseProductSearchResultItem(_context: RequestContext, product: MagentoProduct): ProductSearchResultItem;
+    protected parseVariant(variant: MagentoProduct, product: MagentoProduct): ProductSearchResultItemVariant;
+}

package/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './schema/magento.schema.js';
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './core/client.js';
+export * from './factories/index.js';
+export * from './capabilities/product.capability.js';
+export * from './capabilities/product-search.capability.js';
+export * from './capabilities/category.capability.js';
+export * from './capabilities/inventory.capability.js';
+export * from './capabilities/price.capability.js';
+export * from './capabilities/identity.capability.js';
+export * from './capabilities/cart.capability.js';

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,74 @@
+import type { CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, RequestContext, Cache } from '@reactionary/core';
+import type { MagentoConfiguration } from './configuration.schema.js';
+import type { MagentoClient } from '../core/client.js';
+import * as z from 'zod';
+export declare const MagentoCapabilitiesSchema: z.ZodObject<{
+    product: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    cart: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    category: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    inventory: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    identity: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export interface MagentoCapabilityFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: MagentoConfiguration;
+    magentoApi: MagentoClient;
+}
+export interface MagentoFactoryCapabilityArgs<TFactory> extends MagentoCapabilityFactoryArgs {
+    factory: TFactory;
+}
+export interface MagentoCapabilityConfig<TFactory, TCapability> {
+    enabled: boolean;
+    factory?: TFactory;
+    capability?: (args: MagentoFactoryCapabilityArgs<TFactory>) => TCapability;
+}
+export interface MagentoDirectCapabilityConfig<TCapability> {
+    enabled: boolean;
+    capability?: (args: MagentoCapabilityFactoryArgs) => TCapability;
+}
+export type MagentoProductCapabilityConfig = MagentoCapabilityConfig<ProductFactoryWithOutput<ProductFactory>, ProductCapability>;
+export type MagentoProductSearchCapabilityConfig = MagentoCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
+export type MagentoCartCapabilityConfig = MagentoCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+export type MagentoCategoryCapabilityConfig = MagentoCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
+export type MagentoPriceCapabilityConfig = MagentoCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+export type MagentoInventoryCapabilityConfig = MagentoCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryCapability>;
+export type MagentoIdentityCapabilityConfig = MagentoDirectCapabilityConfig<IdentityCapability>;
+export type MagentoCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability, TCartFactory extends CartFactory = CartFactory, TCartCapability extends CartCapability = CartCapability, TCategoryFactory extends CategoryFactory = CategoryFactory, TCategoryCapability extends CategoryCapability = CategoryCapability, TPriceFactory extends PriceFactory = PriceFactory, TPriceCapability extends PriceCapability = PriceCapability, TInventoryFactory extends InventoryFactory = InventoryFactory, TInventoryCapability extends InventoryCapability = InventoryCapability, TIdentityCapability extends IdentityCapability = IdentityCapability> = {
+    product?: MagentoCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
+    productSearch?: MagentoCapabilityConfig<ProductSearchFactoryWithOutput<TProductSearchFactory>, TProductSearchCapability>;
+    cart?: MagentoCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartCapability>;
+    category?: MagentoCapabilityConfig<CategoryFactoryWithOutput<TCategoryFactory>, TCategoryCapability>;
+    price?: MagentoCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceCapability>;
+    inventory?: MagentoCapabilityConfig<InventoryFactoryWithOutput<TInventoryFactory>, TInventoryCapability>;
+    identity?: MagentoDirectCapabilityConfig<TIdentityCapability>;
+};

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+export declare const MagentoConfigurationSchema: z.ZodObject<{
+    adminApiKey: z.ZodString;
+    baseUrl: z.ZodString;
+    mediaUrl: z.ZodOptional<z.ZodString>;
+    defaultCurrency: z.ZodDefault<z.ZodString>;
+    rootCategoryId: z.ZodDefault<z.ZodString>;
+    allCurrencies: z.ZodArray<z.ZodString>;
+    storeCode: z.ZodDefault<z.ZodString>;
+}, z.core.$loose>;
+export type MagentoConfiguration = z.infer<typeof MagentoConfigurationSchema>;

package/src/schema/magento.schema.d.ts

@@ -0,0 +1,5 @@
+import type * as z from "zod";
+export declare const MagentoCartIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$loose>;
+export type MagentoCartIdentifier = z.infer<typeof MagentoCartIdentifierSchema>;

package/src/schema/magento.types.d.ts

@@ -0,0 +1,200 @@
+export interface MagentoCustomAttribute {
+    attribute_code: string;
+    value: unknown;
+}
+export interface MagentoCategoryLink {
+    position: number;
+    category_id: string;
+}
+export interface MagentoMediaGalleryEntry {
+    id: number;
+    media_type: string;
+    label: string | null;
+    position: number;
+    disabled: boolean;
+    types: string[];
+    file: string;
+}
+export interface MagentoTierPrice {
+    customer_group_id: number;
+    qty: number;
+    value: number;
+    extension_attributes?: Record<string, unknown>;
+}
+export interface MagentoExtensionAttributes {
+    category_links?: MagentoCategoryLink[];
+    website_ids?: number[];
+    stock_item?: MagentoStockItem;
+    [key: string]: unknown;
+}
+export interface MagentoStockItem {
+    item_id: number;
+    product_id: number;
+    stock_id: number;
+    qty: number;
+    is_in_stock: boolean;
+    is_qty_decimal: boolean;
+    min_qty: number;
+    min_sale_qty: number;
+    max_sale_qty: number;
+}
+export interface MagentoCartItem {
+    item_id: number;
+    sku: string;
+    qty: number;
+    name?: string;
+    price: number;
+    product_type?: string;
+    quote_id?: string;
+    discount_amount?: number;
+    row_total?: number;
+    row_total_incl_tax?: number;
+    tax_amount?: number;
+    tax_percent?: number;
+    extension_attributes?: Record<string, unknown>;
+}
+export interface MagentoCartCustomer {
+    id?: number;
+    group_id?: number;
+    email?: string;
+    firstname?: string;
+    lastname?: string;
+}
+export interface MagentoCart {
+    id: number;
+    masked_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    is_active?: boolean;
+    is_virtual?: boolean;
+    items: MagentoCartItem[];
+    items_count?: number;
+    items_qty?: number;
+    customer: MagentoCartCustomer;
+    billing_address?: Record<string, unknown>;
+    currency?: {
+        global_currency_code?: string;
+        base_currency_code?: string;
+        quote_currency_code?: string;
+        store_currency_code?: string;
+    };
+    quote_currency_code?: string;
+    name?: string;
+    description?: string;
+    subtotal?: number;
+    base_subtotal?: number;
+    grand_total?: number;
+    base_grand_total?: number;
+    tax_amount?: number;
+    base_tax_amount?: number;
+    shipping_amount?: number;
+    base_shipping_amount?: number;
+    discount_amount?: number;
+    base_discount_amount?: number;
+    coupon_code?: string;
+    extension_attributes?: Record<string, unknown>;
+    /** Synthetic property injected by the capability with the requested cart identifier */
+    _requestedId?: string;
+}
+export interface MagentoCategory {
+    id: number;
+    parent_id: number;
+    name: string;
+    is_active?: boolean;
+    position?: number;
+    level?: number;
+    product_count?: number;
+    children_data?: MagentoCategory[];
+    custom_attributes?: MagentoCustomAttribute[];
+    created_at?: string;
+    updated_at?: string;
+    path?: string;
+    include_in_menu?: boolean;
+}
+export interface MagentoCategorySearchResult {
+    items: MagentoCategory[];
+    total_count: number;
+    search_criteria?: Record<string, unknown>;
+}
+export interface MagentoIdentity {
+    id: number;
+    group_id?: number;
+    default_billing?: string;
+    default_shipping?: string;
+    email: string;
+    firstname: string;
+    lastname: string;
+    store_id?: number;
+    website_id?: number;
+    created_at?: string;
+    updated_at?: string;
+    addresses?: MagentoAddress[];
+    extension_attributes?: Record<string, unknown>;
+    custom_attributes?: MagentoCustomAttribute[];
+}
+export interface MagentoAddress {
+    id?: number;
+    customer_id?: number;
+    firstname: string;
+    lastname: string;
+    street: string[];
+    city: string;
+    region?: {
+        region_code: string;
+        region: string;
+        region_id: number;
+    };
+    postcode: string;
+    country_id: string;
+    telephone?: string;
+    default_billing?: boolean;
+    default_shipping?: boolean;
+}
+export interface MagentoStockStatus {
+    product_id: number;
+    stock_id: number;
+    qty: number;
+    stock_status: number;
+}
+export interface MagentoSourceItem {
+    sku: string;
+    source_code: string;
+    quantity: number;
+    status: number;
+}
+export interface MagentoInventory {
+    stock_item?: MagentoStockStatus;
+    source_items?: MagentoSourceItem[];
+}
+export interface MagentoPrice {
+    price: number;
+    special_price?: number | null;
+    special_from_date?: string | null;
+    special_to_date?: string | null;
+    tier_prices?: MagentoTierPrice[];
+    custom_attributes?: MagentoCustomAttribute[];
+}
+export interface MagentoProduct {
+    id: number;
+    sku: string;
+    name: string;
+    attribute_set_id?: number;
+    price?: number;
+    status?: number;
+    visibility?: number;
+    type_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    weight?: number;
+    extension_attributes?: MagentoExtensionAttributes;
+    product_links?: Array<Record<string, unknown>>;
+    options?: Array<Record<string, unknown>>;
+    media_gallery_entries?: MagentoMediaGalleryEntry[];
+    tier_prices?: MagentoTierPrice[];
+    custom_attributes?: MagentoCustomAttribute[];
+}
+export interface MagentoProductSearchResult {
+    items: MagentoProduct[];
+    search_criteria?: Record<string, unknown>;
+    total_count: number;
+}