@voyant-travel/accommodations 0.108.1 → 0.108.3

package/dist/routes-room-blocks.d.ts

@@ -6,7 +6,14 @@
  * the transactional DB. See RFC voyant#1489 §4.2/§8.
  *
  * Routes stay thin: validate input, call `roomBlockService`, serialize.
+ *
+ * Contract: authored as `@hono/zod-openapi` routes (voyant#2114). The request
+ * bodies reuse the exported `validation-room-blocks` schemas; the response
+ * schemas are authored here against the service return types (room-block /
+ * pickup rows + the derived summary), with `Date`-origin columns serialized as
+ * strings per api-route-authoring §17 — the wire shape, not the Drizzle row.
  */
+import { OpenAPIHono, z } from "@hono/zod-openapi";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 type Env = {
     Variables: {
@@ -14,26 +21,107 @@ type Env = {
         userId?: string;
     };
 };
-export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env, {
+/**
+ * Wire shape of a `room_blocks` row. `optionDate`/`cutoffDate` are SQL `date`
+ * columns and `createdAt`/`updatedAt` are timestamps — both serialize to
+ * strings over the wire (§17), never `Date`.
+ */
+export declare const roomBlockSchema: z.ZodObject<{
+    id: z.ZodString;
+    programId: z.ZodNullable<z.ZodString>;
+    supplierId: z.ZodNullable<z.ZodString>;
+    propertyId: z.ZodNullable<z.ZodString>;
+    roomTypeId: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        inquiry: "inquiry";
+        cancelled: "cancelled";
+        held: "held";
+        confirmed: "confirmed";
+        released: "released";
+        expired: "expired";
+    }>;
+    currency: z.ZodString;
+    netRateCents: z.ZodNullable<z.ZodNumber>;
+    sellRateCents: z.ZodNullable<z.ZodNumber>;
+    optionDate: z.ZodNullable<z.ZodString>;
+    cutoffDate: z.ZodNullable<z.ZodString>;
+    attritionTerms: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    depositTerms: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    notes: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Wire shape of a `room_block_pickups` ledger row. `checkIn`/`checkOut` are
+ * `date` columns and `pickedUpAt`/`reversedAt` are timestamps — strings over
+ * the wire (§17).
+ */
+export declare const roomBlockPickupRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    blockId: z.ZodString;
+    bookingId: z.ZodNullable<z.ZodString>;
+    stayBookingItemId: z.ZodNullable<z.ZodString>;
+    checkIn: z.ZodString;
+    checkOut: z.ZodString;
+    rooms: z.ZodNumber;
+    status: z.ZodEnum<{
+        active: "active";
+        reversed: "reversed";
+    }>;
+    pickedUpAt: z.ZodString;
+    reversedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** Derived ops view — counters + pickup progress for a block. */
+export declare const roomBlockSummarySchema: z.ZodObject<{
+    blockId: z.ZodString;
+    status: z.ZodEnum<{
+        inquiry: "inquiry";
+        cancelled: "cancelled";
+        held: "held";
+        confirmed: "confirmed";
+        released: "released";
+        expired: "expired";
+    }>;
+    totalHeld: z.ZodNumber;
+    totalPickedUp: z.ZodNumber;
+    totalReleased: z.ZodNumber;
+    totalRemaining: z.ZodNumber;
+    pickupProgress: z.ZodEnum<{
+        none: "none";
+        partial: "partial";
+        full: "full";
+    }>;
+}, z.core.$strip>;
+export declare const roomBlockAdminRoutes: OpenAPIHono<Env, {
     "/room-blocks": {
         $post: {
-            input: {};
+            input: {
+                json: {
+                    roomTypeId: string;
+                    name: string;
+                    currency: string;
+                    programId?: string | undefined;
+                    supplierId?: string | undefined;
+                    propertyId?: string | undefined;
+                    netRateCents?: number | undefined;
+                    sellRateCents?: number | undefined;
+                    optionDate?: string | undefined;
+                    cutoffDate?: string | undefined;
+                    notes?: string | undefined;
+                };
+            };
             output: {
                 data: {
                     id: string;
-                    createdAt: string;
-                    updatedAt: string;
-                    propertyId: string | null;
+                    programId: string | null;
                     supplierId: string | null;
+                    propertyId: string | null;
+                    roomTypeId: string;
                     name: string;
+                    status: "inquiry" | "cancelled" | "held" | "confirmed" | "released" | "expired";
                     currency: string;
-                    status: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
-                    metadata: {
-                        [x: string]: import("hono/utils/types").JSONValue;
-                    } | null;
-                    notes: string | null;
-                    roomTypeId: string;
-                    programId: string | null;
                     netRateCents: number | null;
                     sellRateCents: number | null;
                     optionDate: string | null;
@@ -44,26 +132,42 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                     depositTerms: {
                         [x: string]: import("hono/utils/types").JSONValue;
                     } | null;
+                    notes: string | null;
+                    metadata: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
                 };
             };
             outputFormat: "json";
             status: 201;
-        };
-    };
-} & {
-    "/room-blocks/:id": {
-        $get: {
+        } | {
             input: {
-                param: {
-                    id: string;
+                json: {
+                    roomTypeId: string;
+                    name: string;
+                    currency: string;
+                    programId?: string | undefined;
+                    supplierId?: string | undefined;
+                    propertyId?: string | undefined;
+                    netRateCents?: number | undefined;
+                    sellRateCents?: number | undefined;
+                    optionDate?: string | undefined;
+                    cutoffDate?: string | undefined;
+                    notes?: string | undefined;
                 };
             };
             output: {
                 error: string;
             };
             outputFormat: "json";
-            status: 404;
-        } | {
+            status: 400;
+        };
+    };
+} & {
+    "/room-blocks/:id": {
+        $get: {
             input: {
                 param: {
                     id: string;
@@ -73,19 +177,13 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                 data: {
                     block: {
                         id: string;
-                        createdAt: string;
-                        updatedAt: string;
-                        propertyId: string | null;
+                        programId: string | null;
                         supplierId: string | null;
+                        propertyId: string | null;
+                        roomTypeId: string;
                         name: string;
+                        status: "inquiry" | "cancelled" | "held" | "confirmed" | "released" | "expired";
                         currency: string;
-                        status: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        notes: string | null;
-                        roomTypeId: string;
-                        programId: string | null;
                         netRateCents: number | null;
                         sellRateCents: number | null;
                         optionDate: string | null;
@@ -96,20 +194,37 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                         depositTerms: {
                             [x: string]: import("hono/utils/types").JSONValue;
                         } | null;
+                        notes: string | null;
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        createdAt: string;
+                        updatedAt: string;
                     };
                     summary: {
                         blockId: string;
-                        status: import("./schema-room-blocks.js").RoomBlock["status"];
+                        status: "inquiry" | "cancelled" | "held" | "confirmed" | "released" | "expired";
                         totalHeld: number;
                         totalPickedUp: number;
                         totalReleased: number;
                         totalRemaining: number;
-                        pickupProgress: import("@voyant-travel/allotments").PickupProgress;
+                        pickupProgress: "none" | "partial" | "full";
                     } | null;
                 };
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
         };
     };
 } & {
@@ -119,6 +234,35 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    nights: {
+                        date: string;
+                        roomsHeld: number;
+                        netRateCentsOverride?: number | undefined;
+                        sellRateCentsOverride?: number | undefined;
+                    }[];
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    nights: {
+                        date: string;
+                        roomsHeld: number;
+                        netRateCentsOverride?: number | undefined;
+                        sellRateCentsOverride?: number | undefined;
+                    }[];
+                };
             };
             output: {
                 error: string;
@@ -130,20 +274,29 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    nights: {
+                        date: string;
+                        roomsHeld: number;
+                        netRateCentsOverride?: number | undefined;
+                        sellRateCentsOverride?: number | undefined;
+                    }[];
+                };
             };
             output: {
                 data: {
                     blockId: string;
-                    status: import("./schema-room-blocks.js").RoomBlock["status"];
+                    status: "inquiry" | "cancelled" | "held" | "confirmed" | "released" | "expired";
                     totalHeld: number;
                     totalPickedUp: number;
                     totalReleased: number;
                     totalRemaining: number;
-                    pickupProgress: import("@voyant-travel/allotments").PickupProgress;
+                    pickupProgress: "none" | "partial" | "full";
                 } | null;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 } & {
@@ -153,53 +306,122 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    checkIn: string;
+                    checkOut: string;
+                    bookingId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                    rooms?: number | undefined;
+                };
             };
             output: {
-                data: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
                     id: string;
-                    status: "active" | "reversed";
-                    bookingId: string | null;
-                    rooms: number;
+                };
+            } & {
+                json: {
                     checkIn: string;
                     checkOut: string;
-                    stayBookingItemId: string | null;
-                    blockId: string;
-                    pickedUpAt: string;
-                    reversedAt: string | null;
+                    bookingId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                    rooms?: number | undefined;
                 };
             };
+            output: {
+                error: string;
+            };
             outputFormat: "json";
-            status: 200 | 201;
+            status: 404;
         } | {
             input: {
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    checkIn: string;
+                    checkOut: string;
+                    bookingId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                    rooms?: number | undefined;
+                };
             };
             output: {
-                error: string;
+                data: {
+                    id: string;
+                    blockId: string;
+                    bookingId: string | null;
+                    stayBookingItemId: string | null;
+                    checkIn: string;
+                    checkOut: string;
+                    rooms: number;
+                    status: "active" | "reversed";
+                    pickedUpAt: string;
+                    reversedAt: string | null;
+                };
             };
             outputFormat: "json";
-            status: 404;
+            status: 201;
         } | {
             input: {
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    checkIn: string;
+                    checkOut: string;
+                    bookingId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                    rooms?: number | undefined;
+                };
             };
             output: {
-                error: string;
+                data: {
+                    id: string;
+                    blockId: string;
+                    bookingId: string | null;
+                    stayBookingItemId: string | null;
+                    checkIn: string;
+                    checkOut: string;
+                    rooms: number;
+                    status: "active" | "reversed";
+                    pickedUpAt: string;
+                    reversedAt: string | null;
+                };
             };
             outputFormat: "json";
