@reactionary/medusa 0.10.23 → 0.10.25

package/schema/capabilities.schema.js

@@ -23,7 +23,8 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   identity: true,
   profile: true,
   productAssociations: true,
-  personalizationProfile: true
+  personalizationProfile: true,
+  company: true
 }).extend({
   product: OverridableCapabilitySchema.optional(),
   productSearch: OverridableCapabilitySchema.optional(),
@@ -35,6 +36,10 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   orderSearch: OverridableCapabilitySchema.optional(),
   inventory: OverridableCapabilitySchema.optional(),
   identity: DirectCapabilitySchema.optional(),
+  employee: OverridableCapabilitySchema.optional(),
+  employeeInvitation: OverridableCapabilitySchema.optional(),
+  company: OverridableCapabilitySchema.optional(),
+  companyRegistration: OverridableCapabilitySchema.optional(),
   profile: OverridableCapabilitySchema.optional(),
   productAssociations: OverridableCapabilitySchema.optional(),
   productRecommendations: DirectCapabilitySchema.optional(),

package/src/capabilities/company-registration.capability.d.ts

@@ -0,0 +1,25 @@
+import { type Address, type Cache, CompanyRegistrationCapability, type CompanyRegistrationFactory, type CompanyRegistrationFactoryWithOutput, type CompanyRegistrationMutationRegister, type CompanyRegistrationQueryCheckRegistrationStatus, type CompanyRegistrationRequest, type RequestContext, type Result } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaCompanyRegistrationFactory } from '../factories/company-registration/company-registration.factory.js';
+import type { MedusaRawCompany } from '../factories/company/company.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+export declare class MedusaCompanyRegistrationCapability<TFactory extends CompanyRegistrationFactory = MedusaCompanyRegistrationFactory> extends CompanyRegistrationCapability {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: CompanyRegistrationFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CompanyRegistrationFactoryWithOutput<TFactory>);
+    protected fetchCompany(companyId: string): Promise<MedusaRawCompany | null>;
+    protected addressPayload(address: Address): {
+        address_name: string;
+        first_name: string;
+        last_name: string;
+        street_address: string;
+        street_number: string;
+        city: string;
+        region: string;
+        postal_code: string;
+        country_code: string;
+    };
+    requestRegistration(payload: CompanyRegistrationMutationRegister): Promise<Result<CompanyRegistrationRequest>>;
+    checkRequestStatus(payload: CompanyRegistrationQueryCheckRegistrationStatus): Promise<Result<CompanyRegistrationRequest>>;
+}

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

@@ -0,0 +1,37 @@
+import { type Address, type Cache, type Company, CompanyCapability, type CompanyFactory, type CompanyFactoryWithOutput, type CompanyMutationAddShippingAddress, type CompanyMutationMakeShippingAddressDefault, type CompanyMutationRemoveShippingAddress, type CompanyMutationUpdateShippingAddress, type CompanyPaginatedList, type CompanyQueryById, type CompanyQueryList, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaCompanyFactory, MedusaRawCompany, MedusaRawCompanyAddress } from '../factories/company/company.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+export declare class MedusaCompanyCapability<TFactory extends CompanyFactory = MedusaCompanyFactory> extends CompanyCapability {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: CompanyFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: CompanyFactoryWithOutput<TFactory>);
+    protected fetchCompany(companyId: string): Promise<MedusaRawCompany | null>;
+    protected fetchCompanyOrThrow(companyId: string): Promise<MedusaRawCompany>;
+    protected fetchCompanyByTaxIdentifier(taxIdentifier: string): Promise<MedusaRawCompany | null>;
+    protected findAddress(company: MedusaRawCompany, nickName: string, type: 'billing' | 'shipping'): MedusaRawCompanyAddress | undefined;
+    protected addressPayload(address: Address): {
+        address_name: string;
+        first_name: string;
+        last_name: string;
+        street_address: string;
+        street_number: string;
+        city: string;
+        region: string;
+        postal_code: string;
+        country_code: string;
+    };
+    getById(payload: CompanyQueryById): Promise<Result<Company>>;
+    /**
+     * ponytail: there's no "list companies" route on this backend - membership is only discoverable via
+     * /store/customers/me/employees, which returns company id+name but not the full Company shape, so each
+     * distinct company id is re-fetched individually. Fine for the handful of companies a person typically
+     * belongs to; upgrade path: ask the backend for a proper GET /store/companies scoped to the caller.
+     */
+    listCompanies(payload: CompanyQueryList): Promise<Result<CompanyPaginatedList>>;
+    addShippingAddress(payload: CompanyMutationAddShippingAddress): Promise<Result<Company, NotFoundError>>;
+    updateShippingAddress(payload: CompanyMutationUpdateShippingAddress): Promise<Result<Company, NotFoundError>>;
+    removeShippingAddress(payload: CompanyMutationRemoveShippingAddress): Promise<Result<Company, NotFoundError>>;
+    makeShippingAddressDefault(payload: CompanyMutationMakeShippingAddressDefault): Promise<Result<Company, NotFoundError>>;
+}

