@voyant-travel/cruises 0.118.2

package/dist/schema-search.js

@@ -0,0 +1,64 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { sql } from "drizzle-orm";
+import { char, date, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { cruises } from "./schema-core.js";
+import { cruiseSourceEnum, cruiseTypeEnum } from "./schema-shared.js";
+export const cruiseSearchIndex = pgTable("cruise_search_index", {
+    id: typeId("cruise_search_index"),
+    source: cruiseSourceEnum("source").notNull(),
+    sourceProvider: text("source_provider"),
+    sourceRef: jsonb("source_ref").$type(),
+    localCruiseId: typeIdRef("local_cruise_id").references(() => cruises.id, {
+        onDelete: "cascade",
+    }),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+    cruiseType: cruiseTypeEnum("cruise_type").notNull(),
+    lineName: text("line_name").notNull(),
+    shipName: text("ship_name").notNull(),
+    nights: integer("nights").notNull(),
+    embarkPortName: text("embark_port_name"),
+    embarkPortCanonicalPlaceId: text("embark_port_canonical_place_id"),
+    disembarkPortName: text("disembark_port_name"),
+    disembarkPortCanonicalPlaceId: text("disembark_port_canonical_place_id"),
+    regionIds: jsonb("region_ids").$type().default([]),
+    waterwayIds: jsonb("waterway_ids").$type().default([]),
+    portIds: jsonb("port_ids").$type().default([]),
+    countryIso: jsonb("country_iso").$type().default([]),
+    regions: jsonb("regions").$type().default([]),
+    waterways: jsonb("waterways").$type().default([]),
+    ports: jsonb("ports").$type().default([]),
+    countries: jsonb("countries").$type().default([]),
+    themes: jsonb("themes").$type().default([]),
+    earliestDeparture: date("earliest_departure"),
+    latestDeparture: date("latest_departure"),
+    departureCount: integer("departure_count"),
+    lowestPriceCents: integer("lowest_price_cents"),
+    lowestPriceCurrency: char("lowest_price_currency", { length: 3 }),
+    salesStatus: text("sales_status"),
+    heroImageUrl: text("hero_image_url"),
+    refreshedAt: timestamp("refreshed_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_cruise_search_index_slug").on(table.slug),
+    index("idx_cruise_search_index_source_refreshed").on(table.source, table.refreshedAt),
+    index("idx_cruise_search_index_type_price").on(table.cruiseType, table.lowestPriceCents),
+    index("idx_cruise_search_index_earliest_departure").on(table.earliestDeparture),
+    index("idx_cruise_search_index_latest_departure").on(table.latestDeparture),
+    index("idx_cruise_search_index_embark_place").on(table.embarkPortCanonicalPlaceId),
+    index("idx_cruise_search_index_disembark_place").on(table.disembarkPortCanonicalPlaceId),
+    index("idx_cruise_search_index_region_ids_gin").using("gin", table.regionIds),
+    index("idx_cruise_search_index_waterway_ids_gin").using("gin", table.waterwayIds),
+    index("idx_cruise_search_index_port_ids_gin").using("gin", table.portIds),
+    index("idx_cruise_search_index_country_iso_gin").using("gin", table.countryIso),
+    index("idx_cruise_search_index_regions_gin").using("gin", table.regions),
+    index("idx_cruise_search_index_waterways_gin").using("gin", table.waterways),
+    index("idx_cruise_search_index_ports_gin").using("gin", table.ports),
+    index("idx_cruise_search_index_countries_gin").using("gin", table.countries),
+    index("idx_cruise_search_index_themes_gin").using("gin", table.themes),
+    uniqueIndex("uidx_cruise_search_index_external")
+        .on(table.sourceProvider, table.sourceRef)
+        // agent-quality: raw-sql reviewed -- owner: cruises; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        .where(sql `${table.source} = 'external'`),
+]);

package/dist/schema-shared.d.ts

@@ -0,0 +1,23 @@
+export declare const cruiseTypeEnum: import("drizzle-orm/pg-core").PgEnum<["ocean", "river", "expedition", "coastal"]>;
+export declare const cruiseStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "awaiting_review", "live", "archived"]>;
+export declare const cruiseSourceEnum: import("drizzle-orm/pg-core").PgEnum<["local", "external"]>;
+export declare const cruiseVoyageGroupKindEnum: import("drizzle-orm/pg-core").PgEnum<["combination", "grand_voyage", "world_cruise", "cruise_tour"]>;
+export declare const cruiseVoyageSegmentKindEnum: import("drizzle-orm/pg-core").PgEnum<["cruise", "land", "hotel", "transfer", "rail", "air", "other"]>;
+export declare const cruiseVoyageSegmentRoleEnum: import("drizzle-orm/pg-core").PgEnum<["core", "pre_extension", "post_extension"]>;
+export declare const shipTypeEnum: import("drizzle-orm/pg-core").PgEnum<["ocean", "river", "expedition", "yacht", "sailing", "coastal"]>;
+export declare const cabinRoomTypeEnum: import("drizzle-orm/pg-core").PgEnum<["inside", "oceanview", "balcony", "suite", "penthouse", "single"]>;
+export declare const sailingSalesStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "on_request", "wait_list", "sold_out", "closed"]>;
+export declare const priceAvailabilityEnum: import("drizzle-orm/pg-core").PgEnum<["available", "limited", "on_request", "wait_list", "sold_out"]>;
+export declare const priceFareVariantEnum: import("drizzle-orm/pg-core").PgEnum<["cruise_only", "air_inclusive"]>;
+export declare const priceComponentKindEnum: import("drizzle-orm/pg-core").PgEnum<["gratuity", "onboard_credit", "port_charge", "tax", "ncf", "airfare", "transfer", "insurance"]>;
+export declare const priceComponentDirectionEnum: import("drizzle-orm/pg-core").PgEnum<["addition", "inclusion", "credit"]>;
+export declare const cruiseMediaTypeEnum: import("drizzle-orm/pg-core").PgEnum<["image", "video", "document"]>;
+export declare const cruiseInclusionKindEnum: import("drizzle-orm/pg-core").PgEnum<["meals", "drinks", "gratuities", "transfers", "excursions", "wifi", "other"]>;
+export declare const enrichmentProgramKindEnum: import("drizzle-orm/pg-core").PgEnum<["naturalist", "historian", "photographer", "lecturer", "expert", "other"]>;
+/**
+ * Sailing direction. River cruises use upstream/downstream; ocean cruises
+ * typically use round_trip (return to embark port) — though many lines
+ * leave it null, which is valid.
+ */
+export declare const cruiseSailingDirectionEnum: import("drizzle-orm/pg-core").PgEnum<["upstream", "downstream", "round_trip", "one_way"]>;
+//# sourceMappingURL=schema-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-shared.d.ts","sourceRoot":"","sources":["../src/schema-shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,mFAAqE,CAAA;AAEhG,eAAO,MAAM,gBAAgB,wFAK3B,CAAA;AAEF,eAAO,MAAM,gBAAgB,6DAAiD,CAAA;AAE9E,eAAO,MAAM,yBAAyB,sGAKpC,CAAA;AAEF,eAAO,MAAM,2BAA2B,uGAQtC,CAAA;AAEF,eAAO,MAAM,2BAA2B,mFAItC,CAAA;AAEF,eAAO,MAAM,YAAY,uGAOvB,CAAA;AAEF,eAAO,MAAM,iBAAiB,0GAO5B,CAAA;AAEF,eAAO,MAAM,sBAAsB,iGAMjC,CAAA;AAEF,eAAO,MAAM,qBAAqB,uGAMhC,CAAA;AAEF,eAAO,MAAM,oBAAoB,wEAG/B,CAAA;AAEF,eAAO,MAAM,sBAAsB,uIASjC,CAAA;AAEF,eAAO,MAAM,2BAA2B,2EAItC,CAAA;AAEF,eAAO,MAAM,mBAAmB,sEAA8D,CAAA;AAE9F,eAAO,MAAM,uBAAuB,qHAQlC,CAAA;AAEF,eAAO,MAAM,yBAAyB,kHAOpC,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,2FAKrC,CAAA"}