-            status: 400;
+            status: 200;
         } | {
             input: {
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    checkIn: string;
+                    checkOut: string;
+                    bookingId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                    rooms?: number | undefined;
+                };
             };
             output: {
                 error: string;
+            } | {
+                error: string;
+                detail: {
+                    date: string;
+                    remaining: number;
+                    needed: number;
+                };
             };
             outputFormat: "json";
             status: 409;
@@ -212,6 +434,27 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    pickupId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    pickupId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                };
             };
             output: {
                 error: string;
@@ -223,23 +466,28 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                 param: {
                     id: string;
                 };
+            } & {
+                json: {
+                    pickupId?: string | undefined;
+                    stayBookingItemId?: string | undefined;
+                };
             };
             output: {
                 data: {
                     id: string;
-                    status: "active" | "reversed";
+                    blockId: string;
                     bookingId: string | null;
-                    rooms: number;
+                    stayBookingItemId: string | null;
                     checkIn: string;
                     checkOut: string;
-                    stayBookingItemId: string | null;
-                    blockId: string;
+                    rooms: number;
+                    status: "active" | "reversed";
                     pickedUpAt: string;
                     reversedAt: string | null;
                 };
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 } & {
@@ -266,19 +514,13 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                     releasedRooms: number;
                     block: {
                         id: string;
-                        createdAt: string;
-                        updatedAt: string;
-                        propertyId: string | null;
+                        programId: string | null;
                         supplierId: string | null;
+                        propertyId: string | null;
+                        roomTypeId: string;
                         name: string;
+                        status: "inquiry" | "cancelled" | "held" | "confirmed" | "released" | "expired";
                         currency: string;
-                        status: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        notes: string | null;
-                        roomTypeId: string;
-                        programId: string | null;
                         netRateCents: number | null;
                         sellRateCents: number | null;
                         optionDate: string | null;
@@ -289,14 +531,20 @@ export declare const roomBlockAdminRoutes: import("hono/hono-base").HonoBase<Env
                         depositTerms: {
                             [x: string]: import("hono/utils/types").JSONValue;
                         } | null;
+                        notes: string | null;
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
+                        createdAt: string;
+                        updatedAt: string;
                     };
                 };
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
-}, "/", "/room-blocks/:id/release">;
+}, "/">;
 export type RoomBlockAdminRoutes = typeof roomBlockAdminRoutes;
 export {};
 //# sourceMappingURL=routes-room-blocks.d.ts.map

