npm - @voyantjs/catalog-authoring - Versions diffs - 0.104.1 - Mend

@voyantjs/catalog-authoring 0.104.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/extension.d.ts ADDED Viewed

@@ -0,0 +1,50 @@
+import type { HonoExtension } from "@voyantjs/hono/module";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+/**
+ * Catalog authoring rides on the `products` admin prefix as a HonoExtension,
+ * so its routes land at `/v1/admin/products/...` without `packages/products`
+ * depending on this package (which would cycle, since this package depends on
+ * both products and pricing). Same mechanism as `bookingsSupplierExtension`.
+ *
+ *   POST /v1/admin/products/{id}/duplicate   — clone   (#1493)
+ *   POST /v1/admin/products/compose          — compose (#1495)
+ *
+ * Phase 0: routes are mounted but not yet implemented. The builder, clone,
+ * validator and compose land in later phases.
+ */
+type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare const catalogAuthoringRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/compose": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 501;
+        };
+    };
+} & {
+    "/:id/duplicate": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 501;
+        };
+    };
+}, "/", "/:id/duplicate">;
+export declare const catalogAuthoringExtension: HonoExtension;
+export {};
+//# sourceMappingURL=extension.d.ts.map

package/dist/extension.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE;;;;;;;;;;;GAWG;AAEH,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;yBAEwC,CAAA;AAO3E,eAAO,MAAM,yBAAyB,EAAE,aAGvC,CAAA"}

package/dist/extension.js ADDED Viewed

@@ -0,0 +1,12 @@
+import { Hono } from "hono";
+export const catalogAuthoringRoutes = new Hono()
+    .post("/compose", (c) => c.json({ error: "not_implemented" }, 501))
+    .post("/:id/duplicate", (c) => c.json({ error: "not_implemented" }, 501));
+const catalogAuthoringExtensionDef = {
+    name: "catalog-authoring",
+    module: "products",
+};
+export const catalogAuthoringExtension = {
+    extension: catalogAuthoringExtensionDef,
+    adminRoutes: catalogAuthoringRoutes,
+};

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Module } from "@voyantjs/core";
+export declare const catalogAuthoringModule: Module;
+export { catalogAuthoringExtension, catalogAuthoringRoutes } from "./extension.js";
+export type { NewProductAuthoringRequest, ProductAuthoringRequest } from "./schema.js";
+export { productAuthoringRequests } from "./schema.js";
+export { type ProductGraphSpec, productGraphSpecSchema, } from "./spec.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,eAAO,MAAM,sBAAsB,EAAE,MAEpC,CAAA;AAED,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAClF,YAAY,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EACL,KAAK,gBAAgB,EACrB,sBAAsB,GACvB,MAAM,WAAW,CAAA"}

package/dist/index.js ADDED Viewed

@@ -0,0 +1,6 @@
+export const catalogAuthoringModule = {
+    name: "catalog-authoring",
+};
+export { catalogAuthoringExtension, catalogAuthoringRoutes } from "./extension.js";
+export { productAuthoringRequests } from "./schema.js";
+export { productGraphSpecSchema, } from "./spec.js";

package/dist/schema.d.ts ADDED Viewed

