@voyant-travel/inventory 0.1.0

package/dist/service-catalog-plane.js

@@ -0,0 +1,431 @@
+// agent-quality: file-size exception -- owner: inventory; existing service module stays co-located until a dedicated split preserves behavior and tests.
+/**
+ * Catalog-plane integration for the products service.
+ *
+ * Adds catalog-aware service methods alongside the existing `productsService`
+ * surface in `service.ts`. Routes opt in: the original `getProductById` /
+ * `listProducts` continue to return raw DB rows; the methods here return
+ * resolved CatalogEntry views with overlays + visibility filtering applied.
+ *
+ * Existing service code is untouched. Migration is per-route, gradual.
+ *
+ * Naming note: this file is `service-catalog-plane.ts` (not `service-catalog.ts`)
+ * because the existing `service-catalog.ts` handles the products module's own
+ * catalog management (categories, tags, types). The "catalog plane" is the
+ * cross-vertical projection / overlay / snapshot infrastructure from
+ * `@voyant-travel/catalog`.
+ *
+ * See `docs/architecture/catalog-architecture.md` §9.1 for the integration
+ * pattern this file establishes (replicated for cruises, accommodations, etc.
+ * in their own service-catalog-plane.ts files).
+ */
+import { buildIndexerDocument, buildSnapshotInputFromView, createFieldPolicyRegistry, fetchOverlaysForEntities, resolveEntityView, resolveEntityViewWithOverlays, } from "@voyant-travel/catalog";
+import { asc, eq, sql } from "drizzle-orm";
+import { productCatalogPolicy } from "./catalog-policy.js";
+import { products } from "./schema-core.js";
+import { productDays, productItineraries, productMedia } from "./schema-itinerary.js";
+import { productLocations, productTranslations } from "./schema-settings.js";
+/**
+ * Lazy-initialized registry. Built once per process; the field-policy file
+ * is static so this is safe to memoize.
+ */
+let _registry;
+function getProductsRegistry() {
+    if (!_registry) {
+        _registry = createFieldPolicyRegistry(productCatalogPolicy);
+    }
+    return _registry;
+}
+/**
+ * Maps a product row to a field-keyed projection consumable by the catalog
+ * resolver. Field paths match the policy registry declarations in
+ * `catalog-policy.ts`.
+ *
+ * Provenance fields (`source.kind`, `source.ref`, `seller.operator_id`) are
+ * synthesized: today's products module models operator-owned inventory
+ * exclusively, so `source.kind = "owned"` and `source.ref = undefined`.
+ * When sourced products land (e.g. via Voyant Connect), this helper picks
+ * up the provenance from a parallel provenance row instead.
+ */
+export function productRowToProjection(row, context) {
+    const projection = new Map([
+        // Provenance — synthesized for owned products.
+        ["source.kind", "owned"],
+        ["seller.operator_id", context.sellerOperatorId],
+        // Identity
+        ["id", row.id],
+        ["createdAt", row.createdAt],
+        ["updatedAt", row.updatedAt],
+        // Merchandisable
+        ["name", row.name],
+        ["description", row.description],
+        ["inclusionsHtml", row.inclusionsHtml],
+        ["exclusionsHtml", row.exclusionsHtml],
+        ["termsHtml", row.termsHtml],
+        ["tags[]", row.tags],
+        // Structural
+        ["status", row.status],
+        ["bookingMode", row.bookingMode],
+        ["capacityMode", row.capacityMode],
+        ["visibility", row.visibility],
+        ["activated", row.activated],
+        ["productTypeId", row.productTypeId],
+        ["facilityId", row.facilityId],
+        ["supplierId", row.supplierId],
+        ["pax", row.pax],
+        ["startDate", row.startDate],
+        ["endDate", row.endDate],
+        ["startDateEpochDays", dateToEpochDays(row.startDate)],
+        ["endDateEpochDays", dateToEpochDays(row.endDate)],
+        ["timezone", row.timezone],
+        ["reservationTimeoutMinutes", row.reservationTimeoutMinutes],
+        ["termsShowOnContract", row.termsShowOnContract],
+        // Pricing (configured defaults — quote-time prices come from pricing module)
+        ["sellAmountCents", row.sellAmountCents],
+        ["sellCurrency", row.sellCurrency],
+        // Internal / staff-only
+        ["costAmountCents", row.costAmountCents],
+        ["marginPercent", row.marginPercent],
+    ]);
+    return projection;
+}
+/**
+ * Returns the Provenance tuple for a product row. Owned products synthesize
+ * a `source.kind: "owned"` provenance with `static` freshness; sourced
+ * products (Voyant Connect / GDS / direct API) carry their actual source
+ * connection identity. Phase 1 ships only the owned form.
+ */
+export function productProvenance(_row, _context) {
+    return {
+        source_kind: "owned",
+        source_freshness: "static",
+    };
+}
+/**
+ * Catalog-aware product fetch. Returns the resolved view (source projection
+ * + active overlays + visibility filtering) instead of the raw DB row.
+ *
+ * The original `productsService.getProductById` continues to return raw
+ * rows — routes that haven't migrated to the catalog plane keep working.
+ *
+ * Returns `null` if no product with `id` exists.
+ */
+export async function getResolvedProductById(db, id, context) {
+    const rows = await db.select().from(products).where(eq(products.id, id)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return null;
+    const projection = productRowToProjection(row, {
+        sellerOperatorId: context.sellerOperatorId,
+    });
+    return resolveEntityView(db, getProductsRegistry(), "products", id, projection, context.scope);
+}
+/**
+ * Catalog-aware product list. Returns resolved views per row.
+ *
+ * Caller fetches the rows (typically via the existing `productsService.listProducts`
+ * with whatever filtering / pagination / sort the route applies) and passes
+ * them in. This keeps query construction in the existing service layer and
+ * adds the catalog overlay step on top.
+ *
+ * Overlays for the whole page are fetched in ONE query via
+ * `fetchOverlaysForEntities` and applied in-memory per product — the
+ * per-product output is byte-identical to calling `resolveEntityView`
+ * once per row, minus the N-1 sequential round trips.
+ *
+ * Real high-volume list paths (storefront browse, admin search) should
+ * still go through the search index instead — `IndexerService.search` is
+ * already wired for that purpose. Use this method for small admin-facing
+ * lists or detail-page composition where the index isn't on the read path.
+ */
+export async function listResolvedProducts(db, rows, context) {
+    const registry = getProductsRegistry();
+    const overlaysByEntity = await fetchOverlaysForEntities(db, "products", rows.map((row) => row.id));
+    return rows.map((row) => {
+        const projection = productRowToProjection(row, {
+            sellerOperatorId: context.sellerOperatorId,
+        });
+        return resolveEntityViewWithOverlays(registry, projection, overlaysByEntity.get(row.id) ?? [], context.scope);
+    });
+}
+/**
+ * Build a `CaptureSnapshotInput` for a product to feed into the catalog
+ * plane's `captureSnapshot` / `captureSnapshotGraph` helpers at booking
+ * commit time. Fetches the product, resolves its view (overlays applied,
+ * visibility filter for the supplied scope), and returns the snapshot
+ * input shape.
+ *
+ * Returns `null` if the product doesn't exist.
+ *
+ * Composition: a single-product booking calls this once and passes the
+ * result to `captureSnapshot`. A composite booking (e.g. a tour-package
+ * booking with referenced accommodations + excursions) calls this and the
+ * other verticals' equivalents, collects the inputs, and passes them all
+ * to `captureSnapshotGraph` in one transaction.
+ */
+export async function buildProductSnapshotInput(db, productId, context) {
+    const view = await getResolvedProductById(db, productId, context);
+    if (!view)
+        return null;
+    return buildSnapshotInputFromView(view, {
+        entityModule: "products",
+        entityId: productId,
+        sourceKind: "owned",
+        pricingBasis: context.pricingBasis,
+    });
+}
+/**
+ * Compose the registry from the base product policy plus any contributing
+ * extensions' policies. Templates wire this when they enable child-entity
+ * registries.
+ */
+export function createProductsRegistry(...extensionPolicies) {
+    if (extensionPolicies.length === 0)
+        return getProductsRegistry();
+    const composed = [...productCatalogPolicy];
+    for (const policies of extensionPolicies) {
+        composed.push(...policies);
+    }
+    return createFieldPolicyRegistry(composed);
+}
+/**
+ * Construct a sync `DocumentEmitter` for products. The emitter takes a
+ * pre-fetched product row + a slice and returns the indexer document
+ * (filtered by visibility, with blob-only fields skipped).
+ *
+ * Bulk-reindex pipelines that already have rows in hand call this directly.
+ * Live reindex paths use `createProductDocumentBuilder` below, which fetches
+ * the row before emitting.
+ *
+ * Pass a custom `registry` when the deployment composes additional
+ * child-entity policies; otherwise the default products registry is used.
+ */
+export function createProductDocumentEmitter(context) {
+    const registry = context.registry ?? getProductsRegistry();
+    return {
+        vertical: "products",
+        emit(source, slice) {
+            const projection = productRowToProjection(source, {
+                sellerOperatorId: context.sellerOperatorId,
+            });
+            return buildIndexerDocument(registry, projection, slice, source.id);
+        },
+    };
+}
+function isPublicStorefrontProduct(row) {
+    return row.status === "active" && row.activated === true && row.visibility === "public";
+}
+function shouldEmitForSlice(row, slice) {
+    // The catalog is a "bookable now" surface — draft and archived
+    // products don't belong there, regardless of audience. Operators
+    // browsing /catalog get the same active-only set the storefront sees,
+    // just with staff-visible attribute columns.
+    if (row.status !== "active")
+        return false;
+    if (slice.audience === "customer" ||
+        slice.audience === "partner" ||
+        slice.audience === "supplier") {
+        return isPublicStorefrontProduct(row);
+    }
+    return true;
+}
+/**
+ * Async `DocumentBuilder` for products — fetches the row by id, then emits.
+ * Plug this into `IndexerService.reindexEntity` for live reindex events.
+ *
+ * Returns `null` if the product no longer exists (e.g. it was deleted
+ * between the reindex enqueue and the worker picking it up). Callers can
+ * treat `null` as a delete signal.
+ *
+ * `extensions` denormalize child-entity fields onto the product doc. They
+ * run in parallel after the base row is fetched. An extension that throws
+ * fails the whole build — failures here would otherwise produce silently
+ * incomplete documents.
+ *
+ * Pass a custom `registry` (composed via `createProductsRegistry`) when
+ * extensions contribute fields beyond the base products policy.
+ */
+export function createProductDocumentBuilder(db, context) {
+    const registry = context.registry ?? getProductsRegistry();
+    const extensions = context.extensions ?? [];
+    return async (entityId, slice) => {
+        const rows = await db.select().from(products).where(eq(products.id, entityId)).limit(1);
+        const row = rows[0];
+        if (!row)
+            return null;
+        if (!shouldEmitForSlice(row, slice))
+            return null;
+        const baseProjection = productRowToProjection(row, {
+            sellerOperatorId: context.sellerOperatorId,
+        });
+        if (extensions.length === 0) {
+            return buildIndexerDocument(registry, baseProjection, slice, entityId);
+        }
+        const extensionProjections = await Promise.all(extensions.map((ext) => ext.project(db, entityId, slice)));
+        const merged = new Map(baseProjection);
+        for (const projection of extensionProjections) {
+            for (const [path, value] of projection) {
+                merged.set(path, value);
+            }
+        }
+        return buildIndexerDocument(registry, merged, slice, entityId);
+    };
+}
+/**
+ * Product-owned storefront-card projection. This extension keeps the
+ * customer catalog slice directly renderable by denormalizing localized
+ * routing, card media, duration, and map coordinates into the search doc.
+ */
+export function createProductStorefrontCardProjectionExtension() {
+    return {
+        name: "products:storefront-card",
+        async project(db, productId, slice) {
+            // Wave 1: everything keyed by productId alone runs concurrently —
+            // including the departures count, which used to trail sequentially.
+            const [translations, mediaRows, locationRows, itineraryRows, availableDeparturesCount] = await Promise.all([
+                db
+                    .select({
+                    languageTag: productTranslations.languageTag,
+                    name: productTranslations.name,
+                    slug: productTranslations.slug,
+                    shortDescription: productTranslations.shortDescription,
+                    inclusionsHtml: productTranslations.inclusionsHtml,
+                    exclusionsHtml: productTranslations.exclusionsHtml,
+                    termsHtml: productTranslations.termsHtml,
+                })
+                    .from(productTranslations)
+                    .where(eq(productTranslations.productId, productId))
+                    .orderBy(asc(productTranslations.updatedAt)),
+                db
+                    .select({
+                    url: productMedia.url,
+                    mediaType: productMedia.mediaType,
+                    isCover: productMedia.isCover,
+                    isBrochure: productMedia.isBrochure,
+                    sortOrder: productMedia.sortOrder,
+                    createdAt: productMedia.createdAt,
+                })
+                    .from(productMedia)
+                    .where(eq(productMedia.productId, productId))
+                    .orderBy(asc(productMedia.sortOrder), asc(productMedia.createdAt)),
+                db
+                    .select({
+                    latitude: productLocations.latitude,
+                    longitude: productLocations.longitude,
+                    sortOrder: productLocations.sortOrder,
+                    createdAt: productLocations.createdAt,
+                })
+                    .from(productLocations)
+                    .where(eq(productLocations.productId, productId))
+                    .orderBy(asc(productLocations.sortOrder), asc(productLocations.createdAt)),
+                db
+                    .select({ id: productItineraries.id, isDefault: productItineraries.isDefault })
+                    .from(productItineraries)
+                    .where(eq(productItineraries.productId, productId))
+                    .orderBy(asc(productItineraries.sortOrder)),
+                countAvailableDepartures(db, productId),
+            ]);
+            const translation = pickTranslation(translations, slice.locale);
+            const imageMediaRows = mediaRows.filter((m) => !m.isBrochure && m.mediaType === "image");
+            const cover = imageMediaRows.find((m) => m.isCover);
+            const primaryMedia = cover ?? imageMediaRows[0] ?? null;
+            const coordinateLocation = locationRows.find((l) => l.latitude != null && l.longitude != null) ?? null;
+            const defaultItinerary = itineraryRows.find((it) => it.isDefault) ?? itineraryRows[0];
+            // Wave 2: the duration estimate needs `defaultItinerary`, which is only
+            // known after the itinerary rows land — it cannot join wave 1.
+            const durationDays = defaultItinerary
+                ? await estimateItineraryDurationDays(db, defaultItinerary.id)
+                : null;
+            const out = new Map([
+                ["slug", translation?.slug ?? null],
+                ["shortDescription", translation?.shortDescription ?? null],
+                ["primaryMediaUrl", primaryMedia?.url ?? null],
+                ["thumbnailUrl", primaryMedia?.url ?? null],
+                ["coverMediaUrl", primaryMedia?.url ?? null],
+                ["durationDays", durationDays],
+                ["availableDeparturesCount", availableDeparturesCount],
+                ["latitude", coordinateLocation?.latitude ?? null],
+                ["longitude", coordinateLocation?.longitude ?? null],
+            ]);
+            if (translation?.name) {
+                out.set("name", translation.name);
+            }
+            if (translation?.inclusionsHtml != null) {
+                out.set("inclusionsHtml", translation.inclusionsHtml);
+            }
+            if (translation?.exclusionsHtml != null) {
+                out.set("exclusionsHtml", translation.exclusionsHtml);
+            }
+            if (translation?.termsHtml != null) {
+                out.set("termsHtml", translation.termsHtml);
+            }
+            return out;
+        },
+    };
+}
+function pickTranslation(rows, locale) {
+    return (rows.find((row) => row.languageTag === locale) ??
+        rows.find((row) => row.languageTag.toLowerCase() === locale.toLowerCase()) ??
+        rows.find((row) => row.languageTag.split("-")[0] === locale.split("-")[0]) ??
+        rows[0] ??
+        null);
+}
+/**
+ * Counts future, open availability slots for a product — surfaces in the
+ * catalog index as `availableDeparturesCount` so the operator catalog
+ * table can show booking-ready stock at a glance without a separate
+ * round-trip. Owned-products only; sourced products carry departures via
+ * the upstream feed and don't write to `availability_slots`.
+ *
+ * Cross-package boundary: queries `availability_slots` by raw table name
+ * via `sql` so the products module doesn't take a hard dependency on the
+ * `@voyant-travel/operations` schema.
+ */
+async function countAvailableDepartures(db, productId) {
+    try {
+        const result = await db.execute(sql `
+      SELECT COUNT(*)::int AS count
+      FROM availability_slots
+      WHERE product_id = ${productId}
+        AND status = 'open'
+        AND starts_at >= NOW()
+    `);
+        // postgres-js + neon-serverless both return `{ count }` on the first row;
+        // shape-defensive read in case a driver wraps it differently.
+        const rows = Array.isArray(result) ? result : (result.rows ?? []);
+        const row = rows[0];
+        const value = row?.count;
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string") {
+            const n = Number(value);
+            return Number.isFinite(n) ? n : 0;
+        }
+        return 0;
+    }
+    catch {
+        // availability_slots may not exist in slim test fixtures; treat as 0
+        // so reindex doesn't fail.
+        return 0;
+    }
+}
+async function estimateItineraryDurationDays(db, itineraryId) {
+    const rows = await db
+        .select({ dayNumber: productDays.dayNumber })
+        .from(productDays)
+        .where(eq(productDays.itineraryId, itineraryId))
+        .orderBy(asc(productDays.dayNumber));
+    if (rows.length === 0)
+        return null;
+    const max = Math.max(...rows.map((row) => row.dayNumber));
+    return Number.isFinite(max) && max > 0 ? max : null;
+}
+function dateToEpochDays(value) {
+    if (!value)
+        return null;
+    const date = typeof value === "string" ? new Date(value) : value;
+    const time = date.getTime();
+    if (Number.isNaN(time))
+        return null;
+    return Math.floor(time / (24 * 60 * 60 * 1000));
+}

