@unchainedshop/core 4.6.1 → 4.6.2

package/lib/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './common.ts';

package/lib/errors/index.js

@@ -0,0 +1 @@
+export * from "./common.js";

package/lib/plugins/PluginRegistry.d.ts

@@ -0,0 +1,42 @@
+import type { UnchainedCore } from '../core-index.ts';
+import type { IBaseAdapter } from '@unchainedshop/utils';
+import type { mongodb } from '@unchainedshop/mongodb';
+export interface PluginHttpRoute {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'ALL';
+    handler: (request: Request, context: UnchainedCore & {
+        params: Record<string, string>;
+        userId?: string;
+        impersonatorId?: string;
+    }) => Response | Promise<Response>;
+}
+export type PluginModuleFactory = (options: {
+    db: mongodb.Db;
+}) => Record<string, any>;
+export interface IPlugin {
+    key: string;
+    label: string;
+    version: string;
+    adapters?: IBaseAdapter[];
+    module?: PluginModuleFactory;
+    routes?: PluginHttpRoute[];
+    onRegister?: (unchainedAPI: UnchainedCore) => void | boolean | Promise<void | boolean>;
+    onShutdown?: (unchainedAPI: UnchainedCore) => void | Promise<void>;
+}
+declare class PluginRegistry {
+    private plugins;
+    private moduleFactories;
+    private skippedPlugins;
+    register(plugin: IPlugin): void;
+    initialize(unchainedAPI: UnchainedCore): Promise<void>;
+    getModuleFactories(): PluginModuleFactory[];
+    getRoutes(): PluginHttpRoute[];
+    shutdown(unchainedAPI: UnchainedCore): Promise<void>;
+    getPlugin(key: string): IPlugin | undefined;
+    getAllPlugins(): IPlugin[];
+    getAdapters(adapterType: symbol): IBaseAdapter[];
+    hasPlugin(key: string): boolean;
+    clear(): void;
+}
+export declare const pluginRegistry: PluginRegistry;
+export {};

package/lib/plugins/PluginRegistry.js

