@voyant-travel/mice 0.2.0 → 0.4.0

package/dist/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAoBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAqDxB,CAAA;AAEJ,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAA"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AA0DjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0MxB,CAAA;AAEJ,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAA"}

package/dist/routes.js

@@ -5,8 +5,14 @@
 import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
 import { Hono } from "hono";
 import { createProgram, getProgram, listPrograms, updateProgram } from "./service.js";
+import { createDelegate, enrollDelegate, getDelegate, listDelegates, updateDelegate, } from "./service-delegates.js";
+import { rfpService } from "./service-rfp.js";
+import { createRoomingAssignment, getRoomingAssignment, listRoomingAssignments, setRoomingDelegates, updateRoomingAssignment, } from "./service-rooming.js";
 import { createSession, deleteSession, getSession, listSessions, setSessionInclusions, updateSession, } from "./service-sessions.js";
 import { createProgramSchema, programListQuerySchema, updateProgramSchema } from "./validation.js";
+import { createDelegateSchema, delegateListQuerySchema, enrollDelegateSchema, updateDelegateSchema, } from "./validation-delegates.js";
+import { addBidEvaluationSchema, awardRfpSchema, createBidSchema, createRfpSchema, inviteSupplierSchema, rfpListQuerySchema, setBidLinesSchema, updateBidSchema, updateRfpSchema, } from "./validation-rfp.js";
+import { createRoomingAssignmentSchema, roomingListQuerySchema, setRoomingDelegatesSchema, updateRoomingAssignmentSchema, } from "./validation-rooming.js";
 import { createSessionSchema, sessionListQuerySchema, setSessionInclusionsSchema, updateSessionSchema, } from "./validation-sessions.js";
 export const miceAdminRoutes = new Hono()
     .get("/programs", async (c) => {
@@ -68,4 +74,165 @@ export const miceAdminRoutes = new Hono()
         return c.json({ error: "Session not found" }, 404);
     const { inclusions } = await parseJsonBody(c, setSessionInclusionsSchema);
     return c.json({ data: await setSessionInclusions(c.get("db"), id, inclusions) });
+})
+    // Delegates + session enrollment (RFC voyant#1489 Phase 3).
+    .get("/delegates", async (c) => {
+    const query = await parseQuery(c, delegateListQuerySchema);
+    return c.json(await listDelegates(c.get("db"), query));
+})
+    .post("/delegates", async (c) => {
+    const body = await parseJsonBody(c, createDelegateSchema);
+    const outcome = await createDelegate(c.get("db"), body);
+    if (outcome.status === "program_not_found")
+        return c.json({ error: "Program not found" }, 404);
+    return c.json({ data: outcome.delegate }, 201);
+})
+    .get("/delegates/:id", async (c) => {
+    const delegate = await getDelegate(c.get("db"), c.req.param("id"));
+    if (!delegate)
+        return c.json({ error: "Delegate not found" }, 404);
+    return c.json({ data: delegate });
+})
+    .patch("/delegates/:id", async (c) => {
+    const body = await parseJsonBody(c, updateDelegateSchema);
+    const delegate = await updateDelegate(c.get("db"), c.req.param("id"), body);
+    if (!delegate)
+        return c.json({ error: "Delegate not found" }, 404);
+    return c.json({ data: delegate });
+})
+    .post("/delegates/:id/enrollments", async (c) => {
+    const body = await parseJsonBody(c, enrollDelegateSchema);
+    const outcome = await enrollDelegate(c.get("db"), c.req.param("id"), body);
+    switch (outcome.status) {
+        case "ok":
+            return c.json({ data: outcome.enrollment }, outcome.idempotent ? 200 : 201);
+        case "delegate_not_found":
+            return c.json({ error: "Delegate not found" }, 404);
+        case "session_not_found":
+            return c.json({ error: "Session not found" }, 404);
+        case "program_mismatch":
+            return c.json({ error: "Session belongs to a different program" }, 409);
+    }
+})
+    // Rooming manifest (RFC voyant#1489 Phase 3).
+    .get("/rooming-assignments", async (c) => {
+    const query = await parseQuery(c, roomingListQuerySchema);
+    return c.json(await listRoomingAssignments(c.get("db"), query));
+})
+    .post("/rooming-assignments", async (c) => {
+    const body = await parseJsonBody(c, createRoomingAssignmentSchema);
+    const outcome = await createRoomingAssignment(c.get("db"), body);
+    if (outcome.status === "program_not_found")
+        return c.json({ error: "Program not found" }, 404);
+    return c.json({ data: outcome.assignment }, 201);
+})
+    .get("/rooming-assignments/:id", async (c) => {
+    const assignment = await getRoomingAssignment(c.get("db"), c.req.param("id"));
+    if (!assignment)
+        return c.json({ error: "Rooming assignment not found" }, 404);
+    return c.json({ data: assignment });
+})
+    .patch("/rooming-assignments/:id", async (c) => {
+    const body = await parseJsonBody(c, updateRoomingAssignmentSchema);
+    const assignment = await updateRoomingAssignment(c.get("db"), c.req.param("id"), body);
+    if (!assignment)
+        return c.json({ error: "Rooming assignment not found" }, 404);
+    return c.json({ data: assignment });
+})
+    .put("/rooming-assignments/:id/delegates", async (c) => {
+    const { delegates } = await parseJsonBody(c, setRoomingDelegatesSchema);
+    const outcome = await setRoomingDelegates(c.get("db"), c.req.param("id"), delegates);
+    switch (outcome.status) {
+        case "ok":
+            return c.json({ data: outcome.delegates });
+        case "assignment_not_found":
+            return c.json({ error: "Rooming assignment not found" }, 404);
+        case "delegate_not_found":
+            return c.json({ error: "Delegate not found", detail: { missing: outcome.missing } }, 404);
+        case "program_mismatch":
+            return c.json({
+                error: "Delegate belongs to a different program",
+                detail: { offending: outcome.offending },
+            }, 409);
+    }
+})
+    // Sourcing funnel: RFP → invitations → bids → evaluation → award (Phase 4).
+    .get("/rfps", async (c) => {
+    const query = await parseQuery(c, rfpListQuerySchema);
+    return c.json(await rfpService.listRfps(c.get("db"), query));
+})
+    .post("/rfps", async (c) => {
+    const body = await parseJsonBody(c, createRfpSchema);
+    const outcome = await rfpService.createRfp(c.get("db"), body);
+    if (outcome.status === "program_not_found")
+        return c.json({ error: "Program not found" }, 404);
+    return c.json({ data: outcome.rfp }, 201);
+})
+    .get("/rfps/:id", async (c) => {
+    const rfp = await rfpService.getRfp(c.get("db"), c.req.param("id"));
+    if (!rfp)
+        return c.json({ error: "RFP not found" }, 404);
+    return c.json({ data: rfp });
+})
+    .patch("/rfps/:id", async (c) => {
+    const body = await parseJsonBody(c, updateRfpSchema);
+    const rfp = await rfpService.updateRfp(c.get("db"), c.req.param("id"), body);
+    if (!rfp)
+        return c.json({ error: "RFP not found" }, 404);
+    return c.json({ data: rfp });
+})
+    .post("/rfps/:id/invitations", async (c) => {
+    const body = await parseJsonBody(c, inviteSupplierSchema);
+    const outcome = await rfpService.inviteSupplier(c.get("db"), c.req.param("id"), body);
+    if (outcome.status === "rfp_not_found")
+        return c.json({ error: "RFP not found" }, 404);
+    return c.json({ data: outcome.invitation }, outcome.idempotent ? 200 : 201);
+})
+    .post("/rfps/:id/bids", async (c) => {
+    const body = await parseJsonBody(c, createBidSchema);
+    const outcome = await rfpService.createBid(c.get("db"), c.req.param("id"), body);
+    if (outcome.status === "rfp_not_found")
+        return c.json({ error: "RFP not found" }, 404);
+    return c.json({ data: outcome.bid }, 201);
+})
+    .post("/rfps/:id/award", async (c) => {
+    const { bidId } = await parseJsonBody(c, awardRfpSchema);
+    const outcome = await rfpService.awardRfp(c.get("db"), c.req.param("id"), bidId);
+    switch (outcome.status) {
+        case "ok":
+            return c.json({ data: { rfp: outcome.rfp, bid: outcome.bid } });
+        case "rfp_not_found":
+            return c.json({ error: "RFP not found" }, 404);
+        case "bid_not_found":
+            return c.json({ error: "Bid not found on this RFP" }, 404);
+        case "already_awarded":
+            return c.json({ error: "RFP is already awarded" }, 409);
+    }
+})
+    .get("/bids/:id", async (c) => {
+    const bid = await rfpService.getBid(c.get("db"), c.req.param("id"));
+    if (!bid)
+        return c.json({ error: "Bid not found" }, 404);
+    return c.json({ data: bid });
+})
+    .patch("/bids/:id", async (c) => {
+    const body = await parseJsonBody(c, updateBidSchema);
+    const bid = await rfpService.updateBid(c.get("db"), c.req.param("id"), body);
+    if (!bid)
+        return c.json({ error: "Bid not found" }, 404);
+    return c.json({ data: bid });
+})
+    .put("/bids/:id/lines", async (c) => {
+    const { lines } = await parseJsonBody(c, setBidLinesSchema);
+    const outcome = await rfpService.setBidLines(c.get("db"), c.req.param("id"), lines);
+    if (outcome.status === "bid_not_found")
+        return c.json({ error: "Bid not found" }, 404);
+    return c.json({ data: outcome.lines });
+})
+    .post("/bids/:id/evaluations", async (c) => {
+    const body = await parseJsonBody(c, addBidEvaluationSchema);
+    const outcome = await rfpService.addBidEvaluation(c.get("db"), c.req.param("id"), body);
+    if (outcome.status === "bid_not_found")
+        return c.json({ error: "Bid not found" }, 404);
+    return c.json({ data: outcome.evaluation }, 201);
 });

