@porulle/core 0.7.0 → 0.9.0

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

@@ -1,6 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import { changeOrderStatusRoute, listOrdersRoute, orderLookupRoute, getOrderRoute, getOrderFulfillmentsRoute, createOrderRoute, refundOrderRoute, captureOrderRoute } from "../schemas/orders.js";
+import { changeOrderStatusRoute, listOrdersRoute, orderLookupRoute, getOrderRoute, getOrderFulfillmentsRoute, createOrderRoute, refundOrderRoute, captureOrderRoute, createOrderFulfillmentRoute, addOrderLineItemRoute, updateOrderLineItemRoute, removeOrderLineItemRoute, refundOrderLinesRoute, undoOrderRefundRoute, listOrderRefundsRoute, refundCapStatusRoute, createOrderNoteRoute, listOrderNotesRoute, deleteOrderNoteRoute, orderTimelineRoute } from "../schemas/orders.js";
 import { isUUID, mapErrorToResponse, mapErrorToStatus, parsePagination } from "../utils.js";
+import { assertPermission } from "../../../auth/permissions.js";
 export function orderRoutes(kernel) {
     const router = new OpenAPIHono();
     // @ts-expect-error -- openapi handler union return type
@@ -55,6 +56,12 @@ export function orderRoutes(kernel) {
     });
     // @ts-expect-error -- openapi handler union return type
     router.openapi(createOrderRoute, async (c) => {
+        try {
+            assertPermission(c.get("actor"), "orders:manage");
+        }
+        catch (error) {
+            return c.json(mapErrorToResponse(error), mapErrorToStatus(error));
+        }
         const body = c.req.valid("json");
         const result = await kernel.services.orders.create(body, c.get("actor"));
         if (!result.ok)
@@ -69,6 +76,66 @@ export function orderRoutes(kernel) {
             return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
         return c.json({ data: result.value });
     });
+    // ── Notes + activity timeline (issue #56) ──────────────────────────
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOrderNoteRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.addNote(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);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listOrderNotesRoute, async (c) => {
+        const result = await kernel.services.orders.listNotes(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(deleteOrderNoteRoute, async (c) => {
+        const result = await kernel.services.orders.deleteNote(c.req.param("id"), c.req.param("noteId"), 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(orderTimelineRoute, async (c) => {
+        const result = await kernel.services.orders.timeline(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 });
+    });
+    // ── Line-level refunds (issue #52) ─────────────────────────────────
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(refundCapStatusRoute, async (c) => {
+        const result = await kernel.services.orders.refundCapStatus(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(refundOrderLinesRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.refundLines(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);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(undoOrderRefundRoute, async (c) => {
+        const result = await kernel.services.orders.undoRefund(c.req.param("id"), c.req.param("refundId"), 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(listOrderRefundsRoute, async (c) => {
+        const result = await kernel.services.orders.listRefunds(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(captureOrderRoute, async (c) => {
         const body = c.req.valid("json");
@@ -77,6 +144,35 @@ export function orderRoutes(kernel) {
             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(addOrderLineItemRoute, async (c) => {
+        try {
+            assertPermission(c.get("actor"), "orders:manage");
+        }
+        catch (error) {
+            return c.json(mapErrorToResponse(error), mapErrorToStatus(error));
+        }
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.addLineItem(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);
+    });
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(updateOrderLineItemRoute, async (c) => {
+        const body = c.req.valid("json");
+        const result = await kernel.services.orders.updateOrderLineItem(c.req.param("id"), c.req.param("lineItemId"), body, 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(removeOrderLineItemRoute, async (c) => {
+        const result = await kernel.services.orders.removeLineItem(c.req.param("id"), c.req.param("lineItemId"), 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() enforces strict response typing but our handler
     // returns union responses (200 | 400 | 404). The route definition documents the
     // contract; the handler returns dynamic status.
@@ -92,6 +188,20 @@ export function orderRoutes(kernel) {
         return c.json({ data: result.value });
     });
     // @ts-expect-error -- openapi handler union return type
+    router.openapi(createOrderFulfillmentRoute, async (c) => {
+        const actor = c.get("actor");
+        const orderId = c.req.param("id");
+        // Verify the order exists and the actor has access before recording
+        const orderResult = await kernel.services.orders.getById(orderId, actor);
+        if (!orderResult.ok)
+            return c.json(mapErrorToResponse(orderResult.error), mapErrorToStatus(orderResult.error));
+        const body = c.req.valid("json");
+        const result = await kernel.services.fulfillment.createFulfillment({ ...body, orderId: orderResult.value.id }, 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(getOrderFulfillmentsRoute, async (c) => {
         const orderId = c.req.param("id");
         const actor = c.get("actor");

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

@@ -1 +1 @@
-{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCAoE3C"}
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCA+G3C"}

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

@@ -2,7 +2,7 @@ import { OpenAPIHono } from "@hono/zod-openapi";
 import { resolveOrgId } from "../../../auth/org.js";
 import { CommerceValidationError } from "../../../kernel/errors.js";
 import { CatalogRepository } from "../../../modules/catalog/repository/index.js";
-import { setBasePriceRoute, createModifierRoute, listPricesRoute } from "../schemas/pricing.js";
+import { setBasePriceRoute, createModifierRoute, listPricesRoute, listModifiersRoute, updateModifierRoute, deleteModifierRoute } from "../schemas/pricing.js";
 import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
 export function pricingRoutes(kernel) {
     const router = new OpenAPIHono();
@@ -37,6 +37,41 @@ export function pricingRoutes(kernel) {
         return c.json({ data: result.value });
     });
     router.use("/modifiers", requirePerm("pricing:manage"));
+    router.use("/modifiers/:id", requirePerm("pricing:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(listModifiersRoute, async (c) => {
+        const actor = c.get("actor");
+        const entityId = c.req.query("entityId");
+        const currency = c.req.query("currency");
+        const active = c.req.query("active");
+        const result = await kernel.services.pricing.listModifiers({
+            ...(entityId !== undefined ? { entityId } : {}),
+            ...(currency !== undefined ? { currency } : {}),
+            ...(active === "true" ? { active: true } : {}),
+        }, 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(updateModifierRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.pricing.updateModifier(c.req.param("id"), c.req.valid("json"), 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(deleteModifierRoute, async (c) => {
+        const actor = c.get("actor");
+        const result = await kernel.services.pricing.deleteModifier(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.

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

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

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

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

@@ -0,0 +1,50 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { KNOWN_GROUP_SCHEMAS, getAllSettingsRoute, getSettingsGroupRoute, patchSettingsGroupRoute, } from "../schemas/settings.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function settingsRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/", requirePerm("settings:manage"));
+    router.use("/:group", requirePerm("settings:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(getAllSettingsRoute, async (c) => {
+        const result = await kernel.services.settings.getAll(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(getSettingsGroupRoute, async (c) => {
+        const result = await kernel.services.settings.getGroup(c.req.param("group"), 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(patchSettingsGroupRoute, async (c) => {
+        const group = c.req.param("group");
+        const body = c.req.valid("json");
+        // Known groups get typed validation; unknown groups accept any object.
+        const groupSchema = KNOWN_GROUP_SCHEMAS[group];
+        if (groupSchema) {
+            const parsed = groupSchema.safeParse(body);
+            if (!parsed.success) {
+                const isProd = process.env.NODE_ENV === "production";
+                return c.json({
+                    error: {
+                        code: "VALIDATION_FAILED",
+                        message: isProd
+                            ? "Invalid input."
+                            : parsed.error.issues
+                                .map((i) => `${i.path.join(".")}: ${i.message}`)
+                                .join("; "),
+                    },
+                }, 422);
+            }
+        }
+        const result = await kernel.services.settings.updateGroup(group, body, c.get("actor"));
+        if (!result.ok)
+            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+        return c.json({ data: result.value });
+    });
+    return router;
+}

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

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

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

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

@@ -0,0 +1,68 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createShippingZoneRoute, listShippingZonesRoute, updateShippingZoneRoute, deleteShippingZoneRoute, createShippingRateRoute, listShippingRatesRoute, updateShippingRateRoute, deleteShippingRateRoute, } from "../schemas/shipping.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function shippingRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/zones", requirePerm("shipping:manage"));
+    router.use("/zones/:id", requirePerm("shipping:manage"));
+    router.use("/rates", requirePerm("shipping:manage"));
+    router.use("/rates/:id", requirePerm("shipping:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createShippingZoneRoute, async (c) => {
+        const result = await kernel.services.shipping.createZone(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(listShippingZonesRoute, async (c) => {
+        const result = await kernel.services.shipping.listZones(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(updateShippingZoneRoute, async (c) => {
+        const result = await kernel.services.shipping.updateZone(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(deleteShippingZoneRoute, async (c) => {
+        const result = await kernel.services.shipping.deleteZone(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(createShippingRateRoute, async (c) => {
+        const result = await kernel.services.shipping.createRate(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(listShippingRatesRoute, async (c) => {
+        const zoneId = c.req.query("zoneId");
+        const result = await kernel.services.shipping.listRates(zoneId !== undefined ? { zoneId } : undefined, 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(updateShippingRateRoute, async (c) => {
+        const result = await kernel.services.shipping.updateRate(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(deleteShippingRateRoute, async (c) => {
+        const result = await kernel.services.shipping.deleteRate(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 });
+    });
+    return router;
+}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tax.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/tax.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAWzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,gCA2EvC"}

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

@@ -0,0 +1,68 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createTaxRateRoute, listTaxRatesRoute, updateTaxRateRoute, deleteTaxRateRoute, createTaxClassRoute, listTaxClassesRoute, updateTaxClassRoute, deleteTaxClassRoute, } from "../schemas/tax.js";
+import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+export function taxRoutes(kernel) {
+    const router = new OpenAPIHono();
+    router.use("/rates", requirePerm("tax:manage"));
+    router.use("/rates/:id", requirePerm("tax:manage"));
+    router.use("/classes", requirePerm("tax:manage"));
+    router.use("/classes/:id", requirePerm("tax:manage"));
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createTaxRateRoute, async (c) => {
+        const result = await kernel.services.tax.createTaxRate(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(listTaxRatesRoute, async (c) => {
+        const result = await kernel.services.tax.listTaxRates(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(updateTaxRateRoute, async (c) => {
+        const result = await kernel.services.tax.updateTaxRate(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(deleteTaxRateRoute, async (c) => {
+        const result = await kernel.services.tax.deleteTaxRate(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 });
+    });
+    // ── Product tax classes (issue #57) ───────────────────────────────
+    // @ts-expect-error -- openapi handler union return type
+    router.openapi(createTaxClassRoute, async (c) => {
+        const result = await kernel.services.tax.createTaxClass(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(listTaxClassesRoute, async (c) => {
+        const result = await kernel.services.tax.listTaxClasses(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(updateTaxClassRoute, async (c) => {
+        const result = await kernel.services.tax.updateTaxClass(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(deleteTaxClassRoute, async (c) => {
+        const result = await kernel.services.tax.deleteTaxClass(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 });
+    });
+    return router;
+}