@@ -0,0 +1,113 @@
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:core');
+class PluginRegistry {
+    plugins = new Map();
+    moduleFactories = [];
+    skippedPlugins = new Set();
+    register(plugin) {
+        if (this.plugins.has(plugin.key)) {
+            logger.warn(`Plugin ${plugin.key} already registered, skipping`, {
+                label: plugin.label,
+            });
+            return;
+        }
+        logger.info(`Registering plugin: ${plugin.label} (${plugin.key})`, {
+            version: plugin.version,
+        });
+        this.plugins.set(plugin.key, plugin);
+        if (plugin.module) {
+            this.moduleFactories.push(plugin.module);
+        }
+    }
+    async initialize(unchainedAPI) {
+        logger.info(`Initializing ${this.plugins.size} plugins`);
+        const skippedPlugins = new Set();
+        for (const plugin of this.plugins.values()) {
+            if (plugin.onRegister) {
+                try {
+                    const result = await plugin.onRegister(unchainedAPI);
+                    if (result === false) {
+                        skippedPlugins.add(plugin.key);
+                        logger.warn(`Plugin ${plugin.key} skipped adapter registration`, {
+                            label: plugin.label,
+                        });
+                    }
+                    else {
+                        logger.debug(`Plugin ${plugin.key} initialized`, {
+                            label: plugin.label,
+                        });
+                    }
+                }
+                catch (error) {
+                    skippedPlugins.add(plugin.key);
+                    const reason = error instanceof Error ? error.message : String(error);
+                    logger.warn(`Plugin ${plugin.key} skipped adapter registration - ${reason}`, {
+                        label: plugin.label,
+                    });
+                }
+            }
+        }
+        this.skippedPlugins = skippedPlugins;
+    }
+    getModuleFactories() {
+        return this.moduleFactories;
+    }
+    getRoutes() {
+        const routes = [];
+        for (const plugin of this.plugins.values()) {
+            if (this.skippedPlugins.has(plugin.key)) {
+                continue;
+            }
+            if (plugin.routes) {
+                routes.push(...plugin.routes);
+            }
+        }
+        return routes;
+    }
+    async shutdown(unchainedAPI) {
+        logger.info('Shutting down plugins');
+        for (const plugin of this.plugins.values()) {
+            if (plugin.onShutdown) {
+                try {
+                    await plugin.onShutdown(unchainedAPI);
+                    logger.debug(`Plugin ${plugin.key} shutdown complete`, {
+                        label: plugin.label,
+                    });
+                }
+                catch (error) {
+                    logger.error(`Error shutting down plugin ${plugin.key}`, {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    getPlugin(key) {
+        return this.plugins.get(key);
+    }
+    getAllPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    getAdapters(adapterType) {
+        const result = [];
+        for (const plugin of this.plugins.values()) {
+            if (!plugin.adapters)
+                continue;
+            for (const adapter of plugin.adapters) {
+                if (adapter.adapterType === adapterType) {
+                    result.push(adapter);
+                }
+            }
+        }
+        return result;
+    }
+    hasPlugin(key) {
+        return this.plugins.has(key);
+    }
+    clear() {
+        this.plugins.clear();
+        this.moduleFactories = [];
+        this.skippedPlugins.clear();
+    }
+}
+export const pluginRegistry = new PluginRegistry();

package/lib/services/addCartDiscount.d.ts

@@ -0,0 +1,10 @@
+import type { OrderDiscount } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+import type { User } from '@unchainedshop/core-users';
+export interface AddCartDiscountParams {
+    orderId?: string;
+    code: string;
+    user: User;
+    countryCode: string;
+}
+export declare function addCartDiscountService(this: Modules, params: AddCartDiscountParams): Promise<OrderDiscount>;

package/lib/services/addCartDiscount.js

@@ -0,0 +1,27 @@
+import { createManualOrderDiscountService } from "./createManualOrderDiscount.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { OrderNotFoundError, OrderWrongStatusError, OrderDiscountCodeAlreadyPresentError, OrderDiscountCodeNotValidError, } from "../errors/index.js";
+export async function addCartDiscountService(params) {
+    const { orderId, code, user, countryCode } = params;
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: orderId || null });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    if (await this.orders.discounts.isDiscountCodeUsed({ code, orderId: order._id })) {
+        throw new OrderDiscountCodeAlreadyPresentError({ orderId: order._id, code });
+    }
+    const discount = await createManualOrderDiscountService.bind(this)({ order, code });
+    if (!discount) {
+        throw new OrderDiscountCodeNotValidError({ code });
+    }
+    await updateCalculationService.bind(this)(order._id);
+    return discount;
+}

package/lib/services/addCartItem.d.ts

@@ -0,0 +1,15 @@
+import { type OrderPosition } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AddCartItemParams {
+    orderId?: string;
+    productId: string;
+    quantity: number;
+    configuration?: {
+        key: string;
+        value: string;
+    }[];
+    user: User;
+    countryCode: string;
+}
+export declare function addCartItemService(this: Modules, params: AddCartItemParams, context: any): Promise<OrderPosition>;

package/lib/services/addCartItem.js

@@ -0,0 +1,41 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { ProductNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, } from "../errors/index.js";
+export async function addCartItemService(params, context) {
+    const { orderId, productId: originalProductId, quantity, configuration, user, countryCode } = params;
+    if (quantity < 1) {
+        throw new OrderQuantityTooLowError({ quantity });
+    }
+    const originalProduct = await this.products.findProduct({ productId: originalProductId });
+    if (!originalProduct) {
+        throw new ProductNotFoundError({ productId: originalProductId });
+    }
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const product = await this.products.resolveOrderableProduct(originalProduct, { configuration });
+    await ordersSettings.validateOrderPosition({
+        order,
+        product,
+        configuration,
+        quantityDiff: quantity,
+    }, context);
+    const orderPosition = await this.orders.positions.addProductItem({
+        quantity,
+        configuration,
+        productId: product._id,
+        originalProductId,
+        orderId: order._id,
+    });
+    await updateCalculationService.bind(this)(order._id);
+    return (await this.orders.positions.findOrderPosition({ itemId: orderPosition._id }));
+}

package/lib/services/addCartQuotation.d.ts

@@ -0,0 +1,16 @@
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AddCartQuotationParams {
+    orderId?: string;
+    quotationId: string;
+    quantity: number;
+    configuration: {
+        key: string;
+        value: string;
+    }[];
+    user: User;
+    countryCode: string;
+    context: unknown;
+}
+export declare function addCartQuotationService(this: Modules, params: AddCartQuotationParams): Promise<OrderPosition>;

package/lib/services/addCartQuotation.js

@@ -0,0 +1,52 @@
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { QuotationDirector } from "../directors/QuotationDirector.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, QuotationNotFoundError, QuotationWrongStatusError, QuotationItemConfigurationError, } from "../errors/index.js";
+export async function addCartQuotationService(params) {
+    const { orderId, quotationId, quantity, configuration, user, countryCode, context } = params;
+    if (quantity < 1) {
+        throw new OrderQuantityTooLowError({ quantity });
+    }
+    const quotation = await this.quotations.findQuotation({ quotationId });
+    if (!quotation) {
+        throw new QuotationNotFoundError({ quotationId });
+    }
+    if (quotation.status !== QuotationStatus.PROPOSED) {
+        throw new QuotationWrongStatusError({ status: quotation.status });
+    }
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: orderId || null });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    if (!(await this.products.productExists({ productId: quotation.productId }))) {
+        throw new ProductNotFoundError({ productId: quotation.productId });
+    }
+    const director = await QuotationDirector.actions({ quotation }, context);
+    const quotationConfiguration = await director.transformItemConfiguration({
+        quantity,
+        configuration,
+    });
+    if (!quotationConfiguration) {
+        throw new QuotationItemConfigurationError({ configuration });
+    }
+    const updatedOrderPosition = await this.orders.positions.addProductItem({
+        quantity: quotationConfiguration.quantity || 1,
+        configuration: quotationConfiguration.configuration,
+        quotationId,
+        productId: quotation.productId,
+        originalProductId: quotation.productId,
+        orderId: order._id,
+    });
+    await updateCalculationService.bind(this)(order._id);
+    return (await this.orders.positions.findOrderPosition({
+        itemId: updatedOrderPosition._id,
+    }));
+}

package/lib/services/addEmail.d.ts

@@ -0,0 +1,7 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AddEmailParams {
+    userId: string;
+    email: string;
+}
+export declare function addEmailService(this: Modules, params: AddEmailParams): Promise<User>;

package/lib/services/addEmail.js

@@ -0,0 +1,17 @@
+import { UserNotFoundError, EmailAlreadyExistsError } from "../errors/index.js";
+export async function addEmailService(params) {
+    const { userId, email } = params;
+    if (!(await this.users.userExists({ userId }))) {
+        throw new UserNotFoundError({ userId });
+    }
+    try {
+        await this.users.addEmail(userId, email);
+    }
+    catch (e) {
+        if (e.cause === 'EMAIL_INVALID') {
+            throw new EmailAlreadyExistsError({ email });
+        }
+        throw e;
+    }
+    return (await this.users.findUserById(userId));
+}

package/lib/services/addProductAssignment.d.ts

@@ -0,0 +1,3 @@
+import { type Product, type ProductConfiguration } from '@unchainedshop/core-products';
+import type { Modules } from '../modules.ts';
+export declare function addProductAssignmentService(this: Modules, proxyId: string, productId: string, vectors: ProductConfiguration[]): Promise<Product | null>;

package/lib/services/addProductAssignment.js

@@ -0,0 +1,63 @@
+import { ProductType, } from '@unchainedshop/core-products';
+import { ProductNotFoundError, ProductWrongTypeError, ProductVariationInfinityLoopError, ProductVariationVectorInvalidError, ProductVariationVectorAlreadySetError, } from "../errors/index.js";
+const extractVariationMatrix = (variations = []) => {
+    const cartesianProduct = (arrays) => {
+        return arrays.reduce((acc, array) => acc.flatMap((item) => array.map((value) => [...item, value])), [
+            [],
+        ]);
+    };
+    const keys = variations.map((item) => item.key);
+    const options = variations.map((item) => item.options);
+    const combinations = cartesianProduct(options);
+    return combinations.map((combination) => combination.reduce((acc, value, index) => {
+        acc[keys[index]] = value;
+        return acc;
+    }, {}));
+};
+const combinationExists = (matrix, combination) => {
+    return matrix.some((variation) => {
+        return (Object.keys(variation).length === Object.keys(combination).length &&
+            Object.entries(combination).every(([key, value]) => variation[key] === value));
+    });
+};
+export async function addProductAssignmentService(proxyId, productId, vectors) {
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    const proxyProduct = await this.products.findProduct({ productId: proxyId });
+    if (!proxyProduct) {
+        throw new ProductNotFoundError({ productId: proxyId });
+    }
+    if (productId === proxyId) {
+        throw new ProductVariationInfinityLoopError({ productId });
+    }
+    if (proxyProduct.type !== ProductType.CONFIGURABLE_PRODUCT) {
+        throw new ProductWrongTypeError({
+            proxyId,
+            received: proxyProduct.type,
+            required: ProductType.CONFIGURABLE_PRODUCT,
+        });
+    }
+    const variations = await this.products.variations.findProductVariations({
+        productId: proxyId,
+    });
+    const variationMatrix = extractVariationMatrix(variations);
+    const normalizedVectors = vectors?.reduce((prev, { key, value }) => {
+        return {
+            ...prev,
+            [key]: value,
+        };
+    }, {});
+    if (!combinationExists(variationMatrix, normalizedVectors)) {
+        throw new ProductVariationVectorInvalidError({ proxyId, vectors });
+    }
+    const added = await this.products.assignments.addProxyAssignment({
+        productId,
+        proxyId,
+        vectors,
+    });
+    if (!added) {
+        throw new ProductVariationVectorAlreadySetError({ proxyId, vectors });
+    }
+    return this.products.findProduct({ productId: proxyId });
+}

package/lib/services/authenticateWithPassword.d.ts

@@ -0,0 +1,15 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AuthenticateWithPasswordParams {
+    username?: string;
+    email?: string;
+    password: string;
+}
+export interface HttpContext {
+    remoteAddress?: string;
+    remotePort?: number;
+    userAgent?: string;
+    locale?: string;
+    countryCode: string;
+}
+export declare function authenticateWithPasswordService(this: Modules, params: AuthenticateWithPasswordParams, httpContext: HttpContext, currentUserId?: string): Promise<User>;

package/lib/services/authenticateWithPassword.js

@@ -0,0 +1,34 @@
+import { migrateUserDataService } from "./migrateUserData.js";
+import { nextUserCartService } from "./nextUserCart.js";
+import { UsernameOrEmailRequiredError, InvalidCredentialsError } from "../errors/index.js";
+export async function authenticateWithPasswordService(params, httpContext, currentUserId) {
+    const { username, email, password } = params;
+    if (!username && !email) {
+        throw new UsernameOrEmailRequiredError();
+    }
+    let user = username
+        ? await this.users.findUserByUsername(username)
+        : await this.users.findUserByEmail(email);
+    if (!user) {
+        throw new InvalidCredentialsError({ username, email });
+    }
+    const verified = user.services?.password && (await this.users.verifyPassword(user.services.password, password));
+    if (!verified) {
+        throw new InvalidCredentialsError({ username, email });
+    }
+    if (user.guest) {
+        await this.users.updateGuest(user, false);
+    }
+    user = (await this.users.updateHeartbeat(user._id, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    if (currentUserId) {
+        await migrateUserDataService.bind(this)(currentUserId, user._id);
+    }
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return user;
+}

package/lib/services/changePassword.d.ts

@@ -0,0 +1,10 @@
+import type { Modules } from '../modules.ts';
+export interface ChangePasswordParams {
+    userId: string;
+    oldPassword: string;
+    newPassword: string;
+}
+export interface ChangePasswordResult {
+    success: boolean;
+}
+export declare function changePasswordService(this: Modules, params: ChangePasswordParams): Promise<ChangePasswordResult>;

package/lib/services/changePassword.js

@@ -0,0 +1,19 @@
+import { InvalidCredentialsError, PasswordInvalidError } from "../errors/index.js";
+export async function changePasswordService(params) {
+    const { userId, oldPassword, newPassword } = params;
+    const user = await this.users.findUserById(userId);
+    const isValidCurrentPassword = user?.services?.password && (await this.users.verifyPassword(user.services.password, oldPassword));
+    if (!isValidCurrentPassword) {
+        throw new InvalidCredentialsError();
+    }
+    try {
+        await this.users.setPassword(user._id, newPassword);
+        return { success: true };
+    }
+    catch (e) {
+        if (e.cause === 'PASSWORD_INVALID') {
+            throw new PasswordInvalidError({ userId });
+        }
+        throw e;
+    }
+}

package/lib/services/countOrdersWithFilters.d.ts

@@ -0,0 +1,3 @@
+import type { OrderQuery } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function countOrdersWithFiltersService(this: Modules, params: OrderQuery): Promise<number>;

package/lib/services/countOrdersWithFilters.js

@@ -0,0 +1,25 @@
+export async function countOrdersWithFiltersService(params) {
+    const { paymentProviderIds, deliveryProviderIds, ...restParams } = params;
+    if (!paymentProviderIds?.length && !deliveryProviderIds?.length) {
+        return this.orders.count(restParams);
+    }
+    const [orderPayments, orderDeliveries] = await Promise.all([
+        paymentProviderIds?.length
+            ? this.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+            : [],
+        deliveryProviderIds?.length
+            ? this.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+            : [],
+    ]);
+    if ((paymentProviderIds?.length && !orderPayments.length) ||
+        (deliveryProviderIds?.length && !orderDeliveries.length)) {
+        return 0;
+    }
+    const paymentIds = orderPayments.map((p) => p._id);
+    const deliveryIds = orderDeliveries.map((d) => d._id);
+    return this.orders.count({
+        ...restParams,
+        paymentIds,
+        deliveryIds,
+    });
+}

package/lib/services/createAssortment.d.ts

@@ -0,0 +1,7 @@
+import type { Assortment, AssortmentText } from '@unchainedshop/core-assortments';
+import type { Modules } from '../modules.ts';
+export interface CreateAssortmentParams {
+    assortment: Partial<Assortment>;
+    texts?: AssortmentText[];
+}
+export declare function createAssortmentService(this: Modules, params: CreateAssortmentParams): Promise<Assortment>;

package/lib/services/createAssortment.js

@@ -0,0 +1,10 @@
+export async function createAssortmentService(params) {
+    const { assortment: assortmentData, texts } = params;
+    const assortment = await this.assortments.create({
+        ...assortmentData,
+    });
+    if (texts) {
+        await this.assortments.texts.updateTexts(assortment._id, texts);
+    }
+    return assortment;
+}

package/lib/services/createBookmark.d.ts

@@ -0,0 +1,8 @@
+import type { Bookmark } from '@unchainedshop/core-bookmarks';
+import type { Modules } from '../modules.ts';
+export interface CreateBookmarkParams {
+    productId: string;
+    userId: string;
+    meta?: any;
+}
+export declare function createBookmarkService(this: Modules, params: CreateBookmarkParams): Promise<Bookmark>;

package/lib/services/createBookmark.js

@@ -0,0 +1,21 @@
+import { ProductNotFoundError, BookmarkAlreadyExistsError } from "../errors/index.js";
+export async function createBookmarkService(params) {
+    const { productId, userId, meta } = params;
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    const [existingBookmark] = await this.bookmarks.findBookmarks({
+        productId,
+        userId,
+        meta,
+    });
+    if (existingBookmark) {
+        throw new BookmarkAlreadyExistsError({ bookmarkId: existingBookmark._id });
+    }
+    const bookmarkId = await this.bookmarks.create({
+        userId,
+        productId,
+        meta,
+    });
+    return (await this.bookmarks.findBookmarkById(bookmarkId));
+}

package/lib/services/createDeliveryProvider.d.ts

@@ -0,0 +1,6 @@
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { Modules } from '../modules.ts';
+export interface CreateDeliveryProviderParams {
+    deliveryProvider: Pick<DeliveryProvider, 'type' | 'adapterKey'>;
+}
+export declare function createDeliveryProviderService(this: Modules, params: CreateDeliveryProviderParams): Promise<DeliveryProvider | null>;

package/lib/services/createDeliveryProvider.js

@@ -0,0 +1,19 @@
+import { DeliveryDirector } from "../directors/DeliveryDirector.js";
+import { ProviderConfigurationInvalidError } from "../errors/index.js";
+export async function createDeliveryProviderService(params) {
+    const { deliveryProvider } = params;
+    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
+    if (!Adapter)
+        return null;
+    const provider = await this.delivery.create({
+        configuration: Adapter.initialConfiguration,
+        ...deliveryProvider,
+    });
+    if (!provider) {
+        throw new ProviderConfigurationInvalidError({
+            adapterKey: deliveryProvider.adapterKey,
+            type: deliveryProvider.type,
+        });
+    }
+    return provider;
+}

package/lib/services/createEnrollment.d.ts

@@ -0,0 +1,17 @@
+import type { Enrollment, EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { Address, Contact } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface CreateEnrollmentParams {
+    productId: string;
+    quantity?: number;
+    configuration?: EnrollmentPlan['configuration'];
+    billingAddress?: Address;
+    contact?: Contact;
+    payment?: Enrollment['payment'];
+    delivery?: Enrollment['delivery'];
+    meta?: any;
+    countryCode: string;
+    currencyCode: string;
+    userId: string;
+}
+export declare function createEnrollmentService(this: Modules, params: CreateEnrollmentParams): Promise<Enrollment>;