package/dist/routes-room-blocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes-room-blocks.d.ts","sourceRoot":"","sources":["../src/routes-room-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAmBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA2D7B,CAAA;AAEJ,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA"}
+{"version":3,"file":"routes-room-blocks.d.ts","sourceRoot":"","sources":["../src/routes-room-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAe,WAAW,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AAG/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAkBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAUD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB1B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAWnC,CAAA;AAEF,iEAAiE;AACjE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;iBAQjC,CAAA;AAmLF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+D7B,CAAA;AAEJ,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/routes-room-blocks.js

@@ -6,36 +6,266 @@
  * the transactional DB. See RFC voyant#1489 §4.2/§8.
  *
  * Routes stay thin: validate input, call `roomBlockService`, serialize.
+ *
+ * Contract: authored as `@hono/zod-openapi` routes (voyant#2114). The request
+ * bodies reuse the exported `validation-room-blocks` schemas; the response
+ * schemas are authored here against the service return types (room-block /
+ * pickup rows + the derived summary), with `Date`-origin columns serialized as
+ * strings per api-route-authoring §17 — the wire shape, not the Drizzle row.
  */
-import { parseJsonBody } from "@voyant-travel/hono";
-import { Hono } from "hono";
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { ALLOTMENT_PICKUP_STATUSES, ALLOTMENT_STATUSES } from "@voyant-travel/allotments";
+import { openApiValidationHook } from "@voyant-travel/hono";
 import { createRoomBlock, getRoomBlock, pickupRoomBlock, releaseRoomBlockAtCutoff, reverseRoomBlockPickup, setRoomBlockNights, summarizeRoomBlock, } from "./service-room-blocks.js";
 import { createRoomBlockSchema, reverseRoomBlockPickupSchema, roomBlockPickupSchema, setRoomBlockNightsSchema, } from "./validation-room-blocks.js";
-export const roomBlockAdminRoutes = new Hono()
-    .post("/room-blocks", async (c) => {
-    const body = await parseJsonBody(c, createRoomBlockSchema);
-    return c.json({ data: await createRoomBlock(c.get("db"), body) }, 201);
-})
-    .get("/room-blocks/:id", async (c) => {
-    const id = c.req.param("id");
+const errorResponseSchema = z.object({ error: z.string() });
+const idParamSchema = z.object({ id: z.string() });
+const jsonRecordSchema = z.record(z.string(), z.unknown());
+/** DERIVED at read time from per-night counters — never a stored header value. */
+const PICKUP_PROGRESS_VALUES = ["none", "partial", "full"];
+/**
+ * Wire shape of a `room_blocks` row. `optionDate`/`cutoffDate` are SQL `date`
+ * columns and `createdAt`/`updatedAt` are timestamps — both serialize to
+ * strings over the wire (§17), never `Date`.
+ */
+export const roomBlockSchema = z.object({
+    id: z.string(),
+    programId: z.string().nullable(),
+    supplierId: z.string().nullable(),
+    propertyId: z.string().nullable(),
+    roomTypeId: z.string(),
+    name: z.string(),
+    status: z.enum(ALLOTMENT_STATUSES),
+    currency: z.string(),
+    netRateCents: z.number().int().nullable(),
+    sellRateCents: z.number().int().nullable(),
+    optionDate: z.string().nullable(),
+    cutoffDate: z.string().nullable(),
+    attritionTerms: jsonRecordSchema.nullable(),
+    depositTerms: jsonRecordSchema.nullable(),
+    notes: z.string().nullable(),
+    metadata: jsonRecordSchema.nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+/**
+ * Wire shape of a `room_block_pickups` ledger row. `checkIn`/`checkOut` are
+ * `date` columns and `pickedUpAt`/`reversedAt` are timestamps — strings over
+ * the wire (§17).
+ */
+export const roomBlockPickupRowSchema = z.object({
+    id: z.string(),
+    blockId: z.string(),
+    bookingId: z.string().nullable(),
+    stayBookingItemId: z.string().nullable(),
+    checkIn: z.string(),
+    checkOut: z.string(),
+    rooms: z.number().int(),
+    status: z.enum(ALLOTMENT_PICKUP_STATUSES),
+    pickedUpAt: z.string(),
+    reversedAt: z.string().nullable(),
+});
+/** Derived ops view — counters + pickup progress for a block. */
+export const roomBlockSummarySchema = z.object({
+    blockId: z.string(),
+    status: z.enum(ALLOTMENT_STATUSES),
+    totalHeld: z.number().int(),
+    totalPickedUp: z.number().int(),
+    totalReleased: z.number().int(),
+    totalRemaining: z.number().int(),
+    pickupProgress: z.enum(PICKUP_PROGRESS_VALUES),
+});
+const roomBlockDetailResponseSchema = z.object({
+    data: z.object({ block: roomBlockSchema, summary: roomBlockSummarySchema.nullable() }),
+});
+const roomBlockResponseSchema = z.object({ data: roomBlockSchema });
+const roomBlockSummaryResponseSchema = z.object({ data: roomBlockSummarySchema.nullable() });
+const roomBlockPickupResponseSchema = z.object({ data: roomBlockPickupRowSchema });
+const roomBlockReleaseResponseSchema = z.object({
+    data: z.object({ releasedRooms: z.number().int(), block: roomBlockSchema }),
+});
+const nightUnavailableResponseSchema = z.object({
+    error: z.string(),
+    detail: z.object({
+        date: z.string(),
+        remaining: z.number().int(),
+        needed: z.number().int(),
+    }),
+});
+const createRoomBlockRoute = createRoute({
+    method: "post",
+    path: "/room-blocks",
+    request: {
+        body: {
+            required: true,
+            content: { "application/json": { schema: createRoomBlockSchema } },
+        },
+    },
+    responses: {
+        201: {
+            description: "The created room block (starts in `inquiry`; nights are set separately)",
+            content: { "application/json": { schema: roomBlockResponseSchema } },
+        },
+        400: {
+            description: "Invalid request body",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+    },
+});
+const getRoomBlockRoute = createRoute({
+    method: "get",
+    path: "/room-blocks/{id}",
+    request: { params: idParamSchema },
+    responses: {
+        200: {
+            description: "The room block header plus its derived pickup summary",
+            content: { "application/json": { schema: roomBlockDetailResponseSchema } },
+        },
+        404: {
+            description: "Room block not found",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+    },
+});
+const setRoomBlockNightsRoute = createRoute({
+    method: "put",
+    path: "/room-blocks/{id}/nights",
+    request: {
+        params: idParamSchema,
+        body: {
+            required: true,
+            description: "Upsert the held inventory (and optional rate overrides) per night. Only " +
+                "`roomsHeld` and the rate overrides are caller-controlled; the pickup / " +
+                "release counters are owned by the lifecycle actions and never set here.",
+            content: { "application/json": { schema: setRoomBlockNightsSchema } },
+        },
+    },
+    responses: {
+        200: {
+            description: "The recomputed block summary after the nights upsert",
+            content: { "application/json": { schema: roomBlockSummaryResponseSchema } },
+        },
+        400: {
+            description: "Invalid request body",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+        404: {
+            description: "Room block not found",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+    },
+});
+const pickupRoomBlockRoute = createRoute({
+    method: "post",
+    path: "/room-blocks/{id}/pickups",
+    request: {
+        params: idParamSchema,
+        body: {
+            required: true,
+            description: "Record a pickup against the block. Idempotent on `stayBookingItemId`: " +
+                "re-processing the same stay item returns the existing active pickup with " +
+                "a 200 instead of a 201.",
+            content: { "application/json": { schema: roomBlockPickupSchema } },
+        },
+    },
+    responses: {
+        200: {
+            description: "An existing active pickup (idempotent replay on `stayBookingItemId`)",
+            content: { "application/json": { schema: roomBlockPickupResponseSchema } },
+        },
+        201: {
+            description: "The newly recorded pickup",
+            content: { "application/json": { schema: roomBlockPickupResponseSchema } },
+        },
+        400: {
+            description: "Invalid check-in/check-out range",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+        404: {
+            description: "Room block not found",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+        409: {
+            description: "The block is no longer accepting pickups, or a night has insufficient " +
+                "inventory (the latter carries a `detail` with the short night)",
+            content: {
+                "application/json": {
+                    schema: z.union([errorResponseSchema, nightUnavailableResponseSchema]),
+                },
+            },
+        },
+    },
+});
+const reverseRoomBlockPickupRoute = createRoute({
+    method: "post",
+    path: "/room-blocks/{id}/pickups/reverse",
+    request: {
+        params: idParamSchema,
+        body: {
+            required: true,
+            description: "Reverse a pickup (booking cancelled / rooms reduced). Exactly one of " +
+                "`pickupId` or `stayBookingItemId` is required; the body schema enforces " +
+                "this, so a request with neither (or both) fails request validation with a " +
+                "400 `invalid_request`. A well-formed request whose pickup isn't found (or " +
+                "belongs to a different block) returns 404.",
+            content: { "application/json": { schema: reverseRoomBlockPickupSchema } },
+        },
+    },
+    responses: {
+        200: {
+            description: "The reversed pickup ledger row",
+            content: { "application/json": { schema: roomBlockPickupResponseSchema } },
+        },
+        400: {
+            description: "Invalid body — neither (or both) of `pickupId`/`stayBookingItemId` supplied",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+        404: {
+            description: "Active pickup not found (or it belongs to a different block)",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+    },
+});
+const releaseRoomBlockRoute = createRoute({
+    method: "post",
+    path: "/room-blocks/{id}/release",
+    request: { params: idParamSchema },
+    responses: {
+        200: {
+            description: "Unpicked rooms released back to the property; the block moves to `released`",
+            content: { "application/json": { schema: roomBlockReleaseResponseSchema } },
+        },
+        404: {
+            description: "Room block not found",
+            content: { "application/json": { schema: errorResponseSchema } },
+        },
+    },
+});
+export const roomBlockAdminRoutes = new OpenAPIHono({ defaultHook: openApiValidationHook })
+    .openapi(createRoomBlockRoute, async (c) => c.json({ data: await createRoomBlock(c.get("db"), c.req.valid("json")) }, 201))
+    .openapi(getRoomBlockRoute, async (c) => {
+    const id = c.req.valid("param").id;
     const block = await getRoomBlock(c.get("db"), id);
     if (!block)
         return c.json({ error: "Room block not found" }, 404);
     const summary = await summarizeRoomBlock(c.get("db"), id);
-    return c.json({ data: { block, summary } });
+    return c.json({ data: { block, summary } }, 200);
 })
-    .put("/room-blocks/:id/nights", async (c) => {
-    const id = c.req.param("id");
+    .openapi(setRoomBlockNightsRoute, async (c) => {
+    const id = c.req.valid("param").id;
     const block = await getRoomBlock(c.get("db"), id);
     if (!block)
         return c.json({ error: "Room block not found" }, 404);
-    const { nights } = await parseJsonBody(c, setRoomBlockNightsSchema);
+    const { nights } = c.req.valid("json");
     await setRoomBlockNights(c.get("db"), id, nights);
-    return c.json({ data: await summarizeRoomBlock(c.get("db"), id) });
+    return c.json({ data: await summarizeRoomBlock(c.get("db"), id) }, 200);
 })
-    .post("/room-blocks/:id/pickups", async (c) => {
-    const body = await parseJsonBody(c, roomBlockPickupSchema);
-    const outcome = await pickupRoomBlock(c.get("db"), { blockId: c.req.param("id"), ...body });
+    .openapi(pickupRoomBlockRoute, async (c) => {
+    const body = c.req.valid("json");
+    const outcome = await pickupRoomBlock(c.get("db"), {
+        blockId: c.req.valid("param").id,
+        ...body,
+    });
     switch (outcome.status) {
         case "ok":
             return c.json({ data: outcome.pickup }, outcome.idempotent ? 200 : 201);
@@ -52,21 +282,23 @@ export const roomBlockAdminRoutes = new Hono()
             }, 409);
     }
 })
-    .post("/room-blocks/:id/pickups/reverse", async (c) => {
-    const body = await parseJsonBody(c, reverseRoomBlockPickupSchema);
+    .openapi(reverseRoomBlockPickupRoute, async (c) => {
+    const body = c.req.valid("json");
     const outcome = await reverseRoomBlockPickup(c.get("db"), {
-        blockId: c.req.param("id"),
+        blockId: c.req.valid("param").id,
         ...body,
     });
     if (outcome.status === "pickup_not_found") {
         return c.json({ error: "Active pickup not found" }, 404);
     }
-    return c.json({ data: outcome.pickup });
+    return c.json({ data: outcome.pickup }, 200);
 })
-    .post("/room-blocks/:id/release", async (c) => {
-    const outcome = await releaseRoomBlockAtCutoff(c.get("db"), { blockId: c.req.param("id") });
+    .openapi(releaseRoomBlockRoute, async (c) => {
+    const outcome = await releaseRoomBlockAtCutoff(c.get("db"), {
+        blockId: c.req.valid("param").id,
+    });
     if (outcome.status === "block_not_found") {
         return c.json({ error: "Room block not found" }, 404);
     }
-    return c.json({ data: { releasedRooms: outcome.releasedRooms, block: outcome.block } });
+    return c.json({ data: { releasedRooms: outcome.releasedRooms, block: outcome.block } }, 200);
 });

package/dist/schema-bookings.d.ts

@@ -279,7 +279,7 @@ export declare const stayBookingItems: import("drizzle-orm/pg-core").PgTableWith
             tableName: "stay_booking_items";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "cancelled" | "no_show" | "reserved";
+            data: "reserved" | "cancelled" | "no_show";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/dist/schema-inventory.d.ts

@@ -109,7 +109,7 @@ export declare const roomTypes: import("drizzle-orm/pg-core").PgTableWithColumns
             tableName: "room_types";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "virtual" | "pooled" | "serialized";
+            data: "pooled" | "serialized" | "virtual";
             driverParam: string;
             notNull: true;
             hasDefault: true;
@@ -1018,7 +1018,7 @@ export declare const ratePlans: import("drizzle-orm/pg-core").PgTableWithColumns
             tableName: "rate_plans";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "none" | "on_request" | "deposit" | "card_hold" | "full_prepay";
+            data: "none" | "card_hold" | "deposit" | "full_prepay" | "on_request";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/dist/schema-room-blocks.d.ts

@@ -121,7 +121,7 @@ export declare const roomBlocks: import("drizzle-orm/pg-core").PgTableWithColumn
             tableName: "room_blocks";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "held" | "confirmed" | "cancelled" | "expired" | "inquiry" | "released";
+            data: "inquiry" | "cancelled" | "held" | "confirmed" | "released" | "expired";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyant-travel/accommodations",
-  "version": "0.108.1",
+  "version": "0.108.3",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -61,17 +61,18 @@
     }
   },
   "dependencies": {
+    "@hono/zod-openapi": "^1.4.0",
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
     "@voyant-travel/accommodations-contracts": "^0.105.3",
     "@voyant-travel/allotments": "^0.2.0",
-    "@voyant-travel/bookings": "^0.136.2",
-    "@voyant-travel/catalog": "^0.134.1",
+    "@voyant-travel/bookings": "^0.137.1",
+    "@voyant-travel/catalog": "^0.135.1",
     "@voyant-travel/core": "^0.111.0",
     "@voyant-travel/db": "^0.109.4",
-    "@voyant-travel/hono": "^0.116.2",
-    "@voyant-travel/operations": "^0.5.1"
+    "@voyant-travel/hono": "^0.118.0",
+    "@voyant-travel/operations": "^0.5.3"
   },
   "devDependencies": {
     "drizzle-kit": "^0.31.10",
@@ -101,10 +102,10 @@
     ]
   },
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
     "lint": "biome check src/",
     "test": "vitest run",
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json",
     "clean": "rm -rf dist tsconfig.tsbuildinfo",
     "db:generate": "drizzle-kit generate --config=drizzle.migrations.config.ts --name=accommodations_baseline && node ../../scripts/migrations/guard-create-type.mjs ./migrations && node ../../scripts/migrations/ensure-extensions.mjs ./migrations"
   },