package/src/capabilities/employee-invitation.capability.d.ts

@@ -0,0 +1,18 @@
+import { type Cache, type EmployeeInvitation, EmployeeInvitationCapability, type EmployeeInvitationFactory, type EmployeeInvitationFactoryWithOutput, type EmployeeInvitationMutationAcceptInvitation, type EmployeeInvitationMutationInviteEmployee, type EmployeeInvitationMutationRevokeInvitation, type EmployeeInvitationPaginatedList, type EmployeeInvitationQueryList, type EmployeeIssuedInvitation, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import { type MedusaEmployeeInvitationFactory } from '../factories/employee-invitation/employee-invitation.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+export declare class MedusaEmployeeInvitationCapability<TFactory extends EmployeeInvitationFactory = MedusaEmployeeInvitationFactory> extends EmployeeInvitationCapability {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: EmployeeInvitationFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: EmployeeInvitationFactoryWithOutput<TFactory>);
+    protected resolveCompanyId(taxIdentifier: string): Promise<string | null>;
+    protected fetchCompany(companyId: string): Promise<{
+        tax_identifier: string;
+    } | null>;
+    inviteEmployee(payload: EmployeeInvitationMutationInviteEmployee): Promise<Result<EmployeeIssuedInvitation>>;
+    acceptInvitation(payload: EmployeeInvitationMutationAcceptInvitation): Promise<Result<EmployeeInvitation>>;
+    revokeInvitation(payload: EmployeeInvitationMutationRevokeInvitation): Promise<Result<void, NotFoundError>>;
+    listInvitations(payload: EmployeeInvitationQueryList): Promise<Result<EmployeeInvitationPaginatedList>>;
+}

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

