@unifiedcommerce/core 0.3.4 → 0.4.1

package/dist/interfaces/mcp/tools/webhooks.d.ts

@@ -2,8 +2,8 @@ import { z } from "zod";
 import type { ToolDefinition } from "./registry.js";
 export declare const webhooksManage: ToolDefinition<z.ZodObject<{
     action: z.ZodEnum<{
-        delete: "delete";
         create: "create";
+        delete: "delete";
         list: "list";
     }>;
     url: z.ZodOptional<z.ZodString>;

package/dist/interfaces/rest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/interfaces/rest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAezC,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,gCAsD9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/interfaces/rest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAgBzC,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,gCAmE9C"}

package/dist/interfaces/rest/index.js

@@ -1,5 +1,5 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { swaggerUI } from "@hono/swagger-ui";
+import { Scalar } from "@scalar/hono-api-reference";
 import { sql } from "drizzle-orm";
 import { catalogRoutes } from "./routes/catalog.js";
 import { inventoryRoutes } from "./routes/inventory.js";
@@ -14,6 +14,7 @@ import { promotionRoutes } from "./routes/promotions.js";
 import { searchRoutes } from "./routes/search.js";
 import { auditRoutes } from "./routes/audit.js";
 import { adminJobRoutes } from "./routes/admin-jobs.js";
+import { customerRoutes } from "./routes/customers.js";
 export function createRestRoutes(kernel) {
     const router = new OpenAPIHono({
         // Standardize Zod validation error responses across all routes
@@ -57,12 +58,22 @@ export function createRestRoutes(kernel) {
     router.route("/pricing", pricingRoutes(kernel));
     router.route("/promotions", promotionRoutes(kernel));
     router.route("/search", searchRoutes(kernel));
+    router.route("/customers", customerRoutes(kernel));
     router.route("/audit", auditRoutes(kernel));
     router.route("/admin", adminJobRoutes(kernel));
-    // Swagger UI — disabled in production unless config.exposeOpenApiSpec is true
+    // API Reference (Scalar) — disabled in production unless config.exposeOpenApiSpec is true
     const exposeSpec = kernel.config.exposeOpenApiSpec ?? (process.env.NODE_ENV !== "production");
     if (exposeSpec) {
-        router.get("/reference", swaggerUI({ url: "/api/doc" }));
+        router.get("/reference", Scalar({
+            url: "/api/doc-ext",
+            theme: "kepler",
+            layout: "modern",
+            darkMode: true,
+            hideModels: true,
+            tagsSorter: "alpha",
+            defaultHttpClient: { targetKey: "js", clientKey: "fetch" },
+            metaData: { title: "UnifiedCommerce API Reference" },
+        }));
     }
     return router;
 }

package/dist/interfaces/rest/routes/customers.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import type { Kernel } from "../../../runtime/kernel.js";
+import { type AppEnv } from "../utils.js";
+export declare function customerRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=customers.d.ts.map

package/dist/interfaces/rest/routes/customers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customers.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/customers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAQzD,OAAO,EAAE,KAAK,MAAM,EAAyD,MAAM,aAAa,CAAC;AAEjG,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,gCAkF5C"}

package/dist/interfaces/rest/routes/customers.js

@@ -0,0 +1,74 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { listCustomersRoute, getCustomerRoute, updateCustomerRoute, getCustomerOrdersRoute, getCustomerAddressesRoute, } from "../schemas/customers.js";
+import { mapErrorToResponse, mapErrorToStatus, parsePagination } from "../utils.js";
+export function customerRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listCustomersRoute, async (c) => {
+        const actor = c.get("actor");
+        const { page, limit } = parsePagination(c.req.query());
+        const result = await kernel.services.customers.list(actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        const all = result.value;
+        const total = all.length;
+        const start = (page - 1) * limit;
+        const paged = all.slice(start, start + limit);
+        return c.json({
+            data: paged,
+            meta: {
+                pagination: { page, limit, total, totalPages: Math.ceil(total / limit) },
+            },
+        });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getCustomerRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const actor = c.get("actor");
+        const result = await kernel.services.customers.getById(id, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateCustomerRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const body = c.req.valid("json");
+        const actor = c.get("actor");
+        // Strip undefined values — exactOptionalPropertyTypes requires omission, not undefined
+        const updates = {};
+        for (const [k, v] of Object.entries(body)) {
+            if (v !== undefined)
+                updates[k] = v;
+        }
+        const result = await kernel.services.customers.update(id, updates, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getCustomerOrdersRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const actor = c.get("actor");
+        const { page, limit } = parsePagination(c.req.query());
+        const status = c.req.query("status") || undefined;
+        const result = await kernel.services.orders.listByCustomer(id, { page, limit, ...(status ? { status } : {}) }, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value.items, meta: { pagination: result.value.pagination } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getCustomerAddressesRoute, async (c) => {
+        const { id } = c.req.valid("param");
+        const actor = c.get("actor");
+        // Get customer first, then use their userId for address lookup
+        const customerResult = await kernel.services.customers.getById(id, actor);
+        if (!customerResult.ok)
+            return c.json(mapErrorToResponse(customerResult.error), mapErrorToStatus(customerResult.error));
+        const addressResult = await kernel.services.customers.getAddresses(customerResult.value.userId, actor);
+        if (!addressResult.ok)
+            return c.json(mapErrorToResponse(addressResult.error), mapErrorToStatus(addressResult.error));
+        return c.json({ data: addressResult.value });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/inventory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/inventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AASzD,OAAO,EAAE,KAAK,MAAM,EAAwC,MAAM,aAAa,CAAC;AAEhF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,gCAyD7C"}
+{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/inventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAUzD,OAAO,EAAE,KAAK,MAAM,EAAwC,MAAM,aAAa,CAAC;AAEhF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,gCAyE7C"}

package/dist/interfaces/rest/routes/inventory.js

@@ -1,9 +1,22 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { inventoryAdjustRoute, inventoryReserveRoute, inventoryReleaseRoute, createWarehouseRoute, inventoryCheckRoute, listWarehousesRoute, } from "../schemas/inventory.js";
+import { inventoryAdjustRoute, inventoryReserveRoute, inventoryReleaseRoute, createWarehouseRoute, inventoryCheckRoute, listWarehousesRoute, listInventoryLevelsRoute, } from "../schemas/inventory.js";
 import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
 export function inventoryRoutes(kernel) {
     const router = new OpenAPIHono();
     // @ts-expect-error -- openapi handler union return type
+    router.openapi(listInventoryLevelsRoute, async (c) => {
+        const actor = c.get("actor");
+        const warehouseId = c.req.query("warehouseId");
+        const entityId = c.req.query("entityId");
+        const result = await kernel.services.inventory.listLevels({
+            ...(warehouseId ? { warehouseId } : {}),
+            ...(entityId ? { entityId } : {}),
+        }, actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi handler union return type
     router.openapi(inventoryCheckRoute, async (c) => {
         const entityIds = (c.req.query("entityIds") ?? "")
             .split(",")

package/dist/interfaces/rest/schemas/customers.d.ts

@@ -0,0 +1,422 @@
+import { z } from "@hono/zod-openapi";
+export declare const listCustomersRoute: {
+    method: "get";
+    path: "/";
+    tags: string[];
+    summary: string;
+    request: {
+        query: z.ZodObject<{
+            page: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        meta: z.ZodObject<{
+                            pagination: z.ZodObject<{
+                                page: z.ZodNumber;
+                                limit: z.ZodNumber;
+                                total: z.ZodNumber;
+                                totalPages: z.ZodNumber;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/";
+};
+export declare const getCustomerRoute: {
+    method: "get";
+    path: "/{id}";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/:id";
+};
+export declare const updateCustomerRoute: {
+    method: "patch";
+    path: "/{id}";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        firstName: z.ZodOptional<z.ZodString>;
+                        lastName: z.ZodOptional<z.ZodString>;
+                        email: z.ZodOptional<z.ZodString>;
+                        phone: z.ZodOptional<z.ZodString>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/:id";
+};
+export declare const getCustomerOrdersRoute: {
+    method: "get";
+    path: "/{id}/orders";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            status: z.ZodOptional<z.ZodString>;
+            page: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        meta: z.ZodObject<{
+                            pagination: z.ZodObject<{
+                                page: z.ZodNumber;
+                                limit: z.ZodNumber;
+                                total: z.ZodNumber;
+                                totalPages: z.ZodNumber;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/:id/orders";
+};
+export declare const getCustomerAddressesRoute: {
+    method: "get";
+    path: "/{id}/addresses";
+    tags: string[];
+    summary: string;
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        400: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Business logic error.";
+        };
+        401: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Authentication required.";
+        };
+        403: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Insufficient permissions.";
+        };
+        404: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Resource not found.";
+        };
+        422: {
+            readonly content: {
+                readonly "application/json": {
+                    readonly schema: z.ZodObject<{
+                        error: z.ZodObject<{
+                            code: z.ZodString;
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            readonly description: "Validation error.";
+        };
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/:id/addresses";
+};
+//# sourceMappingURL=customers.d.ts.map

package/dist/interfaces/rest/schemas/customers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customers.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/schemas/customers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAGnD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC9B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCjC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBpC,CAAC"}