@expofp/schema 0.0.0-experimental.cf063fc

package/dist/lib/config.js

@@ -0,0 +1,438 @@
+import * as z from 'zod';
+import { RawBoothSchema } from './booth.js';
+import { SelectionStyleSchema, WayfindingColorsSchema } from './branding.js';
+import { CameraSchema } from './camera.js';
+import { RawCategorySchema } from './categories.js';
+import { LegacyLogoSchema, RawExhibitorSchema } from './exhibitor.js';
+import { FiltersSchema } from './filters.js';
+import { FlagsSchema } from './flags.js';
+import { FpSvgJsRefSchema, FpSvgLayerJsRefSchema } from './fp-svg.js';
+import { HeatmapSchema } from './heatmap.js';
+import { IntentsSchema } from './intents.js';
+import { JourneyLinkSchema } from './journey.js';
+import { KioskSchema } from './kiosk.js';
+import { MapLibreConfigSchema } from './maplibre.js';
+import { MapsProviderSchema } from './maps.js';
+import { RawPoiTypeSchema } from './poi-types.js';
+import { ScheduleItemSchema } from './schedule.js';
+import { FilterButtonsConfigSchema } from './search.js';
+import { VenueSchema, VenuesVersionSchema } from './venues.js';
+import { VisibilitySchema } from './visibility.js';
+import { WfDataJsRefSchema } from './wayfinding.js';
+// The document schemas below are LOOSE objects (`z.looseObject`): the platform
+// emits fields faster than this file learns them, and the effective config is
+// the runtime's ONLY copy of the expo data — a stripping parse would silently
+// lose anything unmodeled. Fields are declared for typing, docs and `asset`
+// tagging (`resolveAssetUrlsInPlace`); everything else passes through.
+/**
+ * One `customCssFonts` entry — a web font to load alongside custom CSS.
+ *
+ * Deliberately tolerant: `customCssFonts` is rare, author-authored platform
+ * data, and this schema now *validates* `data.js` (a shape slip used to be
+ * harmless on the untyped `window.__data`). Requiring the fields would let a
+ * numeric `weight` or a missing `style`/`url` throw and abort the whole config
+ * load — the label renderer already coerces `weight` with `+` and falls back to
+ * the default font when a field is absent, so a bad entry should degrade, not
+ * fail boot.
+ */
+const FontUrlSchema = z.looseObject({
+    weight: z.union([z.string(), z.number()]).optional(),
+    style: z.string().optional(),
+    url: z.string().meta({ asset: true }).optional(),
+});
+/**
+ * The cookie-consent decision for analytics. `'granted'` / `'denied'` apply a
+ * pre-made decision — no consent prompt, analytics on/off accordingly. `'ask'`
+ * (the default) leaves the decision to the visitor: GDPR visitors get the
+ * consent prompt, everyone else falls back to the regional gtag defaults.
+ */
+export const ConsentSchema = z.enum(['ask', 'granted', 'denied']);
+// this one presented to the world
+export const ConfigSchema = z.object({
+    expo: z.string(),
+    intents: z.array(IntentsSchema),
+    // The config carries only REFS to the legacy payload documents — the
+    // resolved payloads live in @expofp/resolve's memo (`getResolved`).
+    // `loadConfig` resolves fpSvgJsRef and wfDataJsRef eagerly before it
+    // returns, so they are always warm; layer refs resolve on demand.
+    /** `fp.svg.js` ref (the drawing); null derives `<legacyDataUrlBase>fp.svg.js`. */
+    fpSvgJsRef: FpSvgJsRefSchema.nullable(),
+    /** Per-layer `fp.svg.<layerName>.js` refs (by layer name), resolved on demand. */
+    fpSvgLayerJsRefs: z.record(z.string(), FpSvgLayerJsRefSchema),
+    /** `wf.data.js` (wayfinding graph) ref; null without legacy data. */
+    wfDataJsRef: WfDataJsRefSchema.nullable(),
+    // data.js (__data)
+    noFeatured: z.boolean(),
+    isTrial: z.boolean(),
+    expoFpAd: z.boolean(),
+    free: z.boolean(),
+    trialExpiresAt: z.string(),
+    title: z.string(),
+    subtitle: z.string(),
+    homeUrl: z.string(),
+    registerUrl: z.string(),
+    startDate: z.string(),
+    endDate: z.string(),
+    // `optionalAsset`: the effective logo can be a data-dir-relative *guess* —
+    // `normalizeLegacyData` fabricates `<expo>-logo.png` when data.js carries no
+    // logo — so a 404 must warn-and-skip during offline generation, not abort the
+    // whole archive (an event logo is non-critical branding).
+    logo: z.string().meta({ asset: true, optionalAsset: true }),
+    gallery: z.array(LegacyLogoSchema),
+    gtag: z.string(),
+    boothTerm: z.string(),
+    levelTerm: z.string(),
+    reserveButtonTerm: z.string(),
+    exhibitorTerm: z.string(),
+    exhibitorTermPlural: z.string(),
+    locale: z.string(),
+    booths: z.array(RawBoothSchema),
+    exhibitors: z.array(RawExhibitorSchema),
+    categories: z.array(RawCategorySchema),
+    poiTypes: z.array(RawPoiTypeSchema),
+    reserveInstructions: z.string(),
+    sendLoginLinkUrl: z.string(),
+    trackerUrl: z.string(),
+    hideWayInformation: z.boolean(),
+    hideDirections: z.boolean(),
+    hideExhibitors: z.boolean(),
+    onlyFeaturedExhibitors: z.boolean(),
+    hideExhibitorBoothNumber: z.boolean(),
+    dimensionless: z.boolean(),
+    hideCategoriesLink: z.boolean(),
+    hideEventHomeLink: z.boolean(),
+    hideRegisterToAttendLink: z.boolean(),
+    hideDownloadPdfLink: z.boolean(),
+    hideBookmarksLink: z.boolean(),
+    hideBookmarks: z.boolean(),
+    hideLanguage: z.boolean(),
+    hideLanguageLink: z.boolean(),
+    /** Only these locale ids are offered in the language menu; empty = all bundled locales. */
+    uiLanguages: z.array(z.string()),
+    /** Hide the level name on the booth badges inside the exhibitor card. */
+    hideBoothLevel: z.boolean(),
+    /** Selected booth highlight: blinking interpolation (default) or a solid fill without outline. */
+    selectionStyle: SelectionStyleSchema,
+    /** Selected booth / POI color; empty keeps the plan's `__fpSettings` value. */
+    selectionColor: z.string(),
+    wayfindingColors: WayfindingColorsSchema,
+    autoTrackingGps: z.boolean(),
+    enableIPS: z.boolean(),
+    allow3dView: z.boolean(),
+    hide3dMapDefault: z.boolean(),
+    hideModeSwitchButton: z.boolean(),
+    isRebooking: z.boolean(),
+    events: z.array(ScheduleItemSchema),
+    customCss: z.string().meta({ cssAsset: true }),
+    customCssFonts: z.array(FontUrlSchema),
+    showLevelLabel: z.boolean(),
+    showCategories: z.boolean(),
+    showCompaniesAndBooths: z.boolean(),
+    showOtherSpaces: z.boolean(),
+    hideShareButton: z.boolean(),
+    /**
+     * Fold long exhibitor and session descriptions under a fade that expands
+     * on tap (in kiosk mode, the whole details block behind "Show more").
+     * `false` always shows the full text.
+     */
+    collapseDescriptions: z.boolean(),
+    /**
+     * While the visitor types in search, frame the matching booths and points once typing pauses:
+     * the matches in the venue on screen, or the venue all matches share. `false` keeps the camera
+     * where it is until a result is picked.
+     */
+    searchCameraFollow: z.boolean(),
+    viewOptimizationLevel: z.number(),
+    shortLevelName: z.boolean(),
+    searchText: z.string(),
+    filterButtonsConfig: FilterButtonsConfigSchema,
+    enableRotation: z.boolean(),
+    alwaysShowSidebar: z.boolean(),
+    customKioskQrCodeUrl: z.string(),
+    /**
+     * Address every QR code the plan prints is built on — the route code and the
+     * cross-venue journey deep link alike. Empty, the default, means the plan's
+     * own canonical `https://<expo>.expofp.com`, which is right whenever the plan
+     * is served from there; a copy served from somewhere else — a branch runtime,
+     * an offline build, a page embedding the plan under its own address — sets
+     * this so a scanned code lands on a page that exists.
+     *
+     * Only the part before the query is honored: each code writes its own query
+     * over whatever this carries. Everything after it rides along untouched, so a
+     * host that selects the plan with a fragment keeps it.
+     */
+    qrCodeBaseUrl: z.string(),
+    /** Wire version of the multi-venue payload. Revision 2 defines version 1. */
+    venuesVersion: VenuesVersionSchema,
+    /**
+     * Multi-venue definitions. A plan has a venue model when this array is
+     * present, non-empty, and valid — the loose shape here lets a malformed
+     * venue through so it can be quarantined with a diagnostic rather than
+     * failing the whole plan (contract enforcement lives in
+     * `packages/floorplan/src/data/venues.ts`).
+     */
+    venues: z.array(VenueSchema),
+    /**
+     * Producer override for the external maps provider a cross-venue journey
+     * hands off to. Unset — the default — leaves the choice to the platform
+     * (Apple Maps on iOS/iPadOS, Google Maps elsewhere); setting it forces that
+     * provider everywhere, so a partnership or regional preference is honored on
+     * every device. Inert unless `crossVenueJourneys` is on.
+     */
+    mapsProvider: MapsProviderSchema.optional(),
+    /**
+     * The journey a deep link asks for — the query a scanned kiosk QR or a
+     * desktop "continue on your phone" link arrives as. Absent on an ordinary
+     * load. Identifiers only: opening the link recomputes the journey from the
+     * plan the device has now (`?journey[to]=A-12&journey[from]=B-30`).
+     */
+    journey: JourneyLinkSchema.optional(),
+    /**
+     * Indoor-positioning provider for the native SDKs, opaque web-side:
+     * `<provider>.<version>.<base64url credentials>`, e.g.
+     * `indooratlas.1.SGVsbG8gV29ybGQh`. `null` (the default) means none — not
+     * `''`, so the native bridge sees Kotlin `null` / Swift `nil`.
+     */
+    mobileLocationProvider: z.string().nullable(),
+    ...FlagsSchema.shape,
+    // user preferences
+    /** Debug mode: verbose logs, the in-map debug overlay, dev-leniency in error paths. */
+    debugMode: z.boolean(),
+    debugPattern: z.string(),
+    showDebugButton: z.boolean(),
+    // options
+    previewMode: z.boolean(),
+    noOverlay: z.boolean(),
+    offHistory: z.boolean(),
+    ignoreQuery: z.boolean(),
+    consent: ConsentSchema,
+    viewerMode: z.boolean(),
+    disableRuntimeAlerts: z.boolean(),
+    maplibre: MapLibreConfigSchema,
+    // presentation toggles, historically one-shot URL params scrubbed by the
+    // legacy router; now ordinary config fields every layer (manifest, options,
+    // localStorage, URL) can set
+    /** Render the plan in grayscale. */
+    monochrome: z.boolean(),
+    /** Hide the header logo (and the ExpoFP logo). */
+    hideHeaderLogo: z.boolean(),
+    /** Hide exhibitor logos inside booths. */
+    hideLogoInBooth: z.boolean(),
+    /** Drop the `featured` flag from every exhibitor (no featured view). */
+    disableFeatured: z.boolean(),
+    /** Disable adding entities to bookmarks. */
+    disableBookmarked: z.boolean(),
+    /** Start with GPS tracking off. */
+    disableGps: z.boolean(),
+    /**
+     * The initial camera, applied once at boot (an empty object means "don't
+     * move"). The URL form is `?camera[x]=…`; the runtime counterpart is
+     * `FloorPlan.setCamera` / the `setCamera` intent.
+     */
+    camera: CameraSchema,
+    /**
+     * Visibility of the map chrome, applied once at boot. An empty object leaves
+     * the chrome untouched; a non-empty one REBUILDS the set — every element it
+     * omits resets to visible — so a URL that hides one element must list every
+     * other element it also wants hidden. The URL form is
+     * `?visibility[header]=false`; the runtime counterpart is
+     * `FloorPlan.setVisibility` / the `setVisibility` intent.
+     */
+    visibility: VisibilitySchema,
+    /**
+     * Search filters applied once at boot by the URL filter manager (an empty
+     * object applies nothing). Canonical URL form `?filters[categories][0]=food`;
+     * the legacy `?categories=`/`?poiType=`/`?poiTypes=`/`?exhibitors=true` keys
+     * keep working — and remain the form the floor plan writes back to the URL
+     * as the visitor changes filters.
+     */
+    filters: FiltersSchema,
+    /**
+     * Heatmap mode, engaged once at boot (an empty object — the default — means
+     * no heatmap). A non-empty node engages the mode unless `enabled` is
+     * explicitly `false`, so `heatmap: { variant: 'yah' }` implies enabled;
+     * `variant` picks the dataset (`booths` view stats by default, `yah` for
+     * "You are here" QR scans; `kiosk: true` narrows `yah` to kiosk positions).
+     * Heatmap mode freezes the page URL for the whole session (the legacy
+     * contract). The legacy `?heatmap=true&type=yah&subtype=kiosk` links keep
+     * working as a translation; the access token `?t=` stays a separate raw
+     * query param, not config.
+     */
+    heatmap: HeatmapSchema,
+    /**
+     * The kiosk anchor — where a kiosk device stands and how its camera is
+     * framed, applied at boot when the device has no locally-saved kiosk (the
+     * on-device SetKiosk flow wins; `localStorage['kiosk']='0'` disables both).
+     * Canonical URL form `?kiosk[x]=…`, and `?kiosk=1/0` keeps toggling kiosk
+     * mode. The legacy `kiosk_x/y/z` params are a separate, narrower channel:
+     * they carry the anchor POSITION to a phone scanning a kiosk's route QR
+     * code, and put that phone in no kiosk mode of its own.
+     */
+    kiosk: KioskSchema,
+});
+/**
+ * Deprecated `allowConsent` input alias, accepted by the data and options input
+ * schemas and folded into `consent` by `loadConfig` (`true` → `'granted'`,
+ * `false` → `'denied'`; a layer's own `consent` wins). The effective config
+ * never carries it. RETIRED from the URL query — `?consent=` is the only query
+ * form (see `retiredKeys` in `@expofp/config`'s legacy-url codec).
+ */
+const DeprecatedConsentAlias = {
+    allowConsent: z.boolean().optional(),
+};
+/**
+ * Load-time diagnostic inputs — accepted from the URL query and localStorage but
+ * NEVER carried on the effective config (`loadConfig` reads them up front, then
+ * strips them before the config is frozen). So far only `validateSchema`: it
+ * gates schema validation during the load itself (consumed by `@expofp/config`'s
+ * `readValidateFlag`) and is meaningless once the config exists — hence kept off
+ * `ConfigSchema`, like the deprecated `allowConsent` alias above.
+ */
+const LoadDiagnostics = {
+    validateSchema: z.boolean().optional(),
+};
+/**
+ * The expo data document — the `__data` global of the legacy `data.js`: every
+ * config field optional, plus the deprecated nested `flags`.
+ */
+export const DataSchema = z.looseObject({
+    ...ConfigSchema.partial().shape,
+    ...DeprecatedConsentAlias,
+    flags: FlagsSchema.optional().meta({ description: 'deprecated, use root-level fields' }),
+});
+/**
+ * The evaluated `data.js` payload. Like `fp.svg.js`, the file is a classic
+ * window-assigning browser script (`window.__data = …`) that `resolve`
+ * (`@expofp/resolve`) evaluates to its globals; the expo data document rides
+ * on `__data`.
+ */
+export const DataJsSchema = z.looseObject({
+    __data: DataSchema.optional(),
+});
+// manifest, options, localStorage, URL -> all fields optional
+// result config - all fields are set, except raw (bool/string that are empty)
+// Loose for the same reason as DataSchema: an offline copy's manifest IS
+// the merged expo data, so unmodeled fields must survive the parse.
+export const ManifestSchema = z.looseObject({
+    ...ConfigSchema.partial().required({ expo: true }).shape,
+    ...DeprecatedConsentAlias,
+    /**
+     * The legacy expo-data directory (`data.js`, `fp.svg.js`, …). Consumed by
+     * `loadConfig` to fetch the document and derive the payload refs — it is NOT
+     * carried on the effective config; nothing outside the config package ever
+     * sees it.
+     */
+    legacyDataUrlBase: z.string().optional(),
+    /**
+     * Pin of the legacy data revision — the `version.json` value at manifest
+     * generation time. `loadConfig` cache-busts the legacy file refs with it
+     * (`?v=<pin>`) and skips its own `version.json` probe, so the manifest and
+     * the data it points at stay consistent by construction. `null` states
+     * "probed: no version.json exists" — the runtime cache-busts per load with
+     * a timestamp, still without probing. Only an ABSENT field (legacy
+     * manifests, which predate the pin) leaves the runtime to probe; the
+     * retired `$ref`-pointer shape still parses but is treated as absent. An
+     * input consumed by `loadConfig` like `legacyDataUrlBase`, never carried on
+     * the effective config.
+     */
+    legacyDataVersion: z.union([z.string(), z.null(), z.object({ $ref: z.string() })]).optional(),
+});
+/**
+ * Caller-supplied overrides — the config fields a host may set when embedding
+ * the floor plan (`load(manifest, options)`). Deliberately EXPLICIT (a `pick`,
+ * not `ConfigSchema.partial()`): the expo data proper — booths, exhibitors,
+ * branding, feature flags — comes from the manifest / `data.js`, so `loadConfig`
+ * parses the options layer and strips anything outside this set. `allowConsent`
+ * is the deprecated alias for `consent`.
+ */
+export const OptionsSchema = ConfigSchema.partial()
+    .pick({
+    previewMode: true,
+    noOverlay: true,
+    offHistory: true,
+    ignoreQuery: true,
+    consent: true,
+    viewerMode: true,
+    disableRuntimeAlerts: true,
+    maplibre: true,
+})
+    .extend(DeprecatedConsentAlias);
+/** The subset tunable from the page URL query. */
+export const UrlConfigSchema = ConfigSchema.partial()
+    .pick({
+    enableExperimentalMaplibre: true,
+    enableExperimentalOutdoorMarkers: true,
+    enableExperimentalVenueFraming: true,
+    enableExperimentalNorthUp: true,
+    crossVenueJourneys: true,
+    // the journey provider override — tunable here so a plan can be checked on
+    // either provider from any device, not only the one it defaults to
+    mapsProvider: true,
+    // the journey deep link: ?journey[to]=A-12&journey[from]=B-30 — a scanned
+    // kiosk QR or a desktop hand-off arrives as exactly this
+    journey: true,
+    intents: true,
+    consent: true,
+    // the former one-shot presentation params — the query keys keep their
+    // historical names, which match these field names exactly. `noOverlay` is
+    // NOT among them: the overlay is addressed by `?visibility[overlay]=false`
+    // from the URL, the field stays a manifest/options setting
+    monochrome: true,
+    hideHeaderLogo: true,
+    hideLogoInBooth: true,
+    disableFeatured: true,
+    disableBookmarked: true,
+    disableGps: true,
+    // the canonical camera form: ?camera[x]=6517&camera[y]=3826&camera[bearing]=180
+    camera: true,
+    // the canonical visibility form: ?visibility[header]=false
+    visibility: true,
+    // the canonical filters form: ?filters[categories][0]=food — the legacy
+    // `categories`/`poiType(s)`/`exhibitors` keys stay OUT of this pick: they
+    // live in the URL as the filter manager's property and are never scrubbed
+    filters: true,
+    // the canonical heatmap form: ?heatmap[variant]=yah&heatmap[enabled]=true
+    // (the legacy scalar ?heatmap=true is not this node's shape — it stays a
+    // legacy-URL one-shot and drops out of the tolerant config parse)
+    heatmap: true,
+    // the canonical kiosk-anchor form: ?kiosk[x]=6517&kiosk[y]=3826 — the
+    // legacy scalar ?kiosk=1/0 (the mode toggle) is not this node's shape: it
+    // drops out of the tolerant parse and keeps its params-based primary
+    kiosk: true,
+})
+    .extend(LoadDiagnostics);
+/**
+ * The subset persisted per-user in localStorage.
+ *
+ * `viewerMode` / `previewMode` / `uiScale` are schema-typed here (their keys
+ * are `efp-viewerMode` / `efp-previewMode` / `efp-uiScale`) but deliberately
+ * NOT merged into the effective config by `loadConfig`: the floor plan reads
+ * them from storage lazily, which is what keeps the legacy one-shot URL seeds
+ * (`?viewermode=` / `?previewMode=` / `?uiscale=`, which write these keys)
+ * effective within the same load — a frozen config value could not be
+ * revoked by a same-load disable seed.
+ */
+export const LocalStorageConfigSchema = ConfigSchema.partial()
+    .pick({
+    enableExperimentalMaplibre: true,
+    enableExperimentalOutdoorMarkers: true,
+    enableExperimentalVenueFraming: true,
+    enableExperimentalNorthUp: true,
+    debugMode: true,
+    debugPattern: true,
+    showDebugButton: true,
+    viewerMode: true,
+    previewMode: true,
+})
+    .extend({
+    /**
+     * Per-browser UI-scale preference (0.8–1.4), seeded by the legacy
+     * `?uiscale=` param. Not a `ConfigSchema` field: nothing consumes a
+     * config-level uiScale — the floor plan UI reads the storage key
+     * directly. Tolerant (`catch`): a hand-edited or out-of-range stored
+     * value reads as absent instead of failing the whole storage layer at
+     * boot.
+     */
+    uiScale: z.number().min(0.8).max(1.4).optional().catch(undefined),
+})
+    .extend(LoadDiagnostics);