@@ -0,0 +1,37 @@
+import { type Cache, type CompanyIdentifier, type Employee, EmployeeCapability, type EmployeeFactory, type EmployeeFactoryWithOutput, type EmployeeMutationAssignRole, type EmployeeMutationRemoveEmployee, type EmployeeMutationUnassignRole, type EmployeePaginatedList, type EmployeeQueryByEmail, type EmployeeQueryList, type IdentityIdentifier, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaEmployeeFactory, MedusaRawEmployee } from '../factories/employee/employee.factory.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+export declare class MedusaEmployeeCapability<TFactory extends EmployeeFactory = MedusaEmployeeFactory> extends EmployeeCapability {
+    medusaApi: MedusaAPI;
+    protected config: MedusaConfiguration;
+    protected factory: EmployeeFactoryWithOutput<TFactory>;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI, factory: EmployeeFactoryWithOutput<TFactory>);
+    protected resolveCompanyId(taxIdentifier: string): Promise<string | null>;
+    /**
+     * ponytail: there's no `customer_id` or `role` filter on the backend's employee list route, so
+     * resolving an employee by customer id, or listing by role, means scanning the company's employee
+     * list client-side via iterateCompanyEmployeePages. Upgrade path: ask the backend to add `customer_id`
+     * and `role` filters to `StoreGetEmployeeParams`.
+     */
+    protected fetchCompanyEmployees(companyId: string, opts?: {
+        email?: string;
+        q?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        employees: MedusaRawEmployee[];
+        count: number;
+    }>;
+    protected iterateCompanyEmployeePages(companyId: string, opts?: {
+        email?: string;
+        q?: string;
+    }): AsyncGenerator<MedusaRawEmployee[]>;
+    protected findEmployeeByCustomerId(companyId: string, customerId: string): Promise<MedusaRawEmployee | undefined>;
+    listEmployees(payload: EmployeeQueryList): Promise<Result<EmployeePaginatedList>>;
+    getByEmail(payload: EmployeeQueryByEmail): Promise<Result<Employee>>;
+    protected updateEmployeeRole(company: CompanyIdentifier, employeeIdentifier: IdentityIdentifier, role: string): Promise<Result<Employee, NotFoundError>>;
+    assignRole(payload: EmployeeMutationAssignRole): Promise<Result<Employee, NotFoundError>>;
+    unassignRole(payload: EmployeeMutationUnassignRole): Promise<Result<Employee, NotFoundError>>;
+    removeEmployee(payload: EmployeeMutationRemoveEmployee): Promise<Result<void, NotFoundError>>;
+}

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

