@voyantjs/products 0.3.1 → 0.4.1

package/dist/tasks/brochure-templates.js

@@ -0,0 +1,98 @@
+import { renderStructuredTemplate, } from "@voyantjs/utils/template-renderer";
+import { asc, eq } from "drizzle-orm";
+import { productDayServices, productDays, products } from "../schema.js";
+async function resolveTemplateValue(value, context) {
+    if (typeof value === "function") {
+        return await value(context);
+    }
+    return value;
+}
+function normalizeFilename(value, productName) {
+    const fallback = `${productName.replace(/[^a-zA-Z0-9]/g, "_")}.pdf`;
+    const trimmed = value?.trim();
+    return trimmed || fallback;
+}
+export async function loadProductBrochureTemplateContext(db, productId) {
+    const [product] = await db.select().from(products).where(eq(products.id, productId)).limit(1);
+    if (!product) {
+        throw new Error(`Product not found: ${productId}`);
+    }
+    const days = await db
+        .select()
+        .from(productDays)
+        .where(eq(productDays.productId, productId))
+        .orderBy(asc(productDays.dayNumber));
+    const daysWithServices = await Promise.all(days.map(async (day) => {
+        const services = await db
+            .select()
+            .from(productDayServices)
+            .where(eq(productDayServices.dayId, day.id))
+            .orderBy(asc(productDayServices.sortOrder));
+        return {
+            ...day,
+            services,
+        };
+    }));
+    return {
+        product,
+        days: daysWithServices,
+        generatedAt: new Date(),
+    };
+}
+export function createDefaultProductBrochureTemplate() {
+    return {
+        bodyFormat: "markdown",
+        title: ({ product }) => product.name,
+        filename: ({ product }) => `${product.name.replace(/[^a-zA-Z0-9]/g, "_")}.pdf`,
+        metadataLines: ({ product, generatedAt }) => [
+            `Product ID: ${product.id}`,
+            `Generated: ${generatedAt.toISOString()}`,
+        ],
+        body: [
+            "# {{ product.name }}",
+            "",
+            "{% if product.startDate or product.endDate %}",
+            "Dates: {{ product.startDate | default: 'TBD' }} - {{ product.endDate | default: 'TBD' }}",
+            "{% endif %}",
+            "{% if product.pax %}",
+            "Travelers: {{ product.pax }}",
+            "{% endif %}",
+            "{% if product.sellAmountCents %}",
+            "Total: {{ product.sellAmountCents | divided_by: 100.0 }} {{ product.sellCurrency }}",
+            "{% endif %}",
+            "",
+            "{% if product.description %}{{ product.description }}{% endif %}",
+            "",
+            "{% for day in days %}",
+            "## Day {{ day.dayNumber }}{% if day.title %}: {{ day.title }}{% endif %}",
+            "{% if day.location %}Location: {{ day.location }}{% endif %}",
+            "{% if day.description %}{{ day.description }}{% endif %}",
+            "",
+            "{% for service in day.services %}",
+            "- {{ service.name }} ({{ service.serviceType }}){% if service.quantity > 1 %} x{{ service.quantity }}{% endif %}",
+            "{% if service.notes %}  {{ service.notes }}{% endif %}",
+            "{% endfor %}",
+            "",
+            "{% endfor %}",
+        ].join("\n"),
+    };
+}
+export async function renderProductBrochureTemplate(template, context) {
+    const rawBody = (await resolveTemplateValue(template.body, context)) ?? "";
+    const variables = (await resolveTemplateValue(template.variables, context)) ?? {
+        product: context.product,
+        days: context.days,
+        generatedAt: context.generatedAt.toISOString(),
+    };
+    const title = (await resolveTemplateValue(template.title, context))?.trim() || context.product.name;
+    const filename = normalizeFilename(await resolveTemplateValue(template.filename, context), context.product.name);
+    const metadataLines = (await resolveTemplateValue(template.metadataLines, context)) ?? [];
+    return {
+        body: renderStructuredTemplate(rawBody, template.bodyFormat, variables),
+        bodyFormat: template.bodyFormat,
+        title,
+        filename,
+        variables,
+        metadataLines,
+    };
+}

