@unifiedcommerce/core 0.4.4 → 0.5.0

package/dist/interfaces/rest/routes/admin-jobs.js

@@ -0,0 +1,48 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { eq, and, desc } from "drizzle-orm";
+import { commerceJobs } from "../../../kernel/jobs/schema.js";
+import { listFailedJobsRoute, retryJobRoute } from "../schemas/admin-jobs.js";
+import { requirePerm } from "../utils.js";
+import { resolveOrgId } from "../../../auth/org.js";
+export function adminJobRoutes(kernel) {
+    const router = new OpenAPIHono();
+    const db = kernel.database.db;
+    router.use("/jobs/failed", requirePerm("jobs:admin"));
+    router.openapi(listFailedJobsRoute, async (c) => {
+        const actor = c.get("actor");
+        const orgId = resolveOrgId(actor);
+        const limit = Math.min(Number(c.req.query("limit") ?? "50"), 100);
+        const conditions = [eq(commerceJobs.status, "failed")];
+        // Scope to org unless wildcard admin
+        if (!actor?.permissions?.includes("*:*")) {
+            conditions.push(eq(commerceJobs.organizationId, orgId));
+        }
+        const failed = await db.select()
+            .from(commerceJobs)
+            .where(and(...conditions))
+            .orderBy(desc(commerceJobs.completedAt))
+            .limit(limit);
+        return c.json({ data: failed });
+    });
+    router.use("/jobs/:id/retry", requirePerm("jobs:admin"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(retryJobRoute, async (c) => {
+        const actor = c.get("actor");
+        const orgId = resolveOrgId(actor);
+        const id = c.req.param("id");
+        const conditions = [eq(commerceJobs.id, id)];
+        // Scope to org unless wildcard admin
+        if (!actor?.permissions?.includes("*:*")) {
+            conditions.push(eq(commerceJobs.organizationId, orgId));
+        }
+        const result = await db.update(commerceJobs)
+            .set({ status: "pending", attempts: 0, error: null, waitUntil: null, updatedAt: new Date() })
+            .where(and(...conditions))
+            .returning();
+        if (result.length === 0) {
+            return c.json({ error: { code: "NOT_FOUND", message: "Job not found." } }, 404);
+        }
+        return c.json({ data: { retried: true } });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/audit.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 auditRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=audit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAe,MAAM,aAAa,CAAC;AAGvD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,gCA2CzC"}

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

@@ -0,0 +1,43 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { listAuditRoute, listEntityAuditRoute } from "../schemas/audit.js";
+import { requirePerm } from "../utils.js";
+import { resolveOrgId } from "../../../auth/org.js";
+export function auditRoutes(kernel) {
+    const router = new OpenAPIHono();
+    /**
+     * GET /api/audit
+     * List audit entries with optional filters.
+     */
+    router.use("/", requirePerm("audit:read"));
+    router.openapi(listAuditRoute, async (c) => {
+        const actor = c.get("actor");
+        const orgId = resolveOrgId(actor);
+        const entries = await kernel.services.audit.list({
+            organizationId: orgId,
+            entityType: c.req.query("entityType"),
+            entityId: c.req.query("entityId"),
+            event: c.req.query("event"),
+            actorId: c.req.query("actorId"),
+            from: c.req.query("from") ? new Date(c.req.query("from")) : undefined,
+            to: c.req.query("to") ? new Date(c.req.query("to")) : undefined,
+            limit: c.req.query("limit") ? Number(c.req.query("limit")) : 50,
+        });
+        return c.json({ data: entries });
+    });
+    /**
+     * GET /api/audit/:entityType/:entityId
+     * List audit history for a specific entity.
+     */
+    router.use("/:entityType/:entityId", requirePerm("audit:read"));
+    router.openapi(listEntityAuditRoute, async (c) => {
+        const actor = c.get("actor");
+        const orgId = resolveOrgId(actor);
+        const entries = await kernel.services.audit.listForEntity({
+            organizationId: orgId,
+            entityType: c.req.param("entityType"),
+            entityId: c.req.param("entityId"),
+        });
+        return c.json({ data: entries });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/carts.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 cartRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=carts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"carts.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/carts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAGzD,OAAO,EAAE,KAAK,MAAM,EAAwC,MAAM,aAAa,CAAC;AAEhF,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,gCAkFxC"}

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

@@ -0,0 +1,55 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createCartRoute, addCartItemRoute, updateCartItemQuantityRoute, getCartRoute, removeCartItemRoute } from "../schemas/carts.js";
+import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
+export function cartRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi() enforces strict response typing but our handler
+    // returns union responses (201 | 400 | 422). The route definition documents the
+    // contract; the handler returns dynamic status.
+    router.openapi(createCartRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.cart.create(c.req.valid("json"), actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getCartRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.cart.getById(c.req.param("id"), actor);
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    // @ts-expect-error -- openapi() enforces strict response typing but our handler
+    // returns union responses (201 | 400 | 422). The route definition documents the
+    // contract; the handler returns dynamic status.
+    router.openapi(addCartItemRoute, async (c) => {
+        const result = await kernel.services.cart.addItem({ ...c.req.valid("json"), cartId: c.req.param("id") }, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi() enforces strict response typing but our handler
+    // returns union responses (200 | 400 | 422). The route definition documents the
+    // contract; the handler returns dynamic status.
+    router.openapi(updateCartItemQuantityRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.cart.updateQuantity({
+            cartId: c.req.param("id"),
+            itemId: c.req.param("itemId"),
+            quantity: body.quantity,
+        }, c.get("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(removeCartItemRoute, async (c) => {
+        const result = await kernel.services.cart.removeItem(c.req.param("id"), c.req.param("itemId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { deleted: true } });
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/catalog.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 catalogRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=catalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AA4CzD,OAAO,EACL,KAAK,MAAM,EAMZ,MAAM,aAAa,CAAC;AAErB,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCAsb3C"}

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

@@ -0,0 +1,256 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { listEntitiesRoute, getEntityRoute, getEntityAttributesRoute, listCategoriesRoute, listBrandsRoute, deleteEntityRoute, deleteCategoryRoute, deleteBrandRoute, removeEntityFromCategoryRoute, removeEntityFromBrandRoute, publishEntityRoute, archiveEntityRoute, discontinueEntityRoute, addEntityToCategoryRoute, addEntityToBrandRoute, createEntityRoute, updateEntityRoute, setEntityAttributesRoute, createCategoryRoute, updateCategoryRoute, createBrandRoute, updateBrandRoute, createOptionTypeRoute, createOptionValueRoute, createVariantRoute, generateVariantsRoute, } from "../schemas/catalog.js";
+import { mapErrorToResponse, mapErrorToStatus, parseInclude, parsePagination, parseSort, } from "../utils.js";
+export function catalogRoutes(kernel) {
+    const router = new OpenAPIHono();
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listEntitiesRoute, async (c) => {
+        const include = parseInclude(c.req.query("include"));
+        const pagination = parsePagination(c.req.query());
+        const filter = {};
+        const type = c.req.query("type");
+        const status = c.req.query("status");
+        const category = c.req.query("category");
+        const brand = c.req.query("brand");
+        if (type)
+            filter.type = type;
+        if (status)
+            filter.status = status;
+        if (category)
+            filter.category = category;
+        if (brand)
+            filter.brand = brand;
+        const payload = {
+            filter,
+            pagination,
+        };
+        const sort = parseSort(c.req.query("sort"));
+        if (sort)
+            payload.sort = sort;
+        const result = await kernel.services.catalog.list(payload, c.get("actor"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        let withIncludes = result.value.items;
+        if (include.size > 0) {
+            const includeOptions = {
+                includeAttributes: include.has("attributes"),
+                includeVariants: include.has("variants"),
+                includeOptionTypes: include.has("optionTypes"),
+                includeCategories: include.has("categories"),
+                includeBrands: include.has("brands"),
+                includeMedia: include.has("media"),
+                includeInventory: include.has("inventory"),
+                includePricing: include.has("pricing"),
+            };
+            const hydrated = await Promise.all(result.value.items.map(async (item) => {
+                const full = await kernel.services.catalog.getById(item.id, includeOptions);
+                return full.ok ? full.value : item;
+            }));
+            withIncludes = hydrated;
+        }
+        return c.json({
+            data: withIncludes,
+            meta: {
+                pagination: result.value.pagination,
+            },
+        });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getEntityRoute, async (c) => {
+        const idOrSlug = c.req.param("idOrSlug");
+        const include = parseInclude(c.req.query("include"));
+        const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idOrSlug);
+        const includeOptions = {
+            includeAttributes: include.has("attributes"),
+            includeVariants: include.has("variants"),
+            includeOptionTypes: include.has("optionTypes"),
+            includeCategories: include.has("categories"),
+            includeBrands: include.has("brands"),
+            includeMedia: include.has("media"),
+            includeInventory: include.has("inventory"),
+            includePricing: include.has("pricing"),
+        };
+        const actor = c.get("actor");
+        const result = isUUID
+            ? await kernel.services.catalog.getById(idOrSlug, includeOptions, actor)
+            : await kernel.services.catalog.getBySlug(idOrSlug, includeOptions, 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(createEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.create(c.req.valid("json"), c.get("actor"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.update(c.req.param("id"), c.req.valid("json"), c.get("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(deleteEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.delete(c.req.param("id"), c.get("actor"));
+        if (!result.ok) {
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        }
+        return c.json({ data: { deleted: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(publishEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.publish(c.req.param("id"), c.get("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(archiveEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.archive(c.req.param("id"), c.get("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(discontinueEntityRoute, async (c) => {
+        const result = await kernel.services.catalog.discontinue(c.req.param("id"), c.get("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(setEntityAttributesRoute, async (c) => {
+        const result = await kernel.services.catalog.setAttributes(c.req.param("id"), c.req.param("locale"), c.req.valid("json"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { updated: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getEntityAttributesRoute, async (c) => {
+        const result = await kernel.services.catalog.getAttributes(c.req.param("id"), c.req.param("locale"));
+        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(listCategoriesRoute, async (c) => {
+        const result = await kernel.services.catalog.listCategories({ actor: c.get("actor"), tx: null, requestId: "" });
+        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(createCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.createCategory(c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.updateCategory(c.req.param("categoryId"), c.req.valid("json"), c.get("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(deleteCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.deleteCategory(c.req.param("categoryId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { deleted: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(addEntityToCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.addToCategory(c.req.param("id"), c.req.param("categoryId"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { linked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(removeEntityFromCategoryRoute, async (c) => {
+        const result = await kernel.services.catalog.removeFromCategory(c.req.param("id"), c.req.param("categoryId"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { unlinked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listBrandsRoute, async (c) => {
+        const result = await kernel.services.catalog.listBrands({ actor: c.get("actor"), tx: null, requestId: "" });
+        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(createBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.createBrand(c.req.valid("json"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.updateBrand(c.req.param("brandId"), c.req.valid("json"), c.get("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(deleteBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.deleteBrand(c.req.param("brandId"), c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { deleted: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(addEntityToBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.addToBrand(c.req.param("id"), c.req.param("brandId"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { linked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(removeEntityFromBrandRoute, async (c) => {
+        const result = await kernel.services.catalog.removeFromBrand(c.req.param("id"), c.req.param("brandId"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: { unlinked: true } });
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOptionTypeRoute, async (c) => {
+        const result = await kernel.services.catalog.createOptionType({ ...c.req.valid("json"), entityId: c.req.param("id") }, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOptionValueRoute, async (c) => {
+        const result = await kernel.services.catalog.createOptionValue({ ...c.req.valid("json"), optionTypeId: c.req.param("optionTypeId") }, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createVariantRoute, async (c) => {
+        const result = await kernel.services.catalog.createVariant({ ...c.req.valid("json"), entityId: c.req.param("id") }, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(generateVariantsRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.catalog.generateVariants(c.req.param("id"), body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value }, 201);
+    });
+    return router;
+}

package/dist/interfaces/rest/routes/checkout.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 checkoutRoutes(kernel: Kernel): OpenAPIHono<AppEnv, {}, "/">;
+//# sourceMappingURL=checkout.d.ts.map

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

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