@unchainedshop/api 4.0.0-rc.12 → 4.0.0-rc.13

package/lib/mcp/tools/localization/schemas.d.ts

@@ -0,0 +1,298 @@
+import { z } from 'zod';
+import { SortDirection } from '@unchainedshop/utils';
+export declare const sortDirectionKeys: [keyof typeof SortDirection, ...(keyof typeof SortDirection)[]];
+export declare const LocalizationTypeEnum: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+export declare const LocalizationEntitySchema: z.ZodObject<{
+    isoCode: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+    contractAddress: z.ZodOptional<z.ZodString>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    isActive?: boolean;
+    isoCode?: string;
+    defaultCurrencyCode?: string;
+    contractAddress?: string;
+    decimals?: number;
+}, {
+    isActive?: boolean;
+    isoCode?: string;
+    defaultCurrencyCode?: string;
+    contractAddress?: string;
+    decimals?: number;
+}>;
+export declare const actionValidators: {
+    readonly CREATE: z.ZodObject<{
+        localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+        entity: z.ZodObject<{
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+            contractAddress: z.ZodOptional<z.ZodString>;
+            decimals: z.ZodOptional<z.ZodNumber>;
+        } & {
+            isoCode: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        }, {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entity?: {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        };
+    }, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entity?: {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        };
+    }>;
+    readonly UPDATE: z.ZodObject<{
+        localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+        entityId: z.ZodString;
+        entity: z.ZodObject<{
+            isoCode: z.ZodOptional<z.ZodString>;
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+            contractAddress: z.ZodOptional<z.ZodString>;
+            decimals: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        }, {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entity?: {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        };
+        entityId?: string;
+    }, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entity?: {
+            isActive?: boolean;
+            isoCode?: string;
+            defaultCurrencyCode?: string;
+            contractAddress?: string;
+            decimals?: number;
+        };
+        entityId?: string;
+    }>;
+    readonly REMOVE: z.ZodObject<{
+        localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entityId?: string;
+    }, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entityId?: string;
+    }>;
+    readonly GET: z.ZodObject<{
+        localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entityId?: string;
+    }, {
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+        entityId?: string;
+    }>;
+    readonly LIST: z.ZodObject<{
+        queryString: z.ZodOptional<z.ZodString>;
+        includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodEnum<[string, ...string[]]>;
+        }, "strip", z.ZodTypeAny, {
+            key?: string;
+            value?: string;
+        }, {
+            key?: string;
+            value?: string;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            key?: string;
+            value?: string;
+        }[];
+        includeInactive?: boolean;
+        queryString?: string;
+        limit?: number;
+        offset?: number;
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+    }, {
+        sort?: {
+            key?: string;
+            value?: string;
+        }[];
+        includeInactive?: boolean;
+        queryString?: string;
+        limit?: number;
+        offset?: number;
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+    }>;
+    readonly COUNT: z.ZodObject<{
+        queryString: z.ZodOptional<z.ZodString>;
+        includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+    }, "strip", z.ZodTypeAny, {
+        includeInactive?: boolean;
+        queryString?: string;
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+    }, {
+        includeInactive?: boolean;
+        queryString?: string;
+        localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+    }>;
+};
+export declare const LocalizationManagementSchema: {
+    queryString: z.ZodOptional<z.ZodString>;
+    includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodEnum<[string, ...string[]]>;
+    }, "strip", z.ZodTypeAny, {
+        key?: string;
+        value?: string;
+    }, {
+        key?: string;
+        value?: string;
+    }>, "many">>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodEnum<["CREATE", "UPDATE", "REMOVE", "GET", "LIST", "COUNT"]>;
+    localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+    entity: z.ZodOptional<z.ZodObject<{
+        isoCode: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+        contractAddress: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        isActive?: boolean;
+        isoCode?: string;
+        defaultCurrencyCode?: string;
+        contractAddress?: string;
+        decimals?: number;
+    }, {
+        isActive?: boolean;
+        isoCode?: string;
+        defaultCurrencyCode?: string;
+        contractAddress?: string;
+        decimals?: number;
+    }>>;
+    entityId: z.ZodOptional<z.ZodString>;
+};
+export declare const LocalizationManagementZodSchema: z.ZodObject<{
+    queryString: z.ZodOptional<z.ZodString>;
+    includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodEnum<[string, ...string[]]>;
+    }, "strip", z.ZodTypeAny, {
+        key?: string;
+        value?: string;
+    }, {
+        key?: string;
+        value?: string;
+    }>, "many">>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodEnum<["CREATE", "UPDATE", "REMOVE", "GET", "LIST", "COUNT"]>;
+    localizationType: z.ZodEnum<["COUNTRY", "CURRENCY", "LANGUAGE"]>;
+    entity: z.ZodOptional<z.ZodObject<{
+        isoCode: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+        contractAddress: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        isActive?: boolean;
+        isoCode?: string;
+        defaultCurrencyCode?: string;
+        contractAddress?: string;
+        decimals?: number;
+    }, {
+        isActive?: boolean;
+        isoCode?: string;
+        defaultCurrencyCode?: string;
+        contractAddress?: string;
+        decimals?: number;
+    }>>;
+    entityId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sort?: {
+        key?: string;
+        value?: string;
+    }[];
+    includeInactive?: boolean;
+    queryString?: string;
+    limit?: number;
+    offset?: number;
+    action?: "GET" | "CREATE" | "UPDATE" | "REMOVE" | "LIST" | "COUNT";
+    localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+    entity?: {
+        isActive?: boolean;
+        isoCode?: string;
+        defaultCurrencyCode?: string;
+        contractAddress?: string;
+        decimals?: number;
+    };
+    entityId?: string;
+}, {
+    sort?: {
+        key?: string;
+        value?: string;
+    }[];
+    includeInactive?: boolean;
+    queryString?: string;
+    limit?: number;
+    offset?: number;
+    action?: "GET" | "CREATE" | "UPDATE" | "REMOVE" | "LIST" | "COUNT";
+    localizationType?: "COUNTRY" | "CURRENCY" | "LANGUAGE";
+    entity?: {
+        isActive?: boolean;
+        isoCode?: string;
+        defaultCurrencyCode?: string;
+        contractAddress?: string;
+        decimals?: number;
+    };
+    entityId?: string;
+}>;
+export type LocalizationManagementParams = z.infer<typeof LocalizationManagementZodSchema>;
+export type ActionName = keyof typeof actionValidators;
+export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;
+export type Handler<T extends ActionName> = (localizationModule: any, params: Params<T>) => Promise<unknown>;
+//# sourceMappingURL=schemas.d.ts.map