package/dist/lib/exhibitor.d.ts

@@ -0,0 +1,66 @@
+import * as z from 'zod';
+/** A marketing asset an exhibitor uploads — an entry in `marketMaterials`. */
+export declare const MarketMaterialSchema: z.ZodObject<{
+    fileName: z.ZodString;
+    path: z.ZodString;
+}, z.core.$loose>;
+/** The legacy string logo form — a bare asset URL. */
+export declare const LegacyLogoSchema: z.ZodString;
+/**
+ * The object logo form, carrying pre-scaled variant URLs. The variants are
+ * minted from the full URL without an existence check (`optionalAsset`), so
+ * the platform may never have produced the files — consumers fall back to
+ * `url`, and the offline generator skips a missing variant instead of failing.
+ */
+export declare const LogoSchema: z.ZodObject<{
+    url: z.ZodString;
+    smallUrl: z.ZodOptional<z.ZodString>;
+    tinyUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RawExhibitorSchema: z.ZodObject<{
+    id: z.ZodNonOptional<z.ZodOptional<z.ZodNumber>>;
+    name: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodString>;
+    featured: z.ZodOptional<z.ZodBoolean>;
+    advertise: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    address2: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    zip: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+    phone1: z.ZodOptional<z.ZodString>;
+    website: z.ZodOptional<z.ZodString>;
+    facebook: z.ZodOptional<z.ZodString>;
+    instagram: z.ZodOptional<z.ZodString>;
+    linkedin: z.ZodOptional<z.ZodString>;
+    twitter: z.ZodOptional<z.ZodString>;
+    googlePlus: z.ZodOptional<z.ZodString>;
+    xing: z.ZodOptional<z.ZodString>;
+    youtube: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    privateEmail: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    logo: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+        smallUrl: z.ZodOptional<z.ZodString>;
+        tinyUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    logoInBooth: z.ZodOptional<z.ZodBoolean>;
+    logoAspectRatio: z.ZodOptional<z.ZodNumber>;
+    gallery: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    marketMaterials: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fileName: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$loose>>>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    leadingImageUrl: z.ZodOptional<z.ZodString>;
+    videoUrl: z.ZodOptional<z.ZodString>;
+    rebookingState: z.ZodOptional<z.ZodNumber>;
+    rebookingNote: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type RawExhibitor = z.infer<typeof RawExhibitorSchema>;
+export type MarketMaterial = z.infer<typeof MarketMaterialSchema>;
+export type Logo = z.infer<typeof LogoSchema>;
+//# sourceMappingURL=exhibitor.d.ts.map

package/dist/lib/exhibitor.js

@@ -0,0 +1,69 @@
+import * as z from 'zod';
+/** A marketing asset an exhibitor uploads — an entry in `marketMaterials`. */
+export const MarketMaterialSchema = z.looseObject({
+    fileName: z.string(),
+    path: z.string().meta({ asset: true }),
+});
+/** The legacy string logo form — a bare asset URL. */
+export const LegacyLogoSchema = z.string().meta({ asset: true });
+/**
+ * The object logo form, carrying pre-scaled variant URLs. The variants are
+ * minted from the full URL without an existence check (`optionalAsset`), so
+ * the platform may never have produced the files — consumers fall back to
+ * `url`, and the offline generator skips a missing variant instead of failing.
+ */
+export const LogoSchema = z.object({
+    url: z.string().meta({ asset: true }),
+    smallUrl: z.string().optional().meta({ asset: true, optionalAsset: true }),
+    tinyUrl: z.string().optional().meta({ asset: true, optionalAsset: true }),
+});
+/**
+ * An exhibitor logo. The platform still emits the legacy string form on input;
+ * `normalizeLegacyData` (`@expofp/config`) converts it to {@link LogoSchema} —
+ * the pre-scaled `__small`/`__tiny` siblings become explicit variant URLs — so
+ * the EFFECTIVE config only ever carries the object form. Plain code, not a zod
+ * transform: parse is validation only (gated by the opt-in `validateSchema` flag) and the
+ * pipeline must work without it.
+ */
+const ExhibitorLogoSchema = LegacyLogoSchema.or(LogoSchema);
+export const RawExhibitorSchema = z
+    .looseObject({
+    id: z.number(),
+    name: z.string(),
+    externalId: z.string(),
+    featured: z.boolean(),
+    advertise: z.boolean(),
+    description: z.string(),
+    address: z.string(),
+    address2: z.string(),
+    city: z.string(),
+    state: z.string(),
+    zip: z.string(),
+    country: z.string(),
+    phone1: z.string(),
+    website: z.string(),
+    facebook: z.string(),
+    instagram: z.string(),
+    linkedin: z.string(),
+    twitter: z.string(),
+    googlePlus: z.string(),
+    xing: z.string(),
+    youtube: z.string(),
+    email: z.string(),
+    privateEmail: z.string(),
+    order: z.number(),
+    logo: ExhibitorLogoSchema,
+    /** Paint the logo inside the exhibitor's booth shape on the drawing. */
+    logoInBooth: z.boolean(),
+    /** The logo's width divided by its height. */
+    logoAspectRatio: z.number(),
+    gallery: z.array(LegacyLogoSchema),
+    marketMaterials: z.array(MarketMaterialSchema),
+    categories: z.array(z.number()),
+    leadingImageUrl: z.string().meta({ asset: true }),
+    videoUrl: z.string(),
+    rebookingState: z.number(),
+    rebookingNote: z.string(),
+})
+    .partial()
+    .required({ id: true, name: true });

package/dist/lib/filters.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+/**
+ * Boot-time search filters — the `config.filters` node, applied once by the
+ * floor plan's URL filter manager when the stores are ready. Values are plain
+ * catalog names (no URL encoding), matched case-insensitively; unknown names
+ * warn and drop, and `categories` win over POI types when both are given.
+ *
+ * `poiType` (single) and `poiTypes` (multi) are deliberately distinct fields —
+ * not one array as the retirement-plan sketch had it — because their apply
+ * paths differ: the single form also activates the matching search filter
+ * button (`setPoiFilterId`), while the multi form only pre-selects the
+ * filters. Folding them into one array would silently change what a
+ * one-element list does.
+ */
+export declare const FiltersSchema: z.ZodObject<{
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    poiType: z.ZodOptional<z.ZodString>;
+    poiTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exhibitors: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface Filters extends z.infer<typeof FiltersSchema> {
+}
+//# sourceMappingURL=filters.d.ts.map

package/dist/lib/filters.js

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+/**
+ * Boot-time search filters — the `config.filters` node, applied once by the
+ * floor plan's URL filter manager when the stores are ready. Values are plain
+ * catalog names (no URL encoding), matched case-insensitively; unknown names
+ * warn and drop, and `categories` win over POI types when both are given.
+ *
+ * `poiType` (single) and `poiTypes` (multi) are deliberately distinct fields —
+ * not one array as the retirement-plan sketch had it — because their apply
+ * paths differ: the single form also activates the matching search filter
+ * button (`setPoiFilterId`), while the multi form only pre-selects the
+ * filters. Folding them into one array would silently change what a
+ * one-element list does.
+ */
+export const FiltersSchema = z.object({
+    /** Category names to pre-select; opens the category filter panel. */
+    categories: z.array(z.string()).optional(),
+    /** A single POI type to pre-select; also activates its search filter button. */
+    poiType: z.string().optional(),
+    /** POI type names to pre-select (no filter-button activation). */
+    poiTypes: z.array(z.string()).optional(),
+    /** `true` opens the exhibitors list at boot. */
+    exhibitors: z.boolean().optional(),
+});

package/dist/lib/flags.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+/**
+ * Feature flags. Historically a nested `flags` object; now flattened onto the
+ * config root (`...FlagsSchema.shape` in `ConfigSchema`). The deprecated nested
+ * form still parses through `DataJsonSchema`.
+ */
+export declare const FlagsSchema: z.ZodObject<{
+    enableExperimentalMaplibre: z.ZodOptional<z.ZodBoolean>;
+    enableExperimentalOutdoorMarkers: z.ZodOptional<z.ZodBoolean>;
+    enableExperimentalVenueFraming: z.ZodOptional<z.ZodBoolean>;
+    enableExperimentalNorthUp: z.ZodOptional<z.ZodBoolean>;
+    customSetKiosk: z.ZodOptional<z.ZodString>;
+    hideBoothBadges: z.ZodOptional<z.ZodBoolean>;
+    crossVenueJourneys: z.ZodOptional<z.ZodBoolean>;
+    busRoutes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+//# sourceMappingURL=flags.d.ts.map