package/dist/schema-shared.js

@@ -0,0 +1,107 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const cruiseTypeEnum = pgEnum("cruise_type", ["ocean", "river", "expedition", "coastal"]);
+export const cruiseStatusEnum = pgEnum("cruise_status", [
+    "draft",
+    "awaiting_review",
+    "live",
+    "archived",
+]);
+export const cruiseSourceEnum = pgEnum("cruise_source", ["local", "external"]);
+export const cruiseVoyageGroupKindEnum = pgEnum("cruise_voyage_group_kind", [
+    "combination",
+    "grand_voyage",
+    "world_cruise",
+    "cruise_tour",
+]);
+export const cruiseVoyageSegmentKindEnum = pgEnum("cruise_voyage_segment_kind", [
+    "cruise",
+    "land",
+    "hotel",
+    "transfer",
+    "rail",
+    "air",
+    "other",
+]);
+export const cruiseVoyageSegmentRoleEnum = pgEnum("cruise_voyage_segment_role", [
+    "core",
+    "pre_extension",
+    "post_extension",
+]);
+export const shipTypeEnum = pgEnum("cruise_ship_type", [
+    "ocean",
+    "river",
+    "expedition",
+    "yacht",
+    "sailing",
+    "coastal",
+]);
+export const cabinRoomTypeEnum = pgEnum("cruise_cabin_room_type", [
+    "inside",
+    "oceanview",
+    "balcony",
+    "suite",
+    "penthouse",
+    "single",
+]);
+export const sailingSalesStatusEnum = pgEnum("cruise_sailing_sales_status", [
+    "open",
+    "on_request",
+    "wait_list",
+    "sold_out",
+    "closed",
+]);
+export const priceAvailabilityEnum = pgEnum("cruise_price_availability", [
+    "available",
+    "limited",
+    "on_request",
+    "wait_list",
+    "sold_out",
+]);
+export const priceFareVariantEnum = pgEnum("cruise_price_fare_variant", [
+    "cruise_only",
+    "air_inclusive",
+]);
+export const priceComponentKindEnum = pgEnum("cruise_price_component_kind", [
+    "gratuity",
+    "onboard_credit",
+    "port_charge",
+    "tax",
+    "ncf",
+    "airfare",
+    "transfer",
+    "insurance",
+]);
+export const priceComponentDirectionEnum = pgEnum("cruise_price_component_direction", [
+    "addition",
+    "inclusion",
+    "credit",
+]);
+export const cruiseMediaTypeEnum = pgEnum("cruise_media_type", ["image", "video", "document"]);
+export const cruiseInclusionKindEnum = pgEnum("cruise_inclusion_kind", [
+    "meals",
+    "drinks",
+    "gratuities",
+    "transfers",
+    "excursions",
+    "wifi",
+    "other",
+]);
+export const enrichmentProgramKindEnum = pgEnum("cruise_enrichment_program_kind", [
+    "naturalist",
+    "historian",
+    "photographer",
+    "lecturer",
+    "expert",
+    "other",
+]);
+/**
+ * Sailing direction. River cruises use upstream/downstream; ocean cruises
+ * typically use round_trip (return to embark port) — though many lines
+ * leave it null, which is valid.
+ */
+export const cruiseSailingDirectionEnum = pgEnum("cruise_sailing_direction", [
+    "upstream",
+    "downstream",
+    "round_trip",
+    "one_way",
+]);