package/dist/schema-delegates.d.ts

@@ -0,0 +1,340 @@
+/**
+ * Delegate registry — the attendee roster of a program with role + lifecycle
+ * status, plus per-session enrollment. The gap the audit found: bookings model
+ * travelers but have no attendee lifecycle (invited → … → checked_in/no_show),
+ * delegate roles, or session enrollment.
+ *
+ * No new PII store (§9-Q7): identity/dietary/accessibility live on the linked
+ * CRM person / booking traveler (KMS-encrypted there). A delegate references
+ * `personId`/`bookingId` and carries only role/status/timing.
+ */
+export declare const delegateRoleEnum: import("drizzle-orm/pg-core").PgEnum<["attendee", "speaker", "sponsor", "vip", "staff", "exhibitor", "organizer"]>;
+export declare const delegateStatusEnum: import("drizzle-orm/pg-core").PgEnum<["invited", "registered", "confirmed", "checked_in", "no_show", "cancelled"]>;
+export declare const programDelegates: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "mice_program_delegates";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_program_delegates";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        programId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+        personId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+        bookingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "mice_program_delegates";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "staff" | "attendee" | "speaker" | "sponsor" | "vip" | "exhibitor" | "organizer";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["attendee", "speaker", "sponsor", "vip", "staff", "exhibitor", "organizer"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "mice_program_delegates";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "cancelled" | "invited" | "registered" | "confirmed" | "checked_in" | "no_show";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["invited", "registered", "confirmed", "checked_in", "no_show", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        arrivalAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "arrival_at";
+            tableName: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+        departureAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "departure_at";
+            tableName: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "mice_program_delegates";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "mice_program_delegates";
+            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: "mice_program_delegates";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const enrollmentStatusEnum: import("drizzle-orm/pg-core").PgEnum<["registered", "waitlisted", "attended", "cancelled"]>;
+export declare const delegateSessionEnrollments: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "mice_delegate_session_enrollments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_delegate_session_enrollments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        delegateId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_delegate_session_enrollments";
+            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;
+        }, {}, {}>;
+        sessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "mice_delegate_session_enrollments";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "mice_delegate_session_enrollments";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "cancelled" | "registered" | "waitlisted" | "attended";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["registered", "waitlisted", "attended", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "mice_delegate_session_enrollments";
+            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: "mice_delegate_session_enrollments";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type ProgramDelegate = typeof programDelegates.$inferSelect;
+export type NewProgramDelegate = typeof programDelegates.$inferInsert;
+export type DelegateSessionEnrollment = typeof delegateSessionEnrollments.$inferSelect;
+export type NewDelegateSessionEnrollment = typeof delegateSessionEnrollments.$inferInsert;
+//# sourceMappingURL=schema-delegates.d.ts.map

package/dist/schema-delegates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-delegates.d.ts","sourceRoot":"","sources":["../src/schema-delegates.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,oHAQ3B,CAAA;AAEF,eAAO,MAAM,kBAAkB,oHAO7B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B5B,CAAA;AAED,eAAO,MAAM,oBAAoB,6FAK/B,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBtC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAA;AAClE,MAAM,MAAM,kBAAkB,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAA;AACrE,MAAM,MAAM,yBAAyB,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACtF,MAAM,MAAM,4BAA4B,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA"}

package/dist/schema-delegates.js

@@ -0,0 +1,76 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { index, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { programs } from "./schema.js";
+import { programSessions } from "./schema-sessions.js";
+/**
+ * Delegate registry — the attendee roster of a program with role + lifecycle
+ * status, plus per-session enrollment. The gap the audit found: bookings model
+ * travelers but have no attendee lifecycle (invited → … → checked_in/no_show),
+ * delegate roles, or session enrollment.
+ *
+ * No new PII store (§9-Q7): identity/dietary/accessibility live on the linked
+ * CRM person / booking traveler (KMS-encrypted there). A delegate references
+ * `personId`/`bookingId` and carries only role/status/timing.
+ */
+export const delegateRoleEnum = pgEnum("mice_delegate_role", [
+    "attendee",
+    "speaker",
+    "sponsor",
+    "vip",
+    "staff",
+    "exhibitor",
+    "organizer",
+]);
+export const delegateStatusEnum = pgEnum("mice_delegate_status", [
+    "invited",
+    "registered",
+    "confirmed",
+    "checked_in",
+    "no_show",
+    "cancelled",
+]);
+export const programDelegates = pgTable("mice_program_delegates", {
+    id: typeId("mice_program_delegates"),
+    // Intra-package FK (delegates + programs both live in mice):
+    programId: typeIdRef("program_id")
+        .notNull()
+        .references(() => programs.id, { onDelete: "cascade" }),
+    // Cross-package → loose columns + defineLink at the deployment:
+    personId: typeIdRef("person_id"), // → relationships.people (nullable: leads pre-booking)
+    bookingId: typeIdRef("booking_id"), // → bookings (populated on confirmation)
+    role: delegateRoleEnum("role").notNull().default("attendee"),
+    status: delegateStatusEnum("status").notNull().default("invited"),
+    arrivalAt: timestamp("arrival_at", { withTimezone: true }),
+    departureAt: timestamp("departure_at", { withTimezone: true }),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_program_delegates_program").on(table.programId),
+    index("idx_mice_program_delegates_program_status").on(table.programId, table.status),
+    index("idx_mice_program_delegates_person").on(table.personId),
+    index("idx_mice_program_delegates_booking").on(table.bookingId),
+]);
+export const enrollmentStatusEnum = pgEnum("mice_enrollment_status", [
+    "registered",
+    "waitlisted",
+    "attended",
+    "cancelled",
+]);
+export const delegateSessionEnrollments = pgTable("mice_delegate_session_enrollments", {
+    id: typeId("mice_delegate_session_enrollments"),
+    delegateId: typeIdRef("delegate_id")
+        .notNull()
+        .references(() => programDelegates.id, { onDelete: "cascade" }),
+    sessionId: typeIdRef("session_id")
+        .notNull()
+        .references(() => programSessions.id, { onDelete: "cascade" }),
+    status: enrollmentStatusEnum("status").notNull().default("registered"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_mice_enrollments_session").on(table.sessionId),
+    // A delegate enrolls in a given session at most once.
+    uniqueIndex("uidx_mice_enrollments_delegate_session").on(table.delegateId, table.sessionId),
+]);