@voyant-travel/distribution 0.109.8

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-inventory.d.ts","sourceRoot":"","sources":["../src/schema-inventory.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCtC,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsC5C,CAAA;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BxC,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8C7C,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACtF,MAAM,MAAM,4BAA4B,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACzF,MAAM,MAAM,+BAA+B,GAAG,OAAO,gCAAgC,CAAC,YAAY,CAAA;AAClG,MAAM,MAAM,kCAAkC,GAC5C,OAAO,gCAAgC,CAAC,YAAY,CAAA;AACtD,MAAM,MAAM,2BAA2B,GAAG,OAAO,4BAA4B,CAAC,YAAY,CAAA;AAC1F,MAAM,MAAM,8BAA8B,GAAG,OAAO,4BAA4B,CAAC,YAAY,CAAA;AAC7F,MAAM,MAAM,gCAAgC,GAAG,OAAO,iCAAiC,CAAC,YAAY,CAAA;AACpG,MAAM,MAAM,mCAAmC,GAC7C,OAAO,iCAAiC,CAAC,YAAY,CAAA"}

package/dist/schema-inventory.js

@@ -0,0 +1,102 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, date, index, integer, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { channelContracts, channels } from "./schema-core.js";
+import { channelAllotmentReleaseModeEnum, channelAllotmentUnsoldActionEnum, channelReleaseExecutionActionEnum, channelReleaseExecutionStatusEnum, } from "./schema-shared.js";
+export const channelInventoryAllotments = pgTable("channel_inventory_allotments", {
+    id: typeId("channel_inventory_allotments"),
+    channelId: typeIdRef("channel_id")
+        .notNull()
+        .references(() => channels.id, { onDelete: "cascade" }),
+    contractId: typeIdRef("contract_id").references(() => channelContracts.id, {
+        onDelete: "set null",
+    }),
+    productId: typeIdRef("product_id").notNull(),
+    optionId: typeIdRef("option_id"),
+    startTimeId: typeIdRef("start_time_id"),
+    validFrom: date("valid_from"),
+    validTo: date("valid_to"),
+    guaranteedCapacity: integer("guaranteed_capacity"),
+    maxCapacity: integer("max_capacity"),
+    active: boolean("active").notNull().default(true),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_channel_inventory_allotments_updated").on(table.updatedAt),
+    index("idx_channel_inventory_allotments_channel_updated").on(table.channelId, table.updatedAt),
+    index("idx_channel_inventory_allotments_contract_updated").on(table.contractId, table.updatedAt),
+    index("idx_channel_inventory_allotments_product_updated").on(table.productId, table.updatedAt),
+    index("idx_channel_inventory_allotments_option_updated").on(table.optionId, table.updatedAt),
+    index("idx_channel_inventory_allotments_start_time_updated").on(table.startTimeId, table.updatedAt),
+    index("idx_channel_inventory_allotments_active_updated").on(table.active, table.updatedAt),
+]);
+export const channelInventoryAllotmentTargets = pgTable("channel_inventory_allotment_targets", {
+    id: typeId("channel_inventory_allotment_targets"),
+    allotmentId: typeIdRef("allotment_id")
+        .notNull()
+        .references(() => channelInventoryAllotments.id, { onDelete: "cascade" }),
+    slotId: typeIdRef("slot_id"),
+    startTimeId: typeIdRef("start_time_id"),
+    dateLocal: date("date_local"),
+    guaranteedCapacity: integer("guaranteed_capacity"),
+    maxCapacity: integer("max_capacity"),
+    soldCapacity: integer("sold_capacity"),
+    remainingCapacity: integer("remaining_capacity"),
+    active: boolean("active").notNull().default(true),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_channel_inventory_allotment_targets_updated").on(table.updatedAt),
+    index("idx_channel_inventory_allotment_targets_allotment_updated").on(table.allotmentId, table.updatedAt),
+    index("idx_channel_inventory_allotment_targets_slot_updated").on(table.slotId, table.updatedAt),
+    index("idx_channel_inventory_allotment_targets_start_time_updated").on(table.startTimeId, table.updatedAt),
+    index("idx_channel_inventory_allotment_targets_date_updated").on(table.dateLocal, table.updatedAt),
+    index("idx_channel_inventory_allotment_targets_active_updated").on(table.active, table.updatedAt),
+]);
+export const channelInventoryReleaseRules = pgTable("channel_inventory_release_rules", {
+    id: typeId("channel_inventory_release_rules"),
+    allotmentId: typeIdRef("allotment_id")
+        .notNull()
+        .references(() => channelInventoryAllotments.id, { onDelete: "cascade" }),
+    releaseMode: channelAllotmentReleaseModeEnum("release_mode").notNull().default("automatic"),
+    releaseDaysBeforeStart: integer("release_days_before_start"),
+    releaseHoursBeforeStart: integer("release_hours_before_start"),
+    unsoldAction: channelAllotmentUnsoldActionEnum("unsold_action")
+        .notNull()
+        .default("release_to_general_pool"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_channel_inventory_release_rules_updated").on(table.updatedAt),
+    index("idx_channel_inventory_release_rules_allotment_updated").on(table.allotmentId, table.updatedAt),
+    index("idx_channel_inventory_release_rules_mode_updated").on(table.releaseMode, table.updatedAt),
+]);
+export const channelInventoryReleaseExecutions = pgTable("channel_inventory_release_executions", {
+    id: typeId("channel_inventory_release_executions"),
+    allotmentId: typeIdRef("allotment_id")
+        .notNull()
+        .references(() => channelInventoryAllotments.id, { onDelete: "cascade" }),
+    releaseRuleId: typeIdRef("release_rule_id").references(() => channelInventoryReleaseRules.id, {
+        onDelete: "set null",
+    }),
+    targetId: typeIdRef("target_id").references(() => channelInventoryAllotmentTargets.id, {
+        onDelete: "set null",
+    }),
+    slotId: typeIdRef("slot_id"),
+    actionTaken: channelReleaseExecutionActionEnum("action_taken").notNull().default("released"),
+    status: channelReleaseExecutionStatusEnum("status").notNull().default("pending"),
+    releasedCapacity: integer("released_capacity"),
+    executedAt: timestamp("executed_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_channel_inventory_release_executions_updated").on(table.updatedAt),
+    index("idx_channel_inventory_release_executions_allotment_updated").on(table.allotmentId, table.updatedAt),
+    index("idx_channel_inventory_release_executions_rule_updated").on(table.releaseRuleId, table.updatedAt),
+    index("idx_channel_inventory_release_executions_target_updated").on(table.targetId, table.updatedAt),
+    index("idx_channel_inventory_release_executions_slot_updated").on(table.slotId, table.updatedAt),
+    index("idx_channel_inventory_release_executions_status_updated").on(table.status, table.updatedAt),
+]);

package/dist/schema-push-intents.d.ts

@@ -0,0 +1,387 @@
+/**
+ * Durable handoff rows for the channel-push availability and content
+ * flows. Subscribers INSERT into these tables (returning immediately
+ * per the EventBus contract); the scheduled push workflows drain them.
+ *
+ * Booking push doesn't need its own intent table — `channel_booking_links`
+ * already serves both roles (push_status = 'pending' for in-flight,
+ * 'ok' on success).
+ *
+ * Per docs/architecture/channel-push-architecture.md §7.3 and §12.
+ */
+export declare const channelAvailabilityPushIntents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "channel_availability_push_intents";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        channelId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        sourceConnectionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        slotId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "slot_id";
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        optionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "option_id";
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        startsAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "starts_at";
+            tableName: "channel_availability_push_intents";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requestedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "requested_at";
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "channel_availability_push_intents";
+            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;
+        }, {}, {}>;
+        lastError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error";
+            tableName: "channel_availability_push_intents";
+            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: "channel_availability_push_intents";
+            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: "channel_availability_push_intents";
+            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 channelContentPushIntents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "channel_content_push_intents";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "channel_content_push_intents";
+            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;
+        }, {}, {}>;
+        channelId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "channel_content_push_intents";
+            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;
+        }, {}, {}>;
+        sourceConnectionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "channel_content_push_intents";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "channel_content_push_intents";
+            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;
+        }, {}, {}>;
+        requestedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "requested_at";
+            tableName: "channel_content_push_intents";
+            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;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "channel_content_push_intents";
+            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;
+        }, {}, {}>;
+        lastError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_error";
+            tableName: "channel_content_push_intents";
+            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: "channel_content_push_intents";
+            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: "channel_content_push_intents";
+            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 ChannelAvailabilityPushIntent = typeof channelAvailabilityPushIntents.$inferSelect;
+export type NewChannelAvailabilityPushIntent = typeof channelAvailabilityPushIntents.$inferInsert;
+export type ChannelContentPushIntent = typeof channelContentPushIntents.$inferSelect;
+export type NewChannelContentPushIntent = typeof channelContentPushIntents.$inferInsert;
+//# sourceMappingURL=schema-push-intents.d.ts.map