package/dist/service-catalog.d.ts

@@ -0,0 +1,251 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { products } from "./schema.js";
+import type { CatalogSearchDocument, CatalogSearchDocumentListQuery } from "./validation-catalog.js";
+type CatalogProductRow = typeof products.$inferSelect;
+type HydrateCatalogProductOptions = {
+    includeContent?: boolean;
+    languageTag?: string | null;
+    fallbackLanguageTags?: string[];
+};
+export declare const catalogProductsService: {
+    hydrateProducts(db: PostgresJsDatabase, productRows: CatalogProductRow[], options?: HydrateCatalogProductOptions): Promise<({
+        description: string | null;
+        inclusionsHtml: null;
+        exclusionsHtml: null;
+        termsHtml: null;
+        id: string;
+        name: string;
+        contentLanguageTag: string | null;
+        slug: string | null;
+        shortDescription: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        visibility: "public" | "private" | "hidden";
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        contractTemplateId: string | null;
+        productType: {
+            id: string;
+            code: string;
+            name: string;
+            description: string | null;
+        } | null;
+        categories: {
+            id: string;
+            parentId: string | null;
+            name: string;
+            slug: string;
+            description: string | null;
+            sortOrder: number;
+        }[];
+        tags: {
+            id: string;
+            name: string;
+        }[];
+        capabilities: string[];
+        destinations: {
+            id: string;
+            parentId: string | null;
+            slug: string;
+            canonicalPlaceId: string | null;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            destinationType: string;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+        }[];
+        locations: {
+            id: string;
+            locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+            title: string;
+            address: string | null;
+            city: string | null;
+            countryCode: string | null;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+        }[];
+        coverMedia: {
+            id: string;
+            mediaType: "image" | "video" | "document";
+            name: string;
+            url: string;
+            mimeType: string | null;
+            altText: string | null;
+            sortOrder: number;
+            isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
+        } | null;
+        isFeatured: boolean;
+    } | {
+        brochure: {
+            id: string;
+            mediaType: "image" | "video" | "document";
+            name: string;
+            url: string;
+            mimeType: string | null;
+            altText: string | null;
+            sortOrder: number;
+            isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
+        } | null;
+        media: {
+            id: string;
+            mediaType: "image" | "video" | "document";
+            name: string;
+            url: string;
+            mimeType: string | null;
+            altText: string | null;
+            sortOrder: number;
+            isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
+        }[];
+        features: {
+            id: string;
+            featureType: "other" | "inclusion" | "exclusion" | "highlight" | "important_information";
+            title: string;
+            description: string | null;
+            sortOrder: number;
+        }[];
+        faqs: {
+            id: string;
+            question: string;
+            answer: string;
+            sortOrder: number;
+        }[];
+        id: string;
+        name: string;
+        description: string | null;
+        inclusionsHtml: string | null;
+        exclusionsHtml: string | null;
+        termsHtml: string | null;
+        contentLanguageTag: string | null;
+        slug: string | null;
+        shortDescription: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+        capacityMode: "free_sale" | "limited" | "on_request";
+        visibility: "public" | "private" | "hidden";
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        contractTemplateId: string | null;
+        productType: {
+            id: string;
+            code: string;
+            name: string;
+            description: string | null;
+        } | null;
+        categories: {
+            id: string;
+            parentId: string | null;
+            name: string;
+            slug: string;
+            description: string | null;
+            sortOrder: number;
+        }[];
+        tags: {
+            id: string;
+            name: string;
+        }[];
+        capabilities: string[];
+        destinations: {
+            id: string;
+            parentId: string | null;
+            slug: string;
+            canonicalPlaceId: string | null;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            destinationType: string;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+        }[];
+        locations: {
+            id: string;
+            locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+            title: string;
+            address: string | null;
+            city: string | null;
+            countryCode: string | null;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+        }[];
+        coverMedia: {
+            id: string;
+            mediaType: "image" | "video" | "document";
+            name: string;
+            url: string;
+            mimeType: string | null;
+            altText: string | null;
+            sortOrder: number;
+            isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
+        } | null;
+        isFeatured: boolean;
+    })[]>;
+    listSearchDocuments(db: PostgresJsDatabase, query: CatalogSearchDocumentListQuery): Promise<{
+        data: CatalogSearchDocument[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getSearchDocumentByProductId(db: PostgresJsDatabase, productId: string, query?: Partial<Omit<CatalogSearchDocumentListQuery, "productIds" | "limit" | "offset">>): Promise<{
+        id: string;
+        productId: string;
+        languageTag: string | null;
+        name: string;
+        slug: string | null;
+        shortDescription: string | null;
+        description: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        sellCurrency: string;
+        sellAmountCents: number | null;
+        startDate: string | null;
+        endDate: string | null;
+        pax: number | null;
+        productTypeCode: string | null;
+        productTypeName: string | null;
+        categoryIds: string[];
+        categoryNames: string[];
+        categorySlugs: string[];
+        tagIds: string[];
+        tagNames: string[];
+        capabilities: string[];
+        destinationIds: string[];
+        destinationNames: string[];
+        destinationSlugs: string[];
+        locationTitles: string[];
+        locationCities: string[];
+        locationCountryCodes: string[];
+        coverMediaUrl: string | null;
+        isFeatured: boolean;
+        createdAt: string | null;
+        updatedAt: string | null;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-catalog.d.ts.map

package/dist/service-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog.d.ts","sourceRoot":"","sources":["../src/service-catalog.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAWL,QAAQ,EAMT,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EACV,qBAAqB,EACrB,8BAA8B,EAE/B,MAAM,yBAAyB,CAAA;AAEhC,KAAK,iBAAiB,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAA;AAErD,KAAK,4BAA4B,GAAG;IAClC,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAA;CAChC,CAAA;AA2aD,eAAO,MAAM,sBAAsB;wBAE3B,kBAAkB,eACT,iBAAiB,EAAE,YACvB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAkIjC,kBAAkB,SACf,8BAA8B,GACpC,OAAO,CAAC;QACT,IAAI,EAAE,qBAAqB,EAAE,CAAA;QAC7B,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,EAAE,MAAM,CAAA;KACf,CAAC;qCAkFI,kBAAkB,aACX,MAAM,UACV,OAAO,CAAC,IAAI,CAAC,8BAA8B,EAAE,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAa1F,CAAA"}