package/dist/tasks/brochures.d.ts

@@ -0,0 +1,42 @@
+import type { StorageProvider } from "@voyantjs/voyant-storage";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type ProductBrochurePrinter } from "./brochure-printers.js";
+import { type ProductBrochureTemplateDefinition } from "./brochure-templates.js";
+export interface GenerateAndStoreProductBrochureOptions {
+    storage: StorageProvider;
+    template?: ProductBrochureTemplateDefinition;
+    printer?: ProductBrochurePrinter;
+    keyPrefix?: string;
+    filename?: string | ((generated: {
+        productId: string;
+        filename: string;
+    }) => string);
+    signedUrlExpiresIn?: number;
+}
+export declare function generateAndStoreProductBrochure(db: PostgresJsDatabase, productId: string, options: GenerateAndStoreProductBrochureOptions): Promise<{
+    brochure: {
+        productId: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        sortOrder: number;
+        dayId: string | null;
+        mediaType: "image" | "video" | "document";
+        url: string;
+        storageKey: string | null;
+        mimeType: string | null;
+        fileSize: number | null;
+        altText: string | null;
+        isCover: boolean;
+        isBrochure: boolean;
+        isBrochureCurrent: boolean;
+        brochureVersion: number | null;
+    };
+    filename: string;
+    metadata: Record<string, unknown> | null;
+    sizeBytes: number;
+    storageKey: string;
+    url: string;
+}>;
+//# sourceMappingURL=brochures.d.ts.map

package/dist/tasks/brochures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brochures.d.ts","sourceRoot":"","sources":["../../src/tasks/brochures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAGL,KAAK,iCAAiC,EAEvC,MAAM,yBAAyB,CAAA;AAGhC,MAAM,WAAW,sCAAsC;IACrD,OAAO,EAAE,eAAe,CAAA;IACxB,QAAQ,CAAC,EAAE,iCAAiC,CAAA;IAC5C,OAAO,CAAC,EAAE,sBAAsB,CAAA;IAChC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC,CAAA;IACpF,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,wBAAsB,+BAA+B,CACnD,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;GA2EhD"}

package/dist/tasks/brochures.js

@@ -0,0 +1,69 @@
+import { productsService } from "../service.js";
+import { createBasicPdfProductBrochurePrinter, } from "./brochure-printers.js";
+import { createDefaultProductBrochureTemplate, loadProductBrochureTemplateContext, renderProductBrochureTemplate, } from "./brochure-templates.js";
+import { generateProductPdf } from "./generate-pdf.js";
+export async function generateAndStoreProductBrochure(db, productId, options) {
+    let filename;
+    let pdfBytes;
+    let sizeBytes;
+    let mimeType = "application/pdf";
+    let metadata = null;
+    if (options.template || options.printer) {
+        const templateContext = await loadProductBrochureTemplateContext(db, productId);
+        const rendered = await renderProductBrochureTemplate(options.template ?? createDefaultProductBrochureTemplate(), templateContext);
+        const printer = options.printer ?? createBasicPdfProductBrochurePrinter();
+        const printed = await printer({
+            template: rendered,
+            context: templateContext,
+        });
+        filename =
+            typeof options.filename === "function"
+                ? options.filename({ productId, filename: rendered.filename })
+                : options.filename?.trim() || rendered.filename;
+        pdfBytes = printed.body;
+        sizeBytes = printed.fileSize ?? printed.body.byteLength;
+        mimeType = printed.mimeType ?? mimeType;
+        metadata = printed.metadata ?? null;
+    }
+    else {
+        const generated = await generateProductPdf(db, productId);
+        filename =
+            typeof options.filename === "function"
+                ? options.filename({ productId, filename: generated.filename })
+                : options.filename?.trim() || generated.filename;
+        pdfBytes = generated.pdfBytes;
+        sizeBytes = generated.sizeBytes;
+    }
+    const keyPrefix = options.keyPrefix?.trim() || `brochures/products/${productId}`;
+    const uploaded = await options.storage.upload(pdfBytes, {
+        key: `${keyPrefix.replace(/\/$/, "")}/${filename}`,
+        contentType: mimeType,
+    });
+    const url = uploaded.url ||
+        (options.signedUrlExpiresIn
+            ? await options.storage.signedUrl(uploaded.key, options.signedUrlExpiresIn)
+            : null);
+    if (!url) {
+        throw new Error("Brochure upload did not return a public or signed URL.");
+    }
+    const brochure = await productsService.upsertBrochure(db, productId, {
+        name: filename,
+        url,
+        storageKey: uploaded.key,
+        mimeType,
+        fileSize: sizeBytes,
+        altText: null,
+        sortOrder: 0,
+    });
+    if (!brochure) {
+        throw new Error(`Unable to persist brochure for product ${productId}.`);
+    }
+    return {
+        brochure,
+        filename,
+        metadata,
+        sizeBytes,
+        storageKey: uploaded.key,
+        url,
+    };
+}