@@ -1,8 +1,12 @@
-import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, InventoryFactory, PersonalizationProfileFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductSearchFactory, ProfileFactory } from '@reactionary/core';
+import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, CompanyFactory, CompanyRegistrationFactory, EmployeeFactory, EmployeeInvitationFactory, InventoryFactory, PersonalizationProfileFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductSearchFactory, ProfileFactory } from '@reactionary/core';
 import type { MedusaCapabilities } from '../schema/capabilities.schema.js';
 import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
 import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
 import type { MedusaCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { MedusaCompanyFactory } from '../factories/company/company.factory.js';
+import type { MedusaCompanyRegistrationFactory } from '../factories/company-registration/company-registration.factory.js';
+import type { MedusaEmployeeFactory } from '../factories/employee/employee.factory.js';
+import type { MedusaEmployeeInvitationFactory } from '../factories/employee-invitation/employee-invitation.factory.js';
 import type { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
 import type { MedusaOrderFactory } from '../factories/order/order.factory.js';
 import type { MedusaOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
@@ -15,6 +19,10 @@ import type { MedusaPersonalizationProfileFactory } from '../factories/personali
 import type { MedusaCartCapability } from '../capabilities/cart.capability.js';
 import type { MedusaCategoryCapability } from '../capabilities/category.capability.js';
 import type { MedusaCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { MedusaCompanyCapability } from '../capabilities/company.capability.js';
+import type { MedusaCompanyRegistrationCapability } from '../capabilities/company-registration.capability.js';
+import type { MedusaEmployeeCapability } from '../capabilities/employee.capability.js';
+import type { MedusaEmployeeInvitationCapability } from '../capabilities/employee-invitation.capability.js';
 import type { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
 import type { MedusaOrderCapability } from '../capabilities/order.capability.js';
 import type { MedusaOrderSearchCapability } from '../capabilities/order-search.capability.js';
@@ -26,7 +34,7 @@ import type { MedusaProfileCapability } from '../capabilities/profile.capability
 import type { MedusaPersonalizationProfileCapability } from '../capabilities/personalization-profile.capability.js';
 import type { MedusaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
 import type { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
-type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'order' | 'orderSearch' | 'inventory' | 'profile' | 'productAssociations' | 'personalizationProfile';
+type OverridableCapabilityKey = 'product' | 'productSearch' | 'cart' | 'checkout' | 'category' | 'price' | 'order' | 'orderSearch' | 'inventory' | 'profile' | 'productAssociations' | 'personalizationProfile' | 'employee' | 'employeeInvitation' | 'company' | 'companyRegistration';
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
 } ? true : false;
@@ -57,6 +65,10 @@ type FactoryContractMap = {
     profile: ProfileFactory;
     productAssociations: ProductAssociationsFactory;
     personalizationProfile: PersonalizationProfileFactory;
+    employee: EmployeeFactory;
+    employeeInvitation: EmployeeInvitationFactory;
+    company: CompanyFactory;
+    companyRegistration: CompanyRegistrationFactory;
 };
 type DefaultFactoryMap = {
     product: MedusaProductFactory;
@@ -71,6 +83,10 @@ type DefaultFactoryMap = {
     profile: MedusaProfileFactory;
     productAssociations: MedusaProductAssociationsFactory;
     personalizationProfile: MedusaPersonalizationProfileFactory;
+    employee: MedusaEmployeeFactory;
+    employeeInvitation: MedusaEmployeeInvitationFactory;
+    company: MedusaCompanyFactory;
+    companyRegistration: MedusaCompanyRegistrationFactory;
 };
 type ResolvedFactoryMap<T extends MedusaCapabilities> = {
     [K in OverridableCapabilityKey]: ExtractCapabilityFactory<T[K], FactoryContractMap[K], DefaultFactoryMap[K]>;
@@ -88,6 +104,10 @@ type DefaultCapabilityMap<T extends MedusaCapabilities> = {
     profile: MedusaProfileCapability<ResolvedFactoryMap<T>['profile']>;
     productAssociations: MedusaProductAssociationsCapability<ResolvedFactoryMap<T>['productAssociations']>;
     personalizationProfile: MedusaPersonalizationProfileCapability<ResolvedFactoryMap<T>['personalizationProfile']>;
+    employee: MedusaEmployeeCapability<ResolvedFactoryMap<T>['employee']>;
+    employeeInvitation: MedusaEmployeeInvitationCapability<ResolvedFactoryMap<T>['employeeInvitation']>;
+    company: MedusaCompanyCapability<ResolvedFactoryMap<T>['company']>;
+    companyRegistration: MedusaCompanyRegistrationCapability<ResolvedFactoryMap<T>['companyRegistration']>;
     identity: MedusaIdentityCapability;
     productRecommendations: MedusaProductRecommendationsCapability;
 };

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

@@ -0,0 +1,45 @@
+import type { CompanyPaginatedListSchema, CompanySchema } from '@reactionary/core';
+import { type Address, type AnyCompanyPaginatedListSchema, type AnyCompanySchema, type CompanyFactory, type CompanyQueryList, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export interface MedusaRawCompanyAddress {
+    id: string;
+    type: string;
+    is_default: boolean;
+    address_name?: string | null;
+    first_name: string;
+    last_name: string;
+    street_address: string;
+    street_number?: string | null;
+    city: string;
+    region?: string | null;
+    postal_code: string;
+    country_code: string;
+}
+export interface MedusaRawCompany {
+    id: string;
+    name: string;
+    email: string;
+    phone?: string | null;
+    logo_url?: string | null;
+    logo_alt_text?: string | null;
+    logo_width?: number | null;
+    logo_height?: number | null;
+    status: string;
+    tax_identifier: string;
+    duns_identifier?: string | null;
+    tin_identifier?: string | null;
+    is_custom_addresses_allowed: boolean;
+    is_self_management_of_shipping_addresses_allowed: boolean;
+    addresses?: MedusaRawCompanyAddress[];
+}
+export declare class MedusaCompanyFactory<TCompanySchema extends AnyCompanySchema = typeof CompanySchema, TCompanyPaginatedListSchema extends AnyCompanyPaginatedListSchema = typeof CompanyPaginatedListSchema> implements CompanyFactory<TCompanySchema, TCompanyPaginatedListSchema> {
+    readonly companySchema: TCompanySchema;
+    readonly companyPaginatedListSchema: TCompanyPaginatedListSchema;
+    constructor(companySchema: TCompanySchema, companyPaginatedListSchema: TCompanyPaginatedListSchema);
+    protected parseAddress(raw: MedusaRawCompanyAddress): Address;
+    parseCompany(_context: RequestContext, data: MedusaRawCompany): z.output<TCompanySchema>;
+    parseCompanyPaginatedList(context: RequestContext, data: {
+        items: MedusaRawCompany[];
+        totalCount: number;
+    }, query: CompanyQueryList): z.output<TCompanyPaginatedListSchema>;
+}

package/src/factories/company-registration/company-registration.factory.d.ts

@@ -0,0 +1,10 @@
+import type { CompanyRegistrationRequestSchema } from '@reactionary/core';
+import { type AnyCompanyRegistrationRequestSchema, type CompanyRegistrationFactory, type CompanyRegistrationRequestApprovalStatus, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { MedusaRawCompany } from '../company/company.factory.js';
+export declare class MedusaCompanyRegistrationFactory<TCompanyRegistrationRequestSchema extends AnyCompanyRegistrationRequestSchema = typeof CompanyRegistrationRequestSchema> implements CompanyRegistrationFactory<TCompanyRegistrationRequestSchema> {
+    readonly companyRegistrationRequestSchema: TCompanyRegistrationRequestSchema;
+    constructor(companyRegistrationRequestSchema: TCompanyRegistrationRequestSchema);
+    parseCompanyRegistrationRequest(_context: RequestContext, data: MedusaRawCompany): z.output<TCompanyRegistrationRequestSchema>;
+    protected parseStatus(status: string): CompanyRegistrationRequestApprovalStatus;
+}

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

@@ -0,0 +1,32 @@
+import type { EmployeePaginatedListSchema, EmployeeSchema } from '@reactionary/core';
+import { type AnyEmployeePaginatedListSchema, type AnyEmployeeSchema, type CompanyIdentifier, type EmployeeFactory, type EmployeeQueryList, type EmployeeRole, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export interface MedusaRawEmployeeCustomer {
+    id: string;
+    email: string;
+    first_name?: string | null;
+    last_name?: string | null;
+}
+export interface MedusaRawEmployee {
+    id: string;
+    role: string;
+    spending_limit?: number;
+    company_id: string;
+    customer?: MedusaRawEmployeeCustomer | null;
+}
+export interface ParseEmployeeInput {
+    company: CompanyIdentifier;
+    employee: MedusaRawEmployee;
+}
+export declare class MedusaEmployeeFactory<TEmployeeSchema extends AnyEmployeeSchema = typeof EmployeeSchema, TEmployeePaginatedListSchema extends AnyEmployeePaginatedListSchema = typeof EmployeePaginatedListSchema> implements EmployeeFactory<TEmployeeSchema, TEmployeePaginatedListSchema> {
+    readonly employeeSchema: TEmployeeSchema;
+    readonly employeePaginatedListSchema: TEmployeePaginatedListSchema;
+    constructor(employeeSchema: TEmployeeSchema, employeePaginatedListSchema: TEmployeePaginatedListSchema);
+    parseEmployee(context: RequestContext, data: ParseEmployeeInput): z.output<TEmployeeSchema>;
+    parseEmployeePaginatedList(context: RequestContext, data: {
+        items: ParseEmployeeInput[];
+        totalCount: number;
+    }, query: EmployeeQueryList): z.output<TEmployeePaginatedListSchema>;
+    mapRole(role: EmployeeRole): string;
+    protected parseRole(role: string): EmployeeRole;
+}

package/src/factories/employee-invitation/employee-invitation.factory.d.ts

@@ -0,0 +1,40 @@
+import type { EmployeeInvitationPaginatedListSchema, EmployeeInvitationSchema, EmployeeIssuedInvitationSchema } from '@reactionary/core';
+import { type AnyEmployeeInvitationPaginatedListSchema, type AnyEmployeeInvitationSchema, type AnyEmployeeIssuedInvitationSchema, type EmployeeInvitationFactory, type EmployeeInvitationQueryList, type EmployeeInvitationMutationInviteEmployee, type EmployeeInvitationStatus, type EmployeeRole, type RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export interface MedusaRawEmployeeInvitation {
+    id: string;
+    email: string;
+    role: string;
+    status: string;
+    company_id: string;
+    company?: {
+        tax_identifier: string;
+    };
+    validUntil?: string | Date | null;
+    securityToken?: string;
+}
+/**
+ * The backend's revoke route needs both a company id and an invitation id, and there is no
+ * company-agnostic single-invitation lookup route for an authenticated store customer, so both
+ * are encoded into the opaque EmployeeInvitationIdentifier.key. Medusa ids never contain ':'.
+ */
+export declare function makeInvitationKey(companyId: string, invitationId: string): string;
+export declare function parseInvitationKey(key: string): {
+    companyId: string;
+    invitationId: string;
+};
+export declare class MedusaEmployeeInvitationFactory<TEmployeeInvitationSchema extends AnyEmployeeInvitationSchema = typeof EmployeeInvitationSchema, TEmployeeIssuedInvitationSchema extends AnyEmployeeIssuedInvitationSchema = typeof EmployeeIssuedInvitationSchema, TEmployeeInvitationPaginatedListSchema extends AnyEmployeeInvitationPaginatedListSchema = typeof EmployeeInvitationPaginatedListSchema> implements EmployeeInvitationFactory<TEmployeeInvitationSchema, TEmployeeIssuedInvitationSchema, TEmployeeInvitationPaginatedListSchema> {
+    readonly employeeInvitationSchema: TEmployeeInvitationSchema;
+    readonly employeeIssuedInvitationSchema: TEmployeeIssuedInvitationSchema;
+    readonly employeeInvitationPaginatedListSchema: TEmployeeInvitationPaginatedListSchema;
+    constructor(employeeInvitationSchema: TEmployeeInvitationSchema, employeeIssuedInvitationSchema: TEmployeeIssuedInvitationSchema, employeeInvitationPaginatedListSchema: TEmployeeInvitationPaginatedListSchema);
+    parseEmployeeInvitation(_context: RequestContext, data: MedusaRawEmployeeInvitation, _payload?: EmployeeInvitationMutationInviteEmployee): z.output<TEmployeeInvitationSchema>;
+    parseEmployeeIssuedInvitation(context: RequestContext, data: MedusaRawEmployeeInvitation, payload?: EmployeeInvitationMutationInviteEmployee): z.output<TEmployeeIssuedInvitationSchema>;
+    parseEmployeeInvitationPaginatedList(context: RequestContext, data: {
+        items: MedusaRawEmployeeInvitation[];
+        totalCount: number;
+    }, query: EmployeeInvitationQueryList): z.output<TEmployeeInvitationPaginatedListSchema>;
+    mapRole(role: EmployeeRole): string;
+    protected parseRole(role: string): EmployeeRole;
+    protected parseStatus(status: string): EmployeeInvitationStatus;
+}

package/src/factories/index.d.ts

@@ -1,6 +1,10 @@
 export * from './cart/cart.factory.js';
 export * from './category/category.factory.js';
 export * from './checkout/checkout.factory.js';
+export * from './company/company.factory.js';
+export * from './company-registration/company-registration.factory.js';
+export * from './employee/employee.factory.js';
+export * from './employee-invitation/employee-invitation.factory.js';
 export * from './identity/identity.factory.js';
 export * from './inventory/inventory.factory.js';
 export * from './order/order.factory.js';

package/src/index.d.ts

@@ -6,6 +6,10 @@ export * from './core/initialize.types.js';
 export * from './core/client.js';
 export * from './factories/index.js';
 export * from './capabilities/cart.capability.js';
+export * from './capabilities/company.capability.js';
+export * from './capabilities/company-registration.capability.js';
+export * from './capabilities/employee.capability.js';
+export * from './capabilities/employee-invitation.capability.js';
 export * from './capabilities/identity.capability.js';
 export * from './capabilities/inventory.capability.js';
 export * from './capabilities/order.capability.js';

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

@@ -1,4 +1,4 @@
-import type { CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PersonalizationProfileFactory, PersonalizationProfileFactoryWithOutput, PersonalizationProfileCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductRecommendationsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, Cache } from '@reactionary/core';
+import type { CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, CompanyFactory, CompanyFactoryWithOutput, CompanyCapability, CompanyRegistrationFactory, CompanyRegistrationFactoryWithOutput, CompanyRegistrationCapability, EmployeeFactory, EmployeeFactoryWithOutput, EmployeeCapability, EmployeeInvitationFactory, EmployeeInvitationFactoryWithOutput, EmployeeInvitationCapability, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PersonalizationProfileFactory, PersonalizationProfileFactoryWithOutput, PersonalizationProfileCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductRecommendationsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, Cache } from '@reactionary/core';
 import type { MedusaConfiguration } from './configuration.schema.js';
 import type { MedusaAPI } from '../core/client.js';
 import * as z from 'zod';
@@ -52,6 +52,26 @@ export declare const MedusaCapabilitiesSchema: z.ZodObject<{
         enabled: z.ZodBoolean;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    employee: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    employeeInvitation: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    company: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    companyRegistration: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
     profile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;
         factory: z.ZodOptional<z.ZodUnknown>;
@@ -94,6 +114,10 @@ export type MedusaProductCapabilityConfig = MedusaCapabilityConfig<ProductFactor
 export type MedusaProductSearchCapabilityConfig = MedusaCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
 export type MedusaCartCapabilityConfig = MedusaCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
 export type MedusaCheckoutCapabilityConfig = MedusaCapabilityConfig<CheckoutFactoryWithOutput<CheckoutFactory>, CheckoutCapability>;
+export type MedusaEmployeeCapabilityConfig = MedusaCapabilityConfig<EmployeeFactoryWithOutput<EmployeeFactory>, EmployeeCapability>;
+export type MedusaEmployeeInvitationCapabilityConfig = MedusaCapabilityConfig<EmployeeInvitationFactoryWithOutput<EmployeeInvitationFactory>, EmployeeInvitationCapability>;
+export type MedusaCompanyCapabilityConfig = MedusaCapabilityConfig<CompanyFactoryWithOutput<CompanyFactory>, CompanyCapability>;
+export type MedusaCompanyRegistrationCapabilityConfig = MedusaCapabilityConfig<CompanyRegistrationFactoryWithOutput<CompanyRegistrationFactory>, CompanyRegistrationCapability>;
 export type MedusaCategoryCapabilityConfig = MedusaCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
 export type MedusaPriceCapabilityConfig = MedusaCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
 export type MedusaOrderCapabilityConfig = MedusaCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
@@ -104,11 +128,15 @@ export type MedusaProfileCapabilityConfig = MedusaCapabilityConfig<ProfileFactor
 export type MedusaProductAssociationsCapabilityConfig = MedusaCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
 export type MedusaPersonalizationProfileCapabilityConfig = MedusaCapabilityConfig<PersonalizationProfileFactoryWithOutput<PersonalizationProfileFactory>, PersonalizationProfileCapability>;
 export type MedusaProductRecommendationsCapabilityConfig = MedusaDirectCapabilityConfig<ProductRecommendationsCapability>;
-export type MedusaCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability, TCartFactory extends CartFactory = CartFactory, TCartCapability extends CartCapability = CartCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability, TCategoryFactory extends CategoryFactory = CategoryFactory, TCategoryCapability extends CategoryCapability = CategoryCapability, TPriceFactory extends PriceFactory = PriceFactory, TPriceCapability extends PriceCapability = PriceCapability, TOrderFactory extends OrderFactory = OrderFactory, TOrderCapability extends OrderCapability = OrderCapability, TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory, TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability, TInventoryFactory extends InventoryFactory = InventoryFactory, TInventoryCapability extends InventoryCapability = InventoryCapability, TIdentityCapability extends IdentityCapability = IdentityCapability, TProfileFactory extends ProfileFactory = ProfileFactory, TProfileCapability extends ProfileCapability = ProfileCapability, TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory, TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability, TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability, TPersonalizationProfileFactory extends PersonalizationProfileFactory = PersonalizationProfileFactory, TPersonalizationProfileCapability extends PersonalizationProfileCapability = PersonalizationProfileCapability> = {
+export type MedusaCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability, TCartFactory extends CartFactory = CartFactory, TCartCapability extends CartCapability = CartCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability, TCategoryFactory extends CategoryFactory = CategoryFactory, TCategoryCapability extends CategoryCapability = CategoryCapability, TPriceFactory extends PriceFactory = PriceFactory, TPriceCapability extends PriceCapability = PriceCapability, TOrderFactory extends OrderFactory = OrderFactory, TOrderCapability extends OrderCapability = OrderCapability, TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory, TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability, TInventoryFactory extends InventoryFactory = InventoryFactory, TInventoryCapability extends InventoryCapability = InventoryCapability, TIdentityCapability extends IdentityCapability = IdentityCapability, TProfileFactory extends ProfileFactory = ProfileFactory, TProfileCapability extends ProfileCapability = ProfileCapability, TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory, TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability, TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability, TPersonalizationProfileFactory extends PersonalizationProfileFactory = PersonalizationProfileFactory, TPersonalizationProfileCapability extends PersonalizationProfileCapability = PersonalizationProfileCapability, TEmployeeFactory extends EmployeeFactory = EmployeeFactory, TEmployeeCapability extends EmployeeCapability = EmployeeCapability, TEmployeeInvitationFactory extends EmployeeInvitationFactory = EmployeeInvitationFactory, TEmployeeInvitationCapability extends EmployeeInvitationCapability = EmployeeInvitationCapability, TCompanyFactory extends CompanyFactory = CompanyFactory, TCompanyCapability extends CompanyCapability = CompanyCapability, TCompanyRegistrationFactory extends CompanyRegistrationFactory = CompanyRegistrationFactory, TCompanyRegistrationCapability extends CompanyRegistrationCapability = CompanyRegistrationCapability> = {
     product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
     productSearch?: MedusaCapabilityConfig<ProductSearchFactoryWithOutput<TProductSearchFactory>, TProductSearchCapability>;
     cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartCapability>;
     checkout?: MedusaCapabilityConfig<CheckoutFactoryWithOutput<TCheckoutFactory>, TCheckoutCapability>;
+    employee?: MedusaCapabilityConfig<EmployeeFactoryWithOutput<TEmployeeFactory>, TEmployeeCapability>;
+    employeeInvitation?: MedusaCapabilityConfig<EmployeeInvitationFactoryWithOutput<TEmployeeInvitationFactory>, TEmployeeInvitationCapability>;
+    company?: MedusaCapabilityConfig<CompanyFactoryWithOutput<TCompanyFactory>, TCompanyCapability>;
+    companyRegistration?: MedusaCapabilityConfig<CompanyRegistrationFactoryWithOutput<TCompanyRegistrationFactory>, TCompanyRegistrationCapability>;
     category?: MedusaCapabilityConfig<CategoryFactoryWithOutput<TCategoryFactory>, TCategoryCapability>;
     price?: MedusaCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceCapability>;
     order?: MedusaCapabilityConfig<OrderFactoryWithOutput<TOrderFactory>, TOrderCapability>;