@reactionary/core 0.6.6 → 0.6.8

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

@@ -5,11 +5,11 @@ import { type AnalyticsMutation, type AnalyticsMutationProductAddToCartEvent, ty
 export declare abstract class AnalyticsCapability extends BaseCapability {
     protected getResourceName(): string;
     track(event: AnalyticsMutation): Promise<void>;
-    protected processProductSummaryView(event: AnalyticsMutationProductSummaryViewEvent): Promise<void>;
-    protected processProductSummaryClick(event: AnalyticsMutationProductSummaryClickEvent): Promise<void>;
-    protected processProductDetailsView(event: AnalyticsMutationProductDetailsViewEvent): Promise<void>;
-    protected processProductAddToCart(event: AnalyticsMutationProductAddToCartEvent): Promise<void>;
-    protected processPurchase(event: AnalyticsMutationPurchaseEvent): Promise<void>;
+    protected processProductSummaryView(_event: AnalyticsMutationProductSummaryViewEvent): Promise<void>;
+    protected processProductSummaryClick(_event: AnalyticsMutationProductSummaryClickEvent): Promise<void>;
+    protected processProductDetailsView(_event: AnalyticsMutationProductDetailsViewEvent): Promise<void>;
+    protected processProductAddToCart(_event: AnalyticsMutationProductAddToCartEvent): Promise<void>;
+    protected processPurchase(_event: AnalyticsMutationPurchaseEvent): Promise<void>;
 }
 export declare class MulticastAnalyticsCapability extends AnalyticsCapability {
     protected capabilities: Array<AnalyticsCapability>;

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

@@ -0,0 +1,21 @@
+import type { CompanyRegistrationRequest } from "../schemas/models/company-registration.model.js";
+import type { CompanyRegistrationMutationRegister } from "../schemas/mutations/company-registration.mutation.js";
+import type { CompanyRegistrationQueryCheckRegistrationStatus } from "../schemas/queries/company-registration.query.js";
+import type { Result } from "../schemas/result.js";
+import { BaseCapability } from "./base.capability.js";
+export declare abstract class CompanyRegistrationCapability extends BaseCapability {
+    protected getResourceName(): string;
+    /**
+     * Usecase:
+     * If site supports self-registration of companies, this method can be used to register a new company. Depending on backend, it might require
+     * additional offline steps (email verification, manual approval, etc) before the company can be used to log in and access company-specific features.
+     * @param payload
+     */
+    abstract requestRegistration(payload: CompanyRegistrationMutationRegister): Promise<Result<CompanyRegistrationRequest>>;
+    /**
+     * Usecase: After registration, if it takes a while (say, if it requires manual approval), the storefront can present the customer with a url with the
+     * registration request identifier in it, to allow the customer to check periodically the status of their company registration, and show appropriate messages (e.g. "your registration is pending approval", "your registration was denied, contact support for more info", etc)
+     * @param payload
+     */
+    abstract checkRequestStatus(payload: CompanyRegistrationQueryCheckRegistrationStatus): Promise<Result<CompanyRegistrationRequest>>;
+}

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

@@ -0,0 +1,85 @@
+import type { NotFoundError } from "../schemas/index.js";
+import type { Company, CompanyPaginatedList } from "../schemas/models/company.model.js";
+import type { CompanyMutationAddShippingAddress, CompanyMutationMakeShippingAddressDefault, CompanyMutationRemoveShippingAddress, CompanyMutationUpdateShippingAddress } from "../schemas/mutations/index.js";
+import type { CompanyQueryById, CompanyQueryList } from "../schemas/queries/index.js";
+import type { Result } from "../schemas/result.js";
+import { BaseCapability } from "./base.capability.js";
+export declare abstract class CompanyCapability extends BaseCapability {
+    protected getResourceName(): string;
+    /**
+     *
+     * Usecase: Fetch company info such as name, default contact person, etc, based on the company identifier in the request context.
+     * This can be used to render company-specific information in the storefront
+     *
+     * @param payload
+     */
+    abstract getById(payload: CompanyQueryById): Promise<Result<Company>>;
+    /**
+     * A list of companies you are allowed to interact with. This is useful for users that are associated with multiple companies, such as consultants or employees of multiple companies.
+     *
+     * Usecase: Consultant logs in and needs to select which company they want to work with. Or a user that is an employee of multiple companies needs to switch between them.
+     * @param payload
+     */
+    abstract listCompanies(payload: CompanyQueryList): Promise<Result<CompanyPaginatedList>>;
+    /**
+     * Updates the base information of the company.
+     * Typically, there is not alot that the user can change himself, if the data is governed from ERP
+     *
+     * Usecase: Update the user's name, email, or phone number.
+     *
+     * NOTE: For now, we are not exposing an update method for companies, as its not super clear
+     * WHAT we'd typically allow them to change on their own. Most of the time, this kind of thing comes from the customer-master
+     *
+     * @param payload
+    public abstract update(payload: CompanyMutationUpdate): Promise<Result<Company, NotFoundError>>;
+     */
+    /**
+     * Creates a new shipping address for the currently authenticated (registered) user.
+     * Does not set it as default automatically.
+     *
+     * Usecase: User adds a new shipping address in their profile or during checkout. Ideally, any address manipulation
+     * done at checkout should be considered local to that session, unless the addressbook is empty.
+     * @param payload
+     */
+    abstract addShippingAddress(payload: CompanyMutationAddShippingAddress): Promise<Result<Company, NotFoundError>>;
+    /**
+     * Updates an existing shipping address for the company (if allowed by backend).
+     *
+     * Usecase: User edits shipping address on company tab in my-account page. Either the default one, or one of the alternates
+     * @param payload
+     */
+    abstract updateShippingAddress(payload: CompanyMutationUpdateShippingAddress): Promise<Result<Company, NotFoundError>>;
+    /**
+     * Removes an existing shipping address for the company (if allowed by backend).
+     * If the removed address was the default shipping address, the default shipping address is set to a random other address.
+     *
+     * Usecase: User deletes a shipping address from their business profile.
+     * @param payload
+     */
+    abstract removeShippingAddress(payload: CompanyMutationRemoveShippingAddress): Promise<Result<Company, NotFoundError>>;
+    /**
+     * Configures an existing shipping address as the default shipping address for the company (if allowed by backend).
+     *
+     * Usecase: User selects a default shipping address in their business profile.
+     * @param payload
+     */
+    abstract makeShippingAddressDefault(payload: CompanyMutationMakeShippingAddressDefault): Promise<Result<Company, NotFoundError>>;
+    /**
+     * Sets the current/active billing address for the company
+     *
+     * Usecase: User sets or updates their billing address in their business profile
+     *
+     * It was a design decision not to support multiple billing addresses. The billing address represents who you are as the commercial
+     * entity being billed, and as such it makes sense to have a single authoritative billing address.
+     * @param payload
+     *
+     * NOTE: We are not exposing this for now, as we expect the billing address to be managed from the ERP side
+    public abstract setBillingAddress(payload: CompanyMutationSetBillingAddress): Promise<Result<Company, NotFoundError>>;
+     */
+    /**
+     * Create an empty company object with the given id. This can be used as a fallback when company is not found, to avoid returning null and causing errors in the storefront.
+     * The storefront can then check if the returned company has an empty name or other fields to determine if it is a valid company or a fallback.
+     * @param id
+     */
+    protected createEmptyCompany(id: string): Company;
+}

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

@@ -0,0 +1,34 @@
+import type { NotFoundError } from "../schemas/index.js";
+import type { EmployeeInvitation, EmployeeIssuedInvitation, EmployeeInvitationPaginatedList } from "../schemas/models/index.js";
+import type { EmployeeInvitationMutationAcceptInvitation, EmployeeInvitationMutationInviteEmployee, EmployeeInvitationMutationRevokeInvitation } from "../schemas/mutations/index.js";
+import type { EmployeeInvitationQueryList } from "../schemas/queries/index.js";
+import type { Result } from "../schemas/result.js";
+import { BaseCapability } from "./base.capability.js";
+export declare abstract class EmployeeInvitationCapability extends BaseCapability {
+    protected getResourceName(): string;
+    /**
+     * Usecase:
+     * List all open invitations sent to employees to join the company.
+     * In my-account store management, you want to see a list of all pending invitations that have been sent to employees to join the company, so you can keep track of who has been invited and resend or revoke invitations if needed.
+     * @param payload
+     */
+    abstract listInvitations(payload: EmployeeInvitationQueryList): Promise<Result<EmployeeInvitationPaginatedList>>;
+    /**
+     * Usecase:
+     * You are an admin of a company, and you want to invite co-workers to join the company.
+     * @param payload
+     */
+    abstract inviteEmployee(payload: EmployeeInvitationMutationInviteEmployee): Promise<Result<EmployeeIssuedInvitation>>;
+    /**
+     * Usecase:
+     * As a co-worker you received the invitation, and you want to accept it so you can start accessing the storefront on behalf of the company.
+     * @param payload
+     */
+    abstract acceptInvitation(payload: EmployeeInvitationMutationAcceptInvitation): Promise<Result<EmployeeInvitation>>;
+    /**
+     * Usecase:
+     * As an admin you changed your mind, and no longer want the invited co-worker to join the company, or you invited the wrong email by mistake. You want to revoke the invitation so that the co-worker can no longer accept it and join the company.
+     * @param payload
+     */
+    abstract revokeInvitation(payload: EmployeeInvitationMutationRevokeInvitation): Promise<Result<void, NotFoundError>>;
+}

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

@@ -0,0 +1,14 @@
+import type { NotFoundError } from '../schemas/index.js';
+import type { Employee, EmployeePaginatedList } from '../schemas/models/employee.model.js';
+import type { EmployeeMutationAssignRole, EmployeeMutationUnassignRole, EmployeeMutationRemoveEmployee } from '../schemas/mutations/employee.mutation.js';
+import type { EmployeeQueryByEmail, EmployeeQueryList } from '../schemas/queries/employee.query.js';
+import type { Result } from '../schemas/result.js';
+import { BaseCapability } from './base.capability.js';
+export declare abstract class EmployeeCapability extends BaseCapability {
+    protected getResourceName(): string;
+    abstract listEmployees(payload: EmployeeQueryList): Promise<Result<EmployeePaginatedList>>;
+    abstract getByEmail(payload: EmployeeQueryByEmail): Promise<Result<Employee>>;
+    abstract assignRole(payload: EmployeeMutationAssignRole): Promise<Result<Employee, NotFoundError>>;
+    abstract unassignRole(payload: EmployeeMutationUnassignRole): Promise<Result<Employee, NotFoundError>>;
+    abstract removeEmployee(payload: EmployeeMutationRemoveEmployee): Promise<Result<void, NotFoundError>>;
+}

package/src/capabilities/index.d.ts

@@ -16,3 +16,7 @@ export * from './product-list.capability.js';
 export * from './store.capability.js';
 export * from './order.capability.js';
 export * from './order-search.capability.js';
+export * from './company-registration.capability.js';
+export * from './employee.capability.js';
+export * from './employee-invitation.capability.js';
+export * from './company.capability.js';

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

@@ -14,14 +14,14 @@ export declare abstract class ProductRecommendationsCapability extends BaseCapab
      * @param query
      */
     getRecommendations(query: ProductRecommendationsQuery): Promise<Result<ProductRecommendation[]>>;
-    getCollection(query: ProductRecommendationsByCollectionQuery): Promise<Result<ProductRecommendation[]>>;
-    protected getFrequentlyBoughtTogetherRecommendations(query: ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery): Promise<ProductRecommendation[]>;
-    protected getSimilarProductsRecommendations(query: ProductRecommendationAlgorithmSimilarProductsQuery): Promise<ProductRecommendation[]>;
-    protected getTrendingInCategoryRecommendations(query: ProductRecommendationAlgorithmTrendingInCategoryQuery): Promise<ProductRecommendation[]>;
-    protected getRelatedProductsRecommendations(query: ProductRecommendationAlgorithmRelatedProductsQuery): Promise<ProductRecommendation[]>;
-    protected getPopularProductsRecommendations(query: ProductRecommendationAlgorithmPopuplarProductsQuery): Promise<ProductRecommendation[]>;
-    protected getTopPicksProductsRecommendations(query: ProductRecommendationAlgorithmTopPicksProductsQuery): Promise<ProductRecommendation[]>;
-    protected getAlsoViewedProductsRecommendations(query: ProductRecommendationAlgorithmAlsoViewedProductsQuery): Promise<ProductRecommendation[]>;
+    getCollection(_query: ProductRecommendationsByCollectionQuery): Promise<Result<ProductRecommendation[]>>;
+    protected getFrequentlyBoughtTogetherRecommendations(_query: ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery): Promise<ProductRecommendation[]>;
+    protected getSimilarProductsRecommendations(_query: ProductRecommendationAlgorithmSimilarProductsQuery): Promise<ProductRecommendation[]>;
+    protected getTrendingInCategoryRecommendations(_query: ProductRecommendationAlgorithmTrendingInCategoryQuery): Promise<ProductRecommendation[]>;
+    protected getRelatedProductsRecommendations(_query: ProductRecommendationAlgorithmRelatedProductsQuery): Promise<ProductRecommendation[]>;
+    protected getPopularProductsRecommendations(_query: ProductRecommendationAlgorithmPopuplarProductsQuery): Promise<ProductRecommendation[]>;
+    protected getTopPicksProductsRecommendations(_query: ProductRecommendationAlgorithmTopPicksProductsQuery): Promise<ProductRecommendation[]>;
+    protected getAlsoViewedProductsRecommendations(_query: ProductRecommendationAlgorithmAlsoViewedProductsQuery): Promise<ProductRecommendation[]>;
     protected getResourceName(): string;
 }
 export declare class MulticastProductRecommendationsCapability extends ProductRecommendationsCapability {

package/src/client/client.d.ts

@@ -6,11 +6,12 @@ import type { PriceCapability } from "../capabilities/price.capability.js";
 import type { InventoryCapability } from "../capabilities/inventory.capability.js";
 import type { Cache } from "../cache/cache.interface.js";
 import type { CategoryCapability } from "../capabilities/category.capability.js";
-import type { AnalyticsCapability, CheckoutCapability, OrderCapability, ProductListCapability, ProfileCapability, StoreCapability } from "../capabilities/index.js";
+import type { AnalyticsCapability, CheckoutCapability, OrderCapability, CompanyCapability, EmployeeCapability, CompanyRegistrationCapability, ProductListCapability, ProfileCapability, StoreCapability } from "../capabilities/index.js";
 import type { OrderSearchCapability } from "../capabilities/order-search.capability.js";
 import type { ProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
 import type { ProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
 import type { ProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+import type { EmployeeInvitationCapability } from "../capabilities/employee-invitation.capability.js";
 export interface Client {
     product: ProductCapability;
     productSearch: ProductSearchCapability;
@@ -30,4 +31,8 @@ export interface Client {
     store: StoreCapability;
     order: OrderCapability;
     orderSearch: OrderSearchCapability;
+    companyRegistration: CompanyRegistrationCapability;
+    employee: EmployeeCapability;
+    company: CompanyCapability;
+    employeeInvitation: EmployeeInvitationCapability;
 }

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

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { CompanyRegistrationRequestSchema } from '../schemas/models/company-registration.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCompanyRegistrationRequestSchema = z.ZodType<z.output<typeof CompanyRegistrationRequestSchema>>;
+export interface CompanyRegistrationFactory<TCompanyRegistrationRequestSchema extends AnyCompanyRegistrationRequestSchema = AnyCompanyRegistrationRequestSchema> {
+    companyRegistrationRequestSchema: TCompanyRegistrationRequestSchema;
+    parseCompanyRegistrationRequest(context: RequestContext, data: unknown): z.output<TCompanyRegistrationRequestSchema>;
+}
+export type CompanyRegistrationFactoryOutput<TFactory extends CompanyRegistrationFactory> = ReturnType<TFactory['parseCompanyRegistrationRequest']>;
+export type CompanyRegistrationFactoryWithOutput<TFactory extends CompanyRegistrationFactory> = Omit<TFactory, 'parseCompanyRegistrationRequest'> & {
+    parseCompanyRegistrationRequest(context: RequestContext, data: unknown): CompanyRegistrationFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,18 @@
+import type * as z from 'zod';
+import type { CompanyPaginatedListSchema, CompanySchema } from '../schemas/models/company.model.js';
+import type { CompanyQueryList } from '../schemas/queries/company.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCompanySchema = z.ZodType<z.output<typeof CompanySchema>>;
+export type AnyCompanyPaginatedListSchema = z.ZodType<z.output<typeof CompanyPaginatedListSchema>>;
+export interface CompanyFactory<TCompanySchema extends AnyCompanySchema = AnyCompanySchema, TCompanyPaginatedListSchema extends AnyCompanyPaginatedListSchema = AnyCompanyPaginatedListSchema> {
+    companySchema: TCompanySchema;
+    companyPaginatedListSchema: TCompanyPaginatedListSchema;
+    parseCompany(context: RequestContext, data: unknown): z.output<TCompanySchema>;
+    parseCompanyPaginatedList(context: RequestContext, data: unknown, query: CompanyQueryList): z.output<TCompanyPaginatedListSchema>;
+}
+export type CompanyFactoryOutput<TFactory extends CompanyFactory> = ReturnType<TFactory['parseCompany']>;
+export type CompanyPaginatedListFactoryOutput<TFactory extends CompanyFactory> = ReturnType<TFactory['parseCompanyPaginatedList']>;
+export type CompanyFactoryWithOutput<TFactory extends CompanyFactory> = Omit<TFactory, 'parseCompany' | 'parseCompanyPaginatedList'> & {
+    parseCompany(context: RequestContext, data: unknown): CompanyFactoryOutput<TFactory>;
+    parseCompanyPaginatedList(context: RequestContext, data: unknown, query: CompanyQueryList): CompanyPaginatedListFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,26 @@
+import type * as z from 'zod';
+import type { EmployeeInvitationPaginatedListSchema, EmployeeInvitationSchema, EmployeeIssuedInvitationSchema } from '../schemas/models/employee-invitation.model.js';
+import type { EmployeeRole } from '../schemas/models/identifiers.model.js';
+import type { EmployeeInvitationMutationInviteEmployee } from '../schemas/mutations/employee-invitation.mutation.js';
+import type { EmployeeInvitationQueryList } from '../schemas/queries/employee-invitation.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyEmployeeInvitationSchema = z.ZodType<z.output<typeof EmployeeInvitationSchema>>;
+export type AnyEmployeeIssuedInvitationSchema = z.ZodType<z.output<typeof EmployeeIssuedInvitationSchema>>;
+export type AnyEmployeeInvitationPaginatedListSchema = z.ZodType<z.output<typeof EmployeeInvitationPaginatedListSchema>>;
+export interface EmployeeInvitationFactory<TEmployeeInvitationSchema extends AnyEmployeeInvitationSchema = AnyEmployeeInvitationSchema, TEmployeeIssuedInvitationSchema extends AnyEmployeeIssuedInvitationSchema = AnyEmployeeIssuedInvitationSchema, TEmployeeInvitationPaginatedListSchema extends AnyEmployeeInvitationPaginatedListSchema = AnyEmployeeInvitationPaginatedListSchema> {
+    employeeInvitationSchema: TEmployeeInvitationSchema;
+    employeeIssuedInvitationSchema: TEmployeeIssuedInvitationSchema;
+    employeeInvitationPaginatedListSchema: TEmployeeInvitationPaginatedListSchema;
+    parseEmployeeInvitation(context: RequestContext, data: unknown, payload?: EmployeeInvitationMutationInviteEmployee): z.output<TEmployeeInvitationSchema>;
+    parseEmployeeIssuedInvitation(context: RequestContext, data: unknown, payload?: EmployeeInvitationMutationInviteEmployee): z.output<TEmployeeIssuedInvitationSchema>;
+    parseEmployeeInvitationPaginatedList(context: RequestContext, data: unknown, query: EmployeeInvitationQueryList): z.output<TEmployeeInvitationPaginatedListSchema>;
+    mapRole(role: EmployeeRole): string;
+}
+export type EmployeeInvitationFactoryOutput<TFactory extends EmployeeInvitationFactory> = ReturnType<TFactory['parseEmployeeInvitation']>;
+export type EmployeeIssuedInvitationFactoryOutput<TFactory extends EmployeeInvitationFactory> = ReturnType<TFactory['parseEmployeeIssuedInvitation']>;
+export type EmployeeInvitationPaginatedListFactoryOutput<TFactory extends EmployeeInvitationFactory> = ReturnType<TFactory['parseEmployeeInvitationPaginatedList']>;
+export type EmployeeInvitationFactoryWithOutput<TFactory extends EmployeeInvitationFactory> = Omit<TFactory, 'parseEmployeeInvitation' | 'parseEmployeeIssuedInvitation' | 'parseEmployeeInvitationPaginatedList'> & {
+    parseEmployeeInvitation(context: RequestContext, data: unknown, payload?: EmployeeInvitationMutationInviteEmployee): EmployeeInvitationFactoryOutput<TFactory>;
+    parseEmployeeIssuedInvitation(context: RequestContext, data: unknown, payload?: EmployeeInvitationMutationInviteEmployee): EmployeeIssuedInvitationFactoryOutput<TFactory>;
+    parseEmployeeInvitationPaginatedList(context: RequestContext, data: unknown, query: EmployeeInvitationQueryList): EmployeeInvitationPaginatedListFactoryOutput<TFactory>;
+};

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

@@ -0,0 +1,20 @@
+import type * as z from 'zod';
+import type { EmployeePaginatedListSchema, EmployeeSchema } from '../schemas/models/employee.model.js';
+import type { EmployeeRole } from '../schemas/models/identifiers.model.js';
+import type { EmployeeQueryList } from '../schemas/queries/employee.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyEmployeeSchema = z.ZodType<z.output<typeof EmployeeSchema>>;
+export type AnyEmployeePaginatedListSchema = z.ZodType<z.output<typeof EmployeePaginatedListSchema>>;
+export interface EmployeeFactory<TEmployeeSchema extends AnyEmployeeSchema = AnyEmployeeSchema, TEmployeePaginatedListSchema extends AnyEmployeePaginatedListSchema = AnyEmployeePaginatedListSchema> {
+    employeeSchema: TEmployeeSchema;
+    employeePaginatedListSchema: TEmployeePaginatedListSchema;
+    parseEmployee(context: RequestContext, data: unknown): z.output<TEmployeeSchema>;
+    parseEmployeePaginatedList(context: RequestContext, data: unknown, query: EmployeeQueryList): z.output<TEmployeePaginatedListSchema>;
+    mapRole(role: EmployeeRole): string;
+}
+export type EmployeeFactoryOutput<TFactory extends EmployeeFactory> = ReturnType<TFactory['parseEmployee']>;
+export type EmployeePaginatedListFactoryOutput<TFactory extends EmployeeFactory> = ReturnType<TFactory['parseEmployeePaginatedList']>;
+export type EmployeeFactoryWithOutput<TFactory extends EmployeeFactory> = Omit<TFactory, 'parseEmployee' | 'parseEmployeePaginatedList'> & {
+    parseEmployee(context: RequestContext, data: unknown): EmployeeFactoryOutput<TFactory>;
+    parseEmployeePaginatedList(context: RequestContext, data: unknown, query: EmployeeQueryList): EmployeePaginatedListFactoryOutput<TFactory>;
+};

package/src/factories/index.d.ts

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

package/src/schemas/models/base.model.d.ts

@@ -27,6 +27,14 @@ export declare const ImageSchema: z.ZodObject<{
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
 }, z.core.$loose>;
+/**
+ * This is a generic schema for holding an email  and an optional phone both values.
+ */
+export declare const PointOfContactSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
 export type Image = InferType<typeof ImageSchema>;
 export type PaginationOptions = InferType<typeof PaginationOptionsSchema>;
 export type BaseModel = InferType<typeof BaseModelSchema>;
+export type PointOfContact = InferType<typeof PointOfContactSchema>;

package/src/schemas/models/checkout.model.d.ts

@@ -2647,6 +2647,10 @@ export declare const CheckoutSchema: z.ZodObject<{
     }, z.core.$loose>>;
     name: z.ZodDefault<z.ZodString>;
     description: z.ZodDefault<z.ZodString>;
+    pointOfContact: z.ZodObject<{
+        email: z.ZodEmail;
+        phone: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
     billingAddress: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         identifier: z.ZodDefault<z.ZodObject<{
             nickName: z.ZodString;

package/src/schemas/models/company-registration.model.d.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+export declare const CompanyRegistrationRequestSchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    companyIdentifier: z.ZodObject<{
+        taxIdentifier: z.ZodString;
+    }, z.core.$loose>;
+    name: z.ZodString;
+    pointOfContact: z.ZodObject<{
+        email: z.ZodEmail;
+        phone: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        approved: "approved";
+        denied: "denied";
+    }>;
+    comment: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CompanyRegistrationRequest = InferType<typeof CompanyRegistrationRequestSchema>;

package/src/schemas/models/company.model.d.ts

@@ -0,0 +1,213 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+/**
+ * Status of a company in the system. This can be used to determine if the company is active and allowed to perform certain actions, or if it is pending approval or blocked due to violations of terms of service or other issues.
+ */
+export declare const CompanyStatusSchema: z.ZodEnum<{
+    active: "active";
+    blocked: "blocked";
+}>;
+export declare const CompanySchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        taxIdentifier: z.ZodString;
+    }, z.core.$loose>;
+    /**
+     * DUN and Bradstreet identifier. Useful for doing automated credit checks
+     */
+    dunsIdentifier: z.ZodOptional<z.ZodString>;
+    /**
+     * EU Tax identifier. Useful for reporting and printing
+     */
+    tinIdentifier: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    logo: z.ZodOptional<z.ZodObject<{
+        sourceUrl: z.ZodDefault<z.ZodString>;
+        altText: z.ZodDefault<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    /**
+     * future
+    parentCompany: CompanyIdentifierSchema.optional(),
+    childOrganizationalEntities: z.array(CompanyIdentifierSchema).optional()
+     */
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+    }>>;
+    /**
+     * The legal contact point for this company. Might not be someone with an actual profile on the site.
+     */
+    pointOfContact: z.ZodObject<{
+        email: z.ZodEmail;
+        phone: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    /**
+     * Default shipping address if different from default billing address
+     */
+    shippingAddress: z.ZodOptional<z.ZodObject<{
+        identifier: z.ZodDefault<z.ZodObject<{
+            nickName: z.ZodString;
+        }, z.core.$loose>>;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        streetAddress: z.ZodString;
+        streetNumber: z.ZodString;
+        city: z.ZodString;
+        region: z.ZodString;
+        postalCode: z.ZodString;
+        countryCode: z.ZodString;
+    }, z.core.$loose>>;
+    /**
+     * The billing address for this company.
+     */
+    billingAddress: z.ZodObject<{
+        identifier: z.ZodDefault<z.ZodObject<{
+            nickName: z.ZodString;
+        }, z.core.$loose>>;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        streetAddress: z.ZodString;
+        streetNumber: z.ZodString;
+        city: z.ZodString;
+        region: z.ZodString;
+        postalCode: z.ZodString;
+        countryCode: z.ZodString;
+    }, z.core.$loose>;
+    /**
+     * Other allowed shipping addresses
+     */
+    alternateShippingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        identifier: z.ZodDefault<z.ZodObject<{
+            nickName: z.ZodString;
+        }, z.core.$loose>>;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        streetAddress: z.ZodString;
+        streetNumber: z.ZodString;
+        city: z.ZodString;
+        region: z.ZodString;
+        postalCode: z.ZodString;
+        countryCode: z.ZodString;
+    }, z.core.$loose>>>;
+    /**
+     * Various indicators the merchant can use to indicate what the company can self-manage.
+     */
+    /**
+     * Can user type in a different shipping address at checkout?
+     */
+    isCustomAddressesAllowed: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Can admin users manage the address book of the company, adding and removing shipping addresses as needed?
+     */
+    isSelfManagementOfShippingAddressesAllowed: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const CompanyPaginatedListSchema: z.ZodObject<{
+    pageNumber: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    totalCount: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodObject<{
+            taxIdentifier: z.ZodString;
+        }, z.core.$loose>;
+        /**
+         * DUN and Bradstreet identifier. Useful for doing automated credit checks
+         */
+        dunsIdentifier: z.ZodOptional<z.ZodString>;
+        /**
+         * EU Tax identifier. Useful for reporting and printing
+         */
+        tinIdentifier: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        logo: z.ZodOptional<z.ZodObject<{
+            sourceUrl: z.ZodDefault<z.ZodString>;
+            altText: z.ZodDefault<z.ZodString>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        /**
+         * future
+        parentCompany: CompanyIdentifierSchema.optional(),
+        childOrganizationalEntities: z.array(CompanyIdentifierSchema).optional()
+         */
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+        }>>;
+        /**
+         * The legal contact point for this company. Might not be someone with an actual profile on the site.
+         */
+        pointOfContact: z.ZodObject<{
+            email: z.ZodEmail;
+            phone: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        /**
+         * Default shipping address if different from default billing address
+         */
+        shippingAddress: z.ZodOptional<z.ZodObject<{
+            identifier: z.ZodDefault<z.ZodObject<{
+                nickName: z.ZodString;
+            }, z.core.$loose>>;
+            firstName: z.ZodString;
+            lastName: z.ZodString;
+            streetAddress: z.ZodString;
+            streetNumber: z.ZodString;
+            city: z.ZodString;
+            region: z.ZodString;
+            postalCode: z.ZodString;
+            countryCode: z.ZodString;
+        }, z.core.$loose>>;
+        /**
+         * The billing address for this company.
+         */
+        billingAddress: z.ZodObject<{
+            identifier: z.ZodDefault<z.ZodObject<{
+                nickName: z.ZodString;
+            }, z.core.$loose>>;
+            firstName: z.ZodString;
+            lastName: z.ZodString;
+            streetAddress: z.ZodString;
+            streetNumber: z.ZodString;
+            city: z.ZodString;
+            region: z.ZodString;
+            postalCode: z.ZodString;
+            countryCode: z.ZodString;
+        }, z.core.$loose>;
+        /**
+         * Other allowed shipping addresses
+         */
+        alternateShippingAddresses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            identifier: z.ZodDefault<z.ZodObject<{
+                nickName: z.ZodString;
+            }, z.core.$loose>>;
+            firstName: z.ZodString;
+            lastName: z.ZodString;
+            streetAddress: z.ZodString;
+            streetNumber: z.ZodString;
+            city: z.ZodString;
+            region: z.ZodString;
+            postalCode: z.ZodString;
+            countryCode: z.ZodString;
+        }, z.core.$loose>>>;
+        /**
+         * Various indicators the merchant can use to indicate what the company can self-manage.
+         */
+        /**
+         * Can user type in a different shipping address at checkout?
+         */
+        isCustomAddressesAllowed: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Can admin users manage the address book of the company, adding and removing shipping addresses as needed?
+         */
+        isSelfManagementOfShippingAddressesAllowed: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    identifier: z.ZodObject<{
+        paginationOptions: z.ZodObject<{
+            pageNumber: z.ZodDefault<z.ZodNumber>;
+            pageSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type CompanyPaginatedList = InferType<typeof CompanyPaginatedListSchema>;
+export type Company = InferType<typeof CompanySchema>;