package/dist/tasks/index.d.ts

@@ -1,2 +1,5 @@
+export { type CloudflareBrowserBrochurePrinterOptions, createBasicPdfProductBrochurePrinter, createCloudflareBrowserProductBrochurePrinter, createCloudflareBrowserProductBrochurePrinterFromEnv, type PrintedProductBrochureArtifact, type ProductBrochurePrinter, type ProductBrochurePrinterContext, } from "./brochure-printers.js";
+export { createDefaultProductBrochureTemplate, loadProductBrochureTemplateContext, type ProductBrochureDayContext, type ProductBrochureTemplateContext, type ProductBrochureTemplateDefinition, type RenderedProductBrochureTemplate, renderProductBrochureTemplate, } from "./brochure-templates.js";
+export { type GenerateAndStoreProductBrochureOptions, generateAndStoreProductBrochure, } from "./brochures.js";
 export { type GenerateProductPdfResult, generateProductPdf } from "./generate-pdf.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/tasks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tasks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tasks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uCAAuC,EAC5C,oCAAoC,EACpC,6CAA6C,EAC7C,oDAAoD,EACpD,KAAK,8BAA8B,EACnC,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,GACnC,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,oCAAoC,EACpC,kCAAkC,EAClC,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EACnC,KAAK,iCAAiC,EACtC,KAAK,+BAA+B,EACpC,6BAA6B,GAC9B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,KAAK,sCAAsC,EAC3C,+BAA+B,GAChC,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,KAAK,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/tasks/index.js

@@ -1 +1,4 @@
+export { createBasicPdfProductBrochurePrinter, createCloudflareBrowserProductBrochurePrinter, createCloudflareBrowserProductBrochurePrinterFromEnv, } from "./brochure-printers.js";
+export { createDefaultProductBrochureTemplate, loadProductBrochureTemplateContext, renderProductBrochureTemplate, } from "./brochure-templates.js";
+export { generateAndStoreProductBrochure, } from "./brochures.js";
 export { generateProductPdf } from "./generate-pdf.js";

package/dist/validation-catalog.d.ts