package/dist/schema-push-intents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-push-intents.d.ts","sourceRoot":"","sources":["../src/schema-push-intents.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8C1C,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBrC,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG,OAAO,8BAA8B,CAAC,YAAY,CAAA;AAC9F,MAAM,MAAM,gCAAgC,GAAG,OAAO,8BAA8B,CAAC,YAAY,CAAA;AACjG,MAAM,MAAM,wBAAwB,GAAG,OAAO,yBAAyB,CAAC,YAAY,CAAA;AACpF,MAAM,MAAM,2BAA2B,GAAG,OAAO,yBAAyB,CAAC,YAAY,CAAA"}

package/dist/schema-push-intents.js

@@ -0,0 +1,77 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { index, integer, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { channels } from "./schema-core.js";
+/**
+ * Durable handoff rows for the channel-push availability and content
+ * flows. Subscribers INSERT into these tables (returning immediately
+ * per the EventBus contract); the scheduled push workflows drain them.
+ *
+ * Booking push doesn't need its own intent table — `channel_booking_links`
+ * already serves both roles (push_status = 'pending' for in-flight,
+ * 'ok' on success).
+ *
+ * Per docs/architecture/channel-push-architecture.md §7.3 and §12.
+ */
+export const channelAvailabilityPushIntents = pgTable("channel_availability_push_intents", {
+    id: typeId("channel_availability_push_intents"),
+    channelId: typeIdRef("channel_id")
+        .notNull()
+        .references(() => channels.id, { onDelete: "cascade" }),
+    /**
+     * Connection id resolving to a registered SourceAdapter. Subscriber
+     * reads it from the resolved channel mapping at insert time so the
+     * worker doesn't need to re-resolve.
+     */
+    sourceConnectionId: text("source_connection_id").notNull(),
+    /** Slot id (typeid). Plain text to avoid cross-package FK. */
+    slotId: text("slot_id").notNull(),
+    /** Product id (typeid). Plain text to avoid cross-package FK. */
+    productId: text("product_id").notNull(),
+    /** Optional option id when the channel allotment is option-scoped. */
+    optionId: text("option_id"),
+    /** Slot start time, mirrored from the source event. Diagnostic. */
+    startsAt: timestamp("starts_at", { withTimezone: true }).notNull(),
+    /**
+     * Time the most recent supersession event landed for this
+     * (channel, slot) pair. Workers scan oldest-first; the unique
+     * constraint below collapses concurrent events to one row, so
+     * this is bumped on every UPSERT.
+     */
+    requestedAt: timestamp("requested_at", { withTimezone: true }).notNull().defaultNow(),
+    /** Number of dispatch attempts so far. */
+    attempts: integer("attempts").notNull().default(0),
+    /** Most recent error from the last failed attempt. */
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_chan_avail_push_intents_requested").on(table.channelId, table.requestedAt),
+    index("idx_chan_avail_push_intents_product").on(table.productId, table.requestedAt),
+    /**
+     * Supersession key. Concurrent slot.changed events for the same
+     * (channel, slot) collapse to one row — the worker reads the
+     * *current* slot state when it processes, so stale event payloads
+     * never propagate. Per §5.2.
+     */
+    uniqueIndex("uniq_chan_avail_push_intents_per_slot").on(table.channelId, table.slotId),
+]);
+export const channelContentPushIntents = pgTable("channel_content_push_intents", {
+    id: typeId("channel_content_push_intents"),
+    channelId: typeIdRef("channel_id")
+        .notNull()
+        .references(() => channels.id, { onDelete: "cascade" }),
+    sourceConnectionId: text("source_connection_id").notNull(),
+    productId: text("product_id").notNull(),
+    requestedAt: timestamp("requested_at", { withTimezone: true }).notNull().defaultNow(),
+    attempts: integer("attempts").notNull().default(0),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_chan_content_push_intents_requested").on(table.channelId, table.requestedAt),
+    /**
+     * Supersession key. Concurrent product.content.changed events
+     * collapse to one row per (channel, product). Per §6.2.
+     */
+    uniqueIndex("uniq_chan_content_push_intents_per_product").on(table.channelId, table.productId),
+]);

package/dist/schema-relations.d.ts

@@ -0,0 +1,95 @@
+export declare const channelsRelations: import("drizzle-orm").Relations<"channels", {
+    contracts: import("drizzle-orm").Many<"channel_contracts">;
+    productMappings: import("drizzle-orm").Many<"channel_product_mappings">;
+    bookingLinks: import("drizzle-orm").Many<"channel_booking_links">;
+    webhookEvents: import("drizzle-orm").Many<"channel_webhook_events">;
+    inventoryAllotments: import("drizzle-orm").Many<"channel_inventory_allotments">;
+    settlementRuns: import("drizzle-orm").Many<"channel_settlement_runs">;
+    reconciliationRuns: import("drizzle-orm").Many<"channel_reconciliation_runs">;
+    settlementPolicies: import("drizzle-orm").Many<"channel_settlement_policies">;
+    reconciliationPolicies: import("drizzle-orm").Many<"channel_reconciliation_policies">;
+    remittanceExceptions: import("drizzle-orm").Many<"channel_remittance_exceptions">;
+    contactProjection: import("drizzle-orm").One<"channel_contact_projections", true>;
+}>;
+export declare const channelContactProjectionsRelations: import("drizzle-orm").Relations<"channel_contact_projections", {
+    channel: import("drizzle-orm").One<"channels", true>;
+}>;
+export declare const channelContractsRelations: import("drizzle-orm").Relations<"channel_contracts", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    supplier: import("drizzle-orm").One<"suppliers", false>;
+    commissionRules: import("drizzle-orm").Many<"channel_commission_rules">;
+    inventoryAllotments: import("drizzle-orm").Many<"channel_inventory_allotments">;
+    settlementRuns: import("drizzle-orm").Many<"channel_settlement_runs">;
+    reconciliationRuns: import("drizzle-orm").Many<"channel_reconciliation_runs">;
+}>;
+export declare const channelCommissionRulesRelations: import("drizzle-orm").Relations<"channel_commission_rules", {
+    contract: import("drizzle-orm").One<"channel_contracts", true>;
+}>;
+export declare const channelProductMappingsRelations: import("drizzle-orm").Relations<"channel_product_mappings", {
+    channel: import("drizzle-orm").One<"channels", true>;
+}>;
+export declare const channelBookingLinksRelations: import("drizzle-orm").Relations<"channel_booking_links", {
+    channel: import("drizzle-orm").One<"channels", true>;
+}>;
+export declare const channelInventoryAllotmentsRelations: import("drizzle-orm").Relations<"channel_inventory_allotments", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+    targets: import("drizzle-orm").Many<"channel_inventory_allotment_targets">;
+    releaseRules: import("drizzle-orm").Many<"channel_inventory_release_rules">;
+    releaseExecutions: import("drizzle-orm").Many<"channel_inventory_release_executions">;
+}>;
+export declare const channelInventoryAllotmentTargetsRelations: import("drizzle-orm").Relations<"channel_inventory_allotment_targets", {
+    allotment: import("drizzle-orm").One<"channel_inventory_allotments", true>;
+}>;
+export declare const channelInventoryReleaseRulesRelations: import("drizzle-orm").Relations<"channel_inventory_release_rules", {
+    allotment: import("drizzle-orm").One<"channel_inventory_allotments", true>;
+    schedules: import("drizzle-orm").Many<"channel_release_schedules">;
+}>;
+export declare const channelSettlementRunsRelations: import("drizzle-orm").Relations<"channel_settlement_runs", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+    items: import("drizzle-orm").Many<"channel_settlement_items">;
+    approvals: import("drizzle-orm").Many<"channel_settlement_approvals">;
+}>;
+export declare const channelSettlementItemsRelations: import("drizzle-orm").Relations<"channel_settlement_items", {
+    settlementRun: import("drizzle-orm").One<"channel_settlement_runs", true>;
+    bookingLink: import("drizzle-orm").One<"channel_booking_links", false>;
+    commissionRule: import("drizzle-orm").One<"channel_commission_rules", false>;
+}>;
+export declare const channelReconciliationRunsRelations: import("drizzle-orm").Relations<"channel_reconciliation_runs", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+    items: import("drizzle-orm").Many<"channel_reconciliation_items">;
+}>;
+export declare const channelReconciliationItemsRelations: import("drizzle-orm").Relations<"channel_reconciliation_items", {
+    reconciliationRun: import("drizzle-orm").One<"channel_reconciliation_runs", true>;
+    bookingLink: import("drizzle-orm").One<"channel_booking_links", false>;
+}>;
+export declare const channelInventoryReleaseExecutionsRelations: import("drizzle-orm").Relations<"channel_inventory_release_executions", {
+    allotment: import("drizzle-orm").One<"channel_inventory_allotments", true>;
+    releaseRule: import("drizzle-orm").One<"channel_inventory_release_rules", false>;
+    target: import("drizzle-orm").One<"channel_inventory_allotment_targets", false>;
+}>;
+export declare const channelSettlementPoliciesRelations: import("drizzle-orm").Relations<"channel_settlement_policies", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+}>;
+export declare const channelReconciliationPoliciesRelations: import("drizzle-orm").Relations<"channel_reconciliation_policies", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+}>;
+export declare const channelReleaseSchedulesRelations: import("drizzle-orm").Relations<"channel_release_schedules", {
+    releaseRule: import("drizzle-orm").One<"channel_inventory_release_rules", true>;
+}>;
+export declare const channelRemittanceExceptionsRelations: import("drizzle-orm").Relations<"channel_remittance_exceptions", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    settlementItem: import("drizzle-orm").One<"channel_settlement_items", false>;
+    reconciliationItem: import("drizzle-orm").One<"channel_reconciliation_items", false>;
+}>;
+export declare const channelSettlementApprovalsRelations: import("drizzle-orm").Relations<"channel_settlement_approvals", {
+    settlementRun: import("drizzle-orm").One<"channel_settlement_runs", true>;
+}>;
+export declare const channelWebhookEventsRelations: import("drizzle-orm").Relations<"channel_webhook_events", {
+    channel: import("drizzle-orm").One<"channels", true>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map