@bash-app/bash-common 30.285.0 → 30.291.0

package/dist/dist/utils/service/serviceUtils.js

@@ -0,0 +1,651 @@
+import { ServiceSubscriptionStatus, ServiceTypes } from "@prisma/client";
+import { ServiceCancellationPolicy } from "../../mirroredPrismaEnums.js";
+export const SERVICE_CANCELLATION_POLICY_DATA = {
+    [ServiceCancellationPolicy.None]: {
+        name: "None",
+        refundPolicy: [],
+        description: "No cancellation policy.",
+    },
+    [ServiceCancellationPolicy.VeryFlexible]: {
+        name: "Very Flexible",
+        refundPolicy: [
+            {
+                hours: 24,
+                refundPercentage: 100,
+            },
+        ],
+    },
+    [ServiceCancellationPolicy.Flexible]: {
+        name: "Flexible",
+        refundPolicy: [
+            {
+                days: 7,
+                refundPercentage: 100,
+            },
+            {
+                hours: 24,
+                refundPercentage: 50,
+            },
+        ],
+    },
+    [ServiceCancellationPolicy.Standard30Day]: {
+        name: "Standard 30 Day",
+        refundPolicy: [
+            {
+                days: 30,
+                refundPercentage: 100,
+            },
+            {
+                days: 7,
+                refundPercentage: 50,
+            },
+        ],
+    },
+    [ServiceCancellationPolicy.Standard90Day]: {
+        name: "Standard 90 Day",
+        refundPolicy: [
+            {
+                days: 90,
+                refundPercentage: 100,
+            },
+            {
+                days: 14,
+                refundPercentage: 50,
+            },
+        ],
+    },
+    // Vendor-specific policies (vendor pays host, different language needed)
+    [ServiceCancellationPolicy.VendorFlexible]: {
+        name: "Vendor Flexible",
+        refundPolicy: [
+            {
+                days: 7,
+                refundPercentage: 100,
+            },
+            {
+                hours: 24,
+                refundPercentage: 50,
+            },
+        ],
+        description: "Flexible policy for vendor bookings",
+    },
+    [ServiceCancellationPolicy.VendorStandard]: {
+        name: "Vendor Standard",
+        refundPolicy: [
+            {
+                days: 14,
+                refundPercentage: 100,
+            },
+            {
+                days: 3,
+                refundPercentage: 50,
+            },
+        ],
+        description: "Standard policy for vendor bookings",
+    },
+    [ServiceCancellationPolicy.VendorStrict]: {
+        name: "Vendor Strict",
+        refundPolicy: [
+            {
+                days: 30,
+                refundPercentage: 100,
+            },
+            {
+                days: 7,
+                refundPercentage: 25,
+            },
+        ],
+        description: "Strict policy for vendor bookings with longer notice periods",
+    },
+    // Exhibitor / Sponsor: same tier math as vendor; separate enum + copy for role clarity
+    [ServiceCancellationPolicy.ExhibitorFlexible]: {
+        name: "Exhibitor Flexible",
+        refundPolicy: [
+            {
+                days: 7,
+                refundPercentage: 100,
+            },
+            {
+                hours: 24,
+                refundPercentage: 50,
+            },
+        ],
+        description: "Flexible policy for exhibitor bookings",
+    },
+    [ServiceCancellationPolicy.ExhibitorStandard]: {
+        name: "Exhibitor Standard",
+        refundPolicy: [
+            {
+                days: 14,
+                refundPercentage: 100,
+            },
+            {
+                days: 3,
+                refundPercentage: 50,
+            },
+        ],
+        description: "Standard policy for exhibitor bookings",
+    },
+    [ServiceCancellationPolicy.ExhibitorStrict]: {
+        name: "Exhibitor Strict",
+        refundPolicy: [
+            {
+                days: 30,
+                refundPercentage: 100,
+            },
+            {
+                days: 7,
+                refundPercentage: 25,
+            },
+        ],
+        description: "Strict policy for exhibitor bookings",
+    },
+    [ServiceCancellationPolicy.SponsorFlexible]: {
+        name: "Sponsor Flexible",
+        refundPolicy: [
+            {
+                days: 7,
+                refundPercentage: 100,
+            },
+            {
+                hours: 24,
+                refundPercentage: 50,
+            },
+        ],
+        description: "Flexible policy for sponsorship bookings",
+    },
+    [ServiceCancellationPolicy.SponsorStandard]: {
+        name: "Sponsor Standard",
+        refundPolicy: [
+            {
+                days: 14,
+                refundPercentage: 100,
+            },
+            {
+                days: 3,
+                refundPercentage: 50,
+            },
+        ],
+        description: "Standard policy for sponsorship bookings",
+    },
+    [ServiceCancellationPolicy.SponsorStrict]: {
+        name: "Sponsor Strict",
+        refundPolicy: [
+            {
+                days: 30,
+                refundPercentage: 100,
+            },
+            {
+                days: 7,
+                refundPercentage: 25,
+            },
+        ],
+        description: "Strict policy for sponsorship bookings",
+    },
+};
+function generateDescription(refundPolicy) {
+    const descriptions = refundPolicy.map((policy, index) => {
+        const unit = policy.days ? "days" : "hours";
+        const timeValue = policy.days ?? policy.hours;
+        const refundText = policy.refundPercentage === 100
+            ? "a full refund (including all Fees)"
+            : `${policy.refundPercentage}% refund (excluding Fees)`;
+        if (index === 0) {
+            return `Guests may cancel their Booking until ${timeValue} ${unit} before the event start time and will receive ${refundText} of their Booking Price.`;
+        }
+        else {
+            const prevPolicy = refundPolicy[index - 1];
+            const prevUnit = prevPolicy.days ? "days" : "hours";
+            const prevTime = prevPolicy.days ?? prevPolicy.hours;
+            return `Guests may cancel their Booking between ${prevTime} ${prevUnit} and ${timeValue} ${unit} before the event start time and receive ${refundText} of their Booking Price.`;
+        }
+    });
+    const lastTime = refundPolicy[refundPolicy.length - 1].days ??
+        refundPolicy[refundPolicy.length - 1].hours;
+    descriptions.push(`Cancellations submitted less than ${lastTime} ${refundPolicy[refundPolicy.length - 1].days ? "days" : "hours"} before the Event start time are not refundable.`);
+    return descriptions.join(" ");
+}
+/**
+ * Vendor cancellation policy copy shown in the service wizard. Hosts send
+ * **booking requests**; after acceptance and payment, the vendor's obligation
+ * is a **verified booking**. Use "verified booking" for vendor-initiated
+ * cancellation—never "booking request" in this generator.
+ */
+function generateVendorDescription(refundPolicy) {
+    const descriptions = refundPolicy.map((policy, index) => {
+        const unit = policy.days ? "days" : "hours";
+        const timeValue = policy.days ?? policy.hours;
+        const refundText = policy.refundPercentage === 100
+            ? "a full refund from the Host (including all Fees)"
+            : `${policy.refundPercentage}% refund from the Host (excluding Fees)`;
+        if (index === 0) {
+            return `If you (the vendor) cancel your verified booking at least ${timeValue} ${unit} before the event start time, you will receive ${refundText} of what you paid the Host.`;
+        }
+        else {
+            const prevPolicy = refundPolicy[index - 1];
+            const prevUnit = prevPolicy.days ? "days" : "hours";
+            const prevTime = prevPolicy.days ?? prevPolicy.hours;
+            return `If you (the vendor) cancel your verified booking between ${prevTime} ${prevUnit} and ${timeValue} ${unit} before the event start time, you will receive ${refundText} of what you paid the Host.`;
+        }
+    });
+    const lastTime = refundPolicy[refundPolicy.length - 1].days ??
+        refundPolicy[refundPolicy.length - 1].hours;
+    descriptions.push(`If you (the vendor) cancel your verified booking less than ${lastTime} ${refundPolicy[refundPolicy.length - 1].days ? "days" : "hours"} before the event start time, your payment is not refundable under this policy.`);
+    descriptions.push(`If the Host cancels the event or your verified booking, you will generally receive a full refund of what you paid, unless the cancellation was due to your non-compliance with the Host's or event's requirements.`);
+    return descriptions.join(" ");
+}
+/**
+ * Exhibitor-facing copy: hosts send booking requests; after accept + pay, use
+ * "verified booking" for exhibitor-initiated cancellation (same convention as vendors).
+ */
+function generateExhibitorDescription(refundPolicy) {
+    const descriptions = refundPolicy.map((policy, index) => {
+        const unit = policy.days ? "days" : "hours";
+        const timeValue = policy.days ?? policy.hours;
+        const refundText = policy.refundPercentage === 100
+            ? "a full refund from the Host (including all Fees)"
+            : `${policy.refundPercentage}% refund from the Host (excluding Fees)`;
+        if (index === 0) {
+            return `If you (the exhibitor) cancel your verified booking at least ${timeValue} ${unit} before the event start time, you will receive ${refundText} of what you paid the Host.`;
+        }
+        else {
+            const prevPolicy = refundPolicy[index - 1];
+            const prevUnit = prevPolicy.days ? "days" : "hours";
+            const prevTime = prevPolicy.days ?? prevPolicy.hours;
+            return `If you (the exhibitor) cancel your verified booking between ${prevTime} ${prevUnit} and ${timeValue} ${unit} before the event start time, you will receive ${refundText} of what you paid the Host.`;
+        }
+    });
+    const lastTime = refundPolicy[refundPolicy.length - 1].days ??
+        refundPolicy[refundPolicy.length - 1].hours;
+    descriptions.push(`If you (the exhibitor) cancel your verified booking less than ${lastTime} ${refundPolicy[refundPolicy.length - 1].days ? "days" : "hours"} before the event start time, your payment is not refundable under this policy.`);
+    descriptions.push(`If the Host cancels the event or your verified booking, you will generally receive a full refund of what you paid, unless the cancellation was due to your non-compliance with the Host's or event's requirements.`);
+    return descriptions.join(" ");
+}
+/**
+ * Sponsor-facing copy: same payment-to-host model; use "sponsorship commitment" where
+ * "verified booking" would be awkward for sponsors.
+ */
+function generateSponsorDescription(refundPolicy) {
+    const descriptions = refundPolicy.map((policy, index) => {
+        const unit = policy.days ? "days" : "hours";
+        const timeValue = policy.days ?? policy.hours;
+        const refundText = policy.refundPercentage === 100
+            ? "a full refund from the Host (including all Fees)"
+            : `${policy.refundPercentage}% refund from the Host (excluding Fees)`;
+        if (index === 0) {
+            return `If you (the sponsor) cancel your verified sponsorship commitment at least ${timeValue} ${unit} before the event start time, you will receive ${refundText} of what you paid the Host.`;
+        }
+        else {
+            const prevPolicy = refundPolicy[index - 1];
+            const prevUnit = prevPolicy.days ? "days" : "hours";
+            const prevTime = prevPolicy.days ?? prevPolicy.hours;
+            return `If you (the sponsor) cancel your verified sponsorship commitment between ${prevTime} ${prevUnit} and ${timeValue} ${unit} before the event start time, you will receive ${refundText} of what you paid the Host.`;
+        }
+    });
+    const lastTime = refundPolicy[refundPolicy.length - 1].days ??
+        refundPolicy[refundPolicy.length - 1].hours;
+    descriptions.push(`If you (the sponsor) cancel your verified sponsorship commitment less than ${lastTime} ${refundPolicy[refundPolicy.length - 1].days ? "days" : "hours"} before the event start time, your payment is not refundable under this policy.`);
+    descriptions.push(`If the Host cancels the event or your sponsorship, you will generally receive a full refund of what you paid, unless the cancellation was due to your non-compliance with the Host's or event's requirements.`);
+    return descriptions.join(" ");
+}
+Object.keys(SERVICE_CANCELLATION_POLICY_DATA)
+    .filter((policyKey) => policyKey !=
+    ServiceCancellationPolicy.None)
+    .forEach((policyKey) => {
+    const policy = SERVICE_CANCELLATION_POLICY_DATA[policyKey];
+    const keyStr = policyKey;
+    if (keyStr.startsWith("Vendor")) {
+        policy.description = generateVendorDescription(policy.refundPolicy);
+    }
+    else if (keyStr.startsWith("Exhibitor")) {
+        policy.description = generateExhibitorDescription(policy.refundPolicy);
+    }
+    else if (keyStr.startsWith("Sponsor")) {
+        policy.description = generateSponsorDescription(policy.refundPolicy);
+    }
+    else {
+        policy.description = generateDescription(policy.refundPolicy);
+    }
+});
+export function serviceSubscriptionIsActive(status) {
+    return [
+        ServiceSubscriptionStatus.Normal,
+        ServiceSubscriptionStatus.Trialing,
+    ].includes(status);
+}
+export function serviceGetSpecificType(service) {
+    if (service.serviceType == null) {
+        // throw new Error(`serviceGetSpecificType invalid serviceType`);
+        return null;
+    }
+    const specificFieldName = serviceTypeToField(service.serviceType);
+    if (specificFieldName == null) {
+        // throw new Error(`serviceGetSpecificType invalid serviceType`);
+        return null;
+    }
+    const specificId = service[`${specificFieldName}Id`];
+    return {
+        serviceId: service.id,
+        serviceType: service.serviceType,
+        specificFieldName: specificFieldName,
+        specificId: specificId,
+    };
+}
+export function serviceDetailUrl(serviceId, serviceType, specificId) {
+    return `/services/${serviceId}/${serviceType}/${specificId}`;
+}
+export function serviceWizardUrl(serviceId, serviceType, specificId, step = 0, substep = 0) {
+    return `/wz/services/${serviceId}/${serviceType}/${specificId}/${step}/${substep}`;
+}
+/**
+ * Vendor, Exhibitor, and Sponsor profile wizards share this layout: major step 6 = "How",
+ * sub-step 3 = "Payment method" (partner profile wizard payment step).
+ */
+export const PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_MAJOR_STEP = 6;
+export const PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_SUB_STEP = 3;
+export function partnerServiceProfileWizardPaymentMethodUrl(serviceId, serviceType, specificId) {
+    return serviceWizardUrl(serviceId, serviceType, specificId, PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_MAJOR_STEP, PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_SUB_STEP);
+}
+/** Venue wizard: major step index for Loyalty Builder (before Finish). */
+export const VENUE_WIZARD_LOYALTY_MAJOR_STEP = 7;
+/** Venue wizard: major step index for Finish (after Loyalty Builder). */
+export const VENUE_WIZARD_FINISH_MAJOR_STEP = 8;
+export function venueWizardLoyaltyBuilderUrl(serviceId, serviceType, venueId) {
+    return serviceWizardUrl(serviceId, serviceType, venueId, VENUE_WIZARD_LOYALTY_MAJOR_STEP, 0);
+}
+/** Stable ids for Venue loyalty template chips (stored in Venue.loyaltyTemplateIds). */
+export const VENUE_LOYALTY_TEMPLATE_IDS = [
+    "booking_discount",
+    "vip_access",
+    "early_access",
+    "parking",
+    "merch",
+    "custom",
+];
+export function serviceCheckoutUrl(serviceId, serviceType, specificId) {
+    return `/checkout/services/${serviceId}/${serviceType}/${specificId}`;
+}
+// Define the keys and values in a single object
+const serviceKeysObject = {
+    eventService: true,
+    entertainmentService: true,
+    vendor: true,
+    exhibitor: true,
+    sponsor: true,
+    venue: true,
+    organization: true,
+    volunteerService: true,
+};
+export const serviceKeysArray = Object.keys(serviceKeysObject);
+export const specificServiceMap = {
+    EventServices: "eventService",
+    EntertainmentServices: "entertainmentService",
+    Vendors: "vendor",
+    Exhibitors: "exhibitor",
+    Sponsors: "sponsor",
+    Venues: "venue",
+    Organizations: "organization",
+    Volunteers: "volunteerService",
+};
+export const serviceTypeToField = (serviceType) => {
+    return specificServiceMap[serviceType];
+};
+export function aiServiceInfoToInfoString(field, info) {
+    return `${field}: ${info.description} - ${info.type}${info.isArray ? "[]" : ""}`;
+}
+export function aiServiceInfoToExampleString(field, info) {
+    return `${field}: ${info.example} - ${info.type}${info.isArray ? "[]" : ""}`;
+}
+export const serviceGetInfoAI = (serviceType) => {
+    const res = {
+        serviceName: {
+            description: `serviceName (a catchy, descriptive name for the ${serviceType})`,
+            example: `The Grand Atrium`,
+            type: "string",
+            isArray: false,
+        },
+        tagline: {
+            description: `tagline (a short, compelling tagline or subtitle - different from description)`,
+            example: `Where Every Event Becomes Extraordinary`,
+            type: "string",
+            isArray: false,
+        },
+        description: {
+            description: `description for the ${serviceType}`,
+            example: `The Grand Atrium provides a fantastic dining experience with great prices and supports local farmers and reduces environmental impact.`,
+            type: "string",
+            isArray: false,
+        },
+        mission: {
+            description: `if the ${serviceType} has a mission to make a positive impact, describe it`,
+            example: `We strive to provide a sustainable dining experience that supports local farmers and reduces environmental impact.`,
+            type: "string",
+            isArray: false,
+        },
+        communityInvolvement: {
+            description: `describe how the ${serviceType} is involved in the community, if applicable`,
+            example: `We host monthly charity events and donate 10% of profits to local education initiatives.`,
+            type: "string",
+            isArray: false,
+        },
+    };
+    return res;
+};
+export const serviceSpecificInfoAI = {
+    EventServices: {},
+    EntertainmentServices: {
+        yearsOfExperience: {
+            description: `yearsOfExperience (use "LessThanOneYear", "OneToThreeYears", "ThreeToFiveYears", or "FivePlusYears" - for "10+ years" or similar use "FivePlusYears")`,
+            example: `"FivePlusYears"`,
+            type: "string",
+            isArray: false,
+        },
+        entertainmentServiceTypes: {
+            description: `entertainmentServiceTypes (array of EntertainmentServiceType enum values: "Emcees", "DJs", "Bands", "SoloMusicians", "Comedy", "VarietyActs", "PerformanceArtists", "Magic", "Dancers", "Aerialists", "Impersonators", "Speakers", "Auctioneers", "Musicians", "Producers", "Singers", "Instrumentalists", "Other")`,
+            example: `["DJs", "SoloMusicians"]`,
+            type: "string",
+            isArray: true,
+        },
+        genre: {
+            description: `genre (use MusicGenreType enum values: "EDM", "Electronic", "House", "Techno", "Dubstep", "Trance", "Pop", "Rock", "HipHop", "Country", "RnB", "Jazz", "Blues", "Indie", "Alternative", "Folk", "Acoustic", "Classical", "Opera", "World", "Latin", "Experimental", "Fusion", "Other")`,
+            example: `"Electronic"`,
+            type: "string",
+            isArray: false,
+        },
+    },
+    Vendors: {
+        yearsOfExperience: {
+            description: `yearsOfExperience (use "LessThanOneYear", "OneToThreeYears", "ThreeToFiveYears", or "FivePlusYears" - for "10+ years" or similar use "FivePlusYears")`,
+            example: `"FivePlusYears"`,
+            type: "string",
+            isArray: false,
+        },
+        vendorType: {
+            description: `vendorType: use "products" for physical goods (retail food, merchandise, packaged goods) and "services" for experiential booth activities (face painting, henna, etc.). If the prompt is only a well-known business or brand name, infer the correct mode: restaurant chains, bakeries, coffee shops, snack brands → "products"; activity-only brands → "services" when appropriate.`,
+            example: `"products"`,
+            type: "string",
+            isArray: false,
+        },
+        vendorProductTypes: {
+            description: `vendorProductTypes (array of VendedProductType enum values for PRODUCT vendors: Art, HandcraftedItems, Pottery, Woodwork, LeatherGoods, Textiles, BakedGoods, Beverages, FoodItems, HoneyAndJams, PopcornAndSnacks, SweetTreats, Spices, Sauces, MakeupCosmetics, SkincareProducts, BodyCareProducts, Soaps, Perfumes, HairCareProducts, Clothing, TShirtsAndApparel, Jewelry, Accessories, Hats, Bags, Shoes, HomeDecor, Candles, Plants, Succulents, Furniture, Kitchenware, Books, Crystals, SpiritualItems, HerbalRemedies, VintageAntiques, Collectibles, PhotographyPrints, StickersAndStationery, Prints, Zines, Toys, BabyItems, PetProducts, TechAccessories, Other). Only use for vendors with vendorType="products". For famous food/dessert brands (e.g. doughnuts, coffee), use FoodItems and/or SweetTreats (both are valid when appropriate).`,
+            example: `["FoodItems", "SweetTreats"]`,
+            type: "string",
+            isArray: true,
+        },
+        vendorServiceTypes: {
+            description: `vendorServiceTypes (array of VendorServiceType enum values for SERVICE vendors: BalloonArt, CaricatureDrawings, LivePainting, SilhouetteCutting, CustomCalligraphy, PortraitSketching, SprayPaintArt, FacePainting, HairBraiding, HennaArt, TemporaryTattoos, GlitterBodyArt, AirbrushMakeup, NailArt, HairStyling, ChairMassages, WellnessDemos, YogaOrMovementClasses, Reiki, Aromatherapy, Magician, ClownServices, StiltWalking, BubblePerformances, JugglingActs, MimeArtist, KidsCraftBooths, PettingZoos, PonyRides, BounceHouseOperator, GameBoothOperator, PhotoBooths, InstantPhotography, VideoMessages, GreenScreenPhotos, PsychicOrTarotReadings, PalmReading, AuraPhotography, Astrology, Other). Only use for vendors with vendorType="services".`,
+            example: `["FacePainting", "BalloonArt"]`,
+            type: "string",
+            isArray: true,
+        },
+        goodsOrServices: {
+            description: `goodsOrServices (array of specific items offered — e.g. "Donuts", "Coffee", "Glazed doughnuts", not just category names). When the user names a famous brand, infer typical menu or product lines for that brand.`,
+            example: `["Donuts", "Coffee", "Seasonal flavors"]`,
+            type: "string",
+            isArray: true,
+        },
+        detailsText: {
+            description: `detailsText (additional vendor details)`,
+            example: `"Specializing in handmade Ecuadorian crafts"`,
+            type: "string",
+            isArray: false,
+        },
+        minBoothFeeCents: {
+            description: `minBoothFeeCents (minimum booth fee vendor is willing to pay in cents)`,
+            example: `5000`,
+            type: "integer",
+            isArray: false,
+        },
+        maxBoothFeeCents: {
+            description: `maxBoothFeeCents (maximum booth fee vendor is willing to pay in cents)`,
+            example: `50000`,
+            type: "integer",
+            isArray: false,
+        },
+        preferredBoothFeeCents: {
+            description: `preferredBoothFeeCents (preferred booth fee vendor is willing to pay in cents)`,
+            example: `20000`,
+            type: "integer",
+            isArray: false,
+        },
+    },
+    Exhibitors: {},
+    Sponsors: {},
+    Venues: {
+        venueTypes: {
+            description: `venueTypes (array of primary venue types)`,
+            example: `["Restaurant", "Bar"]`,
+            type: "string",
+            isArray: true,
+        },
+        secondaryVenueTypes: {
+            description: `secondaryVenueTypes (array of secondary venue types)`,
+            example: `["Event Venue", "Private Dining"]`,
+            type: "string",
+            isArray: true,
+        },
+        vibe: {
+            description: `describe the atmosphere/mood - this will be used as the main description`,
+            example: `Upscale and sophisticated with a warm, inviting atmosphere`,
+            type: "string",
+            isArray: false,
+        },
+        dress: {
+            description: `specify dress code`,
+            example: `Smart casual`,
+            type: "string",
+            isArray: false,
+        },
+        allowed: {
+            description: `what guests can bring or do`,
+            example: `Outside food for special occasions with prior approval`,
+            type: "string",
+            isArray: false,
+        },
+        notAllowed: {
+            description: `what guests cannot bring or do`,
+            example: `Smoking, outside alcohol, disruptive behavior`,
+            type: "string",
+            isArray: false,
+        },
+        capacity: {
+            description: `number of people the venue can accommodate`,
+            example: `150`,
+            type: "integer",
+            isArray: false,
+        },
+        amenities: {
+            description: `array of amenities like "WiFi", "Parking", etc.`,
+            example: `["WiFi", "Parking", "Wheelchair Access", "Restrooms"]`,
+            type: "string",
+            isArray: false,
+        },
+        features: {
+            description: `array of features like "Stage", "Dance Floor", etc.`,
+            example: `["Private Dining Area", "Full Bar", "Audio System", "Projector"]`,
+            type: "string",
+            isArray: false,
+        },
+        yearsInBusiness: {
+            description: `how long the venue has been in business as a string: "LessThanOneYear", "OneToThreeYears", "ThreeToFiveYears", "FivePlusYears"`,
+            example: `"ThreeToFiveYears"`,
+            type: "string",
+            isArray: false,
+        },
+    },
+    Organizations: {},
+};
+/**
+ * Builds a formatted string of AI context fields, handling optional schemas and types.
+ */
+export function buildAIFieldsString(data, info) {
+    return Object.entries(info)
+        .map(([key, cfg]) => {
+        const { type, isArray } = cfg;
+        const raw = data[key];
+        const formatSingle = (val) => {
+            if (val == null)
+                return "";
+            switch (type) {
+                case "integer":
+                    return Number(val).toFixed(0);
+                case "float":
+                    return Number(val).toString();
+                case "boolean":
+                    return Boolean(val).toString();
+                case "date": {
+                    const d = new Date(val);
+                    return isNaN(d.getTime()) ? String(val) : d.toISOString();
+                }
+                case "string":
+                default:
+                    return String(val);
+            }
+        };
+        let display;
+        if (isArray) {
+            if (Array.isArray(raw)) {
+                display = raw.map(formatSingle).join(", ");
+            }
+            else {
+                display = formatSingle(raw);
+            }
+        }
+        else {
+            display = formatSingle(raw);
+        }
+        return `${String(key)}: ${raw != null ? display : `No ${String(key)} provided`}`;
+    })
+        .join(",\n        ");
+}
+export function serviceExcludeIds(service) {
+    const { id, venueId, entertainmentServiceId, eventServiceId, organizationId, volunteerServiceId, sponsorId, vendorId, exhibitorId, googlePlaceId, stripeAccountId, targetAudienceId, creatorId, ownerId, ...rest } = service;
+    return rest;
+}
+export function serviceExcludeOwners(service) {
+    const { owner, creator, ...rest } = service;
+    return rest;
+}
+export function serviceExcludeRates(service) {
+    const { serviceRatesAssociation, ...rest } = service;
+    return rest;
+}
+export function serviceExcludeDates(service) {
+    const { createdAt, updatedAt, ...rest } = service;
+    return rest;
+}
+export function serviceExcludeMiscData(service) {
+    const { serviceName, isApproved, serviceType, cancellationPolicy, instantBookingLeadTimeHours, allowsInstantBooking, displayBashReviewsOnDetailPage, displayGoogleReviewsOnDetailPage, subscriptionStatus, serviceCondition, serviceStatus, visibility, ...rest } = service;
+    return rest;
+}
+export function serviceRelevantData(service) {
+    return serviceExcludeOwners(serviceExcludeDates(serviceExcludeRates(serviceExcludeIds(serviceExcludeMiscData(service)))));
+}
+/**
+ * Returns the contextually correct label for a service's sellable items.
+ * Vendors sell "Products"; entertainers and other service types sell "Merch".
+ */
+export function getVendorSalesLabel(serviceType) {
+    return serviceType === ServiceTypes.Vendors ? "Products" : "Merch";
+}
+//# sourceMappingURL=serviceUtils.js.map