@@ -0,0 +1,388 @@
+import { z } from "zod";
+export declare const localizedCatalogProductSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    contentLanguageTag: z.ZodNullable<z.ZodString>;
+    slug: z.ZodNullable<z.ZodString>;
+    shortDescription: z.ZodNullable<z.ZodString>;
+    seoTitle: z.ZodNullable<z.ZodString>;
+    seoDescription: z.ZodNullable<z.ZodString>;
+    bookingMode: z.ZodEnum<{
+        date: "date";
+        other: "other";
+        date_time: "date_time";
+        open: "open";
+        stay: "stay";
+        transfer: "transfer";
+        itinerary: "itinerary";
+    }>;
+    capacityMode: z.ZodEnum<{
+        free_sale: "free_sale";
+        limited: "limited";
+        on_request: "on_request";
+    }>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        hidden: "hidden";
+    }>;
+    sellCurrency: z.ZodString;
+    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+    startDate: z.ZodNullable<z.ZodString>;
+    endDate: z.ZodNullable<z.ZodString>;
+    pax: z.ZodNullable<z.ZodNumber>;
+    productType: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        slug: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    tags: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        on_request: "on_request";
+        private: "private";
+        instant_confirmation: "instant_confirmation";
+        pickup_available: "pickup_available";
+        dropoff_available: "dropoff_available";
+        guided: "guided";
+        shared: "shared";
+        digital_ticket: "digital_ticket";
+        voucher_required: "voucher_required";
+        external_inventory: "external_inventory";
+        multi_day: "multi_day";
+        accommodation: "accommodation";
+        transport: "transport";
+    }>>;
+    destinations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        slug: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        seoTitle: z.ZodNullable<z.ZodString>;
+        seoDescription: z.ZodNullable<z.ZodString>;
+        destinationType: z.ZodEnum<{
+            city: "city";
+            destination: "destination";
+            region: "region";
+            country: "country";
+        }>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    locations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        locationType: z.ZodEnum<{
+            other: "other";
+            start: "start";
+            end: "end";
+            meeting_point: "meeting_point";
+            pickup: "pickup";
+            dropoff: "dropoff";
+            point_of_interest: "point_of_interest";
+        }>;
+        title: z.ZodString;
+        address: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        countryCode: z.ZodNullable<z.ZodString>;
+        latitude: z.ZodNullable<z.ZodNumber>;
+        longitude: z.ZodNullable<z.ZodNumber>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    coverMedia: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        mediaType: z.ZodEnum<{
+            image: "image";
+            video: "video";
+            document: "document";
+        }>;
+        name: z.ZodString;
+        url: z.ZodString;
+        mimeType: z.ZodNullable<z.ZodString>;
+        altText: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        isCover: z.ZodBoolean;
+        isBrochure: z.ZodBoolean;
+        isBrochureCurrent: z.ZodBoolean;
+        brochureVersion: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    isFeatured: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const localizedCatalogProductDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    contentLanguageTag: z.ZodNullable<z.ZodString>;
+    slug: z.ZodNullable<z.ZodString>;
+    shortDescription: z.ZodNullable<z.ZodString>;
+    seoTitle: z.ZodNullable<z.ZodString>;
+    seoDescription: z.ZodNullable<z.ZodString>;
+    bookingMode: z.ZodEnum<{
+        date: "date";
+        other: "other";
+        date_time: "date_time";
+        open: "open";
+        stay: "stay";
+        transfer: "transfer";
+        itinerary: "itinerary";
+    }>;
+    capacityMode: z.ZodEnum<{
+        free_sale: "free_sale";
+        limited: "limited";
+        on_request: "on_request";
+    }>;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        hidden: "hidden";
+    }>;
+    sellCurrency: z.ZodString;
+    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+    startDate: z.ZodNullable<z.ZodString>;
+    endDate: z.ZodNullable<z.ZodString>;
+    pax: z.ZodNullable<z.ZodNumber>;
+    productType: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        slug: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    tags: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        on_request: "on_request";
+        private: "private";
+        instant_confirmation: "instant_confirmation";
+        pickup_available: "pickup_available";
+        dropoff_available: "dropoff_available";
+        guided: "guided";
+        shared: "shared";
+        digital_ticket: "digital_ticket";
+        voucher_required: "voucher_required";
+        external_inventory: "external_inventory";
+        multi_day: "multi_day";
+        accommodation: "accommodation";
+        transport: "transport";
+    }>>;
+    destinations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        slug: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        seoTitle: z.ZodNullable<z.ZodString>;
+        seoDescription: z.ZodNullable<z.ZodString>;
+        destinationType: z.ZodEnum<{
+            city: "city";
+            destination: "destination";
+            region: "region";
+            country: "country";
+        }>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    locations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        locationType: z.ZodEnum<{
+            other: "other";
+            start: "start";
+            end: "end";
+            meeting_point: "meeting_point";
+            pickup: "pickup";
+            dropoff: "dropoff";
+            point_of_interest: "point_of_interest";
+        }>;
+        title: z.ZodString;
+        address: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        countryCode: z.ZodNullable<z.ZodString>;
+        latitude: z.ZodNullable<z.ZodNumber>;
+        longitude: z.ZodNullable<z.ZodNumber>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    coverMedia: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        mediaType: z.ZodEnum<{
+            image: "image";
+            video: "video";
+            document: "document";
+        }>;
+        name: z.ZodString;
+        url: z.ZodString;
+        mimeType: z.ZodNullable<z.ZodString>;
+        altText: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        isCover: z.ZodBoolean;
+        isBrochure: z.ZodBoolean;
+        isBrochureCurrent: z.ZodBoolean;
+        brochureVersion: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    isFeatured: z.ZodBoolean;
+    brochure: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        mediaType: z.ZodEnum<{
+            image: "image";
+            video: "video";
+            document: "document";
+        }>;
+        name: z.ZodString;
+        url: z.ZodString;
+        mimeType: z.ZodNullable<z.ZodString>;
+        altText: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        isCover: z.ZodBoolean;
+        isBrochure: z.ZodBoolean;
+        isBrochureCurrent: z.ZodBoolean;
+        brochureVersion: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    media: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        mediaType: z.ZodEnum<{
+            image: "image";
+            video: "video";
+            document: "document";
+        }>;
+        name: z.ZodString;
+        url: z.ZodString;
+        mimeType: z.ZodNullable<z.ZodString>;
+        altText: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+        isCover: z.ZodBoolean;
+        isBrochure: z.ZodBoolean;
+        isBrochureCurrent: z.ZodBoolean;
+        brochureVersion: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    features: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        featureType: z.ZodEnum<{
+            other: "other";
+            inclusion: "inclusion";
+            exclusion: "exclusion";
+            highlight: "highlight";
+            important_information: "important_information";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+    faqs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        answer: z.ZodString;
+        sortOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const catalogSearchDocumentSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    languageTag: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    shortDescription: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    seoTitle: z.ZodNullable<z.ZodString>;
+    seoDescription: z.ZodNullable<z.ZodString>;
+    sellCurrency: z.ZodString;
+    sellAmountCents: z.ZodNullable<z.ZodNumber>;
+    startDate: z.ZodNullable<z.ZodString>;
+    endDate: z.ZodNullable<z.ZodString>;
+    pax: z.ZodNullable<z.ZodNumber>;
+    productTypeCode: z.ZodNullable<z.ZodString>;
+    productTypeName: z.ZodNullable<z.ZodString>;
+    categoryIds: z.ZodArray<z.ZodString>;
+    categoryNames: z.ZodArray<z.ZodString>;
+    categorySlugs: z.ZodArray<z.ZodString>;
+    tagIds: z.ZodArray<z.ZodString>;
+    tagNames: z.ZodArray<z.ZodString>;
+    capabilities: z.ZodArray<z.ZodString>;
+    destinationIds: z.ZodArray<z.ZodString>;
+    destinationNames: z.ZodArray<z.ZodString>;
+    destinationSlugs: z.ZodArray<z.ZodString>;
+    locationTitles: z.ZodArray<z.ZodString>;
+    locationCities: z.ZodArray<z.ZodString>;
+    locationCountryCodes: z.ZodArray<z.ZodString>;
+    coverMediaUrl: z.ZodNullable<z.ZodString>;
+    isFeatured: z.ZodBoolean;
+    createdAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const catalogSearchDocumentListQuerySchema: z.ZodObject<{
+    productIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    languageTag: z.ZodOptional<z.ZodString>;
+    fallbackLanguageTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        public: "public";
+    }>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        active: "active";
+    }>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const catalogSearchDocumentListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        productId: z.ZodString;
+        languageTag: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        slug: z.ZodNullable<z.ZodString>;
+        shortDescription: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        seoTitle: z.ZodNullable<z.ZodString>;
+        seoDescription: z.ZodNullable<z.ZodString>;
+        sellCurrency: z.ZodString;
+        sellAmountCents: z.ZodNullable<z.ZodNumber>;
+        startDate: z.ZodNullable<z.ZodString>;
+        endDate: z.ZodNullable<z.ZodString>;
+        pax: z.ZodNullable<z.ZodNumber>;
+        productTypeCode: z.ZodNullable<z.ZodString>;
+        productTypeName: z.ZodNullable<z.ZodString>;
+        categoryIds: z.ZodArray<z.ZodString>;
+        categoryNames: z.ZodArray<z.ZodString>;
+        categorySlugs: z.ZodArray<z.ZodString>;
+        tagIds: z.ZodArray<z.ZodString>;
+        tagNames: z.ZodArray<z.ZodString>;
+        capabilities: z.ZodArray<z.ZodString>;
+        destinationIds: z.ZodArray<z.ZodString>;
+        destinationNames: z.ZodArray<z.ZodString>;
+        destinationSlugs: z.ZodArray<z.ZodString>;
+        locationTitles: z.ZodArray<z.ZodString>;
+        locationCities: z.ZodArray<z.ZodString>;
+        locationCountryCodes: z.ZodArray<z.ZodString>;
+        coverMediaUrl: z.ZodNullable<z.ZodString>;
+        isFeatured: z.ZodBoolean;
+        createdAt: z.ZodNullable<z.ZodString>;
+        updatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export type LocalizedCatalogProductSummary = z.infer<typeof localizedCatalogProductSummarySchema>;
+export type LocalizedCatalogProductDetail = z.infer<typeof localizedCatalogProductDetailSchema>;
+export type CatalogSearchDocument = z.infer<typeof catalogSearchDocumentSchema>;
+export type CatalogSearchDocumentListQuery = z.infer<typeof catalogSearchDocumentListQuerySchema>;
+export type CatalogSearchDocumentListResponse = z.infer<typeof catalogSearchDocumentListResponseSchema>;
+//# sourceMappingURL=validation-catalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation-catalog.d.ts","sourceRoot":"","sources":["../src/validation-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAoC,CAAA;AACrF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAmC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCtC,CAAA;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;iBAQ/C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKlD,CAAA;AAEF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC/E,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA"}