package/dist/schema-sourced-content.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Cruises sourced-content cache. Sibling to
+ * `products_sourced_content` — same shape, different vertical.
+ *
+ * One row per sourced cruise × locale × market. Stores the rich
+ * detail-page content the upstream adapter served via `getContent`,
+ * plus the SWR metadata the read service needs.
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §3.2.
+ */
+export type CruisesSourcedContentFetchStatus = "ok" | "stale" | "error" | "unsupported";
+export declare const CRUISES_CONTENT_MARKET_ANY = "*";
+export declare const cruisesSourcedContentTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "cruises_sourced_content";
+    schema: undefined;
+    columns: {
+        entity_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        locale: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locale";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        market: import("drizzle-orm/pg-core").PgColumn<{
+            name: "market";
+            tableName: "cruises_sourced_content";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "cruises_sourced_content";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        content_schema_version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_schema_version";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        returned_locale: import("drizzle-orm/pg-core").PgColumn<{
+            name: "returned_locale";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        machine_translated: import("drizzle-orm/pg-core").PgColumn<{
+            name: "machine_translated";
+            tableName: "cruises_sourced_content";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_updated_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_updated_at";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        fetched_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fetched_at";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        fresh_until: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fresh_until";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        etag: import("drizzle-orm/pg-core").PgColumn<{
+            name: "etag";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+        fetch_status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fetch_status";
+            tableName: "cruises_sourced_content";
+            dataType: "string";
+            columnType: "PgText";
+            data: CruisesSourcedContentFetchStatus;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: CruisesSourcedContentFetchStatus;
+        }>;
+        fetch_error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fetch_error";
+            tableName: "cruises_sourced_content";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type InsertCruisesSourcedContent = typeof cruisesSourcedContentTable.$inferInsert;
+export type SelectCruisesSourcedContent = typeof cruisesSourcedContentTable.$inferSelect;
+//# sourceMappingURL=schema-sourced-content.d.ts.map

package/dist/schema-sourced-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-sourced-content.d.ts","sourceRoot":"","sources":["../src/schema-sourced-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,MAAM,gCAAgC,GAAG,IAAI,GAAG,OAAO,GAAG,OAAO,GAAG,aAAa,CAAA;AAEvF,eAAO,MAAM,0BAA0B,MAAM,CAAA;AAE7C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCtC,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACxF,MAAM,MAAM,2BAA2B,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA"}

package/dist/schema-sourced-content.js

@@ -0,0 +1,38 @@
+/**
+ * Cruises sourced-content cache. Sibling to
+ * `products_sourced_content` — same shape, different vertical.
+ *
+ * One row per sourced cruise × locale × market. Stores the rich
+ * detail-page content the upstream adapter served via `getContent`,
+ * plus the SWR metadata the read service needs.
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §3.2.
+ */
+import { boolean, index, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
+export const CRUISES_CONTENT_MARKET_ANY = "*";
+export const cruisesSourcedContentTable = pgTable("cruises_sourced_content", {
+    /** TypeID matching the cruises module — `crus_*`. */
+    entity_id: text("entity_id").notNull(),
+    /** BCP 47 language tag. */
+    locale: text("locale").notNull(),
+    /** Market id, or `'*'` for all-markets. */
+    market: text("market").notNull().default(CRUISES_CONTENT_MARKET_ANY),
+    payload: jsonb("payload").$type().notNull(),
+    content_schema_version: text("content_schema_version").notNull(),
+    returned_locale: text("returned_locale").notNull(),
+    machine_translated: boolean("machine_translated").notNull().default(false),
+    source_updated_at: timestamp("source_updated_at", { withTimezone: true }),
+    fetched_at: timestamp("fetched_at", { withTimezone: true }).notNull().defaultNow(),
+    fresh_until: timestamp("fresh_until", { withTimezone: true }),
+    etag: text("etag"),
+    fetch_status: text("fetch_status")
+        .$type()
+        .notNull()
+        .default("ok"),
+    fetch_error: text("fetch_error"),
+}, (table) => [
+    primaryKey({ columns: [table.entity_id, table.locale, table.market] }),
+    index("cruises_sourced_content_locale_fresh_idx").on(table.locale, table.fresh_until),
+    index("cruises_sourced_content_returned_locale_idx").on(table.entity_id, table.returned_locale),
+    index("cruises_sourced_content_schema_version_idx").on(table.content_schema_version),
+]);

package/dist/schema.d.ts

@@ -0,0 +1,10 @@
+export { bookingCruiseDetails, bookingGroupCruiseDetails, cruiseBookingModeEnum, } from "./booking-extension.js";
+export * from "./schema-cabins.js";
+export * from "./schema-content.js";
+export * from "./schema-core.js";
+export * from "./schema-itinerary.js";
+export * from "./schema-pricing.js";
+export * from "./schema-search.js";
+export * from "./schema-shared.js";
+export { CRUISES_CONTENT_MARKET_ANY, type CruisesSourcedContentFetchStatus, cruisesSourcedContentTable, type InsertCruisesSourcedContent, type SelectCruisesSourcedContent, } from "./schema-sourced-content.js";
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,wBAAwB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,OAAO,EACL,0BAA0B,EAC1B,KAAK,gCAAgC,EACrC,0BAA0B,EAC1B,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,GACjC,MAAM,6BAA6B,CAAA"}

package/dist/schema.js

@@ -0,0 +1,9 @@
+export { bookingCruiseDetails, bookingGroupCruiseDetails, cruiseBookingModeEnum, } from "./booking-extension.js";
+export * from "./schema-cabins.js";
+export * from "./schema-content.js";
+export * from "./schema-core.js";
+export * from "./schema-itinerary.js";
+export * from "./schema-pricing.js";
+export * from "./schema-search.js";
+export * from "./schema-shared.js";
+export { CRUISES_CONTENT_MARKET_ANY, cruisesSourcedContentTable, } from "./schema-sourced-content.js";

package/dist/service-booking-helpers.d.ts

@@ -0,0 +1,12 @@
+import type { ExternalPassengerComposition, SourceRef } from "./adapters/index.js";
+import type { CruiseBookingPassenger } from "./service-booking-types.js";
+export declare function generateCruiseBookingNumber(suffix?: string | number): string;
+export declare function priceCentsFromString(s: string): number;
+export declare function passengerCompositionFromPassengers(passengers: CruiseBookingPassenger[]): ExternalPassengerComposition;
+export declare function passengerCompositionCount(composition: ExternalPassengerComposition): number;
+export declare function assertPassengerCompositionMatchesPassengers(supplied: ExternalPassengerComposition | null | undefined, passengers: CruiseBookingPassenger[]): ExternalPassengerComposition;
+export declare function sourceRefKey(ref: SourceRef): string;
+export declare function sortValue(value: unknown): unknown;
+export declare function sourceRefMatches(candidate: SourceRef, requested: SourceRef): boolean;
+export declare function passengerCompositionMatches(candidate: ExternalPassengerComposition | null | undefined, requested: ExternalPassengerComposition | null | undefined): boolean;
+//# sourceMappingURL=service-booking-helpers.d.ts.map

package/dist/service-booking-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-booking-helpers.d.ts","sourceRoot":"","sources":["../src/service-booking-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAClF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AAExE,wBAAgB,2BAA2B,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAI5E;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAWtD;AAED,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,sBAAsB,EAAE,GACnC,4BAA4B,CAY9B;AAED,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,4BAA4B,GAAG,MAAM,CAO3F;AAED,wBAAgB,2CAA2C,CACzD,QAAQ,EAAE,4BAA4B,GAAG,IAAI,GAAG,SAAS,EACzD,UAAU,EAAE,sBAAsB,EAAE,GACnC,4BAA4B,CAkC9B;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAEnD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQjD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAKpF;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,4BAA4B,GAAG,IAAI,GAAG,SAAS,EAC1D,SAAS,EAAE,4BAA4B,GAAG,IAAI,GAAG,SAAS,GACzD,OAAO,CAMT"}

package/dist/service-booking-helpers.js

@@ -0,0 +1,94 @@
+export function generateCruiseBookingNumber(suffix) {
+    const ts = Date.now().toString(36).toUpperCase();
+    const rand = Math.random().toString(36).slice(2, 6).toUpperCase();
+    return suffix === undefined ? `CR-${ts}-${rand}` : `CR-${ts}-${rand}-${suffix}`;
+}
+export function priceCentsFromString(s) {
+    // For passing to bookingsService which expects integer cents.
+    // Pricing service emits decimal strings already validated to ^-?\d+(\.\d{1,2})?$
+    const negative = s.startsWith("-");
+    const abs = negative ? s.slice(1) : s;
+    const parts = abs.split(".");
+    const whole = parts[0] ?? "0";
+    const frac = parts[1] ?? "";
+    const fracPadded = `${frac}00`.slice(0, 2);
+    const cents = Number(whole) * 100 + Number(fracPadded);
+    return negative ? -cents : cents;
+}
+export function passengerCompositionFromPassengers(passengers) {
+    let adults = 0;
+    let children = 0;
+    let infants = 0;
+    let seniors = 0;
+    for (const passenger of passengers) {
+        if (passenger.travelerCategory === "child")
+            children += 1;
+        else if (passenger.travelerCategory === "infant")
+            infants += 1;
+        else if (passenger.travelerCategory === "senior")
+            seniors += 1;
+        else
+            adults += 1;
+    }
+    return { adults, children, infants, seniors };
+}
+export function passengerCompositionCount(composition) {
+    return (composition.adults +
+        (composition.children ?? 0) +
+        (composition.infants ?? 0) +
+        (composition.seniors ?? 0));
+}
+export function assertPassengerCompositionMatchesPassengers(supplied, passengers) {
+    const inferred = passengerCompositionFromPassengers(passengers);
+    if (!supplied)
+        return inferred;
+    const expected = {
+        adults: supplied.adults,
+        children: supplied.children ?? 0,
+        infants: supplied.infants ?? 0,
+        seniors: supplied.seniors ?? 0,
+    };
+    const actual = {
+        adults: inferred.adults,
+        children: inferred.children ?? 0,
+        infants: inferred.infants ?? 0,
+        seniors: inferred.seniors ?? 0,
+    };
+    if (expected.adults !== actual.adults ||
+        expected.children !== actual.children ||
+        expected.infants !== actual.infants ||
+        expected.seniors !== actual.seniors) {
+        throw new Error(`passengerComposition does not match passengers: composition=${JSON.stringify(expected)} passengers=${JSON.stringify(actual)}`);
+    }
+    if (supplied.childAges && supplied.childAges.length !== expected.children) {
+        throw new Error(`passengerComposition.childAges length (${supplied.childAges.length}) must match children (${expected.children})`);
+    }
+    return supplied;
+}
+export function sourceRefKey(ref) {
+    return JSON.stringify(sortValue(ref));
+}
+export function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+        out[key] = sortValue(value[key]);
+    }
+    return out;
+}
+export function sourceRefMatches(candidate, requested) {
+    if (sourceRefKey(candidate) === sourceRefKey(requested))
+        return true;
+    const candidateIsLegacy = Object.keys(candidate).length === 1;
+    const requestedIsLegacy = Object.keys(requested).length === 1;
+    return (candidateIsLegacy || requestedIsLegacy) && candidate.externalId === requested.externalId;
+}
+export function passengerCompositionMatches(candidate, requested) {
+    if (!candidate || !requested)
+        return true;
+    return (sourceRefKey({ externalId: "composition", ...candidate }) ===
+        sourceRefKey({ externalId: "composition", ...requested }));
+}