package/lib/mcp/tools/localization/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tools/localization/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD,eAAO,MAAM,iBAAiB,EAAiC,CAC7D,MAAM,OAAO,aAAa,EAC1B,GAAG,CAAC,MAAM,OAAO,aAAa,CAAC,EAAE,CAClC,CAAC;AAEF,eAAO,MAAM,oBAAoB,gDAG/B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;EAmCnC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCnB,CAAC;AAEX,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBxC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAyC,CAAC;AACtF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAE3F,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,gBAAgB,CAAC;AACvD,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjF,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,UAAU,IAAI,CAC1C,kBAAkB,EAAE,GAAG,EACvB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KACd,OAAO,CAAC,OAAO,CAAC,CAAC"}

package/lib/mcp/tools/localization/schemas.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { SortDirection } from '@unchainedshop/utils';
+import { PaginationSchema, SortingSchema, SearchSchema } from '../../utils/sharedSchemas.js';
+export const sortDirectionKeys = Object.keys(SortDirection);
+export const LocalizationTypeEnum = z.enum(['COUNTRY', 'CURRENCY', 'LANGUAGE'], {
+    description: 'Type of localization entity - COUNTRY for geographic regions (US, DE, CH), CURRENCY for monetary units (USD, EUR, CHF), LANGUAGE for locale support (en, de, fr)',
+});
+export const LocalizationEntitySchema = z.object({
+    isoCode: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('ISO identifier: Countries need 2-letter codes (US, DE), Currencies need 3-letter codes (USD, EUR), Languages accept 2-10 characters (en, de-CH). isoCode is required for both CREATE and UPDATE operations'),
+    isActive: z
+        .boolean()
+        .optional()
+        .describe('Active status for the entity - used for all localization types (COUNTRY, CURRENCY, LANGUAGE)'),
+    defaultCurrencyCode: z
+        .string()
+        .optional()
+        .describe('Default currency code for the country - only used when localizationType is COUNTRY, ignored otherwise'),
+    contractAddress: z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid 42-character blockchain address starting with 0x')
+        .optional()
+        .describe('Blockchain contract address for tokenized currencies - only used when localizationType is CURRENCY, ignored otherwise'),
+    decimals: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Decimal precision for currency calculations - only used when localizationType is CURRENCY (2 for traditional currencies like USD, 18 for crypto tokens), ignored otherwise'),
+});
+export const actionValidators = {
+    CREATE: z.object({
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        entity: LocalizationEntitySchema.extend({
+            isoCode: z
+                .string()
+                .min(1)
+                .describe('ISO identifier: Countries need 2-letter codes (US, DE), Currencies need 3-letter codes (USD, EUR), Languages accept 2-10 characters (en, de-CH)'),
+        }).describe('Entity configuration data (required for CREATE)'),
+    }),
+    UPDATE: z.object({
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on, wj'),
+        entityId: z.string().min(1).describe('Database ID of the specific entity instance'),
+        entity: LocalizationEntitySchema.describe('Entity data to update'),
+    }),
+    REMOVE: z.object({
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        entityId: z.string().min(1).describe('Database ID of the specific entity instance'),
+    }),
+    GET: z.object({
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        entityId: z.string().min(1).describe('Database ID of the specific entity instance'),
+    }),
+    LIST: z.object({
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        ...PaginationSchema,
+        ...SortingSchema,
+        ...SearchSchema,
+    }),
+    COUNT: z.object({
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        ...SearchSchema,
+    }),
+};
+export const LocalizationManagementSchema = {
+    action: z
+        .enum(['CREATE', 'UPDATE', 'REMOVE', 'GET', 'LIST', 'COUNT'])
+        .describe('Localization action: CREATE (new entity), UPDATE (modify existing), REMOVE (soft delete), GET (retrieve single), LIST (find multiple with pagination), COUNT (get totals for analytics)'),
+    localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+    entity: LocalizationEntitySchema.optional().describe('Entity configuration data (required for CREATE, optional for UPDATE)'),
+    entityId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Database ID of the specific entity instance (required for UPDATE, REMOVE, GET actions)'),
+    ...PaginationSchema,
+    ...SortingSchema,
+    ...SearchSchema,
+};
+export const LocalizationManagementZodSchema = z.object(LocalizationManagementSchema);
+//# sourceMappingURL=schemas.js.map

