venue-js 1.4.0-next.2 → 1.4.0-next.21

package/dist/index-CrxL_5B7.d.ts

@@ -0,0 +1,1025 @@
+import { QueryClient, QueryObserver, EnsureQueryDataOptions } from '@tanstack/query-core';
+import { Position, Geometry, GeometryCollection, GeoJsonProperties, Point, Polygon, MultiPolygon, LineString, MultiLineString, Feature } from 'geojson';
+import { FuseResult } from 'fuse.js';
+
+type Id = string;
+type MediaFile = {
+    ext: string;
+    hash: string;
+    height: number;
+    mime: string;
+    name: string;
+    path: string | null;
+    size: number;
+    url: string;
+    width: number;
+};
+type Media = MediaFile & {
+    id: Id;
+    alternativeText: string | null;
+    caption: string | null;
+    createdAt: string;
+    ext: string;
+    folderPath: string;
+    formats: Record<string, MediaFile>;
+    previewUrl: string | null;
+    provider: string;
+    provider_metadata: string | null;
+    updatedAt: string;
+};
+type Model3d = {
+    id: Id;
+    name: string;
+    properties: {
+        position: Position;
+        rotation: {
+            x: number;
+            y: number;
+            z?: number;
+        };
+        scale: [number, number, number];
+        url: string;
+    };
+};
+type EntityTimestamps = {
+    createdAt: string;
+    updatedAt: string;
+    publishedAt: string;
+};
+type SymbolProperties = {
+    lineColor?: string;
+    lineWidth?: string;
+    lineDasharray?: string;
+    lineOpacity?: string;
+    lineJoin?: string;
+    lineCap?: string;
+    linePatternFile?: string;
+    lineDx?: string;
+    lineDy?: string;
+    polygonFill?: string;
+    polygonOpacity?: string;
+    polygonPatternFile?: string;
+};
+type TransalatableString = {
+    en: string;
+    th?: string;
+} & Record<string, string | undefined>;
+type SingleGeometry = Exclude<Geometry, GeometryCollection>;
+type ImdfFeature<G extends SingleGeometry | null = SingleGeometry, P = GeoJsonProperties, T extends string = FeatureType | string> = Feature<G, P> & {
+    id: Id;
+    feature_type: T;
+};
+type AnchorGeometry = Point;
+type AnchorProperties = EntityTimestamps & {
+    address_id: Id | null;
+    unit_id: Id;
+    locale: string;
+};
+type AnchorFeature = ImdfFeature<AnchorGeometry, AnchorProperties, "anchor">;
+type AmenityGeometry = Point;
+type AmenityProperties = EntityTimestamps & {
+    amenity_logo: Media | null;
+    category: string;
+    description: TransalatableString | null;
+    gallery: Media[];
+    isNavigatable: boolean;
+    is_featured: boolean;
+    level_id: Id;
+    location_description: string;
+    logo: Media | null;
+    name: TransalatableString | null;
+    style: unknown;
+    unit_ids: Id[];
+    venue_id: Id;
+    hours: string | null;
+};
+type AmenityFeature = ImdfFeature<AmenityGeometry, AmenityProperties, "amenity">;
+type DetailGeometry = Point;
+type DetailProperties = {
+    level_id: Id;
+    [k: string]: any;
+};
+type DetailFeature = ImdfFeature<DetailGeometry, DetailProperties>;
+type FixtureGeometry = Polygon | MultiPolygon | LineString | MultiLineString;
+type FixtureProperties = EntityTimestamps & {
+    anchor_id: Id | null;
+    category: string;
+    is_landmark: boolean;
+    level_id: Id;
+    locale: string;
+    model3d: Model3d[];
+    name: string | null;
+    style: SymbolProperties;
+    venue_id: Id;
+    [k: string]: any;
+};
+type FixtureFeature = ImdfFeature<FixtureGeometry, FixtureProperties, "fixture">;
+type KioskGeometry = Polygon | MultiPolygon;
+type KioskProperties = EntityTimestamps & {
+    alt_name: string;
+    anchor_id: Id;
+    is_landmark: boolean;
+    level_id: Id;
+    locale: string;
+    model3d: Model3d[];
+    name: TransalatableString;
+    style: SymbolProperties;
+    venue_id: Id;
+};
+type KioskFeature = ImdfFeature<KioskGeometry, KioskProperties, "kiosk">;
+type LevelGeometry = Polygon | MultiPolygon;
+type LevelProperties = EntityTimestamps & {
+    alt_name: string | null;
+    display_point: Point | null;
+    name: TransalatableString;
+    ordinal: number;
+    properties?: unknown;
+    venue_id: Id;
+};
+type LevelFeature = ImdfFeature<LevelGeometry, LevelProperties, "level">;
+type ExternalLink = {
+    id: number;
+    link?: string;
+    ios_link?: string;
+    android_link?: string;
+};
+type OccupantGeometry = null;
+type OccupantProperties = EntityTimestamps & {
+    /** Anchor is used for marker position */
+    anchor_id: Id;
+    category: string | null;
+    category_group: string | null;
+    cover_image: Media | null;
+    description: TransalatableString;
+    featured_image: Media | null;
+    gallery: Media[] | null;
+    group_ids: Id[];
+    hours: string;
+    is_featured: boolean;
+    is_landmark: boolean;
+    is_maintenance: boolean;
+    keywords: string[];
+    kiosk_id: Id | null;
+    kiosk_name: string | null;
+    local_category_ids: Id[];
+    local_category_names: string[];
+    logo: Media | null;
+    maintenance_end_date: string | null;
+    maintenance_start_date: string | null;
+    name: TransalatableString;
+    phone: string | null;
+    privilege_ids: Id[];
+    promotion_ids: Id[];
+    render_priority: number;
+    render_type: string;
+    /**
+     * @deprecated Use `unit_id or kiosk_id` instead.
+     */
+    room_no: string | null;
+    short_name: string | null;
+    start_date: string;
+    style: SymbolProperties | null;
+    temp_anchor_id: Id | null;
+    temp_kiosk_id: Id | null;
+    temp_unit_id: Id | null;
+    unit_id: Id | null;
+    unit_name: string | null;
+    venue_id: Id;
+    kiosk_ids: Id[];
+    unit_ids: Id[];
+    website_link: string | null;
+    show_name_on_all_units: boolean;
+    reservations?: ExternalLink[];
+    can_reserve?: boolean;
+    display_settings?: {
+        card_style?: string | null;
+    };
+};
+type OccupantFeature = ImdfFeature<OccupantGeometry, OccupantProperties, "occupant">;
+type OpeningCategories = "automobile" | "bicycle" | "emergencyexit" | "pedestrian" | "pedestrian.principal" | "pedestrian.transit" | "service" | string;
+type OpeningGeometry = LineString;
+type OpeningProperties = EntityTimestamps & {
+    alt_name: string;
+    category: OpeningCategories;
+    door: {
+        type: string;
+    };
+    level_id: Id;
+    name: TransalatableString;
+    style: SymbolProperties;
+    venue_id: Id;
+};
+type OpeningFeature = ImdfFeature<OpeningGeometry, OpeningProperties, "opening">;
+/** Relationship */
+type RelationshipCategories = "elevator" | "escalator" | "movingwalkway" | "ramp" | "stairs" | "stairs.emergencyexit" | "traversal" | "traversal.path" | string;
+type RelationshipDirectionTypes = "directed" | "undirected";
+type UnitTypeAndId = {
+    feature_type: "unit";
+    id: string;
+};
+type OpeningTypeAndId = {
+    feature_type: "opening";
+    id: string;
+};
+type RelationshipGeometry = SingleGeometry | null;
+type BaseRelationshipProperties = EntityTimestamps & {
+    category: RelationshipCategories;
+    destination: UnitTypeAndId | OpeningTypeAndId;
+    direction: RelationshipDirectionTypes;
+    hours: string | null;
+    intermediary: UnitTypeAndId[] | OpeningTypeAndId[];
+    locale: string;
+    name: TransalatableString;
+    origin: UnitTypeAndId | OpeningTypeAndId;
+};
+type RelationshipFeature = ImdfFeature<RelationshipGeometry, BaseRelationshipProperties>;
+type TraversalRelationshipProperties = Omit<BaseRelationshipProperties, "origin" | "destination" | "intermediary" | "category"> & {
+    origin: UnitTypeAndId | null;
+    destination: UnitTypeAndId;
+    intermediary: OpeningTypeAndId[] | null;
+    category: "traversal" | "movingwalkway" | "traversal.path";
+};
+type TraversalRelationshipFeature = ImdfFeature<RelationshipGeometry, TraversalRelationshipProperties>;
+type ElevatorRelationshipProperties = Omit<BaseRelationshipProperties, "origin" | "destination" | "intermediary" | "direction" | "category"> & {
+    origin: UnitTypeAndId;
+    destination: UnitTypeAndId;
+    intermediary: UnitTypeAndId[] | null;
+    direction: "undirected";
+    category: "elevator";
+};
+type ElevatorRelationshipFeature = ImdfFeature<RelationshipGeometry, ElevatorRelationshipProperties>;
+type RampRelationshipProperties = Omit<BaseRelationshipProperties, "origin" | "destination" | "intermediary" | "category"> & {
+    origin: OpeningTypeAndId;
+    destination: OpeningTypeAndId;
+    intermediary: UnitTypeAndId[];
+    category: "ramp";
+};
+type RampRelationshipFeature = ImdfFeature<RelationshipGeometry, EscalatorRelationshipProperties>;
+type StairsRelationshipProperties = Omit<BaseRelationshipProperties, "origin" | "destination" | "intermediary" | "direction" | "category"> & {
+    origin: OpeningTypeAndId;
+    destination: OpeningTypeAndId;
+    intermediary: UnitTypeAndId[] | null;
+    direction: "undirected";
+    category: "stairs" | "stairs.emergencyexit";
+};
+type StairsRelationshipFeature = ImdfFeature<RelationshipGeometry, StairsRelationshipProperties>;
+type EscalatorRelationshipProperties = Omit<BaseRelationshipProperties, "origin" | "destination" | "intermediary" | "category"> & {
+    origin: OpeningTypeAndId;
+    destination: OpeningTypeAndId;
+    intermediary: UnitTypeAndId[];
+    category: "escalator";
+};
+type EscalatorRelationshipFeature = ImdfFeature<RelationshipGeometry, EscalatorRelationshipProperties>;
+type AnyRelationshipFeature = TraversalRelationshipFeature | EscalatorRelationshipFeature | ElevatorRelationshipFeature | RampRelationshipFeature | StairsRelationshipFeature;
+/**
+ * Section
+ */
+type SectionGeometry = Polygon | MultiPolygon;
+type SectionProperties = EntityTimestamps & {
+    venue_id: Id;
+    level_id: Id;
+    correlation_id: Id | null;
+    category: string;
+    ordinal: number;
+    imdf_category: string;
+    local_category_ids: string[];
+    feature_image: Media | null;
+    cover_image: Media | null;
+    gallery: Media[] | null;
+    is_featured: boolean;
+    hours: string | null;
+    [k: string]: any;
+};
+type SectionFeature = ImdfFeature<SectionGeometry, SectionProperties, "section">;
+type UnitGeometry = Polygon | MultiPolygon;
+type UnitProperties = EntityTimestamps & {
+    alt_name: string | null;
+    category: string;
+    is_landmark: boolean;
+    level_id: Id;
+    locale: string;
+    model3d: Model3d[];
+    name: TransalatableString;
+    style: SymbolProperties;
+    venue_id: Id;
+};
+type UnitFeature = ImdfFeature<UnitGeometry, UnitProperties, "unit">;
+type VenueGeometry = Polygon | MultiPolygon;
+type VenueProperties = EntityTimestamps & {
+    address: string;
+    address_id: Id | null;
+    country: string;
+    display_point: Point;
+    hours: string;
+    imdf_category: string;
+    locale: string;
+    locality: string;
+    logo: Media | null;
+    logo_simple: Media | null;
+    model3d: Model3d[];
+    name: TransalatableString;
+    phone: string;
+    postal_code: string;
+    province: string;
+    reference: string;
+    style: SymbolProperties | null;
+    supported_locales: string[];
+    theme_color: string;
+    zoom: string | null;
+};
+type VenueFeature = ImdfFeature<VenueGeometry, VenueProperties, "venue">;
+/**
+ * Non-IMDF
+ *********************** */
+type TaxonomyGeometry = null;
+type TaxonomyProperties = EntityTimestamps & {
+    description: string;
+    icon_image: string;
+    icon_path: string;
+    is_featured: boolean;
+    local_id: string;
+    locale: string;
+    name: TransalatableString;
+    order: number;
+    parent_id: Id | null;
+    reference: string;
+    taxonomy: string;
+    venue_id: Id | null;
+};
+type TaxonomyFeature = ImdfFeature<TaxonomyGeometry, TaxonomyProperties>;
+type EventGeometry = Polygon;
+type EventProperties = {
+    name: string;
+    ordinal: number;
+    venue_id: Id;
+    angle: number;
+    fontSize: number;
+};
+type EventFeature = ImdfFeature<EventGeometry, EventProperties>;
+type PromotionProperties = {
+    name: TransalatableString;
+    category: string;
+    cover_image: Media;
+    daily_end_time: string;
+    daily_start_time: string;
+    description: TransalatableString;
+    end_date: string;
+    feature_id: string | null;
+    gallery: Media[];
+    is_featured: boolean;
+    local_category_ids: string[];
+    locale: string;
+    publishedAt: string;
+    start_date: string;
+    updatedAt: string;
+    venue_id: Id;
+    website_link: string | null;
+};
+type PromotionFeature = ImdfFeature<null, PromotionProperties>;
+type PrivilegeGeometry = null;
+type PrivilegeProperties = {
+    createdAt: string;
+    description: TransalatableString;
+    locale: string;
+    occupant_id: Id;
+    publishedAt: string;
+    updatedAt: string;
+    venue_id: Id;
+};
+type PrivilegeFeature = ImdfFeature<PrivilegeGeometry, PrivilegeProperties>;
+type LabelGeometry = Polygon;
+type LabelProperties = {
+    name: string;
+    ordinal: number;
+    venue_id: Id;
+    angle: number;
+    fontSize: number;
+};
+type LabelFeature = ImdfFeature<LabelGeometry, LabelProperties>;
+type ElementGeometry = null;
+type ElementProperties = EntityTimestamps & {
+    geometries: Array<{
+        type: string;
+        id: Id;
+        geometry: SingleGeometry;
+        options: Record<string, unknown>;
+        properties: {
+            additionalField: string;
+            name: string | null;
+            image: Media | null;
+            ordinal: number;
+        };
+    }>;
+    locale: string;
+    name: TransalatableString;
+};
+type ElementFeature = ImdfFeature<ElementGeometry, ElementProperties>;
+/**
+ * Sponsored Content
+ */
+type SponsoredContentLegacyType = "HOMEPAGE_SPOTLIGHT" | "SCREENSAVER" | "SUGGESTED_BRAND" | "SEARCH_RESULT" | "POPUP_BANNER" | "FOOTER_BANNER" | "RECOMMENDED_EVENT" | "RECOMMENDED_PROMOTION" | "RECOMMENDED_DIRECTORY";
+type SponsoredContentPlacementType = "HOMEPAGE_SPOTLIGHT" | "SEARCH_SUGGESTION" | "SEARCH_RESULT" | "LIST_TOPITEM" | "POPUP_BANNER" | "FOOTER_BANNER";
+type SponsoredContentAttributes = {
+    venue_id: string;
+    project_id: string;
+    name: {
+        en: string;
+    };
+    type: SponsoredContentLegacyType;
+    placement_type: SponsoredContentPlacementType;
+    start_date: string;
+    end_date: string;
+    daily_start_time: string;
+    daily_end_time: string;
+    order: number;
+    url: string | null;
+    feature_id: string | null;
+    createdAt: string;
+    updatedAt: string;
+    publishedAt: string;
+    media?: Media;
+    locale: string;
+};
+type SponsoredContentStrapiV4ApiResponse = {
+    id: string;
+    attributes: SponsoredContentAttributes;
+};
+/** Parsed for internal use */
+type SponsoredContentFeature = SponsoredContentAttributes & {
+    id: string;
+};
+type Page = {
+    id: Id;
+    attributes: Record<string, unknown>;
+};
+type Model3dGeometry = null;
+type Model3dProperties = {
+    name: TransalatableString;
+    model: string;
+    level_id: Id;
+    project_id: Id;
+    rotation_x: number;
+    rotation_y: number;
+    rotation_z: number;
+    center: number[];
+    scale: number;
+    bottom_height: number;
+    translation_x: number;
+    translation_y: number;
+    translation_z: number;
+    createdAt: string;
+    updatedAt: string;
+    publishedAt: string;
+    locale: string;
+};
+type Model3dFeature = ImdfFeature<Model3dGeometry, Model3dProperties>;
+type FeatureResponseMap = {
+    address: ImdfFeature;
+    amenity: AmenityFeature;
+    anchor: AnchorFeature;
+    building: ImdfFeature;
+    detail: DetailFeature;
+    fixture: FixtureFeature;
+    footprint: ImdfFeature;
+    geofence: ImdfFeature;
+    kiosk: KioskFeature;
+    level: LevelFeature;
+    occupant: OccupantFeature;
+    opening: OpeningFeature;
+    relationship: RelationshipFeature;
+    section: SectionFeature;
+    unit: UnitFeature;
+    venue: VenueFeature;
+    taxonomy: TaxonomyFeature;
+    privilege: PrivilegeFeature;
+    event: EventFeature;
+    promotion: PromotionFeature;
+    label: LabelFeature;
+    element: ElementFeature;
+    model3d: Model3dFeature;
+    "sponsored-content": SponsoredContentFeature;
+    page: Page;
+};
+type FeatureType = keyof FeatureResponseMap;
+type PolygonalFeature = UnitFeature | KioskFeature | LevelFeature | SectionFeature;
+
+type AmenityFeaturePopulated = AmenityFeature & {
+    properties: AmenityFeature["properties"] & {
+        /**
+         * [IMDF] Unit(s) the Amenity is associated with
+         */
+        units: UnitFeaturePopulated[];
+        /**
+         * [venue.in.th] Venue that amenity is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [IMDF] Level that amenity is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [Derived] From units[0] --> level's ordinal
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        ordinal: number;
+        /**
+         * [Derived] From units[0] --> level's name
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        level_name: string;
+        /**
+         * [Derived] The section this amenity is on.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        section?: SectionFeaturePopulated;
+        /**
+         * [Experimental | Derived] The kiosk this amenity is on.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        _experimental_kiosk?: KioskFeaturePopulated;
+    };
+};
+type AnchorFeaturePopulated = AnchorFeature & {
+    properties: AnchorFeature["properties"] & {
+        /**
+         * [IMDF] The unit this anchor is on.
+         */
+        unit: UnitFeaturePopulated;
+        /**
+         * [IMDF] Level that kiosk is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that anchor is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] The section this anchor is on.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        section?: SectionFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that anchor is on
+         */
+        ordinal: number;
+    };
+};
+type FixtureFeaturePopulated = FixtureFeature & {
+    properties: FixtureFeature["properties"] & {
+        /**
+         * [IMDF] The unit this anchor is on.
+         */
+        anchor: AnchorFeaturePopulated;
+        /**
+         * [IMDF] Level that kiosk is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+          * [IMDF] Venue that kiosk is in
+          */
+        venue?: VenueFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that fixture is on
+         */
+        ordinal: number;
+    };
+};
+type KioskFeaturePopulated = KioskFeature & {
+    properties: KioskFeature["properties"] & {
+        /**
+         * [IMDF] An Occupant MUST be positioned (via Anchor) within a Kiosk that models a space that is leased to a business entity
+         */
+        anchor: AnchorFeaturePopulated;
+        /**
+         * [IMDF] Level that kiosk is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that kiosk is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] The unit this kiosk is on, usually a walkway.
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        unit: UnitFeaturePopulated;
+        /**
+         * [Derived] The section this kiosk is in
+         * This is added during feature enrichment and not part of the original IMDF dataset.
+         */
+        section?: SectionFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that fixture is on
+         */
+        ordinal: number;
+    };
+};
+type LevelFeaturePopulated = LevelFeature & {
+    properties: LevelFeature["properties"] & {
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+    };
+};
+type OccupantFeaturePopulated = OccupantFeature & {
+    properties: OccupantFeature["properties"] & {
+        /**
+         * [IMDF] Occupant's position
+         */
+        anchor: AnchorFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that occupant is on
+         */
+        ordinal: number;
+        /**
+         * [venue.in.th] Occupant's category
+         */
+        local_categories: TaxonomyFeaturePopulated[];
+        unit?: UnitFeaturePopulated;
+        kiosk?: KioskFeaturePopulated;
+        /**
+         * [venue.in.th] Bind correlation between units on an occupant,
+         * which will be used for highlighting in the floor plan and
+         * displaying location details later.
+         */
+        units: UnitFeaturePopulated[];
+        /**
+         * [venue.in.th] Bind correlation between kiosks on an occupant,
+         * which will be used for highlighting in the floor plan and
+         * displaying location details later.
+         */
+        kiosks: KioskFeaturePopulated[];
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [venue.in.th] Occupant's promotions
+         */
+        promotions: PromotionFeature[];
+        /**
+         * [venue.in.th] Occupant's privileges
+         */
+        privileges: PrivilegeFeature[];
+    };
+};
+type OpeningFeaturePopulated = OpeningFeature & {
+    properties: OpeningFeature["properties"] & {
+        /**
+         * [IMDF] Level that section is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that unit is on
+         */
+        ordinal: number;
+    };
+};
+type RelationshipFeaturePopulated = RelationshipFeature & {
+    properties: RelationshipFeature["properties"] & {
+        origin: UnitFeature | OpeningFeature | null;
+        destination: UnitFeature | OpeningFeature | null;
+        intermediary: (UnitFeature | OpeningFeature)[] | null;
+    };
+};
+type TraversalRelationshipFeaturePopulated = TraversalRelationshipFeature & {
+    properties: TraversalRelationshipFeature["properties"] & {
+        origin: UnitFeature | null;
+        destination: UnitFeature;
+        intermediary: OpeningFeature[] | null;
+    };
+};
+type EscalatorRelationshipFeaturePopulated = EscalatorRelationshipFeature & {
+    properties: EscalatorRelationshipFeature["properties"] & {
+        origin: OpeningFeature;
+        destination: OpeningFeature;
+        intermediary: UnitFeature[] | null;
+    };
+};
+type RampRelationshipFeaturePopulated = RampRelationshipFeature & {
+    properties: RampRelationshipFeature["properties"] & {
+        origin: OpeningFeature;
+        destination: OpeningFeature;
+        intermediary: UnitFeature[] | null;
+    };
+};
+type ElevatorRelationshipFeaturePopulated = ElevatorRelationshipFeature & {
+    properties: ElevatorRelationshipFeature["properties"] & {
+        origin: UnitFeature;
+        destination: UnitFeature;
+        intermediary: UnitFeature[] | null;
+    };
+};
+type StairRelationshipFeaturePopulated = StairsRelationshipFeature & {
+    properties: StairsRelationshipFeature["properties"] & {
+        origin: UnitFeature;
+        destination: UnitFeature;
+        intermediary: UnitFeature[] | null;
+    };
+};
+type SectionFeaturePopulated = SectionFeature & {
+    properties: SectionFeature["properties"] & {
+        /**
+         * [IMDF] Level that section is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that unit is on
+         */
+        ordinal: number;
+    };
+};
+type UnitFeaturePopulated = UnitFeature & {
+    properties: UnitFeature["properties"] & {
+        /**
+         * [IMDF] Level that unit is on
+         */
+        level: LevelFeaturePopulated;
+        /**
+         * [venue.in.th] Venue that level is in
+         */
+        venue: VenueFeaturePopulated;
+        /**
+         * [Derived] Level's ordinal that unit is on
+         */
+        ordinal: number;
+        /**
+         * [Derived] Secion that unit is in
+         */
+        section?: SectionFeaturePopulated;
+    };
+};
+type VenueFeaturePopulated = VenueFeature;
+type TaxonomyFeaturePopulated = TaxonomyFeature & {
+    properties: TaxonomyFeature["properties"] & {
+        venue: VenueFeaturePopulated;
+    };
+};
+type Model3dPopulated = Model3dFeature & {
+    properties: Model3dFeature["properties"] & {
+        /**
+         * [IMDF] Level that model 3D is on
+         */
+        level: LevelFeaturePopulated;
+    };
+};
+type FeaturePopulatedResponseMap = {
+    address: ImdfFeature;
+    amenity: AmenityFeaturePopulated;
+    anchor: AnchorFeaturePopulated;
+    building: ImdfFeature;
+    detail: DetailFeature;
+    fixture: FixtureFeaturePopulated;
+    footprint: ImdfFeature;
+    geofence: ImdfFeature;
+    kiosk: KioskFeaturePopulated;
+    level: LevelFeaturePopulated;
+    occupant: OccupantFeaturePopulated;
+    opening: OpeningFeaturePopulated;
+    relationship: RelationshipFeaturePopulated;
+    section: SectionFeaturePopulated;
+    unit: UnitFeaturePopulated;
+    venue: VenueFeaturePopulated;
+    taxonomy: TaxonomyFeaturePopulated;
+    privilege: PrivilegeFeature;
+    event: EventFeature;
+    promotion: PromotionFeature;
+    label: LabelFeature;
+    element: ImdfFeature;
+    model3d: Model3dPopulated;
+    "sponsored-content": SponsoredContentFeature;
+    page: Page;
+};
+type PopulatableFeatureType = keyof FeaturePopulatedResponseMap;
+
+type Value = string | boolean | number;
+type EqFilter = Value;
+type InFilter = {
+    $in: (Value)[];
+};
+type Filter = EqFilter | InFilter;
+type Filters = Record<string, Filter>;
+
+type WaypointHint = {
+    kind: "landmark";
+    name: TransalatableString;
+    refId?: string;
+} | {
+    kind: "area";
+    name: TransalatableString;
+} | {
+    kind: "generic";
+    name: TransalatableString;
+};
+type Waypoint = {
+    id?: string;
+    type: 'start' | 'end' | 'between';
+    levelId: string | null;
+    ordinal: number | null;
+    point: Position;
+    name: TransalatableString | null;
+    hint?: WaypointHint;
+    source: {
+        type: "occupant";
+        id: string;
+    } | {
+        type: "opening";
+        id: string;
+    } | {
+        type: "kiosk";
+        id: string;
+    } | {
+        type: "amenity";
+        id: string;
+    } | {
+        type: "anchor";
+        id: string;
+    } | {
+        type: "coordinate";
+        raw: string;
+    };
+};
+
+type Step = {
+    from: Waypoint;
+    to: Waypoint;
+    levelIds: string[];
+    ordinals: number[];
+    intermediaryCategory: string;
+    path: Position[];
+    description: null | {
+        text: string;
+        options?: any;
+    };
+};
+
+type GetNavigateClientOptions = {
+    data: {
+        anchors?: AnchorFeature[];
+        amenities?: AmenityFeature[];
+        fixtures?: FixtureFeature[];
+        kiosks?: KioskFeature[];
+        levels: LevelFeature[];
+        occupants?: OccupantFeature[];
+        openings: OpeningFeature[];
+        relationships: RelationshipFeature[];
+        units: UnitFeature[];
+    };
+};
+type FindByIdSync = <T extends FeatureType>(id: string) => FeatureResponseMap[T];
+/** Things that can navigate */
+type FeatureId = `${string}-${number}`;
+type CoordinateOrdinalString = `${number},${number},${number}o`;
+type NavigatableParam = FeatureId | CoordinateOrdinalString;
+type Route = {
+    steps: Step[];
+    duration: null | number;
+    distance: null | number;
+};
+
+interface VenueClientOptions {
+    mode?: "delivery" | "preview";
+    projectId: string;
+    apiKey?: string;
+    previewToken?: string;
+    baseUrl?: string;
+    queryClient?: QueryClient;
+}
+type SearchClient = {
+    search: (txt: string) => FuseResult<ImdfFeature>[];
+};
+type NavigateClient$1 = {
+    findRoute: (origin: string, destination: string) => void;
+};
+interface FindParams {
+    populate?: boolean;
+}
+interface FilterParams {
+    populate?: boolean;
+    filters?: Filters;
+}
+interface PopulatedParams {
+    populate: true;
+}
+interface FeatureQueryOptions {
+    refetchInterval?: number;
+    staleTime?: number;
+    cacheTime?: number;
+    enabled?: boolean;
+    retry?: boolean | number;
+}
+type InternalFindById = <T extends FeatureType>(id: Id) => Promise<FeatureResponseMap[T]>;
+type InternalFilterByType = <T extends FeatureType>(featureType: T) => Promise<FeatureResponseMap[T][]>;
+interface VenueDataClient {
+    projectId: string;
+    queryClient: QueryClient;
+    registerObserver: (featureType: FeatureType, refetchInterval: number) => QueryObserver;
+    destroyObserver: (featureType: FeatureType) => void;
+    destroyObservers: () => void;
+    createFilterByTypeQueryOptions: <T extends FeatureType = FeatureType>(featureType: T, params: FilterParams, options: FeatureQueryOptions) => EnsureQueryDataOptions<FeatureResponseMap[T][] | FeaturePopulatedResponseMap[T][]>;
+    createFindByIdQueryOptions: <T extends FeatureType = FeatureType>(featureType: T, id: string, params: FindParams, options: FeatureQueryOptions) => EnsureQueryDataOptions<FeatureResponseMap[T] | FeaturePopulatedResponseMap[T]>;
+    _internalFindById: InternalFindById;
+    filterByType: <T extends FeatureType>(featureType: T, params?: FilterParams) => Promise<FeatureResponseMap[T][] | FeaturePopulatedResponseMap[T][]>;
+    findById: <T extends FeatureType>(featureType: T, id: string, params?: FindParams) => Promise<FeatureResponseMap[T] | FeaturePopulatedResponseMap[T]>;
+    search: (txt: string) => Promise<FuseResult<ImdfFeature>[]>;
+    navigate: (origin: NavigatableParam, destination: NavigatableParam, options?: any) => any;
+}
+
+declare const DEFAULT_BASE_URL = "https://service.venue.in.th/api";
+declare const IMDF_FEATURE_TYPES: FeatureType[];
+declare const IMDF_UNIT_CATEGORIES: string[];
+declare const NONIMDF_FEATURE_TYPES: FeatureType[];
+declare const GEOJSON_FEATURE_TYPES: FeatureType[];
+declare const ALL_FEATURE_TYPES: FeatureType[];
+declare const defaultFeatureQueryOptionsMap: Record<FeatureType, FeatureQueryOptions>;
+
+type IMDFUnitCategory = typeof IMDF_UNIT_CATEGORIES[number];
+
+/**
+ * Checks if a point is a valid coordinate pair.
+ *
+ * @param point - The point to be checked.
+ * @return True if the point is a valid coordinate pair, false otherwise.
+ */
+declare const isValidCoordinate: (point: Position) => boolean;
+/**
+ * Checks if an input represents a valid polygon, which may include holes.
+ * The input can be a single array of coordinates for simple polygons, or
+ * an array of arrays of coordinates for polygons with holes.
+ *
+ * @param polygon - The input representing a polygon.
+ * @return True if the polygon is valid, false otherwise.
+ */
+declare const isValidPolygonCoordinates: (polygon: Position[] | Position[][]) => boolean;
+/**
+ * Checks if an array of polygons forms a valid MultiPolygon.
+ *
+ * @param multipolygon - The array of polygons.
+ * @return True if the multipolygon is valid, false otherwise.
+ */
+declare const isValidMultiPolygonCoordinates: (multipolygon: Position[][][]) => boolean;
+/**
+ * Checks if a set of points forms a valid LineString.
+ * A valid LineString must have at least two points, each point must be a valid coordinate,
+ * and it should not form a closed loop.
+ *
+ * @param lineString - The array of points representing a LineString.
+ * @return True if the LineString is valid, false otherwise.
+ */
+declare const isValidLineStringCoordinates: (lineString: Position[]) => boolean;
+declare const isValidMultiPolygon: (geometry: Exclude<Geometry, GeometryCollection>) => boolean;
+declare const isValidPolygon: (geometry: Exclude<Geometry, GeometryCollection>) => boolean;
+declare const isValidLineString: (geometry: Exclude<Geometry, GeometryCollection>) => boolean;
+declare const isValidPoint: (geometry: Exclude<Geometry, GeometryCollection>) => boolean;
+
+declare function matchFilter(value: Value | Value[], filter: Filter): boolean;
+declare function matchFilters<T extends Record<string, any>>(item: T, filters: Filters): boolean;
+
+declare const getOccupantMainLocation: (occupant: OccupantFeaturePopulated) => UnitFeaturePopulated | KioskFeaturePopulated;
+declare const getOccupantCorrelatedLocations: (occupant: OccupantFeaturePopulated) => Array<UnitFeaturePopulated | KioskFeaturePopulated>;
+type OccupantMarkerPlacementType = 'ONCE_PER_LEVEL' | 'ALL_LOCATIONS';
+declare const getOccupantMarkerLocations: (occupant: OccupantFeaturePopulated, options?: {
+    type: OccupantMarkerPlacementType;
+}) => Array<UnitFeaturePopulated | KioskFeaturePopulated>;
+
+type occupantHelper_OccupantMarkerPlacementType = OccupantMarkerPlacementType;
+declare const occupantHelper_getOccupantCorrelatedLocations: typeof getOccupantCorrelatedLocations;
+declare const occupantHelper_getOccupantMainLocation: typeof getOccupantMainLocation;
+declare const occupantHelper_getOccupantMarkerLocations: typeof getOccupantMarkerLocations;
+declare namespace occupantHelper {
+  export { type occupantHelper_OccupantMarkerPlacementType as OccupantMarkerPlacementType, occupantHelper_getOccupantCorrelatedLocations as getOccupantCorrelatedLocations, occupantHelper_getOccupantMainLocation as getOccupantMainLocation, occupantHelper_getOccupantMarkerLocations as getOccupantMarkerLocations };
+}
+
+declare const getDataClient: (options: VenueClientOptions) => VenueDataClient;
+
+declare function fetchDeliveryApi<T extends FeatureType = FeatureType>(projectId: string, apiKey: string, featureType: FeatureType, baseUrl?: string): Promise<FeatureResponseMap[T][]>;
+declare function fetchPreviewApi<T extends FeatureType = FeatureType>(projectId: string, previewToken: string, featureType: FeatureType, baseUrl?: string): Promise<FeatureResponseMap[T][]>;
+declare const safeFetchFeature: <T extends FeatureType = FeatureType>(featureType: FeatureType, params: {
+    mode: "delivery" | "preview";
+    projectId: string;
+    apiKey: string;
+    previewToken?: string;
+    baseUrl: string;
+}) => Promise<FeatureResponseMap[T][]>;
+
+declare const getSearchClient: ({ occupants, amenities }: {
+    occupants: OccupantFeature[];
+    amenities: AmenityFeature[];
+}) => SearchClient;
+
+type NavigateClient = {
+    findRoute: (routeOriginParam: NavigatableParam, routeDestinationParam: NavigatableParam, options?: any) => Promise<Route>;
+    findByIdSync: FindByIdSync;
+};
+declare const getNavigateClient: (options: GetNavigateClientOptions) => NavigateClient;
+
+export { type SectionFeature as $, type AnchorGeometry as A, type BaseRelationshipProperties as B, type TraversalRelationshipProperties as C, type DetailGeometry as D, type TraversalRelationshipFeature as E, type FixtureGeometry as F, type ElevatorRelationshipProperties as G, type ElevatorRelationshipFeature as H, type Id as I, type RampRelationshipProperties as J, type KioskGeometry as K, type LevelGeometry as L, type MediaFile as M, type RampRelationshipFeature as N, type OccupantGeometry as O, type StairsRelationshipProperties as P, type StairsRelationshipFeature as Q, type Route as R, type SingleGeometry as S, type TransalatableString as T, type UnitTypeAndId as U, type VenueDataClient as V, type EscalatorRelationshipProperties as W, type EscalatorRelationshipFeature as X, type AnyRelationshipFeature as Y, type SectionGeometry as Z, type SectionProperties as _, type Media as a, type IMDFUnitCategory as a$, type UnitGeometry as a0, type UnitProperties as a1, type UnitFeature as a2, type VenueGeometry as a3, type VenueProperties as a4, type VenueFeature as a5, type TaxonomyGeometry as a6, type TaxonomyProperties as a7, type TaxonomyFeature as a8, type EventGeometry as a9, type FixtureFeaturePopulated as aA, type KioskFeaturePopulated as aB, type LevelFeaturePopulated as aC, type OccupantFeaturePopulated as aD, type OpeningFeaturePopulated as aE, type RelationshipFeaturePopulated as aF, type TraversalRelationshipFeaturePopulated as aG, type EscalatorRelationshipFeaturePopulated as aH, type RampRelationshipFeaturePopulated as aI, type ElevatorRelationshipFeaturePopulated as aJ, type StairRelationshipFeaturePopulated as aK, type SectionFeaturePopulated as aL, type UnitFeaturePopulated as aM, type VenueFeaturePopulated as aN, type TaxonomyFeaturePopulated as aO, type Model3dPopulated as aP, type FeaturePopulatedResponseMap as aQ, type PopulatableFeatureType as aR, type VenueClientOptions as aS, type SearchClient as aT, type NavigateClient$1 as aU, type FindParams as aV, type FilterParams as aW, type PopulatedParams as aX, type FeatureQueryOptions as aY, type InternalFindById as aZ, type InternalFilterByType as a_, type EventProperties as aa, type EventFeature as ab, type PromotionProperties as ac, type PromotionFeature as ad, type PrivilegeGeometry as ae, type PrivilegeProperties as af, type PrivilegeFeature as ag, type LabelGeometry as ah, type LabelProperties as ai, type LabelFeature as aj, type ElementGeometry as ak, type ElementProperties as al, type ElementFeature as am, type SponsoredContentLegacyType as an, type SponsoredContentPlacementType as ao, type SponsoredContentStrapiV4ApiResponse as ap, type SponsoredContentFeature as aq, type Page as ar, type Model3dGeometry as as, type Model3dProperties as at, type Model3dFeature as au, type FeatureResponseMap as av, type FeatureType as aw, type PolygonalFeature as ax, type AmenityFeaturePopulated as ay, type AnchorFeaturePopulated as az, type Model3d as b, DEFAULT_BASE_URL as b0, IMDF_FEATURE_TYPES as b1, IMDF_UNIT_CATEGORIES as b2, NONIMDF_FEATURE_TYPES as b3, GEOJSON_FEATURE_TYPES as b4, ALL_FEATURE_TYPES as b5, defaultFeatureQueryOptionsMap as b6, occupantHelper as b7, isValidCoordinate as b8, isValidPolygonCoordinates as b9, isValidMultiPolygonCoordinates as ba, isValidLineStringCoordinates as bb, isValidMultiPolygon as bc, isValidPolygon as bd, isValidLineString as be, isValidPoint as bf, matchFilter as bg, matchFilters as bh, getDataClient as bi, fetchDeliveryApi as bj, fetchPreviewApi as bk, safeFetchFeature as bl, getSearchClient as bm, getNavigateClient as bn, type ImdfFeature as c, type AnchorProperties as d, type AnchorFeature as e, type AmenityGeometry as f, type AmenityProperties as g, type AmenityFeature as h, type DetailProperties as i, type DetailFeature as j, type FixtureProperties as k, type FixtureFeature as l, type KioskProperties as m, type KioskFeature as n, type LevelProperties as o, type LevelFeature as p, type OccupantProperties as q, type OccupantFeature as r, type OpeningGeometry as s, type OpeningProperties as t, type OpeningFeature as u, type RelationshipCategories as v, type RelationshipDirectionTypes as w, type OpeningTypeAndId as x, type RelationshipGeometry as y, type RelationshipFeature as z };