@voyant-travel/charters 0.117.2

package/dist/schema-pricing.d.ts

@@ -0,0 +1,385 @@
+/**
+ * Per-suite pricing on a voyage. Charter pricing is flat — one row per suite
+ * per voyage, no occupancy variants and no fare codes (unlike cruises). The
+ * four explicit currency columns let SQL filter and order by price natively;
+ * tertiary currencies handle via FX at display time.
+ */
+export declare const charterSuites: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "charter_suites";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        voyageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        suiteCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "suite_code";
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        suiteName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "suite_name";
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        suiteCategory: import("drizzle-orm/pg-core").PgColumn<{
+            name: "suite_category";
+            tableName: "charter_suites";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "standard" | "deluxe" | "suite" | "penthouse" | "owners" | "signature";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["standard", "deluxe", "suite", "penthouse", "owners", "signature"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        squareFeet: import("drizzle-orm/pg-core").PgColumn<{
+            name: "square_feet";
+            tableName: "charter_suites";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        images: import("drizzle-orm/pg-core").PgColumn<{
+            name: "images";
+            tableName: "charter_suites";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        floorplanImages: import("drizzle-orm/pg-core").PgColumn<{
+            name: "floorplan_images";
+            tableName: "charter_suites";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        maxGuests: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_guests";
+            tableName: "charter_suites";
+            dataType: "number";
+            columnType: "PgSmallInt";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricesByCurrency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "prices_by_currency";
+            tableName: "charter_suites";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, string>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, string>;
+        }>;
+        portFeesByCurrency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "port_fees_by_currency";
+            tableName: "charter_suites";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, string>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, string>;
+        }>;
+        availability: import("drizzle-orm/pg-core").PgColumn<{
+            name: "availability";
+            tableName: "charter_suites";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "available" | "on_request" | "wait_list" | "sold_out" | "limited";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["available", "limited", "on_request", "wait_list", "sold_out"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        unitsAvailable: import("drizzle-orm/pg-core").PgColumn<{
+            name: "units_available";
+            tableName: "charter_suites";
+            dataType: "number";
+            columnType: "PgSmallInt";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        appointmentOnly: import("drizzle-orm/pg-core").PgColumn<{
+            name: "appointment_only";
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        extra: import("drizzle-orm/pg-core").PgColumn<{
+            name: "extra";
+            tableName: "charter_suites";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        externalRefs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "external_refs";
+            tableName: "charter_suites";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, string>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, string>;
+        }>;
+        lastSyncedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_synced_at";
+            tableName: "charter_suites";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "charter_suites";
+            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: "charter_suites";
+            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 CharterSuite = typeof charterSuites.$inferSelect;
+export type NewCharterSuite = typeof charterSuites.$inferInsert;
+//# sourceMappingURL=schema-pricing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-pricing.d.ts","sourceRoot":"","sources":["../src/schema-pricing.ts"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DzB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA"}

package/dist/schema-pricing.js

@@ -0,0 +1,62 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, index, jsonb, numeric, pgTable, smallint, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { charterVoyages } from "./schema-core.js";
+import { suiteAvailabilityEnum, suiteCategoryEnum } from "./schema-shared.js";
+/**
+ * Per-suite pricing on a voyage. Charter pricing is flat — one row per suite
+ * per voyage, no occupancy variants and no fare codes (unlike cruises). The
+ * four explicit currency columns let SQL filter and order by price natively;
+ * tertiary currencies handle via FX at display time.
+ */
+export const charterSuites = pgTable("charter_suites", {
+    id: typeId("charter_suites"),
+    voyageId: typeIdRef("voyage_id")
+        .notNull()
+        .references(() => charterVoyages.id, { onDelete: "cascade" }),
+    suiteCode: text("suite_code").notNull(),
+    suiteName: text("suite_name").notNull(),
+    suiteCategory: suiteCategoryEnum("suite_category"),
+    description: text("description"),
+    squareFeet: numeric("square_feet", { precision: 8, scale: 2 }),
+    images: jsonb("images").$type().default([]),
+    floorplanImages: jsonb("floorplan_images").$type().default([]),
+    /** Used at booking time to validate party size; not used for pricing math. */
+    maxGuests: smallint("max_guests"),
+    /**
+     * Per-currency flat suite price as a `{ "<ISO-4217>": "<numeric-string>" }`
+     * map. Numeric strings preserve trailing zeroes and dodge floating-point
+     * drift. Missing key means the suite isn't priced in that currency.
+     * Adding a new currency is a data-only change — no schema migration.
+     */
+    pricesByCurrency: jsonb("prices_by_currency")
+        .$type()
+        .notNull()
+        .default({}),
+    /**
+     * Optional per-currency port fee, separate from suite price. Same shape
+     * as `pricesByCurrency`.
+     */
+    portFeesByCurrency: jsonb("port_fees_by_currency")
+        .$type()
+        .notNull()
+        .default({}),
+    availability: suiteAvailabilityEnum("availability").notNull().default("available"),
+    unitsAvailable: smallint("units_available"),
+    appointmentOnly: boolean("appointment_only").notNull().default(false),
+    notes: text("notes"),
+    /** Per-brand quirks that don't fit the canonical schema. */
+    extra: jsonb("extra").$type().default({}),
+    externalRefs: jsonb("external_refs").$type().default({}),
+    lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("uidx_charter_suites_voyage_code").on(table.voyageId, table.suiteCode),
+    index("idx_charter_suites_voyage_availability").on(table.voyageId, table.availability),
+    // Note: removed the previous (voyage_id, category, price_usd) composite
+    // index when prices moved into a jsonb map. Sort-by-price queries on
+    // the deployment's browse currency now use the GIN index implicitly via
+    // jsonb operators; if a per-currency btree becomes a hot path we can
+    // add an expression index on `(prices_by_currency ->> 'USD')::numeric`.
+    index("idx_charter_suites_voyage_category").on(table.voyageId, table.suiteCategory),
+]);

package/dist/schema-shared.d.ts

@@ -0,0 +1,8 @@
+export declare const charterStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "awaiting_review", "live", "archived"]>;
+export declare const charterSourceEnum: import("drizzle-orm/pg-core").PgEnum<["local", "external"]>;
+export declare const yachtClassEnum: import("drizzle-orm/pg-core").PgEnum<["luxury_motor", "luxury_sailing", "expedition", "small_cruise"]>;
+export declare const voyageSalesStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "on_request", "wait_list", "sold_out", "closed"]>;
+export declare const suiteCategoryEnum: import("drizzle-orm/pg-core").PgEnum<["standard", "deluxe", "suite", "penthouse", "owners", "signature"]>;
+export declare const suiteAvailabilityEnum: import("drizzle-orm/pg-core").PgEnum<["available", "limited", "on_request", "wait_list", "sold_out"]>;
+export declare const charterBookingModeEnum: import("drizzle-orm/pg-core").PgEnum<["per_suite", "whole_yacht"]>;
+//# 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,iBAAiB,wFAK5B,CAAA;AAEF,eAAO,MAAM,iBAAiB,6DAAkD,CAAA;AAEhF,eAAO,MAAM,cAAc,wGAKzB,CAAA;AAEF,eAAO,MAAM,qBAAqB,iGAMhC,CAAA;AAEF,eAAO,MAAM,iBAAiB,2GAO5B,CAAA;AAEF,eAAO,MAAM,qBAAqB,uGAMhC,CAAA;AAEF,eAAO,MAAM,sBAAsB,oEAA+D,CAAA"}

package/dist/schema-shared.js

@@ -0,0 +1,37 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const charterStatusEnum = pgEnum("charter_status", [
+    "draft",
+    "awaiting_review",
+    "live",
+    "archived",
+]);
+export const charterSourceEnum = pgEnum("charter_source", ["local", "external"]);
+export const yachtClassEnum = pgEnum("charter_yacht_class", [
+    "luxury_motor",
+    "luxury_sailing",
+    "expedition",
+    "small_cruise",
+]);
+export const voyageSalesStatusEnum = pgEnum("charter_voyage_sales_status", [
+    "open",
+    "on_request",
+    "wait_list",
+    "sold_out",
+    "closed",
+]);
+export const suiteCategoryEnum = pgEnum("charter_suite_category", [
+    "standard",
+    "deluxe",
+    "suite",
+    "penthouse",
+    "owners",
+    "signature",
+]);
+export const suiteAvailabilityEnum = pgEnum("charter_suite_availability", [
+    "available",
+    "limited",
+    "on_request",
+    "wait_list",
+    "sold_out",
+]);
+export const charterBookingModeEnum = pgEnum("charter_booking_mode", ["per_suite", "whole_yacht"]);