@unifiedcommerce/core 0.4.2 → 0.4.4

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/pricing.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,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCAmD3C"}

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

@@ -1,48 +0,0 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { setBasePriceRoute, createModifierRoute, listPricesRoute } from "../schemas/pricing.js";
-import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
-export function pricingRoutes(kernel) {
-    const router = new OpenAPIHono();
-    router.use("/prices", requirePerm("pricing:manage"));
-    // @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(setBasePriceRoute, async (c) => {
-        const actor = c.get("actor");
-        const result = await kernel.services.pricing.setBasePrice(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(listPricesRoute, async (c) => {
-        const entityId = c.req.query("entityId");
-        const variantId = c.req.query("variantId");
-        const currency = c.req.query("currency");
-        const customerGroupId = c.req.query("customerGroupId");
-        const result = await kernel.services.pricing.listPrices({
-            ...(entityId !== undefined ? { entityId } : {}),
-            ...(variantId !== undefined ? { variantId } : {}),
-            ...(currency !== undefined ? { currency } : {}),
-            ...(customerGroupId !== undefined ? { customerGroupId } : {}),
-        });
-        if (!result.ok) {
-            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
-        }
-        return c.json({ data: result.value });
-    });
-    router.use("/modifiers", requirePerm("pricing:manage"));
-    // @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(createModifierRoute, async (c) => {
-        const actor = c.get("actor");
-        const result = await kernel.services.pricing.createModifier(c.req.valid("json"), 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/promotions.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"promotions.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/promotions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,KAAK,MAAM,EAAqD,MAAM,aAAa,CAAC;AAG7F,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,gCAqF7C"}

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

@@ -1,76 +0,0 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { rateLimiter } from "hono-rate-limiter";
-import { createPromotionRoute, validatePromotionRoute, deactivatePromotionRoute, listActivePromotionsRoute } from "../schemas/promotions.js";
-import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
-import { resolveOrgId } from "../../../auth/org.js";
-export function promotionRoutes(kernel) {
-    const router = new OpenAPIHono();
-    // Rate limit promo code validation — prevents brute-force code enumeration
-    router.use("/validate", rateLimiter({
-        windowMs: 60 * 1000,
-        limit: 10,
-        keyGenerator: (c) => {
-            // Node.js Request has a socket property; Hono types it as unknown.
-            const socket = c.req.raw.socket;
-            return socket?.remoteAddress ?? "unknown";
-        },
-    }));
-    router.use("/", requirePerm("promotions:manage"));
-    // @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(createPromotionRoute, async (c) => {
-        const body = c.req.valid("json");
-        const actor = c.get("actor");
-        const result = await kernel.services.promotions.create(body, actor);
-        if (!result.ok) {
-            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
-        }
-        return c.json({ data: result.value }, 201);
-    });
-    // List active promotions — requires auth
-    router.use("/active", requirePerm("promotions:read"));
-    // @ts-expect-error -- openapi handler union return type
-    router.openapi(listActivePromotionsRoute, async (_c) => {
-        const actor = _c.get("actor");
-        const result = await kernel.services.promotions.listActive(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.
-    router.openapi(validatePromotionRoute, async (c) => {
-        const payload = c.req.valid("json");
-        const actor = c.get("actor");
-        const orgId = resolveOrgId(actor);
-        const result = await kernel.services.promotions.validate(payload.code, {
-            orgId,
-            currency: payload.currency,
-            subtotal: payload.subtotal,
-            lineItems: payload.lineItems,
-            ...(payload.customerId !== undefined ? { customerId: payload.customerId } : {}),
-            ...(payload.customerGroupIds !== undefined ? { customerGroupIds: payload.customerGroupIds } : {}),
-        });
-        if (!result.ok) {
-            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
-        }
-        return c.json({ data: result.value });
-    });
-    router.use("/:id/deactivate", requirePerm("promotions:manage"));
-    // @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.
-    router.openapi(deactivatePromotionRoute, async (c) => {
-        const actor = c.get("actor");
-        const orgId = resolveOrgId(actor);
-        const result = await kernel.services.promotions.deactivate(orgId, c.req.param("id"));
-        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/search.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/search.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,EAAwC,MAAM,aAAa,CAAC;AAEhF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,gCAiE1C"}

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

@@ -1,60 +0,0 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { searchRoute, suggestRoute } from "../schemas/search.js";
-import { mapErrorToResponse, mapErrorToStatus } from "../utils.js";
-export function searchRoutes(kernel) {
-    const router = new OpenAPIHono();
-    // @ts-expect-error -- openapi handler union return type
-    router.openapi(searchRoute, async (c) => {
-        const q = c.req.query("q") ?? "";
-        const type = c.req.query("type");
-        const category = c.req.query("category");
-        const brand = c.req.query("brand");
-        const status = c.req.query("status");
-        const page = Number.parseInt(c.req.query("page") ?? "1", 10);
-        const limit = Number.parseInt(c.req.query("limit") ?? "20", 10);
-        const facets = (c.req.query("facets") ?? "")
-            .split(",")
-            .map((facet) => facet.trim())
-            .filter(Boolean);
-        const result = await kernel.services.search.query({
-            query: q,
-            page,
-            limit,
-            filters: {
-                ...(type ? { type } : {}),
-                ...(category ? { category } : {}),
-                ...(brand ? { brand } : {}),
-                ...(status ? { status } : {}),
-            },
-            ...(facets.length > 0 ? { facets } : {}),
-        }, { 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.hits,
-            meta: {
-                total: result.value.total,
-                page: result.value.page,
-                limit: result.value.limit,
-                facets: result.value.facets,
-            },
-        });
-    });
-    // @ts-expect-error -- openapi handler union return type
-    router.openapi(suggestRoute, async (c) => {
-        const prefix = c.req.query("prefix") ?? "";
-        const type = c.req.query("type");
-        const limit = Number.parseInt(c.req.query("limit") ?? "10", 10);
-        const result = await kernel.services.search.suggest({
-            prefix,
-            ...(type ? { type } : {}),
-            limit,
-        }, { 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 });
-    });
-    return router;
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/routes/webhooks.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,EAAqD,MAAM,aAAa,CAAC;AAE7F,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,gCAwC3C"}

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

@@ -1,39 +0,0 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { createWebhookEndpointRoute, listWebhookEndpointsRoute, deleteWebhookEndpointRoute } from "../schemas/webhooks.js";
-import { mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
-export function webhookRoutes(kernel) {
-    const router = new OpenAPIHono();
-    router.use("/*", requirePerm("webhooks:manage"));
-    // @ts-expect-error -- openapi handler union return type
-    router.openapi(createWebhookEndpointRoute, async (c) => {
-        const body = c.req.valid("json");
-        // Generate a default secret if none provided (Zod schema marks it optional for API convenience)
-        if (!body.secret) {
-            body.secret = `whsec_${crypto.randomUUID().replace(/-/g, "")}`;
-        }
-        const actor = c.get("actor");
-        const result = await kernel.services.webhooks.createEndpoint(body, 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(listWebhookEndpointsRoute, async (c) => {
-        const result = await kernel.services.webhooks.listEndpoints();
-        if (!result.ok) {
-            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
-        }
-        const sanitized = result.value.map(({ secret: _secret, ...rest }) => rest);
-        return c.json({ data: sanitized });
-    });
-    // @ts-expect-error -- openapi handler union return type
-    router.openapi(deleteWebhookEndpointRoute, async (c) => {
-        const result = await kernel.services.webhooks.deleteEndpoint(c.req.param("id"));
-        if (!result.ok) {
-            return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
-        }
-        return c.json({ data: { deleted: true } });
-    });
-    return router;
-}

package/dist/interfaces/rest/schemas/admin-jobs.d.ts

@@ -1,327 +0,0 @@
-import { z } from "@hono/zod-openapi";
-export declare const listFailedJobsRoute: {
-    method: "get";
-    path: "/jobs/failed";
-    tags: string[];
-    summary: string;
-    request: {
-        query: z.ZodObject<{
-            limit: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    };
-    responses: {
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        data: z.ZodArray<import("drizzle-zod").BuildSchema<"select", {
-                            id: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "id";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgUUID";
-                                data: string;
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: true;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            organizationId: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "organization_id";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgText";
-                                data: string;
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: [string, ...string[]];
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            queue: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "queue";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgText";
-                                data: string;
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: [string, ...string[]];
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            taskSlug: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "task_slug";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgText";
-                                data: string;
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: [string, ...string[]];
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            input: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "input";
-                                tableName: "commerce_jobs";
-                                dataType: "json";
-                                columnType: "PgJsonb";
-                                data: unknown;
-                                driverParam: unknown;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            output: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "output";
-                                tableName: "commerce_jobs";
-                                dataType: "json";
-                                columnType: "PgJsonb";
-                                data: unknown;
-                                driverParam: unknown;
-                                notNull: false;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            status: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "status";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgText";
-                                data: "pending" | "processing" | "succeeded" | "failed";
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: ["pending", "processing", "succeeded", "failed"];
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            attempts: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "attempts";
-                                tableName: "commerce_jobs";
-                                dataType: "number";
-                                columnType: "PgInteger";
-                                data: number;
-                                driverParam: string | number;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "max_attempts";
-                                tableName: "commerce_jobs";
-                                dataType: "number";
-                                columnType: "PgInteger";
-                                data: number;
-                                driverParam: string | number;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            error: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "error";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgText";
-                                data: string;
-                                driverParam: string;
-                                notNull: false;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: [string, ...string[]];
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            waitUntil: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "wait_until";
-                                tableName: "commerce_jobs";
-                                dataType: "date";
-                                columnType: "PgTimestamp";
-                                data: Date;
-                                driverParam: string;
-                                notNull: false;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            concurrencyKey: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "concurrency_key";
-                                tableName: "commerce_jobs";
-                                dataType: "string";
-                                columnType: "PgText";
-                                data: string;
-                                driverParam: string;
-                                notNull: false;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: [string, ...string[]];
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            createdAt: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "created_at";
-                                tableName: "commerce_jobs";
-                                dataType: "date";
-                                columnType: "PgTimestamp";
-                                data: Date;
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "updated_at";
-                                tableName: "commerce_jobs";
-                                dataType: "date";
-                                columnType: "PgTimestamp";
-                                data: Date;
-                                driverParam: string;
-                                notNull: true;
-                                hasDefault: true;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            processingStartedAt: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "processing_started_at";
-                                tableName: "commerce_jobs";
-                                dataType: "date";
-                                columnType: "PgTimestamp";
-                                data: Date;
-                                driverParam: string;
-                                notNull: false;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                            completedAt: import("drizzle-orm/pg-core").PgColumn<{
-                                name: "completed_at";
-                                tableName: "commerce_jobs";
-                                dataType: "date";
-                                columnType: "PgTimestamp";
-                                data: Date;
-                                driverParam: string;
-                                notNull: false;
-                                hasDefault: false;
-                                isPrimaryKey: false;
-                                isAutoincrement: false;
-                                hasRuntimeDefault: false;
-                                enumValues: undefined;
-                                baseColumn: never;
-                                identity: undefined;
-                                generated: undefined;
-                            }, {}, {}>;
-                        }, undefined, undefined>>;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-    };
-} & {
-    getRoutingPath(): "/jobs/failed";
-};
-export declare const retryJobRoute: {
-    method: "post";
-    path: "/jobs/{id}/retry";
-    tags: string[];
-    summary: string;
-    request: {
-        params: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>;
-    };
-    responses: {
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        data: z.ZodObject<{
-                            retried: z.ZodLiteral<true>;
-                        }, z.core.$strip>;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-    };
-} & {
-    getRoutingPath(): "/jobs/:id/retry";
-};
-//# sourceMappingURL=admin-jobs.d.ts.map

package/dist/interfaces/rest/schemas/admin-jobs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"admin-jobs.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/rest/schemas/admin-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAKnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB9B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBxB,CAAC"}

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

@@ -1,37 +0,0 @@
-import { z, createRoute } from "@hono/zod-openapi";
-import { JobListResponse } from "./responses.js";
-// ─── Route Definitions ──────────────────────────────────────────────────────
-export const listFailedJobsRoute = createRoute({
-    method: "get",
-    path: "/jobs/failed",
-    tags: ["Admin Jobs"],
-    summary: "List failed jobs",
-    request: {
-        query: z.object({
-            limit: z.string().optional(),
-        }),
-    },
-    responses: {
-        200: {
-            content: { "application/json": { schema: JobListResponse } },
-            description: "Failed jobs",
-        },
-    },
-});
-export const retryJobRoute = createRoute({
-    method: "post",
-    path: "/jobs/{id}/retry",
-    tags: ["Admin Jobs"],
-    summary: "Retry a failed job",
-    request: {
-        params: z.object({
-            id: z.string().min(1).openapi({ example: "job-uuid" }),
-        }),
-    },
-    responses: {
-        200: {
-            content: { "application/json": { schema: z.object({ data: z.object({ retried: z.literal(true) }) }) } },
-            description: "Job retried",
-        },
-    },
-});