@expofp/schema 0.0.0-experimental.cf063fc

package/dist/lib/kiosk.js

@@ -0,0 +1,65 @@
+import * as z from 'zod';
+/**
+ * The kiosk anchor — the `config.kiosk` node: where the physical 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 persists to localStorage
+ * and wins over the config; the `localStorage['kiosk']='0'` device switch
+ * disables both). `?kiosk=1/0` keeps toggling kiosk MODE — the mode and the
+ * anchor are independent inputs.
+ *
+ * The legacy `kiosk_x/y/z` params are a narrower, per-navigation channel for
+ * one purpose: a kiosk's route QR code hands the scanning phone the anchor
+ * POSITION so the route's missing starting point resolves there. The framing
+ * fields below travel only in this node, never through those params, and the
+ * params put the scanning device in no kiosk mode of its own.
+ */
+export const KioskSchema = z.object({
+    /** Anchor x in plan coordinates. */
+    x: z.number().optional(),
+    /** Anchor y in plan coordinates. */
+    y: z.number().optional(),
+    /**
+     * Floor: the level name (a numeric index is accepted and stringified).
+     * Nullable — the on-device SetKiosk flow writes `null` for a plan with no
+     * layers, and that record round-trips through localStorage.
+     */
+    z: z.union([z.string(), z.number()]).nullish(),
+    /** Device heading in degrees — rotates the you-are-here marker. */
+    heading: z.number().optional(),
+    /** GPS latitude (with `lng`, an alternative fix to `x`/`y`). */
+    lat: z.number().optional(),
+    /** GPS longitude. */
+    lng: z.number().optional(),
+    /** You-are-here icon size, in percent. */
+    iconSizePercent: z.number().optional(),
+    /** Per-device UI scale preference (the applied range is 0.8–1.4). */
+    uiScale: z.number().optional(),
+    // the saved camera framing on the plan renderer — SetKiosk captures the
+    // renderer's camera state
+    /** Map roll at the kiosk's home framing, degrees. */
+    mapRollDegrees: z.number().optional(),
+    /** The pt-scale captured when the kiosk was set up (zoom reference). */
+    mapInitialPtScale: z.number().optional(),
+    /** The pt-scale of the saved framing. */
+    mapPtScale: z.number().optional(),
+    /** Home framing center x. */
+    mapCenterX: z.number().optional(),
+    /** Home framing center y. */
+    mapCenterY: z.number().optional(),
+    /** Map pitch at the home framing, degrees. */
+    mapPitch: z.number().optional(),
+    // the map-mode framing — with the MapLibre basemap the plan renderer's camera
+    // is inert, so the home view is captured as the map's own camera instead. The
+    // two sets are fully independent, pitch included: a kiosk carries whichever
+    // set its mode captured, and capturing in one mode never writes the other's.
+    /** Home framing center longitude (map mode). */
+    mapCenterLng: z.number().optional(),
+    /** Home framing center latitude (map mode). */
+    mapCenterLat: z.number().optional(),
+    /** Map zoom level at the home framing (map mode). */
+    mapZoom: z.number().optional(),
+    /** Map bearing at the home framing, degrees (map mode). */
+    mapBearingDegrees: z.number().optional(),
+    /** Map pitch at the home framing, degrees (map mode). */
+    mapPitchDegrees: z.number().optional(),
+});

package/dist/lib/maplibre.d.ts