package/lib/mcp/tools/localization/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../src/mcp/tools/localization/schemas.ts"],"names":[],"mappings":"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"}

package/lib/mcp/tools/localization/types.d.ts

@@ -0,0 +1,35 @@
+export type LocalizationType = 'COUNTRY' | 'CURRENCY' | 'LANGUAGE';
+export interface LocalizationModuleConfig {
+    module: any;
+    NotFoundError: any;
+    entityName: string;
+    idField: string;
+    existsMethod: any;
+    findMethod: any;
+    findMultipleMethod: any;
+}
+export interface LocalizationEntity {
+    isoCode: string;
+    contractAddress?: string;
+    decimals?: number;
+}
+export interface LocalizationUpdateEntity {
+    isoCode?: string;
+    contractAddress?: string;
+    decimals?: number;
+}
+export interface LocalizationListOptions {
+    limit?: number;
+    offset?: number;
+    includeInactive?: boolean;
+    queryString?: string;
+    sort?: {
+        key: string;
+        value: 'ASC' | 'DESC';
+    }[];
+}
+export interface LocalizationCountOptions {
+    includeInactive?: boolean;
+    queryString?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/mcp/tools/localization/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tools/localization/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AAEnE,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,GAAG,CAAC;IACZ,aAAa,EAAE,GAAG,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,GAAG,CAAC;IAClB,UAAU,EAAE,GAAG,CAAC;IAChB,kBAAkB,EAAE,GAAG,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;KACvB,EAAE,CAAC;CACL;AAED,MAAM,WAAW,wBAAwB;IACvC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/lib/mcp/tools/localization/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/mcp/tools/localization/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/mcp/tools/localization/types.ts"],"names":[],"mappings":""}

package/lib/mcp/tools/order/handlers/confirmOrder.d.ts

@@ -0,0 +1,118 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+export default function confirmOrder(context: Context, params: Params<'CONFIRM_ORDER'>): Promise<{
+    order: {
+        total: any;
+        discounts: import("@unchainedshop/core-orders").OrderDiscount[];
+        enrollments: {
+            _id?: string;
+            billingAddress: import("@unchainedshop/mongodb").Address;
+            configuration?: {
+                key: string;
+                value: string;
+            }[];
+            contact: import("@unchainedshop/mongodb").Contact;
+            context?: any;
+            countryCode?: string;
+            currencyCode?: string;
+            delivery: {
+                deliveryProviderId?: string;
+                context?: any;
+            };
+            enrollmentNumber?: string;
+            orderIdForFirstPeriod?: string;
+            expires?: Date;
+            meta?: any;
+            payment: {
+                paymentProviderId?: string;
+                context?: any;
+            };
+            periods: import("@unchainedshop/core-enrollments").EnrollmentPeriod[];
+            productId: string;
+            quantity?: number;
+            status: import("@unchainedshop/core-enrollments").EnrollmentStatus;
+            userId: string;
+        } & import("@unchainedshop/mongodb").LogFields & import("@unchainedshop/mongodb").TimestampFields;
+        currency: {
+            _id?: string;
+            isoCode: string;
+            isActive: boolean;
+            contractAddress?: string;
+            decimals?: number;
+        } & import("@unchainedshop/mongodb").TimestampFields;
+        supportedDeliveryProviders: import("@unchainedshop/core-delivery").DeliveryProvider[];
+        supportedPaymentProviders: import("@unchainedshop/core-payment").PaymentProvider[];
+        country: {
+            _id?: string;
+            isoCode: string;
+            isActive?: boolean;
+            defaultCurrencyCode?: string;
+        } & import("@unchainedshop/mongodb").TimestampFields;
+        user: import("@unchainedshop/core-users").User;
+        status: string;
+        items: {
+            _id?: string;
+            calculation: any[];
+            configuration: {
+                key: string;
+                value: string;
+            }[];
+            context?: any;
+            orderId: string;
+            originalProductId: string;
+            quantity: number;
+            quotationId?: string;
+            scheduling: any[];
+            created?: Date;
+            updated?: Date;
+            deleted?: Date;
+            texts: import("@unchainedshop/core-products").ProductText;
+            media: any[];
+            assignments: any[];
+            variations: any[];
+            bundleItems: any[];
+            pricing: any;
+            reviews: import("@unchainedshop/core-products").ProductReview[];
+            commerce?: import("@unchainedshop/core-products").ProductCommerce;
+            meta?: any;
+            plan: import("@unchainedshop/core-products").ProductPlan;
+            proxy: import("@unchainedshop/core-products").ProductProxy;
+            published?: Date;
+            sequence: number;
+            slugs: string[];
+            status?: string;
+            supply: import("@unchainedshop/core-products").ProductSupply;
+            tags?: string[];
+            type: string;
+            warehousing?: import("@unchainedshop/core-products").ProductWarehousing;
+            tokenization?: import("@unchainedshop/core-products").ProductTokenization;
+        }[];
+        payment: import("@unchainedshop/core-orders").OrderPayment;
+        delivery: import("@unchainedshop/core-orders").OrderDelivery;
+        _id?: string;
+        billingAddress?: import("@unchainedshop/mongodb").Address;
+        calculation: any[];
+        confirmed?: Date;
+        rejected?: Date;
+        contact?: import("@unchainedshop/mongodb").Contact;
+        context?: any;
+        countryCode: string;
+        currencyCode: string;
+        deliveryId?: string;
+        fullfilled?: Date;
+        ordered?: Date;
+        orderNumber?: string;
+        originEnrollmentId?: string;
+        paymentId?: string;
+        userId: string;
+        log: {
+            date: Date;
+            status?: string;
+            info: string;
+        }[];
+        created?: Date;
+        updated?: Date;
+        deleted?: Date;
+    };
+}>;
+//# sourceMappingURL=confirmOrder.d.ts.map

package/lib/mcp/tools/order/handlers/confirmOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirmOrder.d.ts","sourceRoot":"","sources":["../../../../../src/mcp/tools/order/handlers/confirmOrder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGjD,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,wBAA8B,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,eAAe,CAAC;;;;;;;;;;;;;;;;kCAUlE,CAAC;uBAAyB,CAAC;;;;;;;iCAEgF,CAAC;uBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAL7I,CAAC;;;;;;;GAInB"}

package/lib/mcp/tools/order/handlers/confirmOrder.js

@@ -0,0 +1,16 @@
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { OrderNotFoundError, OrderWrongStatusError } from '../../../../errors.js';
+import { getNormalizedOrderDetails } from '../../../utils/getNormalizedOrderDetails.js';
+export default async function confirmOrder(context, params) {
+    const { services, modules } = context;
+    const { orderId, ...transactionContext } = params;
+    const order = await modules.orders.findOrder({ orderId });
+    if (!order)
+        throw new OrderNotFoundError({ orderId });
+    if (order.status !== OrderStatus.PENDING) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    await services.orders.confirmOrder(order, transactionContext);
+    return { order: await getNormalizedOrderDetails({ orderId }, context) };
+}
+//# sourceMappingURL=confirmOrder.js.map

package/lib/mcp/tools/order/handlers/confirmOrder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirmOrder.js","sourceRoot":"","sources":["../../../../../src/mcp/tools/order/handlers/confirmOrder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAGxF,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,YAAY,CAAC,OAAgB,EAAE,MAA+B;IAC1F,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IACtC,MAAM,EAAE,OAAO,EAAE,GAAG,kBAAkB,EAAE,GAAG,MAAM,CAAC;IAElD,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1D,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,kBAAkB,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IACtD,IAAI,KAAK,CAAC,MAAM,KAAK,WAAW,CAAC,OAAO,EAAE,CAAC;QACzC,MAAM,IAAI,qBAAqB,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5D,CAAC;IACD,MAAM,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;IAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC;AAC1E,CAAC"}