@@ -0,0 +1,85 @@
+/**
+ * Dedup ledger for clone/compose. A clone or compose has no natural key
+ * (product names may collide), so we cannot reuse the booking-create
+ * advisory-lock-on-natural-key guard. Instead, callers (agent tool runtimes)
+ * pass an `Idempotency-Key`; a retried/double-tapped request with the same key
+ * returns the originally-created product id instead of building a second graph.
+ */
+export declare const productAuthoringRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "product_authoring_requests";
+    schema: undefined;
+    columns: {
+        idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "idempotency_key";
+            tableName: "product_authoring_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "product_authoring_requests";
+            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;
+        }, {}, {}>;
+        operation: import("drizzle-orm/pg-core").PgColumn<{
+            name: "operation";
+            tableName: "product_authoring_requests";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_authoring_requests";
+            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 ProductAuthoringRequest = typeof productAuthoringRequests.$inferSelect;
+export type NewProductAuthoringRequest = typeof productAuthoringRequests.$inferInsert;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAA;AAClF,MAAM,MAAM,0BAA0B,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAA"}

package/dist/schema.js ADDED Viewed

@@ -0,0 +1,16 @@
+import { index, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+/**
+ * Dedup ledger for clone/compose. A clone or compose has no natural key
+ * (product names may collide), so we cannot reuse the booking-create
+ * advisory-lock-on-natural-key guard. Instead, callers (agent tool runtimes)
+ * pass an `Idempotency-Key`; a retried/double-tapped request with the same key
+ * returns the originally-created product id instead of building a second graph.
+ */
+export const productAuthoringRequests = pgTable("product_authoring_requests", {
+    idempotencyKey: text("idempotency_key").primaryKey(),
+    /** The product produced by the first request with this key. */
+    productId: text("product_id").notNull(),
+    /** `duplicate` | `compose` — for observability only. */
+    operation: text("operation").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [index("idx_par_product").on(t.productId)]);

package/dist/spec.d.ts ADDED Viewed

@@ -0,0 +1,506 @@
+import { z } from "zod";
+export declare const unitSpecSchema: z.ZodObject<{
+    ref: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unitType: z.ZodDefault<z.ZodEnum<{
+        person: "person";
+        group: "group";
+        room: "room";
+        vehicle: "vehicle";
+        service: "service";
+        other: "other";
+    }>>;
+    minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    minAge: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxAge: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    occupancyMin: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    occupancyMax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    isRequired: z.ZodDefault<z.ZodBoolean>;
+    isHidden: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const unitTierSpecSchema: z.ZodObject<{
+    minQuantity: z.ZodNumber;
+    maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const unitPriceRuleSpecSchema: z.ZodObject<{
+    unitRef: z.ZodString;
+    pricingCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricingMode: z.ZodDefault<z.ZodEnum<{
+        per_unit: "per_unit";
+        per_person: "per_person";
+        per_booking: "per_booking";
+        included: "included";
+        free: "free";
+        on_request: "on_request";
+    }>>;
+    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tiers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        minQuantity: z.ZodNumber;
+        maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const optionPriceRuleSpecSchema: z.ZodObject<{
+    priceCatalogId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    priceScheduleId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cancellationPolicyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pricingMode: z.ZodDefault<z.ZodEnum<{
+        per_person: "per_person";
+        per_booking: "per_booking";
+        free: "free";
+        on_request: "on_request";
+        starting_from: "starting_from";
+    }>>;
+    baseSellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    baseCostAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    minPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    allPricingCategories: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    unitPriceRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        unitRef: z.ZodString;
+        pricingCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pricingMode: z.ZodDefault<z.ZodEnum<{
+            per_unit: "per_unit";
+            per_person: "per_person";
+            per_booking: "per_booking";
+            included: "included";
+            free: "free";
+            on_request: "on_request";
+        }>>;
+        sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tiers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            minQuantity: z.ZodNumber;
+            maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            active: z.ZodDefault<z.ZodBoolean>;
+            sortOrder: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const optionSpecSchema: z.ZodObject<{
+    ref: z.ZodString;
+    name: z.ZodString;
+    code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+    availableFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    availableTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    units: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unitType: z.ZodDefault<z.ZodEnum<{
+            person: "person";
+            group: "group";
+            room: "room";
+            vehicle: "vehicle";
+            service: "service";
+            other: "other";
+        }>>;
+        minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minAge: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxAge: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        occupancyMin: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        occupancyMax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        isRequired: z.ZodDefault<z.ZodBoolean>;
+        isHidden: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    priceRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        priceCatalogId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        priceScheduleId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        cancellationPolicyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pricingMode: z.ZodDefault<z.ZodEnum<{
+            per_person: "per_person";
+            per_booking: "per_booking";
+            free: "free";
+            on_request: "on_request";
+            starting_from: "starting_from";
+        }>>;
+        baseSellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        baseCostAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        allPricingCategories: z.ZodDefault<z.ZodBoolean>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        active: z.ZodDefault<z.ZodBoolean>;
+        unitPriceRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            unitRef: z.ZodString;
+            pricingCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pricingMode: z.ZodDefault<z.ZodEnum<{
+                per_unit: "per_unit";
+                per_person: "per_person";
+                per_booking: "per_booking";
+                included: "included";
+                free: "free";
+                on_request: "on_request";
+            }>>;
+            sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            active: z.ZodDefault<z.ZodBoolean>;
+            sortOrder: z.ZodDefault<z.ZodNumber>;
+            notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tiers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                minQuantity: z.ZodNumber;
+                maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                active: z.ZodDefault<z.ZodBoolean>;
+                sortOrder: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const paxPricingTierSpecSchema: z.ZodObject<{
+    unitRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tierPax: z.ZodNumber;
+    pricePerPaxCents: z.ZodNumber;
+    promoPricePerPaxCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    effectiveFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    effectiveTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const dayServiceSpecSchema: z.ZodObject<{
+    supplierServiceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    serviceType: z.ZodEnum<{
+        other: "other";
+        accommodation: "accommodation";
+        transfer: "transfer";
+        experience: "experience";
+        guide: "guide";
+        meal: "meal";
+    }>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    costCurrency: z.ZodString;
+    costAmountCents: z.ZodNumber;
+    quantity: z.ZodDefault<z.ZodNumber>;
+    sortOrder: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const daySpecSchema: z.ZodObject<{
+    dayNumber: z.ZodNumber;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    services: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        supplierServiceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        serviceType: z.ZodEnum<{
+            other: "other";
+            accommodation: "accommodation";
+            transfer: "transfer";
+            experience: "experience";
+            guide: "guide";
+            meal: "meal";
+        }>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        costCurrency: z.ZodString;
+        costAmountCents: z.ZodNumber;
+        quantity: z.ZodDefault<z.ZodNumber>;
+        sortOrder: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const itinerarySpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    sortOrder: z.ZodDefault<z.ZodNumber>;
+    days: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        dayNumber: z.ZodNumber;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        services: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            supplierServiceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            serviceType: z.ZodEnum<{
+                other: "other";
+                accommodation: "accommodation";
+                transfer: "transfer";
+                experience: "experience";
+                guide: "guide";
+                meal: "meal";
+            }>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            costCurrency: z.ZodString;
+            costAmountCents: z.ZodNumber;
+            quantity: z.ZodDefault<z.ZodNumber>;
+            sortOrder: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const productRowSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        inactive: "inactive";
+        archived: "archived";
+    }>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    inclusionsHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    exclusionsHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    termsHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    bookingMode: z.ZodDefault<z.ZodEnum<{
+        date: "date";
+        other: "other";
+        transfer: "transfer";
+        date_time: "date_time";
+        open: "open";
+        stay: "stay";
+        itinerary: "itinerary";
+    }>>;
+    capacityMode: z.ZodDefault<z.ZodEnum<{
+        limited: "limited";
+        unlimited: "unlimited";
+    }>>;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    defaultLanguageTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        private: "private";
+        public: "public";
+        unlisted: "unlisted";
+    }>>;
+    sellCurrency: z.ZodString;
+    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    marginPercent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    facilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    supplierId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    endDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    productTypeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const productGraphSpecSchema: z.ZodObject<{
+    product: z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            draft: "draft";
+            inactive: "inactive";
+            archived: "archived";
+        }>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        inclusionsHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        exclusionsHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        termsHtml: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        bookingMode: z.ZodDefault<z.ZodEnum<{
+            date: "date";
+            other: "other";
+            transfer: "transfer";
+            date_time: "date_time";
+            open: "open";
+            stay: "stay";
+            itinerary: "itinerary";
+        }>>;
+        capacityMode: z.ZodDefault<z.ZodEnum<{
+            limited: "limited";
+            unlimited: "unlimited";
+        }>>;
+        timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        defaultLanguageTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        visibility: z.ZodDefault<z.ZodEnum<{
+            private: "private";
+            public: "public";
+            unlisted: "unlisted";
+        }>>;
+        sellCurrency: z.ZodString;
+        sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        marginPercent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        facilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        supplierId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        startDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        endDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        productTypeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        name: z.ZodString;
+        code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            draft: "draft";
+            inactive: "inactive";
+            archived: "archived";
+        }>>;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        availableFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        availableTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        units: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            name: z.ZodString;
+            code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            unitType: z.ZodDefault<z.ZodEnum<{
+                person: "person";
+                group: "group";
+                room: "room";
+                vehicle: "vehicle";
+                service: "service";
+                other: "other";
+            }>>;
+            minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            minAge: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxAge: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            occupancyMin: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            occupancyMax: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            isRequired: z.ZodDefault<z.ZodBoolean>;
+            isHidden: z.ZodDefault<z.ZodBoolean>;
+            sortOrder: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        priceRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            priceCatalogId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            priceScheduleId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            cancellationPolicyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pricingMode: z.ZodDefault<z.ZodEnum<{
+                per_person: "per_person";
+                per_booking: "per_booking";
+                free: "free";
+                on_request: "on_request";
+                starting_from: "starting_from";
+            }>>;
+            baseSellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            baseCostAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            minPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxPerBooking: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            allPricingCategories: z.ZodDefault<z.ZodBoolean>;
+            isDefault: z.ZodDefault<z.ZodBoolean>;
+            active: z.ZodDefault<z.ZodBoolean>;
+            unitPriceRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                unitRef: z.ZodString;
+                pricingCategoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                pricingMode: z.ZodDefault<z.ZodEnum<{
+                    per_unit: "per_unit";
+                    per_person: "per_person";
+                    per_booking: "per_booking";
+                    included: "included";
+                    free: "free";
+                    on_request: "on_request";
+                }>>;
+                sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                minQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                active: z.ZodDefault<z.ZodBoolean>;
+                sortOrder: z.ZodDefault<z.ZodNumber>;
+                notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                tiers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    minQuantity: z.ZodNumber;
+                    maxQuantity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    sellAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    costAmountCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    active: z.ZodDefault<z.ZodBoolean>;
+                    sortOrder: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    paxPricingTiers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        unitRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tierPax: z.ZodNumber;
+        pricePerPaxCents: z.ZodNumber;
+        promoPricePerPaxCents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        effectiveFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effectiveTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    itineraries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        isDefault: z.ZodDefault<z.ZodBoolean>;
+        sortOrder: z.ZodDefault<z.ZodNumber>;
+        days: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            dayNumber: z.ZodNumber;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            services: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                supplierServiceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                serviceType: z.ZodEnum<{
+                    other: "other";
+                    accommodation: "accommodation";
+                    transfer: "transfer";
+                    experience: "experience";
+                    guide: "guide";
+                    meal: "meal";
+                }>;
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                costCurrency: z.ZodString;
+                costAmountCents: z.ZodNumber;
+                quantity: z.ZodDefault<z.ZodNumber>;
+                sortOrder: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type UnitSpec = z.infer<typeof unitSpecSchema>;
+export type UnitTierSpec = z.infer<typeof unitTierSpecSchema>;
+export type UnitPriceRuleSpec = z.infer<typeof unitPriceRuleSpecSchema>;
+export type OptionPriceRuleSpec = z.infer<typeof optionPriceRuleSpecSchema>;
+export type OptionSpec = z.infer<typeof optionSpecSchema>;
+export type PaxPricingTierSpec = z.infer<typeof paxPricingTierSpecSchema>;
+export type DayServiceSpec = z.infer<typeof dayServiceSpecSchema>;
+export type DaySpec = z.infer<typeof daySpecSchema>;
+export type ItinerarySpec = z.infer<typeof itinerarySpecSchema>;
+export type ProductRowSpec = z.infer<typeof productRowSpecSchema>;
+export type ProductGraphSpec = z.infer<typeof productGraphSpecSchema>;
+//# sourceMappingURL=spec.d.ts.map

package/dist/spec.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../src/spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;iBAezB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;iBAO7B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAelC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsBpC,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY3B,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;iBAQnC,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAW/B,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;iBAMxB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9B,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyB/B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/spec.js ADDED Viewed

@@ -0,0 +1,162 @@
+import { z } from "zod";
+/**
+ * Normalized, transport-agnostic description of a bookable product graph.
+ *
+ * Both entry points feed the same builder:
+ *  - clone   — serialize an existing product into a spec, patch the product row.
+ *  - compose — caller (Max AI agent) supplies the spec directly.
+ *
+ * Cross-references inside an option (a unit price rule pointing at a sibling
+ * unit, a pax tier pointing at a unit) use **local ref keys** (`ref` / `unitRef`),
+ * which the builder resolves to freshly-minted ids. For clone, serialize sets
+ * each `ref` to the source row id; for compose, the caller picks any unique
+ * string. Refs never reach the database.
+ *
+ * NOTE: `availability_slots` (departures) are intentionally absent — they are
+ * date-specific and added separately after the graph exists.
+ *
+ * Home of this type is under review (here vs `@voyantjs/products-contracts`).
+ */
+const money = z.number().int();
+export const unitSpecSchema = z.object({
+    ref: z.string().min(1),
+    name: z.string().min(1).max(255),
+    code: z.string().max(255).nullish(),
+    description: z.string().nullish(),
+    unitType: z.enum(["person", "group", "room", "vehicle", "service", "other"]).default("person"),
+    minQuantity: z.number().int().nullish(),
+    maxQuantity: z.number().int().nullish(),
+    minAge: z.number().int().nullish(),
+    maxAge: z.number().int().nullish(),
+    occupancyMin: z.number().int().nullish(),
+    occupancyMax: z.number().int().nullish(),
+    isRequired: z.boolean().default(false),
+    isHidden: z.boolean().default(false),
+    sortOrder: z.number().int().default(0),
+});
+export const unitTierSpecSchema = z.object({
+    minQuantity: z.number().int(),
+    maxQuantity: z.number().int().nullish(),
+    sellAmountCents: money.nullish(),
+    costAmountCents: money.nullish(),
+    active: z.boolean().default(true),
+    sortOrder: z.number().int().default(0),
+});
+export const unitPriceRuleSpecSchema = z.object({
+    /** Resolves to a sibling unit's `ref` within the same option. */
+    unitRef: z.string().min(1),
+    pricingCategoryId: z.string().nullish(),
+    pricingMode: z
+        .enum(["per_unit", "per_person", "per_booking", "included", "free", "on_request"])
+        .default("per_unit"),
+    sellAmountCents: money.nullish(),
+    costAmountCents: money.nullish(),
+    minQuantity: z.number().int().nullish(),
+    maxQuantity: z.number().int().nullish(),
+    active: z.boolean().default(true),
+    sortOrder: z.number().int().default(0),
+    notes: z.string().nullish(),
+    tiers: z.array(unitTierSpecSchema).default([]),
+});
+export const optionPriceRuleSpecSchema = z.object({
+    /**
+     * Price catalog the rule points at. Optional: clone reuses the source rule's
+     * catalog; compose resolves the operator default when omitted.
+     */
+    priceCatalogId: z.string().nullish(),
+    priceScheduleId: z.string().nullish(),
+    cancellationPolicyId: z.string().nullish(),
+    code: z.string().nullish(),
+    name: z.string().min(1).max(255),
+    description: z.string().nullish(),
+    pricingMode: z
+        .enum(["per_person", "per_booking", "starting_from", "free", "on_request"])
+        .default("per_person"),
+    baseSellAmountCents: money.nullish(),
+    baseCostAmountCents: money.nullish(),
+    minPerBooking: z.number().int().nullish(),
+    maxPerBooking: z.number().int().nullish(),
+    allPricingCategories: z.boolean().default(true),
+    isDefault: z.boolean().default(false),
+    active: z.boolean().default(true),
+    unitPriceRules: z.array(unitPriceRuleSpecSchema).default([]),
+});
+export const optionSpecSchema = z.object({
+    ref: z.string().min(1),
+    name: z.string().min(1).max(255),
+    code: z.string().max(255).nullish(),
+    description: z.string().nullish(),
+    status: z.enum(["draft", "active", "inactive", "archived"]).default("draft"),
+    isDefault: z.boolean().default(false),
+    sortOrder: z.number().int().default(0),
+    availableFrom: z.string().nullish(),
+    availableTo: z.string().nullish(),
+    units: z.array(unitSpecSchema).default([]),
+    priceRules: z.array(optionPriceRuleSpecSchema).default([]),
+});
+export const paxPricingTierSpecSchema = z.object({
+    /** Optional link to a unit (by `ref`) within the spec. */
+    unitRef: z.string().nullish(),
+    tierPax: z.number().int(),
+    pricePerPaxCents: money,
+    promoPricePerPaxCents: money.nullish(),
+    effectiveFrom: z.string().nullish(),
+    effectiveTo: z.string().nullish(),
+});
+export const dayServiceSpecSchema = z.object({
+    supplierServiceId: z.string().nullish(),
+    serviceType: z.enum(["accommodation", "transfer", "experience", "guide", "meal", "other"]),
+    name: z.string().min(1).max(255),
+    description: z.string().nullish(),
+    countryCode: z.string().nullish(),
+    costCurrency: z.string().min(3).max(3),
+    costAmountCents: money,
+    quantity: z.number().int().default(1),
+    sortOrder: z.number().int().nullish(),
+    notes: z.string().nullish(),
+});
+export const daySpecSchema = z.object({
+    dayNumber: z.number().int(),
+    title: z.string().nullish(),
+    description: z.string().nullish(),
+    location: z.string().nullish(),
+    services: z.array(dayServiceSpecSchema).default([]),
+});
+export const itinerarySpecSchema = z.object({
+    name: z.string().min(1).max(255),
+    isDefault: z.boolean().default(false),
+    sortOrder: z.number().int().default(0),
+    days: z.array(daySpecSchema).default([]),
+});
+export const productRowSpecSchema = z.object({
+    name: z.string().min(1).max(255),
+    status: z.enum(["draft", "active", "inactive", "archived"]).default("draft"),
+    description: z.string().nullish(),
+    inclusionsHtml: z.string().nullish(),
+    exclusionsHtml: z.string().nullish(),
+    termsHtml: z.string().nullish(),
+    bookingMode: z
+        .enum(["date", "date_time", "open", "stay", "transfer", "itinerary", "other"])
+        .default("date"),
+    capacityMode: z.enum(["limited", "unlimited"]).default("limited"),
+    timezone: z.string().nullish(),
+    defaultLanguageTag: z.string().nullish(),
+    visibility: z.enum(["private", "public", "unlisted"]).default("private"),
+    sellCurrency: z.string().min(3).max(3),
+    sellAmountCents: money.nullish(),
+    costAmountCents: money.nullish(),
+    marginPercent: z.number().int().nullish(),
+    facilityId: z.string().nullish(),
+    supplierId: z.string().nullish(),
+    startDate: z.string().nullish(),
+    endDate: z.string().nullish(),
+    pax: z.number().int().nullish(),
+    productTypeId: z.string().nullish(),
+    tags: z.array(z.string()).default([]),
+});
+export const productGraphSpecSchema = z.object({
+    product: productRowSpecSchema,
+    options: z.array(optionSpecSchema).default([]),
+    paxPricingTiers: z.array(paxPricingTierSpecSchema).default([]),
+    itineraries: z.array(itinerarySpecSchema).default([]),
+});

package/package.json ADDED Viewed

@@ -0,0 +1,78 @@
+{
+  "name": "@voyantjs/catalog-authoring",
+  "version": "0.104.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./schema": "./src/schema.ts",
+    "./spec": "./src/spec.ts",
+    "./extension": "./src/extension.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "@voyantjs/core": "workspace:^",
+    "@voyantjs/db": "workspace:^",
+    "@voyantjs/hono": "workspace:^",
+    "@voyantjs/pricing": "workspace:^",
+    "@voyantjs/products": "workspace:^",
+    "drizzle-orm": "^0.45.2",
+    "hono": "^4.12.10",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@voyantjs/voyant-test-utils": "workspace:^",
+    "@voyantjs/voyant-typescript-config": "workspace:^",
+    "typescript": "^6.0.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./schema": {
+        "types": "./dist/schema.d.ts",
+        "import": "./dist/schema.js",
+        "default": "./dist/schema.js"
+      },
+      "./spec": {
+        "types": "./dist/spec.d.ts",
+        "import": "./dist/spec.js",
+        "default": "./dist/spec.js"
+      },
+      "./extension": {
+        "types": "./dist/extension.d.ts",
+        "import": "./dist/extension.js",
+        "default": "./dist/extension.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/catalog-authoring"
+  },
+  "voyant": {
+    "schema": "./schema",
+    "requiresSchemas": [
+      "@voyantjs/db",
+      "@voyantjs/products",
+      "@voyantjs/pricing"
+    ]
+  }
+}