@@ -0,0 +1,43 @@
+import * as z from 'zod';
+/**
+ * MapLibre GL JS integration settings — the config's `maplibre` field.
+ *
+ * The style document is MapLibre's, not ours. Offline archives store the
+ * style URL and the style's internal URLs (sprite, glyphs, tile sources)
+ * relative to their containing documents, so the archive stays relocatable;
+ * see the offline package's `generateOfflineMapData`.
+ *
+ * MapLibre itself, though, requires those internal URLs to be *fully absolute*
+ * (scheme + host) and rejects rooted/relative ones — and only the runtime
+ * knows the serving origin. So the SDK absolutizes string-URL styles' internal
+ * resources against the style's own URL through MapLibre's `transformStyle`
+ * hook at load time (`createStyleTransform` in the floorplan's Maplibre
+ * wrapper).
+ */
+export declare const MapLibreConfigSchema: z.ZodObject<{
+    styleUrl: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodAny>;
+    offline: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/** MapLibre options — the inferred type of {@link MapLibreConfigSchema}. */
+export type MaplibreOptions = z.infer<typeof MapLibreConfigSchema>;
+/**
+ * Which basemap palette the map view uses.
+ *
+ * The drawing decides, not the visitor and not the host: the Designer writes
+ * the palette it was authored for into `__fpGeo.properties.config.style`
+ * ({@link FpGeoConfigSchema}), and when that is unset the SDK falls back to the
+ * lightness of the drawing's `__fpSettings.backgroundColor`. Those two are the
+ * only sources — the palette is not a config field.
+ *
+ * Resolved once when the map mounts. Only the basemap responds to it today, and
+ * an explicit `maplibre.style` / `maplibre.styleUrl` is a complete style
+ * document that wins over the theme entirely.
+ */
+export declare const MapThemeSchema: z.ZodEnum<{
+    dark: "dark";
+    light: "light";
+}>;
+/** Basemap palette — the inferred type of {@link MapThemeSchema}. */
+export type MapTheme = z.infer<typeof MapThemeSchema>;
+//# sourceMappingURL=maplibre.d.ts.map

package/dist/lib/maplibre.js

@@ -0,0 +1,51 @@
+import * as z from 'zod';
+/**
+ * MapLibre GL JS integration settings — the config's `maplibre` field.
+ *
+ * The style document is MapLibre's, not ours. Offline archives store the
+ * style URL and the style's internal URLs (sprite, glyphs, tile sources)
+ * relative to their containing documents, so the archive stays relocatable;
+ * see the offline package's `generateOfflineMapData`.
+ *
+ * MapLibre itself, though, requires those internal URLs to be *fully absolute*
+ * (scheme + host) and rejects rooted/relative ones — and only the runtime
+ * knows the serving origin. So the SDK absolutizes string-URL styles' internal
+ * resources against the style's own URL through MapLibre's `transformStyle`
+ * hook at load time (`createStyleTransform` in the floorplan's Maplibre
+ * wrapper).
+ */
+export const MapLibreConfigSchema = z
+    .looseObject({
+    /**
+     * Full, rooted, or relative URL of a MapLibre style document, fetched by
+     * MapLibre GL itself. Its internal resources are resolved by the SDK before
+     * MapLibre consumes the loaded style.
+     */
+    styleUrl: z.string(),
+    /**
+     * Inline style object (takes precedence over `styleUrl`). With no style
+     * URL to resolve against, every URL inside it must already be full.
+     */
+    style: z.any(),
+    /**
+     * The style and everything it references (tiles, sprites, glyphs) are
+     * reachable without network — lets the map stay enabled while
+     * `navigator.onLine` is false.
+     */
+    offline: z.boolean(),
+})
+    .partial();
+/**
+ * Which basemap palette the map view uses.
+ *
+ * The drawing decides, not the visitor and not the host: the Designer writes
+ * the palette it was authored for into `__fpGeo.properties.config.style`
+ * ({@link FpGeoConfigSchema}), and when that is unset the SDK falls back to the
+ * lightness of the drawing's `__fpSettings.backgroundColor`. Those two are the
+ * only sources — the palette is not a config field.
+ *
+ * Resolved once when the map mounts. Only the basemap responds to it today, and
+ * an explicit `maplibre.style` / `maplibre.styleUrl` is a complete style
+ * document that wins over the theme entirely.
+ */
+export const MapThemeSchema = z.enum(['light', 'dark']);

package/dist/lib/maps.d.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+/**
+ * The external maps provider a cross-venue journey's external handoff opens.
+ *
+ * Only the two whose universal URL forms the SDK builds: any other value is a
+ * dead link, so the enum is closed rather than an open string.
+ */
+export declare const MapsProviderSchema: z.ZodEnum<{
+    apple: "apple";
+    google: "google";
+}>;
+export type MapsProvider = z.infer<typeof MapsProviderSchema>;
+/**
+ * Whether a value is a provider the handoff can actually open.
+ *
+ * The effective config merges producer-authored layers tolerantly (a manifest
+ * or `data.js` is only parsed strictly under `?validateSchema`), so a typed
+ * `mapsProvider` can still carry an unmodeled string at runtime — consumers
+ * check before honoring the override.
+ */
+export declare function isMapsProvider(value: unknown): value is MapsProvider;
+//# sourceMappingURL=maps.d.ts.map

package/dist/lib/maps.js

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+/**
+ * The external maps provider a cross-venue journey's external handoff opens.
+ *
+ * Only the two whose universal URL forms the SDK builds: any other value is a
+ * dead link, so the enum is closed rather than an open string.
+ */
+export const MapsProviderSchema = z.enum(['apple', 'google']);
+/**
+ * Whether a value is a provider the handoff can actually open.
+ *
+ * The effective config merges producer-authored layers tolerantly (a manifest
+ * or `data.js` is only parsed strictly under `?validateSchema`), so a typed
+ * `mapsProvider` can still carry an unmodeled string at runtime — consumers
+ * check before honoring the override.
+ */
+export function isMapsProvider(value) {
+    return MapsProviderSchema.safeParse(value).success;
+}

package/dist/lib/poi-types.d.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+/**
+ * A point-of-interest type — an entry in the config's `poiTypes` list.
+ * `parentId` nests them into a shallow tree.
+ */
+export declare const RawPoiTypeSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    parentId: z.ZodOptional<z.ZodNumber>;
+    iconUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type RawPoiType = z.infer<typeof RawPoiTypeSchema>;
+//# sourceMappingURL=poi-types.d.ts.map

package/dist/lib/poi-types.js

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+/**
+ * A point-of-interest type — an entry in the config's `poiTypes` list.
+ * `parentId` nests them into a shallow tree.
+ */
+export const RawPoiTypeSchema = z.looseObject({
+    id: z.number(),
+    name: z.string(),
+    parentId: z.number().optional(),
+    /**
+     * Icon shown for this type; overrides the built-in glyph. A resource like
+     * the event logo, and optional like it too: serialization (offline copies,
+     * normalized folders) copies the file best-effort and drops the field when
+     * it is missing — the built-in glyph is the fallback either way.
+     */
+    iconUrl: z.string().optional().meta({ asset: true, optionalAsset: true }),
+});

package/dist/lib/schedule.d.ts

@@ -0,0 +1,25 @@
+import * as z from 'zod';
+/** A session speaker — an entry in a {@link ScheduleItemSchema}'s `speakers`. */
+export declare const SpeakerSchema: z.ZodObject<{
+    photoFile: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** One agenda/session entry — an entry in the config's `events` list. */
+export declare const ScheduleItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    externalId: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    exhibitorId: z.ZodOptional<z.ZodNumber>;
+    boothId: z.ZodOptional<z.ZodNumber>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    link: z.ZodOptional<z.ZodString>;
+    logoFile: z.ZodOptional<z.ZodString>;
+    speakers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        photoFile: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    tracks: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>;
+export type Speaker = z.infer<typeof SpeakerSchema>;
+export type ScheduleItem = z.infer<typeof ScheduleItemSchema>;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/lib/schedule.js

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+/** A session speaker — an entry in a {@link ScheduleItemSchema}'s `speakers`. */
+export const SpeakerSchema = z.looseObject({
+    photoFile: z.string().optional().meta({ asset: true }),
+});
+/** One agenda/session entry — an entry in the config's `events` list. */
+export const ScheduleItemSchema = z.looseObject({
+    id: z.number(),
+    name: z.string(),
+    externalId: z.string().optional(),
+    description: z.string().optional(),
+    exhibitorId: z.number().optional(),
+    boothId: z.number().optional(),
+    startDate: z.string().optional(),
+    endDate: z.string().optional(),
+    link: z.string().optional(),
+    logoFile: z.string().optional().meta({ asset: true }),
+    speakers: z.array(SpeakerSchema).optional(),
+    tracks: z.array(z.unknown()).optional(),
+});

package/dist/lib/search.d.ts

@@ -0,0 +1,51 @@
+import * as z from 'zod';
+export declare const SearchButtonChildSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    type: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+    count: z.ZodOptional<z.ZodNumber>;
+    linkUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** One search/filter button — an entry in `filterButtonsConfig.searchButtons`. */
+export declare const SearchButtonSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    name: z.ZodString;
+    visible: z.ZodOptional<z.ZodBoolean>;
+    builtIn: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+        count: z.ZodOptional<z.ZodNumber>;
+        linkUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/** The config's `filterButtonsConfig`: the search/filter button set and its sort. */
+export declare const FilterButtonsConfigSchema: z.ZodObject<{
+    isExplicit: z.ZodOptional<z.ZodBoolean>;
+    sortType: z.ZodOptional<z.ZodEnum<{
+        alphabetical: "alphabetical";
+        custom: "custom";
+    }>>;
+    searchButtons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+        name: z.ZodString;
+        visible: z.ZodOptional<z.ZodBoolean>;
+        builtIn: z.ZodOptional<z.ZodBoolean>;
+        order: z.ZodOptional<z.ZodNumber>;
+        children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            type: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+            count: z.ZodOptional<z.ZodNumber>;
+            linkUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+//# sourceMappingURL=search.d.ts.map

package/dist/lib/search.js

@@ -0,0 +1,36 @@
+import * as z from 'zod';
+// Kept as plain strings: the platform emits more types over time (known set:
+// bookmarks, visited, sessions, guided_tours, categories, poi_type, poi_types,
+// link, exhibitors — see floorplan's SearchButtonType), and the runtime ignores
+// the ones it does not recognize; an enum here would fail the whole config load.
+export const SearchButtonChildSchema = z.looseObject({
+    id: z.union([z.number(), z.string()]).optional(),
+    type: z.string(),
+    name: z.string().optional(),
+    // Optional: the platform omits `visible` on buttons that are shown (an
+    // omitted flag means visible; only `false` hides). Requiring it would throw
+    // the whole data.js parse — see the note on SearchButtonSchema.visible.
+    visible: z.boolean().optional(),
+    count: z.number().optional(),
+    linkUrl: z.string().optional(),
+});
+/** One search/filter button — an entry in `filterButtonsConfig.searchButtons`. */
+export const SearchButtonSchema = z.looseObject({
+    id: z.string().optional(),
+    type: z.string(),
+    name: z.string(),
+    // Optional: real published data omits `visible` on shown buttons — e.g. the
+    // built-in Exhibitors button carries no `visible` — so an absent flag means
+    // visible and only `visible: false` hides. `z.boolean()` here made a routine
+    // config throw `invalid_type` and abort the whole data.js parse.
+    visible: z.boolean().optional(),
+    builtIn: z.boolean().optional(),
+    order: z.number().optional(),
+    children: z.array(SearchButtonChildSchema).optional(),
+});
+/** The config's `filterButtonsConfig`: the search/filter button set and its sort. */
+export const FilterButtonsConfigSchema = z.looseObject({
+    isExplicit: z.boolean().optional(),
+    sortType: z.enum(['custom', 'alphabetical']).optional(),
+    searchButtons: z.array(SearchButtonSchema).optional(),
+});

package/dist/lib/venues.d.ts

@@ -0,0 +1,222 @@
+import * as z from 'zod';
+/**
+ * The multi-venue contract (docs/specs/multi-venue-data-contract.md, currently
+ * Revision 4).
+ *
+ * `VenueSchema` is deliberately the PERMISSIVE shape the config parses with —
+ * a malformed venue must not fail the plan. Venues arrive inside `data.js`
+ * alongside everything else, so a strict `ConfigSchema.parse` would throw on
+ * one bad `order` and take the whole floor plan down with it. The loose shape
+ * here lets the payload through; per-venue enforcement of the published
+ * contract (every documented constraint, plus diagnostics) lives in the
+ * imperative parser at `packages/floorplan/src/data/venues.ts`, which is the
+ * contract's one source of truth — not a zod schema.
+ *
+ * **Hand-sync is the accepted permanent cost, not a pending TODO.** Three
+ * copies encode the contract's rules and each must be updated together:
+ *
+ * 1. `packages/floorplan/src/data/venues.ts` — runtime parsing + diagnostics
+ * 2. `docs/specs/validate-venues.mjs` — the export gate (Guard 2, §12)
+ * 3. `docs/specs/multi-venue-data-contract.schema.json` — structural schema
+ *
+ * An earlier TODO here proposed generating 2 and 3 from a strict zod schema in
+ * this module. That schema was deleted as dead code (it had zero consumers and
+ * had already drifted from the parser), so the TODO went with it: the parser
+ * enforces referential and geometric rules that no JSON Schema can express,
+ * which is why it — not zod — is the source of truth.
+ *
+ * What keeps the copies honest is
+ * `packages/floorplan/src/data/validate-venues.test.ts`, which runs all three
+ * implementations over shared fixtures and asserts they agree on the `code`,
+ * `effect` and `path` of every diagnostic. `message` and `consequence` are
+ * deliberately excluded, so either implementation may reword its prose freely.
+ * Add a parity case there whenever you add a rule.
+ */
+/** A point in floor-plan projected coordinates. */
+export declare const VenuePointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+/** How an auxiliary venue layer is drawn. */
+export declare const VenueRenderModeSchema: z.ZodEnum<{
+    marker: "marker";
+    scene: "scene";
+}>;
+/**
+ * Upper size bound for an aux layer: a pixel size, or `'detail'` to track the
+ * venue's own detail cutoff instead of a fixed number.
+ */
+export declare const VenueSizeBoundSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"detail">]>;
+/** One level of a venue, bound to a plan layer. */
+export declare const VenueLevelSchema: z.ZodObject<{
+    layer: z.ZodString;
+    ordinal: z.ZodInt;
+    name: z.ZodOptional<z.ZodString>;
+    initial: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/** A non-level layer a venue draws — a replacing scene or a marker. */
+export declare const VenueAuxLayerSchema: z.ZodObject<{
+    layer: z.ZodString;
+    render: z.ZodEnum<{
+        marker: "marker";
+        scene: "scene";
+    }>;
+    replacesDefault: z.ZodOptional<z.ZodBoolean>;
+    suppressesLabel: z.ZodOptional<z.ZodBoolean>;
+    minSizePx: z.ZodOptional<z.ZodNumber>;
+    maxSizePx: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"detail">]>>;
+}, z.core.$loose>;
+/**
+ * A venue entrance: the authored point where a venue meets the outside world.
+ *
+ * Plan-local on one of the venue's own levels, and therefore geo-projectable
+ * through the plan's GPS anchors — which is what lets a cross-venue journey
+ * hand a maps app a door rather than the middle of a building footprint. The
+ * wayfinding engine never learns the concept: an entrance reaches it as an
+ * ordinary route endpoint, exactly as a kiosk anchor does.
+ *
+ * A venue may author several; the SDK chooses between them by cost and never
+ * asks the visitor to pick. Authoring none is permanent, supported behavior —
+ * such a venue keeps marker-point targeting forever.
+ */
+export declare const VenueEntranceSchema: z.ZodObject<{
+    layer: z.ZodString;
+    point: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * The plan's whole-campus frame (Revision 9): an axis-aligned rectangle in
+ * plan-local coordinates, with no angle. Plan-wide although a venue carries it
+ * — the first carrier by `order` wins. A usable one has finite members and a
+ * positive `width` and `height`; that, like every venue constraint, is the
+ * parser's to enforce (`campus-viewbox-invalid`), not this schema's.
+ */
+export declare const VenueCampusViewboxSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$loose>;
+/**
+ * The shape the config parses with: same fields, no constraints. Anything
+ * structurally venue-like survives into the payload so the quarantine — not the
+ * parser — decides what to drop.
+ */
+export declare const VenueSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    order: z.ZodOptional<z.ZodNumber>;
+    levels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        layer: z.ZodOptional<z.ZodString>;
+        ordinal: z.ZodOptional<z.ZodInt>;
+        name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        initial: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$loose>>>;
+    contour: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>>;
+    markerPoint: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    detailMinSizePx: z.ZodOptional<z.ZodNumber>;
+    markerMaxSizePx: z.ZodOptional<z.ZodNumber>;
+    layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        layer: z.ZodOptional<z.ZodString>;
+        render: z.ZodOptional<z.ZodEnum<{
+            marker: "marker";
+            scene: "scene";
+        }>>;
+        replacesDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        suppressesLabel: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        minSizePx: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        maxSizePx: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"detail">]>>>;
+    }, z.core.$loose>>>;
+    entrances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        layer: z.ZodOptional<z.ZodString>;
+        point: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$loose>>>;
+    campusViewbox: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** Wire version of the multi-venue payload. Revision 2 defines version 1. */
+export declare const VenuesVersionSchema: z.ZodLiteral<1>;
+/**
+ * The venue-bearing slice of the `data.js` payload, as the parser receives it.
+ *
+ * Both fields are optional and the object is loose: callers hand the whole data
+ * module over, and a plan with no venues omits them entirely. A payload that
+ * carries `venues` under a version the runtime does not know is the parser's
+ * problem to report, not a reason to reject the shape here.
+ */
+export declare const VenuePayloadSchema: z.ZodObject<{
+    venuesVersion: z.ZodOptional<z.ZodLiteral<1>>;
+    venues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        order: z.ZodOptional<z.ZodNumber>;
+        levels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            layer: z.ZodOptional<z.ZodString>;
+            ordinal: z.ZodOptional<z.ZodInt>;
+            name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            initial: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$loose>>>;
+        contour: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>>;
+        markerPoint: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        detailMinSizePx: z.ZodOptional<z.ZodNumber>;
+        markerMaxSizePx: z.ZodOptional<z.ZodNumber>;
+        layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            layer: z.ZodOptional<z.ZodString>;
+            render: z.ZodOptional<z.ZodEnum<{
+                marker: "marker";
+                scene: "scene";
+            }>>;
+            replacesDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            suppressesLabel: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            minSizePx: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            maxSizePx: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"detail">]>>>;
+        }, z.core.$loose>>>;
+        entrances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            layer: z.ZodOptional<z.ZodString>;
+            point: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, z.core.$loose>>>;
+        campusViewbox: z.ZodOptional<z.ZodObject<{
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type VenuePoint = z.infer<typeof VenuePointSchema>;
+export type VenueRenderMode = z.infer<typeof VenueRenderModeSchema>;
+export type VenueSizeBound = z.infer<typeof VenueSizeBoundSchema>;
+export type RawVenueLevel = z.infer<typeof VenueLevelSchema>;
+export type RawVenueAuxLayer = z.infer<typeof VenueAuxLayerSchema>;
+export type RawVenueEntrance = z.infer<typeof VenueEntranceSchema>;
+export type VenueCampusViewbox = z.infer<typeof VenueCampusViewboxSchema>;
+export type RawVenue = z.infer<typeof VenueSchema>;
+export type VenuePayload = z.infer<typeof VenuePayloadSchema>;
+//# sourceMappingURL=venues.d.ts.map