package/dist/validation-catalog.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { publicCatalogProductDetailSchema, publicCatalogProductSummarySchema, } from "./validation-public.js";
+import { languageTagSchema } from "./validation-shared.js";
+export const localizedCatalogProductSummarySchema = publicCatalogProductSummarySchema;
+export const localizedCatalogProductDetailSchema = publicCatalogProductDetailSchema;
+export const catalogSearchDocumentSchema = z.object({
+    id: z.string(),
+    productId: z.string(),
+    languageTag: z.string().nullable(),
+    name: z.string(),
+    slug: z.string().nullable(),
+    shortDescription: z.string().nullable(),
+    description: z.string().nullable(),
+    seoTitle: z.string().nullable(),
+    seoDescription: z.string().nullable(),
+    sellCurrency: z.string(),
+    sellAmountCents: z.number().int().nullable(),
+    startDate: z.string().nullable(),
+    endDate: z.string().nullable(),
+    pax: z.number().int().nullable(),
+    productTypeCode: z.string().nullable(),
+    productTypeName: z.string().nullable(),
+    categoryIds: z.array(z.string()),
+    categoryNames: z.array(z.string()),
+    categorySlugs: z.array(z.string()),
+    tagIds: z.array(z.string()),
+    tagNames: z.array(z.string()),
+    capabilities: z.array(z.string()),
+    destinationIds: z.array(z.string()),
+    destinationNames: z.array(z.string()),
+    destinationSlugs: z.array(z.string()),
+    locationTitles: z.array(z.string()),
+    locationCities: z.array(z.string()),
+    locationCountryCodes: z.array(z.string()),
+    coverMediaUrl: z.string().nullable(),
+    isFeatured: z.boolean(),
+    createdAt: z.string().nullable(),
+    updatedAt: z.string().nullable(),
+});
+export const catalogSearchDocumentListQuerySchema = z.object({
+    productIds: z.array(z.string()).optional(),
+    languageTag: languageTagSchema.optional(),
+    fallbackLanguageTags: z.array(languageTagSchema).optional(),
+    visibility: z.enum(["public", "all"]).default("public"),
+    status: z.enum(["active", "all"]).default("active"),
+    limit: z.coerce.number().int().min(1).max(200).default(100),
+    offset: z.coerce.number().int().min(0).default(0),
+});
+export const catalogSearchDocumentListResponseSchema = z.object({
+    data: z.array(catalogSearchDocumentSchema),
+    total: z.number().int(),
+    limit: z.number().int(),
+    offset: z.number().int(),
+});