import * as _mappedin_mvf_v22 from "@mappedin/mvf-v2";
import { AnnotationCollection, AnnotationSymbol, AreaCollection, AreaId, BaseTextAreaProperties, Category, CategoryId, Connection as Connection$1, Details, EnterpriseCategory as EnterpriseCategory$1, EnterpriseCategoryId, EnterpriseLocation as EnterpriseLocation$1, EnterpriseLocationId, EnterpriseLocationInstance, EnterpriseTexture, EnterpriseVenue as EnterpriseVenue$1, EnterpriseVenueType, EntranceCollection, EntranceFeature, Facade as Facade$1, Feature as Feature$1, FeatureCollection as FeatureCollection$1, FloatingFloorTextProperties, FloorCollection, FloorId, FloorProperties, FloorStack as FloorStack$1, FloorTextCommonProperties, Geometry as Geometry$1, Hyperlink as Hyperlink$1, Image, Language, LineStringStyle, LineStringStyle as TMVFLineStringStyle, Location, LocationId, LocationLink, LocationSocial, LocationSocial as LocationSocial$1, LocationState, LocationState as LocationState$1, MVFv2_STANDARD_MVFv3, MultiPolygon as MultiPolygon$1, NavigationFlagDeclarations, NodeCollection, NodeId, ObstructionCollection, ObstructionCollection as ObstructionCollection$1, ObstructionFeature, ObstructionId, OpeningHoursSpecification, OperationHours, OperationHours as OperationHours$1, ParsedMVF, ParsedMVF as TMVF, ParsedMVFLocalePack, Point as Point$1, PointStyle, PointStyle as TMVFPointStyle, Polygon as Polygon$1, PolygonStyle, PolygonStyle as TMVFPolygonStyle, SiblingGroup, SiblingGroup as SiblingGroup$1, SpaceCollection, SpaceCollection as SpaceCollection$1, SpaceFeature, SpaceId, SpaceProperties, Style as TMVFStyle, StyleCollection, StyleCollection as TMVFStyleCollection, TilesetStyle } from "@mappedin/mvf-v2";
import { MVFv2_STANDARD_MVFv3 as MVFv2_STANDARD_MVFv3$1, ParsedMVF as ParsedMVF$1, RawMVF } from "@mappedin/mvf-v2/no-validator-lite";
import * as _mappedin_renderer_three0 from "@mappedin/renderer-three";
import { AddLabelOptionsInternal, AddText3DOptions, AddText3DOptions as AddText3DOptions$1, AddText3DPointOptions, CameraSystemState, ColorString, DebugState, DebugState as DebugState$1, EntityId, EnvMapOptions, EnvMapOptions as EnvMapOptions$1, GLTFExportOptions as GLTFExportOptions$1, GroupContainerState, ISystemPlugin, ISystemPlugin as ISystemPlugin$1, ImagePlacementOptions, InitializeModelState, InitializeModelState as InitializeModelState$1, InitializeText3DState, InsetPadding, InsetPadding as InsetPadding$1, InsetPaddingOption, InsetPaddingOption as InsetPaddingOption$1, InterpolateOn, Interpolation, LabelAppearance as LabelAppearance$1, LabelRenderedState, LabelTextPlacement as LabelTextPlacement$1, LineStyle, LineStyle as LineStyle$1, MapViewState, MarkerState, OutlinesOptions, PaintStyle, PaintStyle as PaintStyle$1, PathState, PathWidth, PathWidth as PathWidth$1, PixelWidth, Position as Position$1, RendererCore, RendererCoreOptions, RendererCoreOptions as RendererCoreOptions$1, Shading, Text3DState, WatermarkUpdateOptions } from "@mappedin/renderer-three";
import * as _tweenjs_tween_js0 from "@tweenjs/tween.js";
import { Group, Tween } from "@tweenjs/tween.js";
import { CustomLayerInterface, IControl, Map as Map$1, MapEventType } from "@mappedin/outdoor-context";
import { ANIMATION_TWEENS, PathWidth as PathWidth$2, PathWidth as PathWidth$3, enableTestMode } from "@mappedin/renderer-shared";
import { MatchInfo, SearchResult as SearchResult$1, Suggestion, Suggestion as Suggestion$1 } from "minisearch";
import * as three0 from "three";
import { AmbientLight, BatchedMesh, BatchedMeshGeometryRange, Box3, BufferAttribute, BufferGeometry, Camera as Camera$1, Color, DirectionalLight, Group as Group$1, Intersection, LineSegments, Matrix4, Mesh, MeshLambertMaterial, MeshLambertMaterialParameters, Object3D, Object3DEventMap, PerspectiveCamera, Plane, PlaneGeometry, Raycaster, Scene, ShaderMaterial, Texture, TubeGeometry, Vector2, Vector3, WebGLRenderer } from "three";
import { BatchedText, BatchedText as BatchedText$1, Text, Text as Text$1 } from "troika-three-text";
import "../../renderer-three/src/styles/interactions.scss";
import "../../renderer-three/src/styles/html-controls.scss";
import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
import "../../renderer-three/src/styles/outdoor-context.css";
import "../../2d-labels-markers/src/styles/marker.scss";
import "../../2d-labels-markers/src/styles/collisions.scss";

//#region ../../node_modules/.pnpm/@types+geojson@7946.0.8/node_modules/@types/geojson/index.d.ts
/**
 * The valid values for the "type" property of GeoJSON geometry objects.
 * https://tools.ietf.org/html/rfc7946#section-1.4
 */
type GeoJsonGeometryTypes = Geometry['type'];
/**
 * The value values for the "type" property of GeoJSON Objects.
 * https://tools.ietf.org/html/rfc7946#section-1.4
 */
type GeoJsonTypes = GeoJSON$1['type'];
/**
 * Bounding box
 * https://tools.ietf.org/html/rfc7946#section-5
 */
type BBox = [number, number, number, number] | [number, number, number, number, number, number];
/**
 * A Position is an array of coordinates.
 * https://tools.ietf.org/html/rfc7946#section-3.1.1
 * Array should contain between two and three elements.
 * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
 * but the current specification only allows X, Y, and (optionally) Z to be defined.
 */
type Position = number[];
// [number, number] | [number, number, number];

/**
 * The base GeoJSON object.
 * https://tools.ietf.org/html/rfc7946#section-3
 * The GeoJSON specification also allows foreign members
 * (https://tools.ietf.org/html/rfc7946#section-6.1)
 * Developers should use "&" type in TypeScript or extend the interface
 * to add these foreign members.
 */
interface GeoJsonObject {
  // Don't include foreign members directly into this type def.
  // in order to preserve type safety.
  // [key: string]: any;
  /**
   * Specifies the type of GeoJSON object.
   */
  type: GeoJsonTypes;
  /**
   * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
   * The value of the bbox member is an array of length 2*n where n is the number of dimensions
   * represented in the contained geometries, with all axes of the most southwesterly point
   * followed by all axes of the more northeasterly point.
   * The axes order of a bbox follows the axes order of geometries.
   * https://tools.ietf.org/html/rfc7946#section-5
   */
  bbox?: BBox | undefined;
}
/**
 * Union of GeoJSON objects.
 */
type GeoJSON$1 = Geometry | Feature | FeatureCollection;
/**
 * Geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3
 */
type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
type GeometryObject = Geometry;
/**
 * Point geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.2
 */
interface Point extends GeoJsonObject {
  type: "Point";
  coordinates: Position;
}
/**
 * MultiPoint geometry object.
 *  https://tools.ietf.org/html/rfc7946#section-3.1.3
 */
interface MultiPoint extends GeoJsonObject {
  type: "MultiPoint";
  coordinates: Position[];
}
/**
 * LineString geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.4
 */
interface LineString extends GeoJsonObject {
  type: "LineString";
  coordinates: Position[];
}
/**
 * MultiLineString geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.5
 */
interface MultiLineString extends GeoJsonObject {
  type: "MultiLineString";
  coordinates: Position[][];
}
/**
 * Polygon geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.6
 */
interface Polygon extends GeoJsonObject {
  type: "Polygon";
  coordinates: Position[][];
}
/**
 * MultiPolygon geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.7
 */
interface MultiPolygon extends GeoJsonObject {
  type: "MultiPolygon";
  coordinates: Position[][][];
}
/**
 * Geometry Collection
 * https://tools.ietf.org/html/rfc7946#section-3.1.8
 */
interface GeometryCollection extends GeoJsonObject {
  type: "GeometryCollection";
  geometries: Geometry[];
}
type GeoJsonProperties = {
  [name: string]: any;
} | null;
/**
 * A feature object which contains a geometry and associated properties.
 * https://tools.ietf.org/html/rfc7946#section-3.2
 */
interface Feature<G extends Geometry | null = Geometry, P$1 = GeoJsonProperties> extends GeoJsonObject {
  type: "Feature";
  /**
   * The feature's geometry
   */
  geometry: G;
  /**
   * A value that uniquely identifies this feature in a
   * https://tools.ietf.org/html/rfc7946#section-3.2.
   */
  id?: string | number | undefined;
  /**
   * Properties associated with this feature.
   */
  properties: P$1;
}
/**
 * A collection of feature objects.
 *  https://tools.ietf.org/html/rfc7946#section-3.3
 */
interface FeatureCollection<G extends Geometry | null = Geometry, P$1 = GeoJsonProperties> extends GeoJsonObject {
  type: "FeatureCollection";
  features: Array<Feature<G, P$1>>;
}
//#endregion
//#region ../packages/mvf-utils/constants.d.ts
/**
 * Represents the environment state configuration.
 * @example
 * const mapData = getMapData({
 *  key: '',
 *  secret: '',
 *  environment: 'eu'
 * })
 */
type Environment = {
  /**
   * The base URI for the API.
   */
  baseUri: string;
  /**
   * The base URI for authentication.
   */
  baseAuthUri: string;
  /**
   * The base URI for analytics.
   */
  analyticsBaseUri: string;
  /**
   * The URI for the tile server.
   */
  tileServerUri: string;
};
type InternalServiceEnvironment = 'us' | 'us-enterprise' | 'eu' | 'us-staging-enterprise' | 'us-staging-self-serve';
type ServiceEnvironment = 'us' | 'eu';
//#endregion
//#region ../packages/mvf-utils/mvf-utils.d.ts
/**
 * Options for configuring search functionality.
 */
type TSearchOptions = {
  /**
   * Indicates whether search functionality is enabled.
   */
  enabled: boolean;
};
type TGetMapDataSharedOptions = {
  /**
   * Mappedin map ID.
   */
  mapId: string;
  /**
   * Optionally provide a custom base URL for the Mappedin API request.
   * Use the {@link Environment | `environment`} setting to switch environments
   */
  baseUri?: string;
  /**
   * Optionally provide a custom base URL for authentication when obtaining an access token.
   * Use the {@link Environment | `environment`} setting to switch environments.
   */
  baseAuthUri?: string;
  /**
   * Optionally provide an entirely custom URL for authentication when obtaining an access token.
   * @hidden
   * @internal
   */
  customAuthUri?: string;
  /**
   * Callback for when the Mappedin map data has been fetched and parsed as Mappedin Venue Format (MVF) data.
   * @param mvf Parsed MVF data.
   */
  onMVFParsed?: (mvf: ParsedMVF$1) => void;
  /**
   * Load different view of mvf data based on configId
   */
  viewId?: string;
  /**
   * set the target SDK environment
   * @default 'us'
   * @example
   * const mapData = getMapData({
   *  key: '',
   *  secret: '',
   *  environment: 'eu'
   * })
   */
  environment?: ServiceEnvironment;
  /**
   * The language of the map data.
   * The ISO 639-1 language code to change to (e.g., 'en' for English, 'fr' for French). Check ({@link EnterpriseVenue.languages}) for available languages
   */
  language?: string;
  /**
   * Whether to use browser's language settings as fallback if the supplied language code is not available.
   * @default true
   * */
  fallbackToNavigatorLanguage?: boolean;
  /**
   * Analytics configuration.
   */
  analytics?: {
    /**
     * Whether to log analytics events.
     * @default false
     */
    logEvents?: boolean;
    /**
     * Whether to send analytics events to the server.
     * @default false
     */
    sendEvents?: boolean;
    /**
     * Custom base URI for analytics requests. If not provided, the default analytics endpoint will be used.
     * Use the {@link Environment | `environment`} setting to switch environments.
     */
    baseUri?: string;
    /**
     * Context for analytics events.
     * @default 'websdk'
     * @internal
     */
    context?: string;
    /**
     * Version override for analytics events.
     * @internal
     */
    version?: string;
    /**
     * The externalId parameter attaches a custom tracking identifier to every analytics event sent during the session.
     * This is useful for correlating Mappedin analytics data with an external system — for example, linking a map session
     * back to a specific marketing campaign, CRM record, or third-party tracking platform.
     */
    externalId?: string;
  };
  search?: TSearchOptions;
  /**
   * Fetch bearer and SAS tokens for the map ahead of time and keep them up to date in the background.
   * @default true
   */
  prefetchTokens?: boolean;
  /**
   * @hidden
   * @internal
   */
  layoutId?: 'draft';
  /**
   * @hidden
   * @internal
   */
  mvfVersion?: '2.0.0' | '2.0.0-c' | '3.0.0';
};
/**
 * Fetch map data using a key/secret pair and additional options.
 *
 * **Data-model note:** The key you supply determines which data model the API returns.
 * - Keys starting with `"mik_"` use the **Maker** data model
 *   (`LocationProfile`, `LocationCategory`).
 * - All other keys use the **CMS / Enterprise** data model
 *   (`EnterpriseLocation`, `EnterpriseCategory`).
 *
 * Using the wrong data types for your key type will return empty results.
 *
 * @interface
 */
type TGetMapDataWithCredentialsOptions = {
  /**
   * Mappedin auth key.
   *
   * Keys starting with `"mik_"` use the Maker data model
   * (`LocationProfile`, `LocationCategory`).
   * All other keys use the CMS/Enterprise data model
   * (`EnterpriseLocation`, `EnterpriseCategory`).
   * Using the wrong data types for your key type will return empty results.
   */
  key: string;
  /**
   * Mappedin auth secret.
   */
  secret: string;
} & TGetMapDataSharedOptions;
/**
 * @interface
 */
type TGetMapDataWithAccessTokenOptions = {
  /**
   * Mappedin access token.
   */
  accessToken: string;
} & TGetMapDataSharedOptions;
type TGetMapDataOptions = TGetMapDataWithCredentialsOptions | TGetMapDataWithAccessTokenOptions;
/**
 * @internal
 */
declare function parseMVFv2(raw: RawMVF): ParsedMVF$1;
/**
 * @internal
 */
declare function unzipMVFv2(data: Uint8Array): Promise<RawMVF>;
type LocalePackUrls = {
  [key: string]: string;
};
declare function createEnvControl(): {
  /**
   * @internal
   */
  updateByUserOption(userOption: TGetMapDataOptions): void;
  /**
   * @internal
   */
  updateTileServerBaseUrl(url: string): void;
  /**
   * @internal
   */
  updateEnvironment(env: InternalServiceEnvironment): void;
  /**
   * @internal
   */
  setEnterprise(isEnterprise: boolean): void;
  getBaseUri(): string;
  getBaseAuthUri(): string;
  getAnalyticsBaseUri(): string;
  getTileServerUri(): string;
  reset(): void;
  /**
   * @internal
   */
  __getState: () => Environment;
};
type EnvControl = ReturnType<typeof createEnvControl>;
/**
 * Result type for MVF parsing that includes both v2 (converted) and optional v3 (original)
 */
type ParsedMVFResult = {
  mvf2: ParsedMVF$1;
  mvf3?: MVFv2_STANDARD_MVFv3$1;
};
declare function unzipAndParseMVFv2(data: Uint8Array, inputVersion?: string): Promise<ParsedMVFResult>;
//#endregion
//#region src/hydrate-map-data.d.ts
type THydrateMapDataBundle = {
  type: 'binary';
  options?: {
    version?: '2.0.0' | '3.0.0';
    /**
     * @deprecated This option is no longer needed and will be removed in a future release.
     * Enterprise mode is now automatically detected from the MVF data.
     */
    enterprise?: boolean;
  };
  languagePacks?: {
    language: {
      code: string;
      name: string;
    };
    localePack: Uint8Array;
  }[];
  main: Uint8Array;
} | {
  type: 'json';
  options?: {
    version?: '2.0.0' | '3.0.0';
    /**
     * @deprecated This option is no longer needed and will be removed in a future release.
     * Enterprise mode is now automatically detected from the MVF data.
     */
    enterprise?: boolean;
    mvf3?: MVFv2_STANDARD_MVFv3;
  };
  languagePacks?: {
    language: {
      code: string;
      name: string;
    };
    localePack: ParsedMVFLocalePack;
  }[];
  main: ParsedMVF;
};
/**
 * Load a MapData instance from a backup bundle (zip file or parsed MVF).
 *
 * This function automatically detects whether the data is from a Maker or CMS/Enterprise
 * source by checking for the presence of the `enterprise` field in the MVF data. Use
 * `mapData.isEnterpriseMode` after loading to determine which data types to access.
 *
 * @param backup - The map data bundle (binary zip, parsed JSON, or raw MVF)
 * @param userOptions - Optional configuration including credentials for outdoor view and analytics
 * @returns A Promise that resolves to a MapData instance
 *
 * @example Loading from a zip file with auto-detection
 * ```ts
 * const response = await fetch('map-bundle.zip');
 * const buffer = new Uint8Array(await response.arrayBuffer());
 * const mapData = await hydrateMapData({ type: 'binary', main: buffer });
 *
 * // Check which data source was detected
 * const locations = mapData.isEnterpriseMode
 *   ? mapData.getByType('enterprise-location')
 *   : mapData.getByType('location-profile');
 * ```
 */
declare const hydrateMapData: (backup: THydrateMapDataBundle | ParsedMVF, userOptions?: TGetMapDataOptions) => Promise<MapData>;
//#endregion
//#region ../packages/common/async.d.ts
/**
 * A debounced function with a cancel method
 */
interface DebouncedFunction<T$1 extends (...args: any[]) => void> {
  (...args: Parameters<T$1>): void;
  /**
   * Cancels any pending debounced execution
   */
  cancel: () => void;
}
//#endregion
//#region src/analytics/customer.d.ts
/**
 * Valid track-analytics API contexts. These should match the expected values of that endpoint or the requests will fail.
 * If a set context is not in this list, it will default to the first VALID_CONTEXTS value.
 */
declare const VALID_CONTEXTS: readonly ["websdk", "web", "webv2", "kiosk", "kiosk-v2", "mobile", "iossdk", "androidsdk", "reactnativesdk", "gen7", "bespoke", "reactsdk", "minimap"];
type ValidContext = (typeof VALID_CONTEXTS)[number];
declare const FOUND_POSITION = "found-position";
declare const FOUND_FLOOR = "found-floor";
type BlueDotEvents = typeof FOUND_FLOOR | typeof FOUND_POSITION;
declare class AnalyticsInternal {
  #private;
  private oneTimeEventsSent;
  constructor();
  init(options: AnalyticsUpdateOptions): void;
  /**
   * Reset state and options
   */
  reset(): void;
  private updateStateWithOptions;
  updateState(update: UpdateStateParam): void;
  private handleStateUpdate;
  get authReady(): boolean;
  getState(): AnalyticState;
  private getContext;
  private getSessionId;
  private getDeviceId;
  private sendAnalyticEvent;
  capture<T$1 extends keyof CaptureEventsPayloadMap>(eventName: T$1, query: CaptureEventsPayloadMap[T$1]): Promise<Response> | Promise<void>;
  capture<T$1 extends keyof CaptureEventsPayloadMap | (string & NonNullable<unknown>)>(target: T$1, query: T$1 extends keyof CaptureEventsPayloadMap ? CaptureEventsPayloadMap[T$1] : Record<string, any>): Promise<Response> | Promise<void>;
  /**
   * @internal
   */
  sendGetMapDataEvent(payload: {
    parseDuration: number;
    downloadDuration: number;
    viewId?: string;
  }): void | Promise<void> | Promise<Response>;
  sendChangeLanguageEvent(payload: {
    fromLanguage: string;
  }): void | Promise<void> | Promise<Response>;
  sendWatchPositionDenied(): void | Promise<void> | Promise<Response>;
  /**
   * @internal
   */
  sendMapViewLoadedEvent({
    firstRenderDuration,
    dimension,
    collisionWorkerDisabled,
    outdoorsWorkerDisabled
  }: {
    firstRenderDuration: number;
    dimension: {
      height: number;
      width: number;
    };
    /**
     * True when setWorkerURL is set, but the worker file cannot be found, so we disable the collision worker and use sync collision detection instead
     */
    collisionWorkerDisabled: boolean;
    /**
     * True when setWorkerURL is set, but the worker file cannot be found, so we disable the outdoor context
     */
    outdoorsWorkerDisabled: boolean;
  }): void | Promise<void> | Promise<Response>;
  /**
   * @internal
   */
  sendGetDirectionsEvent: DebouncedFunction<(start: string, end: string, accessible?: boolean) => void | Promise<void> | Promise<Response>>;
  sendBlueDotEvents(event: BlueDotEvents): void | Promise<void> | Promise<Response>;
}
type UpdateStateParam = Partial<Pick<AnalyticState, 'geolocationMode' | 'context' | 'logEvents' | 'userPosition' | 'mapId' | 'sendEvents' | 'logEvents' | 'accessToken' | 'sessionId' | 'deviceId' | 'externalId'>>;
/**
 * Maps reserved analytics event names to their payload structures.
 *
 * This type is used by the {@link Analytics.capture} method to provide type safety for reserved analytics events.
 * When using these event names, the payload must match the corresponding structure.
 */
type CaptureEventsPayloadMap = {
  /**
   * Event fired when a location is selected.
   */
  '$select-location': {
    /**
     * The ID of the selected location.
     */
    id: string;
  };
  /**
   * Event fired when a category is selected.
   */
  '$select-category': {
    /**
     * The ID of the selected category.
     */
    id: string;
  };
  /**
   * Event fired when query suggestions are generated.
   */
  '$query-suggest': {
    /**
     * The search query string.
     */
    query: string;
    /**
     * Optional array of suggestion strings.
     */
    suggestions?: string[];
  };
  /**
   * Event fired when a search query is executed.
   */
  '$query-search': {
    /**
     * The search query string.
     */
    query: string;
    /**
     * Optional array of result IDs (hits).
     */
    hits?: string[];
  };
};
declare class Analytics {
  #private;
  /**
   * @internal
   */
  constructor(internalAnalytics: AnalyticsInternal);
  /**
   * Captures an analytic event with a custom target and query payload.
   *
   * @param target - The event name or target can be one of: `$select-location`, `$select-category`, `$query-suggest`, `$query-search`
   * @param query - The payload associated with the event.
   * @returns A promise that resolves to the server response or void.
   */
  capture: typeof AnalyticsInternal.prototype.capture;
  /**
   * Updates the analytics state with the provided parameters.
   * @param update - The state parameters to update.
   */
  updateState: (update: TAnalyticsUpdateState) => void;
  /**
   * Returns the current analytics state.
   * @internal
   * @returns the current analytics state
   */
  getState(): {
    version: string;
    /** The platform string to be included in analytics. */
    platformString: string;
    /** The base URI for the analytics endpoint. */
    baseUri: string;
    /** The base URI with mapId appended. */
    analyticsBaseUrl: string;
    /** Flag to disable authentication. */
    noAuth: boolean;
    /** Flag to enable geolocation mode. */
    geolocationMode: boolean;
    /** The context in which the analytics are being used. */
    context: ValidContext;
    /** The last known user position. */
    userPosition?: AnalyticsUserPosition;
    /** The ID of the map to be used for analytics. */
    mapId?: string;
    /** Flag to enable logging of events. */
    logEvents: boolean;
    /** Flag to enable sending of events. */
    sendEvents: boolean;
    /**
     * The externalId parameter attaches a custom tracking identifier to every analytics event sent during the session.
     * This is useful for correlating Mappedin analytics data with an external system — for example, linking a map session
     * back to a specific marketing campaign, CRM record, or third-party tracking platform.
     */
    externalId?: string;
    /** The API key for authentication. */
    key?: string;
    /** The API secret for authentication. */
    secret?: string;
    /** The access token for authentication. */
    accessToken?: string;
  };
  private getContext;
  private getSessionId;
  private getDeviceId;
}
type AnalyticsUserPosition = {
  bluedotTimestamp: number;
  latitude: number;
  longitude: number;
  floorLevel?: number;
  accuracy?: number;
};
type AnalyticsAuth = {
  /** The API key for authentication. */
  key?: string;
  /** The API secret for authentication. */
  secret?: string;
  /** The access token for authentication. */
  accessToken?: string;
};
type AnalyticState = {
  version: string;
  /** The platform string to be included in analytics. */
  platformString: string;
  /** The base URI for the analytics endpoint. */
  baseUri: string;
  /** The base URI with mapId appended. */
  analyticsBaseUrl: string;
  /** Flag to disable authentication. */
  noAuth: boolean;
  /** Flag to enable geolocation mode. */
  geolocationMode: boolean;
  /** @internal The device ID to be used for analytics. */
  deviceId: string;
  /** @internal The session ID to be used for analytics. */
  sessionId: string;
  /** The context in which the analytics are being used. */
  context: ValidContext;
  /** The last known user position. */
  userPosition?: AnalyticsUserPosition;
  /** The ID of the map to be used for analytics. */
  mapId?: string;
  /** Flag to enable logging of events. */
  logEvents: boolean;
  /** Flag to enable sending of events. */
  sendEvents: boolean;
  /**
   * The externalId parameter attaches a custom tracking identifier to every analytics event sent during the session.
   * This is useful for correlating Mappedin analytics data with an external system — for example, linking a map session
   * back to a specific marketing campaign, CRM record, or third-party tracking platform.
   */
  externalId?: string;
} & AnalyticsAuth;
type AnalyticsOptions = Partial<Omit<AnalyticState, 'analyticsBaseUrl' | 'geolocationMode' | 'userPosition'>>;
type AnalyticsUpdateOptions = Omit<AnalyticsOptions, keyof AnalyticsAuth> & ((Required<Pick<AnalyticsAuth, 'key' | 'secret'>> & Partial<Pick<AnalyticsAuth, 'accessToken'>>) | (Required<Pick<AnalyticsAuth, 'accessToken'>> & Partial<Pick<AnalyticsAuth, 'key' | 'secret'>>));
/**
 * Options for updating the current state of analytics.
 * @interface
 */
type TAnalyticsUpdateState = Pick<Partial<AnalyticState>, 'logEvents' | 'sendEvents' | 'baseUri' | 'accessToken' | 'externalId'>;
//#endregion
//#region ../packages/shave-text/shave-text.d.ts
type TDrawFn = (ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, x: number, y: number) => void;
//#endregion
//#region ../packages/quad-tree/src/types.d.ts
type Point2D<T$1 = unknown> = [number, number, T$1?];
//#endregion
//#region ../packages/quad-tree/src/rectangle.d.ts
/**
 * Class representing a rectangle.
 *
 * @template T - The type of user data stored in the rectangle.
 */
declare class Rectangle<T$1 = unknown> {
  /**
   * The x-coordinate of the rectangle.
   */
  readonly x: number;
  /**
   * The y-coordinate of the rectangle.
   */
  readonly y: number;
  /**
   * The width of the rectangle.
   */
  readonly w: number;
  /**
   * The height of the rectangle.
   */
  readonly h: number;
  /**
   * The user data associated with this rectangle.
   */
  userData: T$1;
  /**
   * Creates an instance of Rectangle.
   *
   * @param {number} x - The x-coordinate of the rectangle.
   * @param {number} y - The y-coordinate of the rectangle.
   * @param {number} w - The width of the rectangle.
   * @param {number} h - The height of the rectangle.
   * @param {T} [userData] - The user data associated with this rectangle.
   */
  constructor(x: number, y: number, w: number, h: number, userData?: T$1);
  /**
   * Checks if this rectangle contains the given rectangle entirely.
   *
   * @param {Rectangle} rectangle - The rectangle to check.
   * @returns {boolean} Whether this rectangle contains the given rectangle.
   */
  contains(rectangle: Rectangle<T$1>): boolean;
  /**
   * Checks if this rectangle intersects with the given rectangle.
   *
   * @param {Rectangle} rectangle - The rectangle to check.
   * @returns {boolean} Whether this rectangle intersects with the given rectangle.
   */
  intersects(rectangle: Rectangle): boolean;
  /**
   * Checks if this rectangle intersects with the given point.
   *
   * @param {Point2D} point - The point to check.
   * @returns {boolean} Whether this rectangle intersects with the given point.
   */
  intersectsPoint(point: Point2D): boolean;
  /**
   * Draws the rectangle on the given canvas context.
   *
   * @param {CanvasRenderingContext2D} context - The canvas context to draw on.
   */
  draw(context: CanvasRenderingContext2D): void;
}
//#endregion
//#region ../packages/quad-tree/src/quad-tree.d.ts
/**
 * This is a QuadTree implementation that can be used to store rectangles
 * and query them based on their position.
 *
 * @template T - The type of data stored in the QuadTree.
 */
declare class QuadTree<T$1 = unknown> {
  /**
   * The top-left quadrant of this QuadTree.
   */
  topLeft: QuadTree<T$1>;
  /**
   * The top-right quadrant of this QuadTree.
   */
  topRight: QuadTree<T$1>;
  /**
   * The bottom-left quadrant of this QuadTree.
   */
  bottomLeft: QuadTree<T$1>;
  /**
   * The bottom-right quadrant of this QuadTree.
   */
  bottomRight: QuadTree<T$1>;
  /**
   * Whether this QuadTree has been subdivided.
   */
  divided: boolean;
  /**
   * The boundary of this QuadTree.
   */
  readonly boundary: Rectangle<T$1>;
  /**
   * The maximum number of objects a QuadTree node can hold before subdividing.
   */
  capacity: number;
  /**
   * The list of objects in this QuadTree node.
   */
  readonly objects: Rectangle<T$1>[];
  /**
   * The parent QuadTree node.
   */
  readonly parent?: QuadTree<T$1>;
  /**
   * Creates an instance of QuadTree.
   *
   * @param {Rectangle<T>} boundary - The boundary of this QuadTree.
   * @param {QuadTree<T>} [parent] - The parent QuadTree node.
   */
  constructor(boundary: Rectangle<T$1>, parent?: QuadTree<T$1>);
  /**
   * Gets the total number of objects in this QuadTree.
   *
   * @returns {number} The total number of objects.
   */
  getSize(): number;
  /**
   * Subdivides this QuadTree into four quadrants.
   */
  subdivide(): void;
  /**
   * Queries this QuadTree for rectangles that intersect the given rectangle.
   *
   * @param {Rectangle} rectangle - The rectangle to query.
   * @returns {Rectangle<T>[]} The list of intersecting rectangles.
   */
  queryRect(rectangle: Rectangle): Rectangle<T$1>[];
  /**
   * Queries this QuadTree for rectangles that contain the given point.
   *
   * @param {Point2D} point - The point to query.
   * @returns {Rectangle<T>[]} The list of rectangles containing the point.
   */
  queryPoint(point: Point2D): Rectangle<T$1>[];
  /**
   * Inserts a rectangle into this QuadTree.
   *
   * @param {Rectangle<T>} rectangle - The rectangle to insert.
   * @returns {boolean} Whether the rectangle was successfully inserted.
   */
  insert(rectangle: Rectangle<T$1>): boolean;
  /**
   * Draws all objects in this QuadTree on the given canvas context.
   *
   * @param {CanvasRenderingContext2D} context - The canvas context to draw on.
   */
  drawObjects(context: CanvasRenderingContext2D): void;
  /**
   * Draws the boundary of this QuadTree on the given canvas context.
   *
   * @param {CanvasRenderingContext2D} context - The canvas context to draw on.
   */
  draw(context: CanvasRenderingContext2D): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/systems/collision/types.d.ts
type WatermarkPosition$1 = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center' | 'top' | 'bottom' | 'left' | 'right';
type TSerializedColliderResponse = [number, 1 | 0, Rectangle?];
type PackedBBox = [x: number, y: number, w: number, h: number, index: number];
type PackedBBoxes = PackedBBox[];
type PackedCollider = [bboxes: PackedBBoxes, enabled: 0 | 1, alwaysVisible: 0 | 1, x: number, y: number, shouldCollideWithScreenEdges?: 0 | 1, onlyExposeStrategyIndex?: number];
type PackedMessage = [colliders: PackedCollider[], devicePixelRatio: number, totalHeight: number, totalWidth: number, watermarkWidth: number, watermarkHeight: number, watermarkPosition: WatermarkPosition$1];
type PackedJsonMessage = {
  x: number;
  y: number;
  enabled: boolean;
  rank: number;
  bboxes: PackedBBoxes;
  shouldCollideWithScreenEdges: boolean;
  lockedToStrategyIndex: number;
};
//#endregion
//#region ../2d-labels-markers/lib/esm/constants.d.ts
/**
 * The visibility of the label's pin.
 */
declare enum PINVISIBILITY {
  /** The pin is visible. */
  ACTIVE = 1,
  /** The pin is visible, but the icon is not visible. */
  INACTIVE = 0.5,
  /** The pin is not visible. */
  HIDDEN = 0,
}
declare enum TEXTALIGN {
  LEFT = "left",
  CENTER = "center",
  RIGHT = "right",
}
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/json-schema.d.cts
type _JSONSchema = boolean | JSONSchema;
type JSONSchema = {
  [k: string]: unknown;
  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
  $id?: string;
  $anchor?: string;
  $ref?: string;
  $dynamicRef?: string;
  $dynamicAnchor?: string;
  $vocabulary?: Record<string, boolean>;
  $comment?: string;
  $defs?: Record<string, JSONSchema>;
  type?: "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
  additionalItems?: _JSONSchema;
  unevaluatedItems?: _JSONSchema;
  prefixItems?: _JSONSchema[];
  items?: _JSONSchema | _JSONSchema[];
  contains?: _JSONSchema;
  additionalProperties?: _JSONSchema;
  unevaluatedProperties?: _JSONSchema;
  properties?: Record<string, _JSONSchema>;
  patternProperties?: Record<string, _JSONSchema>;
  dependentSchemas?: Record<string, _JSONSchema>;
  propertyNames?: _JSONSchema;
  if?: _JSONSchema;
  then?: _JSONSchema;
  else?: _JSONSchema;
  allOf?: JSONSchema[];
  anyOf?: JSONSchema[];
  oneOf?: JSONSchema[];
  not?: _JSONSchema;
  multipleOf?: number;
  maximum?: number;
  exclusiveMaximum?: number | boolean;
  minimum?: number;
  exclusiveMinimum?: number | boolean;
  maxLength?: number;
  minLength?: number;
  pattern?: string;
  maxItems?: number;
  minItems?: number;
  uniqueItems?: boolean;
  maxContains?: number;
  minContains?: number;
  maxProperties?: number;
  minProperties?: number;
  required?: string[];
  dependentRequired?: Record<string, string[]>;
  enum?: Array<string | number | boolean | null>;
  const?: string | number | boolean | null;
  id?: string;
  title?: string;
  description?: string;
  default?: unknown;
  deprecated?: boolean;
  readOnly?: boolean;
  writeOnly?: boolean;
  nullable?: boolean;
  examples?: unknown[];
  format?: string;
  contentMediaType?: string;
  contentEncoding?: string;
  contentSchema?: JSONSchema;
  _prefault?: unknown;
};
type BaseSchema = JSONSchema;
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/standard-schema.d.cts
/** The Standard interface. */
interface StandardTypedV1<Input = unknown, Output = Input> {
  /** The Standard properties. */
  readonly "~standard": StandardTypedV1.Props<Input, Output>;
}
declare namespace StandardTypedV1 {
  /** The Standard properties interface. */
  interface Props<Input = unknown, Output = Input> {
    /** The version number of the standard. */
    readonly version: 1;
    /** The vendor name of the schema library. */
    readonly vendor: string;
    /** Inferred types associated with the schema. */
    readonly types?: Types<Input, Output> | undefined;
  }
  /** The Standard types interface. */
  interface Types<Input = unknown, Output = Input> {
    /** The input type of the schema. */
    readonly input: Input;
    /** The output type of the schema. */
    readonly output: Output;
  }
  /** Infers the input type of a Standard. */
  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
  /** Infers the output type of a Standard. */
  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
}
/** The Standard Schema interface. */
interface StandardSchemaV1<Input = unknown, Output = Input> {
  /** The Standard Schema properties. */
  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
}
declare namespace StandardSchemaV1 {
  /** The Standard Schema properties interface. */
  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
    /** Validates unknown input values. */
    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
  }
  /** The result interface of the validate function. */
  type Result<Output> = SuccessResult<Output> | FailureResult;
  /** The result interface if validation succeeds. */
  interface SuccessResult<Output> {
    /** The typed output value. */
    readonly value: Output;
    /** The absence of issues indicates success. */
    readonly issues?: undefined;
  }
  interface Options {
    /** Implicit support for additional vendor-specific parameters, if needed. */
    readonly libraryOptions?: Record<string, unknown> | undefined;
  }
  /** The result interface if validation fails. */
  interface FailureResult {
    /** The issues of failed validation. */
    readonly issues: ReadonlyArray<Issue>;
  }
  /** The issue interface of the failure output. */
  interface Issue {
    /** The error message of the issue. */
    readonly message: string;
    /** The path of the issue, if any. */
    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
  }
  /** The path segment interface of the issue. */
  interface PathSegment {
    /** The key representing a path segment. */
    readonly key: PropertyKey;
  }
  /** The Standard types interface. */
  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
  /** Infers the input type of a Standard. */
  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
  /** Infers the output type of a Standard. */
  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
}
/** The Standard JSON Schema interface. */
interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
  /** The Standard JSON Schema properties. */
  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
}
declare namespace StandardJSONSchemaV1 {
  /** The Standard JSON Schema properties interface. */
  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
    /** Methods for generating the input/output JSON Schema. */
    readonly jsonSchema: Converter;
  }
  /** The Standard JSON Schema converter interface. */
  interface Converter {
    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
  }
  /** The target version of the generated JSON Schema.
   *
   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
   *
   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
   *
   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
   */
  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
  /** The options for the input/output methods. */
  interface Options {
    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
    readonly target: Target;
    /** Implicit support for additional vendor-specific parameters, if needed. */
    readonly libraryOptions?: Record<string, unknown> | undefined;
  }
  /** The Standard types interface. */
  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
  /** Infers the input type of a Standard. */
  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
  /** Infers the output type of a Standard. */
  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
}
interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {}
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/registries.d.cts
declare const $output: unique symbol;
type $output = typeof $output;
declare const $input: unique symbol;
type $input = typeof $input;
type $replace<Meta, S extends $ZodType> = Meta extends $output ? output<S> : Meta extends $input ? input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends ((...args: infer P) => infer R) ? (...args: { [K in keyof P]: $replace<P[K], S> }) => $replace<R, S> : Meta extends object ? { [K in keyof Meta]: $replace<Meta[K], S> } : Meta;
type MetadataType = object | undefined;
declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
  _meta: Meta;
  _schema: Schema;
  _map: WeakMap<Schema, $replace<Meta, Schema>>;
  _idmap: Map<string, Schema>;
  add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
  clear(): this;
  remove(schema: Schema): this;
  get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
  has(schema: Schema): boolean;
}
interface JSONSchemaMeta {
  id?: string | undefined;
  title?: string | undefined;
  description?: string | undefined;
  deprecated?: boolean | undefined;
  [k: string]: unknown;
}
interface GlobalMeta extends JSONSchemaMeta {}
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/to-json-schema.d.cts
type Processor<T$1 extends $ZodType = $ZodType> = (schema: T$1, ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void;
interface JSONSchemaGeneratorParams {
  processors: Record<string, Processor>;
  /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
   *  @default globalRegistry */
  metadata?: $ZodRegistry<Record<string, any>>;
  /** The JSON Schema version to target.
   * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
   * - `"draft-07"` — JSON Schema Draft 7
   * - `"draft-04"` — JSON Schema Draft 4
   * - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
  target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
  /** How to handle unrepresentable types.
   * - `"throw"` — Default. Unrepresentable types throw an error
   * - `"any"` — Unrepresentable types become `{}` */
  unrepresentable?: "throw" | "any";
  /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
  override?: (ctx: {
    zodSchema: $ZodTypes;
    jsonSchema: BaseSchema;
    path: (string | number)[];
  }) => void;
  /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
   * - `"output"` — Default. Convert the output schema.
   * - `"input"` — Convert the input schema. */
  io?: "input" | "output";
  cycles?: "ref" | "throw";
  reused?: "ref" | "inline";
  external?: {
    registry: $ZodRegistry<{
      id?: string | undefined;
    }>;
    uri?: ((id: string) => string) | undefined;
    defs: Record<string, BaseSchema>;
  } | undefined;
}
/**
 * Parameters for the toJSONSchema function.
 */
type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
interface ProcessParams {
  schemaPath: $ZodType[];
  path: (string | number)[];
}
interface Seen {
  /** JSON Schema result for this Zod schema */
  schema: BaseSchema;
  /** A cached version of the schema that doesn't get overwritten during ref resolution */
  def?: BaseSchema;
  defId?: string | undefined;
  /** Number of times this schema was encountered during traversal */
  count: number;
  /** Cycle path */
  cycle?: (string | number)[] | undefined;
  isParent?: boolean | undefined;
  /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
  ref?: $ZodType | null;
  /** JSON Schema property path for this schema */
  path?: (string | number)[] | undefined;
}
interface ToJSONSchemaContext {
  processors: Record<string, Processor>;
  metadataRegistry: $ZodRegistry<Record<string, any>>;
  target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
  unrepresentable: "throw" | "any";
  override: (ctx: {
    zodSchema: $ZodType;
    jsonSchema: BaseSchema;
    path: (string | number)[];
  }) => void;
  io: "input" | "output";
  counter: number;
  seen: Map<$ZodType, Seen>;
  cycles: "ref" | "throw";
  reused: "ref" | "inline";
  external?: {
    registry: $ZodRegistry<{
      id?: string | undefined;
    }>;
    uri?: ((id: string) => string) | undefined;
    defs: Record<string, BaseSchema>;
  } | undefined;
}
type ZodStandardSchemaWithJSON$1<T$1> = StandardSchemaWithJSONProps<input<T$1>, output<T$1>>;
interface ZodStandardJSONSchemaPayload<T$1> extends BaseSchema {
  "~standard": ZodStandardSchemaWithJSON$1<T$1>;
}
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.d.cts
type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
type IsAny$1<T$1> = 0 extends 1 & T$1 ? true : false;
type Omit$1<T$1, K$1 extends keyof T$1> = Pick<T$1, Exclude<keyof T$1, K$1>>;
type MakePartial<T$1, K$1 extends keyof T$1> = Omit$1<T$1, K$1> & InexactPartial<Pick<T$1, K$1>>;
type NoUndefined<T$1> = T$1 extends undefined ? never : T$1;
type LoosePartial<T$1 extends object> = InexactPartial<T$1> & {
  [k: string]: unknown;
};
type Mask$1<Keys extends PropertyKey> = { [K in Keys]?: true };
type InexactPartial<T$1> = { [P in keyof T$1]?: T$1[P] | undefined };
type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
  readonly [Symbol.toStringTag]: string;
} | Date | Error | Generator | Promise<unknown> | RegExp;
type MakeReadonly<T$1> = T$1 extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T$1 extends Set<infer V> ? ReadonlySet<V> : T$1 extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T$1 extends Array<infer V> ? ReadonlyArray<V> : T$1 extends BuiltIn ? T$1 : Readonly<T$1>;
type SomeObject = Record<PropertyKey, any>;
type Identity<T$1> = T$1;
type Flatten<T$1> = Identity<{ [k in keyof T$1]: T$1[k] }>;
type Prettify<T$1> = { [K in keyof T$1]: T$1[K] } & {};
type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] }>;
type TupleItems = ReadonlyArray<SomeType>;
type AnyFunc = (...args: any[]) => any;
type MaybeAsync<T$1> = T$1 | Promise<T$1>;
type EnumValue = string | number;
type EnumLike = Readonly<Record<string, EnumValue>>;
type ToEnum<T$1 extends EnumValue> = Flatten<{ [k in T$1]: k }>;
type Literal = string | number | bigint | boolean | null | undefined;
type Primitive$1 = string | number | symbol | bigint | boolean | null | undefined;
type HasLength = {
  length: number;
};
type Numeric = number | bigint | Date;
type PropValues = Record<string, Set<Primitive$1>>;
type PrimitiveSet = Set<Primitive$1>;
type EmptyToNever<T$1> = keyof T$1 extends never ? never : T$1;
declare abstract class Class {
  constructor(..._args: any[]);
}
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.d.cts
declare const version: {
  readonly major: 4;
  readonly minor: 3;
  readonly patch: number;
};
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/schemas.d.cts
interface ParseContext<T$1 extends $ZodIssueBase = never> {
  /** Customize error messages. */
  readonly error?: $ZodErrorMap<T$1>;
  /** Include the `input` field in issue objects. Default `false`. */
  readonly reportInput?: boolean;
  /** Skip eval-based fast path. Default `false`. */
  readonly jitless?: boolean;
}
/** @internal */
interface ParseContextInternal<T$1 extends $ZodIssueBase = never> extends ParseContext<T$1> {
  readonly async?: boolean | undefined;
  readonly direction?: "forward" | "backward";
  readonly skipChecks?: boolean;
}
interface ParsePayload<T$1 = unknown> {
  value: T$1;
  issues: $ZodRawIssue[];
  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
  aborted?: boolean;
}
type CheckFn<T$1> = (input: ParsePayload<T$1>) => MaybeAsync<void>;
interface $ZodTypeDef {
  type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
  error?: $ZodErrorMap<never> | undefined;
  checks?: $ZodCheck<never>[];
}
interface _$ZodTypeInternals {
  /** The `@zod/core` version of this schema */
  version: typeof version;
  /** Schema definition. */
  def: $ZodTypeDef;
  /** @internal Randomly generated ID for this schema. */
  /** @internal List of deferred initializers. */
  deferred: AnyFunc[] | undefined;
  /** @internal Parses input and runs all checks (refinements). */
  run(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
  /** @internal Parses input, doesn't run checks. */
  parse(payload: ParsePayload<any>, ctx: ParseContextInternal): MaybeAsync<ParsePayload>;
  /** @internal  Stores identifiers for the set of traits implemented by this schema. */
  traits: Set<string>;
  /** @internal Indicates that a schema output type should be considered optional inside objects.
   * @default Required
   */
  /** @internal */
  optin?: "optional" | undefined;
  /** @internal */
  optout?: "optional" | undefined;
  /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
   *
   * Defined on: enum, const, literal, null, undefined
   * Passthrough: optional, nullable, branded, default, catch, pipe
   * Todo: unions?
   */
  values?: PrimitiveSet | undefined;
  /** Default value bubbled up from  */
  /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
  propValues?: PropValues | undefined;
  /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
  pattern: RegExp | undefined;
  /** @internal The constructor function of this schema. */
  constr: new (def: any) => $ZodType;
  /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
  bag: Record<string, unknown>;
  /** @internal The set of issues this schema might throw during type checking. */
  isst: $ZodIssueBase;
  /** @internal Subject to change, not a public API. */
  processJSONSchema?: ((ctx: ToJSONSchemaContext, json: BaseSchema, params: ProcessParams) => void) | undefined;
  /** An optional method used to override `toJSONSchema` logic. */
  toJSONSchema?: () => unknown;
  /** @internal The parent of this schema. Only set during certain clone operations. */
  parent?: $ZodType | undefined;
}
/** @internal */
interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
  /** @internal The inferred output type */
  output: O;
  /** @internal The inferred input type */
  input: I;
}
type $ZodStandardSchema<T$1> = StandardSchemaV1.Props<input<T$1>, output<T$1>>;
type SomeType = {
  _zod: _$ZodTypeInternals;
};
interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
  _zod: Internals;
  "~standard": $ZodStandardSchema<this>;
}
interface _$ZodType<T$1 extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T$1["output"], T$1["input"], T$1> {}
declare const $ZodType: $constructor<$ZodType>;
interface $ZodStringDef extends $ZodTypeDef {
  type: "string";
  coerce?: boolean;
  checks?: $ZodCheck<string>[];
}
interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
  def: $ZodStringDef;
  /** @deprecated Internal API, use with caution (not deprecated) */
  pattern: RegExp;
  /** @deprecated Internal API, use with caution (not deprecated) */
  isst: $ZodIssueInvalidType;
  bag: LoosePartial<{
    minimum: number;
    maximum: number;
    patterns: Set<RegExp>;
    format: string;
    contentEncoding: string;
  }>;
}
interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {}
declare const $ZodString: $constructor<$ZodString>;
interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, $ZodCheckStringFormatDef<Format> {}
interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, $ZodCheckStringFormatInternals {
  def: $ZodStringFormatDef<Format>;
}
interface $ZodStringFormat<Format extends string = string> extends $ZodType {
  _zod: $ZodStringFormatInternals<Format>;
}
declare const $ZodStringFormat: $constructor<$ZodStringFormat>;
interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {}
interface $ZodGUID extends $ZodType {
  _zod: $ZodGUIDInternals;
}
declare const $ZodGUID: $constructor<$ZodGUID>;
interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
  version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
}
interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
  def: $ZodUUIDDef;
}
interface $ZodUUID extends $ZodType {
  _zod: $ZodUUIDInternals;
}
declare const $ZodUUID: $constructor<$ZodUUID>;
interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {}
interface $ZodEmail extends $ZodType {
  _zod: $ZodEmailInternals;
}
declare const $ZodEmail: $constructor<$ZodEmail>;
interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
  hostname?: RegExp | undefined;
  protocol?: RegExp | undefined;
  normalize?: boolean | undefined;
}
interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
  def: $ZodURLDef;
}
interface $ZodURL extends $ZodType {
  _zod: $ZodURLInternals;
}
declare const $ZodURL: $constructor<$ZodURL>;
interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {}
interface $ZodEmoji extends $ZodType {
  _zod: $ZodEmojiInternals;
}
declare const $ZodEmoji: $constructor<$ZodEmoji>;
interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {}
interface $ZodNanoID extends $ZodType {
  _zod: $ZodNanoIDInternals;
}
declare const $ZodNanoID: $constructor<$ZodNanoID>;
interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {}
interface $ZodCUID extends $ZodType {
  _zod: $ZodCUIDInternals;
}
declare const $ZodCUID: $constructor<$ZodCUID>;
interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {}
interface $ZodCUID2 extends $ZodType {
  _zod: $ZodCUID2Internals;
}
declare const $ZodCUID2: $constructor<$ZodCUID2>;
interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {}
interface $ZodULID extends $ZodType {
  _zod: $ZodULIDInternals;
}
declare const $ZodULID: $constructor<$ZodULID>;
interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {}
interface $ZodXID extends $ZodType {
  _zod: $ZodXIDInternals;
}
declare const $ZodXID: $constructor<$ZodXID>;
interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {}
interface $ZodKSUID extends $ZodType {
  _zod: $ZodKSUIDInternals;
}
declare const $ZodKSUID: $constructor<$ZodKSUID>;
interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
  precision: number | null;
  offset: boolean;
  local: boolean;
}
interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
  def: $ZodISODateTimeDef;
}
interface $ZodISODateTime extends $ZodType {
  _zod: $ZodISODateTimeInternals;
}
declare const $ZodISODateTime: $constructor<$ZodISODateTime>;
interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {}
interface $ZodISODate extends $ZodType {
  _zod: $ZodISODateInternals;
}
declare const $ZodISODate: $constructor<$ZodISODate>;
interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
  precision?: number | null;
}
interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
  def: $ZodISOTimeDef;
}
interface $ZodISOTime extends $ZodType {
  _zod: $ZodISOTimeInternals;
}
declare const $ZodISOTime: $constructor<$ZodISOTime>;
interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {}
interface $ZodISODuration extends $ZodType {
  _zod: $ZodISODurationInternals;
}
declare const $ZodISODuration: $constructor<$ZodISODuration>;
interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
  version?: "v4";
}
interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
  def: $ZodIPv4Def;
}
interface $ZodIPv4 extends $ZodType {
  _zod: $ZodIPv4Internals;
}
declare const $ZodIPv4: $constructor<$ZodIPv4>;
interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
  version?: "v6";
}
interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
  def: $ZodIPv6Def;
}
interface $ZodIPv6 extends $ZodType {
  _zod: $ZodIPv6Internals;
}
declare const $ZodIPv6: $constructor<$ZodIPv6>;
interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
  version?: "v4";
}
interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
  def: $ZodCIDRv4Def;
}
interface $ZodCIDRv4 extends $ZodType {
  _zod: $ZodCIDRv4Internals;
}
declare const $ZodCIDRv4: $constructor<$ZodCIDRv4>;
interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
  version?: "v6";
}
interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
  def: $ZodCIDRv6Def;
}
interface $ZodCIDRv6 extends $ZodType {
  _zod: $ZodCIDRv6Internals;
}
declare const $ZodCIDRv6: $constructor<$ZodCIDRv6>;
interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {}
interface $ZodBase64 extends $ZodType {
  _zod: $ZodBase64Internals;
}
declare const $ZodBase64: $constructor<$ZodBase64>;
interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {}
interface $ZodBase64URL extends $ZodType {
  _zod: $ZodBase64URLInternals;
}
declare const $ZodBase64URL: $constructor<$ZodBase64URL>;
interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {}
interface $ZodE164 extends $ZodType {
  _zod: $ZodE164Internals;
}
declare const $ZodE164: $constructor<$ZodE164>;
interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
  alg?: JWTAlgorithm | undefined;
}
interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
  def: $ZodJWTDef;
}
interface $ZodJWT extends $ZodType {
  _zod: $ZodJWTInternals;
}
declare const $ZodJWT: $constructor<$ZodJWT>;
interface $ZodNumberDef extends $ZodTypeDef {
  type: "number";
  coerce?: boolean;
}
interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
  def: $ZodNumberDef;
  /** @deprecated Internal API, use with caution (not deprecated) */
  pattern: RegExp;
  /** @deprecated Internal API, use with caution (not deprecated) */
  isst: $ZodIssueInvalidType;
  bag: LoosePartial<{
    minimum: number;
    maximum: number;
    exclusiveMinimum: number;
    exclusiveMaximum: number;
    format: string;
    pattern: RegExp;
  }>;
}
interface $ZodNumber<Input = unknown> extends $ZodType {
  _zod: $ZodNumberInternals<Input>;
}
declare const $ZodNumber: $constructor<$ZodNumber>;
interface $ZodBooleanDef extends $ZodTypeDef {
  type: "boolean";
  coerce?: boolean;
  checks?: $ZodCheck<boolean>[];
}
interface $ZodBooleanInternals<T$1 = unknown> extends $ZodTypeInternals<boolean, T$1> {
  pattern: RegExp;
  def: $ZodBooleanDef;
  isst: $ZodIssueInvalidType;
}
interface $ZodBoolean<T$1 = unknown> extends $ZodType {
  _zod: $ZodBooleanInternals<T$1>;
}
declare const $ZodBoolean: $constructor<$ZodBoolean>;
interface $ZodBigIntDef extends $ZodTypeDef {
  type: "bigint";
  coerce?: boolean;
}
interface $ZodBigIntInternals<T$1 = unknown> extends $ZodTypeInternals<bigint, T$1> {
  pattern: RegExp;
  /** @internal Internal API, use with caution */
  def: $ZodBigIntDef;
  isst: $ZodIssueInvalidType;
  bag: LoosePartial<{
    minimum: bigint;
    maximum: bigint;
    format: string;
  }>;
}
interface $ZodBigInt<T$1 = unknown> extends $ZodType {
  _zod: $ZodBigIntInternals<T$1>;
}
declare const $ZodBigInt: $constructor<$ZodBigInt>;
interface $ZodSymbolDef extends $ZodTypeDef {
  type: "symbol";
}
interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
  def: $ZodSymbolDef;
  isst: $ZodIssueInvalidType;
}
interface $ZodSymbol extends $ZodType {
  _zod: $ZodSymbolInternals;
}
declare const $ZodSymbol: $constructor<$ZodSymbol>;
interface $ZodUndefinedDef extends $ZodTypeDef {
  type: "undefined";
}
interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
  pattern: RegExp;
  def: $ZodUndefinedDef;
  values: PrimitiveSet;
  isst: $ZodIssueInvalidType;
}
interface $ZodUndefined extends $ZodType {
  _zod: $ZodUndefinedInternals;
}
declare const $ZodUndefined: $constructor<$ZodUndefined>;
interface $ZodNullDef extends $ZodTypeDef {
  type: "null";
}
interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
  pattern: RegExp;
  def: $ZodNullDef;
  values: PrimitiveSet;
  isst: $ZodIssueInvalidType;
}
interface $ZodNull extends $ZodType {
  _zod: $ZodNullInternals;
}
declare const $ZodNull: $constructor<$ZodNull>;
interface $ZodAnyDef extends $ZodTypeDef {
  type: "any";
}
interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
  def: $ZodAnyDef;
  isst: never;
}
interface $ZodAny extends $ZodType {
  _zod: $ZodAnyInternals;
}
declare const $ZodAny: $constructor<$ZodAny>;
interface $ZodUnknownDef extends $ZodTypeDef {
  type: "unknown";
}
interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
  def: $ZodUnknownDef;
  isst: never;
}
interface $ZodUnknown extends $ZodType {
  _zod: $ZodUnknownInternals;
}
declare const $ZodUnknown: $constructor<$ZodUnknown>;
interface $ZodNeverDef extends $ZodTypeDef {
  type: "never";
}
interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
  def: $ZodNeverDef;
  isst: $ZodIssueInvalidType;
}
interface $ZodNever extends $ZodType {
  _zod: $ZodNeverInternals;
}
declare const $ZodNever: $constructor<$ZodNever>;
interface $ZodVoidDef extends $ZodTypeDef {
  type: "void";
}
interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
  def: $ZodVoidDef;
  isst: $ZodIssueInvalidType;
}
interface $ZodVoid extends $ZodType {
  _zod: $ZodVoidInternals;
}
declare const $ZodVoid: $constructor<$ZodVoid>;
interface $ZodDateDef extends $ZodTypeDef {
  type: "date";
  coerce?: boolean;
}
interface $ZodDateInternals<T$1 = unknown> extends $ZodTypeInternals<Date, T$1> {
  def: $ZodDateDef;
  isst: $ZodIssueInvalidType;
  bag: LoosePartial<{
    minimum: Date;
    maximum: Date;
    format: string;
  }>;
}
interface $ZodDate<T$1 = unknown> extends $ZodType {
  _zod: $ZodDateInternals<T$1>;
}
declare const $ZodDate: $constructor<$ZodDate>;
interface $ZodArrayDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "array";
  element: T$1;
}
interface $ZodArrayInternals<T$1 extends SomeType = $ZodType> extends _$ZodTypeInternals {
  def: $ZodArrayDef<T$1>;
  isst: $ZodIssueInvalidType;
  output: output<T$1>[];
  input: input<T$1>[];
}
interface $ZodArray<T$1 extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T$1>> {}
declare const $ZodArray: $constructor<$ZodArray>;
type OptionalOutSchema = {
  _zod: {
    optout: "optional";
  };
};
type OptionalInSchema = {
  _zod: {
    optin: "optional";
  };
};
type $InferObjectOutput<T$1 extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T$1 ? IsAny$1<T$1[keyof T$1]> extends true ? Record<string, unknown> : Record<string, output<T$1[keyof T$1]>> : keyof (T$1 & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T$1 as T$1[k] extends OptionalOutSchema ? never : k]: T$1[k]["_zod"]["output"] } & { -readonly [k in keyof T$1 as T$1[k] extends OptionalOutSchema ? k : never]?: T$1[k]["_zod"]["output"] } & Extra>;
type $InferObjectInput<T$1 extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T$1 ? IsAny$1<T$1[keyof T$1]> extends true ? Record<string, unknown> : Record<string, input<T$1[keyof T$1]>> : keyof (T$1 & Extra) extends never ? Record<string, never> : Prettify<{ -readonly [k in keyof T$1 as T$1[k] extends OptionalInSchema ? never : k]: T$1[k]["_zod"]["input"] } & { -readonly [k in keyof T$1 as T$1[k] extends OptionalInSchema ? k : never]?: T$1[k]["_zod"]["input"] } & Extra>;
type $ZodObjectConfig = {
  out: Record<string, unknown>;
  in: Record<string, unknown>;
};
type $loose = {
  out: Record<string, unknown>;
  in: Record<string, unknown>;
};
type $strict = {
  out: {};
  in: {};
};
type $strip = {
  out: {};
  in: {};
};
type $catchall<T$1 extends SomeType> = {
  out: {
    [k: string]: output<T$1>;
  };
  in: {
    [k: string]: input<T$1>;
  };
};
type $ZodShape = Readonly<{
  [k: string]: $ZodType;
}>;
interface $ZodObjectDef<Shape$1 extends $ZodShape = $ZodShape> extends $ZodTypeDef {
  type: "object";
  shape: Shape$1;
  catchall?: $ZodType | undefined;
}
interface $ZodObjectInternals< /** @ts-ignore Cast variance */
out Shape$1 extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
  def: $ZodObjectDef<Shape$1>;
  config: Config;
  isst: $ZodIssueInvalidType | $ZodIssueUnrecognizedKeys;
  propValues: PropValues;
  output: $InferObjectOutput<Shape$1, Config["out"]>;
  input: $InferObjectInput<Shape$1, Config["in"]>;
  optin?: "optional" | undefined;
  optout?: "optional" | undefined;
}
type $ZodLooseShape = Record<string, any>;
interface $ZodObject< /** @ts-ignore Cast variance */
out Shape$1 extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params$1 extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape$1, Params$1>> {}
declare const $ZodObject: $constructor<$ZodObject>;
type $InferUnionOutput<T$1 extends SomeType> = T$1 extends any ? output<T$1> : never;
type $InferUnionInput<T$1 extends SomeType> = T$1 extends any ? input<T$1> : never;
interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
  type: "union";
  options: Options;
  inclusive?: boolean;
}
type IsOptionalIn<T$1 extends SomeType> = T$1 extends OptionalInSchema ? true : false;
type IsOptionalOut<T$1 extends SomeType> = T$1 extends OptionalOutSchema ? true : false;
interface $ZodUnionInternals<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
  def: $ZodUnionDef<T$1>;
  isst: $ZodIssueInvalidUnion;
  pattern: T$1[number]["_zod"]["pattern"];
  values: T$1[number]["_zod"]["values"];
  output: $InferUnionOutput<T$1[number]>;
  input: $InferUnionInput<T$1[number]>;
  optin: IsOptionalIn<T$1[number]> extends false ? "optional" | undefined : "optional";
  optout: IsOptionalOut<T$1[number]> extends false ? "optional" | undefined : "optional";
}
interface $ZodUnion<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T$1>> {
  _zod: $ZodUnionInternals<T$1>;
}
declare const $ZodUnion: $constructor<$ZodUnion>;
interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
  discriminator: Disc;
  unionFallback?: boolean;
}
interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
  def: $ZodDiscriminatedUnionDef<Options, Disc>;
  propValues: PropValues;
}
interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
}
declare const $ZodDiscriminatedUnion: $constructor<$ZodDiscriminatedUnion>;
interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "intersection";
  left: Left;
  right: Right;
}
interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
  def: $ZodIntersectionDef<A, B>;
  isst: never;
  optin: A["_zod"]["optin"] | B["_zod"]["optin"];
  optout: A["_zod"]["optout"] | B["_zod"]["optout"];
  output: output<A> & output<B>;
  input: input<A> & input<B>;
}
interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodIntersectionInternals<A, B>;
}
declare const $ZodIntersection: $constructor<$ZodIntersection>;
interface $ZodTupleDef<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
  type: "tuple";
  items: T$1;
  rest: Rest$1;
}
type $InferTupleInputType<T$1 extends TupleItems, Rest$1 extends SomeType | null> = [...TupleInputTypeWithOptionals<T$1>, ...(Rest$1 extends SomeType ? input<Rest$1>[] : [])];
type TupleInputTypeNoOptionals<T$1 extends TupleItems> = { [k in keyof T$1]: input<T$1[k]> };
type TupleInputTypeWithOptionals<T$1 extends TupleItems> = T$1 extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, input<Tail>?] : TupleInputTypeNoOptionals<T$1> : [];
type $InferTupleOutputType<T$1 extends TupleItems, Rest$1 extends SomeType | null> = [...TupleOutputTypeWithOptionals<T$1>, ...(Rest$1 extends SomeType ? output<Rest$1>[] : [])];
type TupleOutputTypeNoOptionals<T$1 extends TupleItems> = { [k in keyof T$1]: output<T$1[k]> };
type TupleOutputTypeWithOptionals<T$1 extends TupleItems> = T$1 extends readonly [...infer Prefix extends SomeType[], infer Tail extends SomeType] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, output<Tail>?] : TupleOutputTypeNoOptionals<T$1> : [];
interface $ZodTupleInternals<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
  def: $ZodTupleDef<T$1, Rest$1>;
  isst: $ZodIssueInvalidType | $ZodIssueTooBig<unknown[]> | $ZodIssueTooSmall<unknown[]>;
  output: $InferTupleOutputType<T$1, Rest$1>;
  input: $InferTupleInputType<T$1, Rest$1>;
}
interface $ZodTuple<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends $ZodType {
  _zod: $ZodTupleInternals<T$1, Rest$1>;
}
declare const $ZodTuple: $constructor<$ZodTuple>;
type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
interface $ZodRecordDef<Key$1 extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "record";
  keyType: Key$1;
  valueType: Value;
  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
  mode?: "strict" | "loose";
}
type $InferZodRecordOutput<Key$1 extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key$1 extends $partial ? Partial<Record<output<Key$1>, output<Value>>> : Record<output<Key$1>, output<Value>>;
type $InferZodRecordInput<Key$1 extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key$1 extends $partial ? Partial<Record<input<Key$1> & PropertyKey, input<Value>>> : Record<input<Key$1> & PropertyKey, input<Value>>;
interface $ZodRecordInternals<Key$1 extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key$1, Value>, $InferZodRecordInput<Key$1, Value>> {
  def: $ZodRecordDef<Key$1, Value>;
  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
  optin?: "optional" | undefined;
  optout?: "optional" | undefined;
}
type $partial = {
  "~~partial": true;
};
interface $ZodRecord<Key$1 extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodRecordInternals<Key$1, Value>;
}
declare const $ZodRecord: $constructor<$ZodRecord>;
interface $ZodMapDef<Key$1 extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "map";
  keyType: Key$1;
  valueType: Value;
}
interface $ZodMapInternals<Key$1 extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<output<Key$1>, output<Value>>, Map<input<Key$1>, input<Value>>> {
  def: $ZodMapDef<Key$1, Value>;
  isst: $ZodIssueInvalidType | $ZodIssueInvalidKey | $ZodIssueInvalidElement<unknown>;
  optin?: "optional" | undefined;
  optout?: "optional" | undefined;
}
interface $ZodMap<Key$1 extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodMapInternals<Key$1, Value>;
}
declare const $ZodMap: $constructor<$ZodMap>;
interface $ZodSetDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "set";
  valueType: T$1;
}
interface $ZodSetInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<Set<output<T$1>>, Set<input<T$1>>> {
  def: $ZodSetDef<T$1>;
  isst: $ZodIssueInvalidType;
  optin?: "optional" | undefined;
  optout?: "optional" | undefined;
}
interface $ZodSet<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodSetInternals<T$1>;
}
declare const $ZodSet: $constructor<$ZodSet>;
type $InferEnumOutput<T$1 extends EnumLike> = T$1[keyof T$1] & {};
type $InferEnumInput<T$1 extends EnumLike> = T$1[keyof T$1] & {};
interface $ZodEnumDef<T$1 extends EnumLike = EnumLike> extends $ZodTypeDef {
  type: "enum";
  entries: T$1;
}
interface $ZodEnumInternals< /** @ts-ignore Cast variance */
out T$1 extends EnumLike = EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T$1>, $InferEnumInput<T$1>> {
  def: $ZodEnumDef<T$1>;
  /** @deprecated Internal API, use with caution (not deprecated) */
  values: PrimitiveSet;
  /** @deprecated Internal API, use with caution (not deprecated) */
  pattern: RegExp;
  isst: $ZodIssueInvalidValue;
}
interface $ZodEnum<T$1 extends EnumLike = EnumLike> extends $ZodType {
  _zod: $ZodEnumInternals<T$1>;
}
declare const $ZodEnum: $constructor<$ZodEnum>;
interface $ZodLiteralDef<T$1 extends Literal> extends $ZodTypeDef {
  type: "literal";
  values: T$1[];
}
interface $ZodLiteralInternals<T$1 extends Literal = Literal> extends $ZodTypeInternals<T$1, T$1> {
  def: $ZodLiteralDef<T$1>;
  values: Set<T$1>;
  pattern: RegExp;
  isst: $ZodIssueInvalidValue;
}
interface $ZodLiteral<T$1 extends Literal = Literal> extends $ZodType {
  _zod: $ZodLiteralInternals<T$1>;
}
declare const $ZodLiteral: $constructor<$ZodLiteral>;
type _File = typeof globalThis extends {
  File: infer F extends new (...args: any[]) => any;
} ? InstanceType<F> : {};
/** Do not reference this directly. */
interface File extends _File {
  readonly type: string;
  readonly size: number;
}
interface $ZodFileDef extends $ZodTypeDef {
  type: "file";
}
interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
  def: $ZodFileDef;
  isst: $ZodIssueInvalidType;
  bag: LoosePartial<{
    minimum: number;
    maximum: number;
    mime: MimeTypes[];
  }>;
}
interface $ZodFile extends $ZodType {
  _zod: $ZodFileInternals;
}
declare const $ZodFile: $constructor<$ZodFile>;
interface $ZodTransformDef extends $ZodTypeDef {
  type: "transform";
  transform: (input: unknown, payload: ParsePayload<unknown>) => MaybeAsync<unknown>;
}
interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
  def: $ZodTransformDef;
  isst: never;
}
interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
  _zod: $ZodTransformInternals<O, I>;
}
declare const $ZodTransform: $constructor<$ZodTransform>;
interface $ZodOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "optional";
  innerType: T$1;
}
interface $ZodOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1> | undefined, input<T$1> | undefined> {
  def: $ZodOptionalDef<T$1>;
  optin: "optional";
  optout: "optional";
  isst: never;
  values: T$1["_zod"]["values"];
  pattern: T$1["_zod"]["pattern"];
}
interface $ZodOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodOptionalInternals<T$1>;
}
declare const $ZodOptional: $constructor<$ZodOptional>;
interface $ZodExactOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodOptionalDef<T$1> {}
interface $ZodExactOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodOptionalInternals<T$1> {
  def: $ZodExactOptionalDef<T$1>;
  output: output<T$1>;
  input: input<T$1>;
}
interface $ZodExactOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodExactOptionalInternals<T$1>;
}
declare const $ZodExactOptional: $constructor<$ZodExactOptional>;
interface $ZodNullableDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "nullable";
  innerType: T$1;
}
interface $ZodNullableInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1> | null, input<T$1> | null> {
  def: $ZodNullableDef<T$1>;
  optin: T$1["_zod"]["optin"];
  optout: T$1["_zod"]["optout"];
  isst: never;
  values: T$1["_zod"]["values"];
  pattern: T$1["_zod"]["pattern"];
}
interface $ZodNullable<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodNullableInternals<T$1>;
}
declare const $ZodNullable: $constructor<$ZodNullable>;
interface $ZodDefaultDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "default";
  innerType: T$1;
  /** The default value. May be a getter. */
  defaultValue: NoUndefined<output<T$1>>;
}
interface $ZodDefaultInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, input<T$1> | undefined> {
  def: $ZodDefaultDef<T$1>;
  optin: "optional";
  optout?: "optional" | undefined;
  isst: never;
  values: T$1["_zod"]["values"];
}
interface $ZodDefault<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodDefaultInternals<T$1>;
}
declare const $ZodDefault: $constructor<$ZodDefault>;
interface $ZodPrefaultDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "prefault";
  innerType: T$1;
  /** The default value. May be a getter. */
  defaultValue: input<T$1>;
}
interface $ZodPrefaultInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, input<T$1> | undefined> {
  def: $ZodPrefaultDef<T$1>;
  optin: "optional";
  optout?: "optional" | undefined;
  isst: never;
  values: T$1["_zod"]["values"];
}
interface $ZodPrefault<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodPrefaultInternals<T$1>;
}
declare const $ZodPrefault: $constructor<$ZodPrefault>;
interface $ZodNonOptionalDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "nonoptional";
  innerType: T$1;
}
interface $ZodNonOptionalInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<NoUndefined<output<T$1>>, NoUndefined<input<T$1>>> {
  def: $ZodNonOptionalDef<T$1>;
  isst: $ZodIssueInvalidType;
  values: T$1["_zod"]["values"];
  optin: "optional" | undefined;
  optout: "optional" | undefined;
}
interface $ZodNonOptional<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodNonOptionalInternals<T$1>;
}
declare const $ZodNonOptional: $constructor<$ZodNonOptional>;
interface $ZodSuccessDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "success";
  innerType: T$1;
}
interface $ZodSuccessInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, input<T$1>> {
  def: $ZodSuccessDef<T$1>;
  isst: never;
  optin: T$1["_zod"]["optin"];
  optout: "optional" | undefined;
}
interface $ZodSuccess<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodSuccessInternals<T$1>;
}
declare const $ZodSuccess: $constructor<$ZodSuccess>;
interface $ZodCatchCtx extends ParsePayload {
  /** @deprecated Use `ctx.issues` */
  error: {
    issues: $ZodIssue[];
  };
  /** @deprecated Use `ctx.value` */
  input: unknown;
}
interface $ZodCatchDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "catch";
  innerType: T$1;
  catchValue: (ctx: $ZodCatchCtx) => unknown;
}
interface $ZodCatchInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1>, input<T$1>> {
  def: $ZodCatchDef<T$1>;
  optin: T$1["_zod"]["optin"];
  optout: T$1["_zod"]["optout"];
  isst: never;
  values: T$1["_zod"]["values"];
}
interface $ZodCatch<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodCatchInternals<T$1>;
}
declare const $ZodCatch: $constructor<$ZodCatch>;
interface $ZodNaNDef extends $ZodTypeDef {
  type: "nan";
}
interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
  def: $ZodNaNDef;
  isst: $ZodIssueInvalidType;
}
interface $ZodNaN extends $ZodType {
  _zod: $ZodNaNInternals;
}
declare const $ZodNaN: $constructor<$ZodNaN>;
interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "pipe";
  in: A;
  out: B;
  /** Only defined inside $ZodCodec instances. */
  transform?: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
  /** Only defined inside $ZodCodec instances. */
  reverseTransform?: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
}
interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<output<B>, input<A>> {
  def: $ZodPipeDef<A, B>;
  isst: never;
  values: A["_zod"]["values"];
  optin: A["_zod"]["optin"];
  optout: B["_zod"]["optout"];
  propValues: A["_zod"]["propValues"];
}
interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodPipeInternals<A, B>;
}
declare const $ZodPipe: $constructor<$ZodPipe>;
interface $ZodReadonlyDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "readonly";
  innerType: T$1;
}
interface $ZodReadonlyInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<MakeReadonly<output<T$1>>, MakeReadonly<input<T$1>>> {
  def: $ZodReadonlyDef<T$1>;
  optin: T$1["_zod"]["optin"];
  optout: T$1["_zod"]["optout"];
  isst: never;
  propValues: T$1["_zod"]["propValues"];
  values: T$1["_zod"]["values"];
}
interface $ZodReadonly<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodReadonlyInternals<T$1>;
}
declare const $ZodReadonly: $constructor<$ZodReadonly>;
interface $ZodTemplateLiteralDef extends $ZodTypeDef {
  type: "template_literal";
  parts: $ZodTemplateLiteralPart[];
  format?: string | undefined;
}
interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
  pattern: RegExp;
  def: $ZodTemplateLiteralDef;
  isst: $ZodIssueInvalidType;
}
interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
  _zod: $ZodTemplateLiteralInternals<Template>;
}
type LiteralPart = Exclude<Literal, symbol>;
interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
  pattern: RegExp;
}
interface SchemaPart extends $ZodType {
  _zod: SchemaPartInternals;
}
type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
declare const $ZodTemplateLiteral: $constructor<$ZodTemplateLiteral>;
type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
type $ZodFunctionIn = $ZodFunctionArgs;
type $ZodFunctionOut = $ZodType;
type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => input<Returns>;
type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : output<Args>) => MaybeAsync<input<Returns>>;
type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => output<Returns>;
type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : input<Args>) => Promise<output<Returns>>;
interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
  type: "function";
  input: In;
  output: Out;
}
interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
  def: $ZodFunctionDef<Args, Returns>;
  isst: $ZodIssueInvalidType;
}
interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
  /** @deprecated */
  _def: $ZodFunctionDef<Args, Returns>;
  _input: $InferInnerFunctionType<Args, Returns>;
  _output: $InferOuterFunctionType<Args, Returns>;
  implement<F$1 extends $InferInnerFunctionType<Args, Returns>>(func: F$1): (...args: Parameters<this["_output"]>) => ReturnType<F$1> extends ReturnType<this["_output"]> ? ReturnType<F$1> : ReturnType<this["_output"]>;
  implementAsync<F$1 extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F$1): F$1 extends $InferOuterFunctionTypeAsync<Args, Returns> ? F$1 : $InferOuterFunctionTypeAsync<Args, Returns>;
  input<const Items extends TupleItems, const Rest$1 extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest$1): $ZodFunction<$ZodTuple<Items, Rest$1>, Returns>;
  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
  input(...args: any[]): $ZodFunction<any, Returns>;
  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
}
declare const $ZodFunction: $constructor<$ZodFunction>;
interface $ZodPromiseDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "promise";
  innerType: T$1;
}
interface $ZodPromiseInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<output<T$1>>, MaybeAsync<input<T$1>>> {
  def: $ZodPromiseDef<T$1>;
  isst: never;
}
interface $ZodPromise<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodPromiseInternals<T$1>;
}
declare const $ZodPromise: $constructor<$ZodPromise>;
interface $ZodLazyDef<T$1 extends SomeType = $ZodType> extends $ZodTypeDef {
  type: "lazy";
  getter: () => T$1;
}
interface $ZodLazyInternals<T$1 extends SomeType = $ZodType> extends $ZodTypeInternals<output<T$1>, input<T$1>> {
  def: $ZodLazyDef<T$1>;
  isst: never;
  /** Auto-cached way to retrieve the inner schema */
  innerType: T$1;
  pattern: T$1["_zod"]["pattern"];
  propValues: T$1["_zod"]["propValues"];
  optin: T$1["_zod"]["optin"];
  optout: T$1["_zod"]["optout"];
}
interface $ZodLazy<T$1 extends SomeType = $ZodType> extends $ZodType {
  _zod: $ZodLazyInternals<T$1>;
}
declare const $ZodLazy: $constructor<$ZodLazy>;
interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, $ZodCheckDef {
  type: "custom";
  check: "custom";
  path?: PropertyKey[] | undefined;
  error?: $ZodErrorMap | undefined;
  params?: Record<string, any> | undefined;
  fn: (arg: O) => unknown;
}
interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, $ZodCheckInternals<O> {
  def: $ZodCustomDef;
  issc: $ZodIssue;
  isst: never;
  bag: LoosePartial<{
    Class: typeof Class;
  }>;
}
interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
  _zod: $ZodCustomInternals<O, I>;
}
declare const $ZodCustom: $constructor<$ZodCustom>;
type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.d.cts
interface $ZodCheckDef {
  check: string;
  error?: $ZodErrorMap<never> | undefined;
  /** If true, no later checks will be executed if this check fails. Default `false`. */
  abort?: boolean | undefined;
  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
  when?: ((payload: ParsePayload) => boolean) | undefined;
}
interface $ZodCheckInternals<T$1> {
  def: $ZodCheckDef;
  /** The set of issues this check might throw. */
  issc?: $ZodIssueBase;
  check(payload: ParsePayload<T$1>): MaybeAsync<void>;
  onattach: ((schema: $ZodType) => void)[];
}
interface $ZodCheck<in T$1 = never> {
  _zod: $ZodCheckInternals<T$1>;
}
declare const $ZodCheck: $constructor<$ZodCheck<any>>;
interface $ZodCheckLessThanDef extends $ZodCheckDef {
  check: "less_than";
  value: Numeric;
  inclusive: boolean;
}
interface $ZodCheckLessThanInternals<T$1 extends Numeric = Numeric> extends $ZodCheckInternals<T$1> {
  def: $ZodCheckLessThanDef;
  issc: $ZodIssueTooBig<T$1>;
}
interface $ZodCheckLessThan<T$1 extends Numeric = Numeric> extends $ZodCheck<T$1> {
  _zod: $ZodCheckLessThanInternals<T$1>;
}
declare const $ZodCheckLessThan: $constructor<$ZodCheckLessThan>;
interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
  check: "greater_than";
  value: Numeric;
  inclusive: boolean;
}
interface $ZodCheckGreaterThanInternals<T$1 extends Numeric = Numeric> extends $ZodCheckInternals<T$1> {
  def: $ZodCheckGreaterThanDef;
  issc: $ZodIssueTooSmall<T$1>;
}
interface $ZodCheckGreaterThan<T$1 extends Numeric = Numeric> extends $ZodCheck<T$1> {
  _zod: $ZodCheckGreaterThanInternals<T$1>;
}
declare const $ZodCheckGreaterThan: $constructor<$ZodCheckGreaterThan>;
interface $ZodCheckMultipleOfDef<T$1 extends number | bigint = number | bigint> extends $ZodCheckDef {
  check: "multiple_of";
  value: T$1;
}
interface $ZodCheckMultipleOfInternals<T$1 extends number | bigint = number | bigint> extends $ZodCheckInternals<T$1> {
  def: $ZodCheckMultipleOfDef<T$1>;
  issc: $ZodIssueNotMultipleOf;
}
interface $ZodCheckMultipleOf<T$1 extends number | bigint = number | bigint> extends $ZodCheck<T$1> {
  _zod: $ZodCheckMultipleOfInternals<T$1>;
}
declare const $ZodCheckMultipleOf: $constructor<$ZodCheckMultipleOf<number | bigint>>;
type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
interface $ZodCheckNumberFormatDef extends $ZodCheckDef {
  check: "number_format";
  format: $ZodNumberFormats;
}
interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {
  def: $ZodCheckNumberFormatDef;
  issc: $ZodIssueInvalidType | $ZodIssueTooBig<"number"> | $ZodIssueTooSmall<"number">;
}
interface $ZodCheckNumberFormat extends $ZodCheck<number> {
  _zod: $ZodCheckNumberFormatInternals;
}
declare const $ZodCheckNumberFormat: $constructor<$ZodCheckNumberFormat>;
interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
  check: "max_length";
  maximum: number;
}
interface $ZodCheckMaxLengthInternals<T$1 extends HasLength = HasLength> extends $ZodCheckInternals<T$1> {
  def: $ZodCheckMaxLengthDef;
  issc: $ZodIssueTooBig<T$1>;
}
interface $ZodCheckMaxLength<T$1 extends HasLength = HasLength> extends $ZodCheck<T$1> {
  _zod: $ZodCheckMaxLengthInternals<T$1>;
}
declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
interface $ZodCheckMinLengthDef extends $ZodCheckDef {
  check: "min_length";
  minimum: number;
}
interface $ZodCheckMinLengthInternals<T$1 extends HasLength = HasLength> extends $ZodCheckInternals<T$1> {
  def: $ZodCheckMinLengthDef;
  issc: $ZodIssueTooSmall<T$1>;
}
interface $ZodCheckMinLength<T$1 extends HasLength = HasLength> extends $ZodCheck<T$1> {
  _zod: $ZodCheckMinLengthInternals<T$1>;
}
declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
  check: "length_equals";
  length: number;
}
interface $ZodCheckLengthEqualsInternals<T$1 extends HasLength = HasLength> extends $ZodCheckInternals<T$1> {
  def: $ZodCheckLengthEqualsDef;
  issc: $ZodIssueTooBig<T$1> | $ZodIssueTooSmall<T$1>;
}
interface $ZodCheckLengthEquals<T$1 extends HasLength = HasLength> extends $ZodCheck<T$1> {
  _zod: $ZodCheckLengthEqualsInternals<T$1>;
}
declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
  check: "string_format";
  format: Format;
  pattern?: RegExp | undefined;
}
interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckStringFormatDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
  format: "regex";
  pattern: RegExp;
}
interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckRegexDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckRegex extends $ZodCheck<string> {
  _zod: $ZodCheckRegexInternals;
}
declare const $ZodCheckRegex: $constructor<$ZodCheckRegex>;
interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {}
interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckLowerCaseDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckLowerCase extends $ZodCheck<string> {
  _zod: $ZodCheckLowerCaseInternals;
}
declare const $ZodCheckLowerCase: $constructor<$ZodCheckLowerCase>;
interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {}
interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckUpperCaseDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckUpperCase extends $ZodCheck<string> {
  _zod: $ZodCheckUpperCaseInternals;
}
declare const $ZodCheckUpperCase: $constructor<$ZodCheckUpperCase>;
interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
  includes: string;
  position?: number | undefined;
}
interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckIncludesDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckIncludes extends $ZodCheck<string> {
  _zod: $ZodCheckIncludesInternals;
}
declare const $ZodCheckIncludes: $constructor<$ZodCheckIncludes>;
interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
  prefix: string;
}
interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckStartsWithDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckStartsWith extends $ZodCheck<string> {
  _zod: $ZodCheckStartsWithInternals;
}
declare const $ZodCheckStartsWith: $constructor<$ZodCheckStartsWith>;
interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
  suffix: string;
}
interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
  def: $ZodCheckEndsWithDef;
  issc: $ZodIssueInvalidStringFormat;
}
interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
  _zod: $ZodCheckEndsWithInternals;
}
declare const $ZodCheckEndsWith: $constructor<$ZodCheckEndsWith>;
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.d.cts
interface $ZodIssueBase {
  readonly code?: string;
  readonly input?: unknown;
  readonly path: PropertyKey[];
  readonly message: string;
}
type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
  readonly code: "invalid_type";
  readonly expected: $ZodInvalidTypeExpected;
  readonly input?: Input;
}
interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
  readonly code: "too_big";
  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
  readonly maximum: number | bigint;
  readonly inclusive?: boolean;
  readonly exact?: boolean;
  readonly input?: Input;
}
interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
  readonly code: "too_small";
  readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
  readonly minimum: number | bigint;
  /** True if the allowable range includes the minimum */
  readonly inclusive?: boolean;
  /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
  readonly exact?: boolean;
  readonly input?: Input;
}
interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
  readonly code: "invalid_format";
  readonly format: $ZodStringFormats | (string & {});
  readonly pattern?: string;
  readonly input?: string;
}
interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
  readonly code: "not_multiple_of";
  readonly divisor: number;
  readonly input?: Input;
}
interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
  readonly code: "unrecognized_keys";
  readonly keys: string[];
  readonly input?: Record<string, unknown>;
}
interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
  readonly code: "invalid_union";
  readonly errors: $ZodIssue[][];
  readonly input?: unknown;
  readonly discriminator?: string | undefined;
  readonly inclusive?: true;
}
interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
  readonly code: "invalid_union";
  readonly errors: [];
  readonly input?: unknown;
  readonly discriminator?: string | undefined;
  readonly inclusive: false;
}
type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
  readonly code: "invalid_key";
  readonly origin: "map" | "record";
  readonly issues: $ZodIssue[];
  readonly input?: Input;
}
interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
  readonly code: "invalid_element";
  readonly origin: "map" | "set";
  readonly key: unknown;
  readonly issues: $ZodIssue[];
  readonly input?: Input;
}
interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
  readonly code: "invalid_value";
  readonly values: Primitive$1[];
  readonly input?: Input;
}
interface $ZodIssueCustom extends $ZodIssueBase {
  readonly code: "custom";
  readonly params?: Record<string, any> | undefined;
  readonly input?: unknown;
}
type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
type $ZodInternalIssue<T$1 extends $ZodIssueBase = $ZodIssue> = T$1 extends any ? RawIssue$1<T$1> : never;
type RawIssue$1<T$1 extends $ZodIssueBase> = T$1 extends any ? Flatten<MakePartial<T$1, "message" | "path"> & {
  /** The input data */
  readonly input: unknown;
  /** The schema or check that originated this issue. */
  readonly inst?: $ZodType | $ZodCheck;
  /** If `true`, Zod will continue executing checks/refinements after this issue. */
  readonly continue?: boolean | undefined;
} & Record<string, unknown>> : never;
type $ZodRawIssue<T$1 extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T$1>;
interface $ZodErrorMap<T$1 extends $ZodIssueBase = $ZodIssue> {
  (issue: $ZodRawIssue<T$1>): {
    message: string;
  } | string | undefined | null;
}
interface $ZodError<T$1 = unknown> extends Error {
  type: T$1;
  issues: $ZodIssue[];
  _zod: {
    output: T$1;
    def: $ZodIssue[];
  };
  stack?: string;
  name: string;
}
declare const $ZodError: $constructor<$ZodError>;
type $ZodFlattenedError<T$1, U$1 = string> = _FlattenedError<T$1, U$1>;
type _FlattenedError<T$1, U$1 = string> = {
  formErrors: U$1[];
  fieldErrors: { [P in keyof T$1]?: U$1[] };
};
type _ZodFormattedError<T$1, U$1 = string> = T$1 extends [any, ...any[]] ? { [K in keyof T$1]?: $ZodFormattedError<T$1[K], U$1> } : T$1 extends any[] ? {
  [k: number]: $ZodFormattedError<T$1[number], U$1>;
} : T$1 extends object ? Flatten<{ [K in keyof T$1]?: $ZodFormattedError<T$1[K], U$1> }> : any;
type $ZodFormattedError<T$1, U$1 = string> = {
  _errors: U$1[];
} & Flatten<_ZodFormattedError<T$1, U$1>>;
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.d.cts
type ZodTrait = {
  _zod: {
    def: any;
    [k: string]: any;
  };
};
interface $constructor<T$1 extends ZodTrait, D = T$1["_zod"]["def"]> {
  new (def: D): T$1;
  init(inst: T$1, def: D): asserts inst is T$1;
}
declare function $constructor<T$1 extends ZodTrait, D = T$1["_zod"]["def"]>(name: string, initializer: (inst: T$1, def: D) => void, params?: {
  Parent?: typeof Class;
}): $constructor<T$1, D>;
declare const $brand: unique symbol;
type $brand<T$1 extends string | number | symbol = string | number | symbol> = {
  [$brand]: { [k in T$1]: true };
};
type $ZodBranded<T$1 extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T$1 & (Dir extends "inout" ? {
  _zod: {
    input: input<T$1> & $brand<Brand>;
    output: output<T$1> & $brand<Brand>;
  };
} : Dir extends "in" ? {
  _zod: {
    input: input<T$1> & $brand<Brand>;
  };
} : {
  _zod: {
    output: output<T$1> & $brand<Brand>;
  };
});
type input<T$1> = T$1 extends {
  _zod: {
    input: any;
  };
} ? T$1["_zod"]["input"] : unknown;
type output<T$1> = T$1 extends {
  _zod: {
    output: any;
  };
} ? T$1["_zod"]["output"] : unknown;
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.d.cts
type Params<T$1 extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T$1["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T$1["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
  error?: string | $ZodErrorMap<IssueTypes> | undefined;
  /** @deprecated This parameter is deprecated. Use `error` instead. */
  message?: string | undefined;
})>>>;
type TypeParams<T$1 extends $ZodType = $ZodType & {
  _isst: never;
}, AlsoOmit extends Exclude<keyof T$1["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T$1, NonNullable<T$1["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
type CheckParams<T$1 extends $ZodCheck = $ZodCheck,
// & { _issc: never },
AlsoOmit extends Exclude<keyof T$1["_zod"]["def"], "check" | "error"> = never> = Params<T$1, NonNullable<T$1["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
type CheckStringFormatParams<T$1 extends $ZodStringFormat = $ZodStringFormat, AlsoOmit extends Exclude<keyof T$1["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T$1, NonNullable<T$1["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
type CheckTypeParams<T$1 extends $ZodType & $ZodCheck = $ZodType & $ZodCheck, AlsoOmit extends Exclude<keyof T$1["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T$1, NonNullable<T$1["_zod"]["isst"] | T$1["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
type $ZodCheckEmailParams = CheckStringFormatParams<$ZodEmail, "when">;
type $ZodCheckGUIDParams = CheckStringFormatParams<$ZodGUID, "pattern" | "when">;
type $ZodCheckUUIDParams = CheckStringFormatParams<$ZodUUID, "pattern" | "when">;
type $ZodCheckURLParams = CheckStringFormatParams<$ZodURL, "when">;
type $ZodCheckEmojiParams = CheckStringFormatParams<$ZodEmoji, "when">;
type $ZodCheckNanoIDParams = CheckStringFormatParams<$ZodNanoID, "when">;
type $ZodCheckCUIDParams = CheckStringFormatParams<$ZodCUID, "when">;
type $ZodCheckCUID2Params = CheckStringFormatParams<$ZodCUID2, "when">;
type $ZodCheckULIDParams = CheckStringFormatParams<$ZodULID, "when">;
type $ZodCheckXIDParams = CheckStringFormatParams<$ZodXID, "when">;
type $ZodCheckKSUIDParams = CheckStringFormatParams<$ZodKSUID, "when">;
type $ZodCheckIPv4Params = CheckStringFormatParams<$ZodIPv4, "pattern" | "when" | "version">;
type $ZodCheckIPv6Params = CheckStringFormatParams<$ZodIPv6, "pattern" | "when" | "version">;
type $ZodCheckCIDRv4Params = CheckStringFormatParams<$ZodCIDRv4, "pattern" | "when">;
type $ZodCheckCIDRv6Params = CheckStringFormatParams<$ZodCIDRv6, "pattern" | "when">;
type $ZodCheckBase64Params = CheckStringFormatParams<$ZodBase64, "pattern" | "when">;
type $ZodCheckBase64URLParams = CheckStringFormatParams<$ZodBase64URL, "pattern" | "when">;
type $ZodCheckE164Params = CheckStringFormatParams<$ZodE164, "when">;
type $ZodCheckJWTParams = CheckStringFormatParams<$ZodJWT, "pattern" | "when">;
type $ZodCheckISODateTimeParams = CheckStringFormatParams<$ZodISODateTime, "pattern" | "when">;
type $ZodCheckISODateParams = CheckStringFormatParams<$ZodISODate, "pattern" | "when">;
type $ZodCheckISOTimeParams = CheckStringFormatParams<$ZodISOTime, "pattern" | "when">;
type $ZodCheckISODurationParams = CheckStringFormatParams<$ZodISODuration, "when">;
type $ZodCheckNumberFormatParams = CheckParams<$ZodCheckNumberFormat, "format" | "when">;
type $ZodCheckLessThanParams = CheckParams<$ZodCheckLessThan, "inclusive" | "value" | "when">;
type $ZodCheckGreaterThanParams = CheckParams<$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
type $ZodCheckMultipleOfParams = CheckParams<$ZodCheckMultipleOf, "value" | "when">;
type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
type $ZodCheckRegexParams = CheckParams<$ZodCheckRegex, "format" | "pattern" | "when">;
type $ZodCheckLowerCaseParams = CheckParams<$ZodCheckLowerCase, "format" | "when">;
type $ZodCheckUpperCaseParams = CheckParams<$ZodCheckUpperCase, "format" | "when">;
type $ZodCheckIncludesParams = CheckParams<$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
type $ZodCheckStartsWithParams = CheckParams<$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
type $ZodCheckEndsWithParams = CheckParams<$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
type $ZodEnumParams = TypeParams<$ZodEnum, "entries">;
type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
type $ZodSuperRefineIssue<T$1 extends $ZodIssueBase = $ZodIssue> = T$1 extends any ? RawIssue<T$1> : never;
type RawIssue<T$1 extends $ZodIssueBase> = T$1 extends any ? Flatten<MakePartial<T$1, "message" | "path"> & {
  /** The schema or check that originated this issue. */
  readonly inst?: $ZodType | $ZodCheck;
  /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
  readonly continue?: boolean | undefined;
} & Record<string, unknown>> : never;
interface $RefinementCtx<T$1 = unknown> extends ParsePayload<T$1> {
  addIssue(arg: string | $ZodSuperRefineIssue): void;
}
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.d.cts
/** An Error-like class used to store Zod validation issues.  */
interface ZodError<T$1 = unknown> extends $ZodError<T$1> {
  /** @deprecated Use the `z.treeifyError(err)` function instead. */
  format(): $ZodFormattedError<T$1>;
  format<U$1>(mapper: (issue: $ZodIssue) => U$1): $ZodFormattedError<T$1, U$1>;
  /** @deprecated Use the `z.treeifyError(err)` function instead. */
  flatten(): $ZodFlattenedError<T$1>;
  flatten<U$1>(mapper: (issue: $ZodIssue) => U$1): $ZodFlattenedError<T$1, U$1>;
  /** @deprecated Push directly to `.issues` instead. */
  addIssue(issue: $ZodIssue): void;
  /** @deprecated Push directly to `.issues` instead. */
  addIssues(issues: $ZodIssue[]): void;
  /** @deprecated Check `err.issues.length === 0` instead. */
  isEmpty: boolean;
}
declare const ZodError: $constructor<ZodError>;
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.d.cts
type ZodSafeParseResult<T$1> = ZodSafeParseSuccess<T$1> | ZodSafeParseError<T$1>;
type ZodSafeParseSuccess<T$1> = {
  success: true;
  data: T$1;
  error?: never;
};
type ZodSafeParseError<T$1> = {
  success: false;
  data?: never;
  error: ZodError<T$1>;
};
//#endregion
//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.cts
type ZodStandardSchemaWithJSON<T$1> = StandardSchemaWithJSONProps<input<T$1>, output<T$1>>;
interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
  def: Internals["def"];
  type: Internals["def"]["type"];
  /** @deprecated Use `.def` instead. */
  _def: Internals["def"];
  /** @deprecated Use `z.output<typeof schema>` instead. */
  _output: Internals["output"];
  /** @deprecated Use `z.input<typeof schema>` instead. */
  _input: Internals["input"];
  "~standard": ZodStandardSchemaWithJSON<this>;
  /** Converts this schema to a JSON Schema representation. */
  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
  clone(def?: Internals["def"], params?: {
    parent: boolean;
  }): this;
  register<R$1 extends $ZodRegistry>(registry: R$1, ...meta: this extends R$1["_schema"] ? undefined extends R$1["_meta"] ? [$replace<R$1["_meta"], this>?] : [$replace<R$1["_meta"], this>] : ["Incompatible schema"]): this;
  brand<T$1 extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T$1): PropertyKey extends T$1 ? this : $ZodBranded<this, T$1, Dir>;
  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R$1, input<this>> : this;
  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>): this;
  overwrite(fn: (x: output<this>) => output<this>): this;
  optional(): ZodOptional<this>;
  exactOptional(): ZodExactOptional<this>;
  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
  nullable(): ZodNullable<this>;
  nullish(): ZodOptional<ZodNullable<this>>;
  default(def: NoUndefined<output<this>>): ZodDefault<this>;
  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
  prefault(def: () => input<this>): ZodPrefault<this>;
  prefault(def: input<this>): ZodPrefault<this>;
  array(): ZodArray<this>;
  or<T$1 extends SomeType>(option: T$1): ZodUnion<[this, T$1]>;
  and<T$1 extends SomeType>(incoming: T$1): ZodIntersection<this, T$1>;
  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
  catch(def: output<this>): ZodCatch<this>;
  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
  pipe<T$1 extends $ZodType<any, output<this>>>(target: T$1 | $ZodType<any, output<this>>): ZodPipe<this, T$1>;
  readonly(): ZodReadonly<this>;
  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
  describe(description: string): this;
  description?: string;
  /** Returns the metadata associated with this instance in `z.globalRegistry` */
  meta(): $replace<GlobalMeta, this> | undefined;
  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
  meta(data: $replace<GlobalMeta, this>): this;
  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
   *
   * ```ts
   * const schema = z.string().optional();
   * const isOptional = schema.safeParse(undefined).success; // true
   * ```
   */
  isOptional(): boolean;
  /**
   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
   *
   * ```ts
   * const schema = z.string().nullable();
   * const isNullable = schema.safeParse(null).success; // true
   * ```
   */
  isNullable(): boolean;
  apply<T$1>(fn: (schema: this) => T$1): T$1;
}
interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
declare const ZodType: $constructor<ZodType>;
interface _ZodString<T$1 extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T$1> {
  format: string | null;
  minLength: number | null;
  maxLength: number | null;
  regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
  includes(value: string, params?: string | $ZodCheckIncludesParams): this;
  startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
  endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
  nonempty(params?: string | $ZodCheckMinLengthParams): this;
  lowercase(params?: string | $ZodCheckLowerCaseParams): this;
  uppercase(params?: string | $ZodCheckUpperCaseParams): this;
  trim(): this;
  normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
  toLowerCase(): this;
  toUpperCase(): this;
  slugify(): this;
}
/** @internal */
declare const _ZodString: $constructor<_ZodString>;
interface ZodString extends _ZodString<$ZodStringInternals<string>> {
  /** @deprecated Use `z.email()` instead. */
  email(params?: string | $ZodCheckEmailParams): this;
  /** @deprecated Use `z.url()` instead. */
  url(params?: string | $ZodCheckURLParams): this;
  /** @deprecated Use `z.jwt()` instead. */
  jwt(params?: string | $ZodCheckJWTParams): this;
  /** @deprecated Use `z.emoji()` instead. */
  emoji(params?: string | $ZodCheckEmojiParams): this;
  /** @deprecated Use `z.guid()` instead. */
  guid(params?: string | $ZodCheckGUIDParams): this;
  /** @deprecated Use `z.uuid()` instead. */
  uuid(params?: string | $ZodCheckUUIDParams): this;
  /** @deprecated Use `z.uuid()` instead. */
  uuidv4(params?: string | $ZodCheckUUIDParams): this;
  /** @deprecated Use `z.uuid()` instead. */
  uuidv6(params?: string | $ZodCheckUUIDParams): this;
  /** @deprecated Use `z.uuid()` instead. */
  uuidv7(params?: string | $ZodCheckUUIDParams): this;
  /** @deprecated Use `z.nanoid()` instead. */
  nanoid(params?: string | $ZodCheckNanoIDParams): this;
  /** @deprecated Use `z.guid()` instead. */
  guid(params?: string | $ZodCheckGUIDParams): this;
  /** @deprecated Use `z.cuid()` instead. */
  cuid(params?: string | $ZodCheckCUIDParams): this;
  /** @deprecated Use `z.cuid2()` instead. */
  cuid2(params?: string | $ZodCheckCUID2Params): this;
  /** @deprecated Use `z.ulid()` instead. */
  ulid(params?: string | $ZodCheckULIDParams): this;
  /** @deprecated Use `z.base64()` instead. */
  base64(params?: string | $ZodCheckBase64Params): this;
  /** @deprecated Use `z.base64url()` instead. */
  base64url(params?: string | $ZodCheckBase64URLParams): this;
  /** @deprecated Use `z.xid()` instead. */
  xid(params?: string | $ZodCheckXIDParams): this;
  /** @deprecated Use `z.ksuid()` instead. */
  ksuid(params?: string | $ZodCheckKSUIDParams): this;
  /** @deprecated Use `z.ipv4()` instead. */
  ipv4(params?: string | $ZodCheckIPv4Params): this;
  /** @deprecated Use `z.ipv6()` instead. */
  ipv6(params?: string | $ZodCheckIPv6Params): this;
  /** @deprecated Use `z.cidrv4()` instead. */
  cidrv4(params?: string | $ZodCheckCIDRv4Params): this;
  /** @deprecated Use `z.cidrv6()` instead. */
  cidrv6(params?: string | $ZodCheckCIDRv6Params): this;
  /** @deprecated Use `z.e164()` instead. */
  e164(params?: string | $ZodCheckE164Params): this;
  /** @deprecated Use `z.iso.datetime()` instead. */
  datetime(params?: string | $ZodCheckISODateTimeParams): this;
  /** @deprecated Use `z.iso.date()` instead. */
  date(params?: string | $ZodCheckISODateParams): this;
  /** @deprecated Use `z.iso.time()` instead. */
  time(params?: string | $ZodCheckISOTimeParams): this;
  /** @deprecated Use `z.iso.duration()` instead. */
  duration(params?: string | $ZodCheckISODurationParams): this;
}
declare const ZodString: $constructor<ZodString>;
interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
  gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
  /** Identical to .min() */
  gte(value: number, params?: string | $ZodCheckGreaterThanParams): this;
  min(value: number, params?: string | $ZodCheckGreaterThanParams): this;
  lt(value: number, params?: string | $ZodCheckLessThanParams): this;
  /** Identical to .max() */
  lte(value: number, params?: string | $ZodCheckLessThanParams): this;
  max(value: number, params?: string | $ZodCheckLessThanParams): this;
  /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
  int(params?: string | $ZodCheckNumberFormatParams): this;
  /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
  safe(params?: string | $ZodCheckNumberFormatParams): this;
  positive(params?: string | $ZodCheckGreaterThanParams): this;
  nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
  negative(params?: string | $ZodCheckLessThanParams): this;
  nonpositive(params?: string | $ZodCheckLessThanParams): this;
  multipleOf(value: number, params?: string | $ZodCheckMultipleOfParams): this;
  /** @deprecated Use `.multipleOf()` instead. */
  step(value: number, params?: string | $ZodCheckMultipleOfParams): this;
  /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
  finite(params?: unknown): this;
  minValue: number | null;
  maxValue: number | null;
  /** @deprecated Check the `format` property instead.  */
  isInt: boolean;
  /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
  isFinite: boolean;
  format: string | null;
}
interface ZodNumber extends _ZodNumber<$ZodNumberInternals<number>> {}
declare const ZodNumber: $constructor<ZodNumber>;
interface _ZodBoolean<T$1 extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T$1> {}
interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
declare const ZodBoolean: $constructor<ZodBoolean>;
interface ZodUndefined extends _ZodType<$ZodUndefinedInternals> {}
declare const ZodUndefined: $constructor<ZodUndefined>;
interface ZodArray<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T$1>>, $ZodArray<T$1> {
  element: T$1;
  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
  nonempty(params?: string | $ZodCheckMinLengthParams): this;
  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
  unwrap(): T$1;
  "~standard": ZodStandardSchemaWithJSON<this>;
}
declare const ZodArray: $constructor<ZodArray>;
type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output<Ext[K]> extends output<Base[K]> ? input<Ext[K]> extends input<Base[K]> ? Ext[K] : never : never : Ext[K] };
interface ZodObject< /** @ts-ignore Cast variance */
out Shape$1 extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape$1, Config>>, $ZodObject<Shape$1, Config> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  shape: Shape$1;
  keyof(): ZodEnum<ToEnum<keyof Shape$1 & string>>;
  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
  catchall<T$1 extends SomeType>(schema: T$1): ZodObject<Shape$1, $catchall<T$1>>;
  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
  passthrough(): ZodObject<Shape$1, $loose>;
  /** Consider `z.looseObject(A.shape)` instead */
  loose(): ZodObject<Shape$1, $loose>;
  /** Consider `z.strictObject(A.shape)` instead */
  strict(): ZodObject<Shape$1, $strict>;
  /** This is the default behavior. This method call is likely unnecessary. */
  strip(): ZodObject<Shape$1, $strip>;
  extend<U$1 extends $ZodLooseShape>(shape: U$1): ZodObject<Extend<Shape$1, U$1>, Config>;
  safeExtend<U$1 extends $ZodLooseShape>(shape: SafeExtendShape<Shape$1, U$1> & Partial<Record<keyof Shape$1, SomeType>>): ZodObject<Extend<Shape$1, U$1>, Config>;
  /**
   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
   */
  merge<U$1 extends ZodObject>(other: U$1): ZodObject<Extend<Shape$1, U$1["shape"]>, U$1["_zod"]["config"]>;
  pick<M$1 extends Mask$1<keyof Shape$1>>(mask: M$1 & Record<Exclude<keyof M$1, keyof Shape$1>, never>): ZodObject<Flatten<Pick<Shape$1, Extract<keyof Shape$1, keyof M$1>>>, Config>;
  omit<M$1 extends Mask$1<keyof Shape$1>>(mask: M$1 & Record<Exclude<keyof M$1, keyof Shape$1>, never>): ZodObject<Flatten<Omit<Shape$1, Extract<keyof Shape$1, keyof M$1>>>, Config>;
  partial(): ZodObject<{ [k in keyof Shape$1]: ZodOptional<Shape$1[k]> }, Config>;
  partial<M$1 extends Mask$1<keyof Shape$1>>(mask: M$1 & Record<Exclude<keyof M$1, keyof Shape$1>, never>): ZodObject<{ [k in keyof Shape$1]: k extends keyof M$1 ? ZodOptional<Shape$1[k]> : Shape$1[k] }, Config>;
  required(): ZodObject<{ [k in keyof Shape$1]: ZodNonOptional<Shape$1[k]> }, Config>;
  required<M$1 extends Mask$1<keyof Shape$1>>(mask: M$1 & Record<Exclude<keyof M$1, keyof Shape$1>, never>): ZodObject<{ [k in keyof Shape$1]: k extends keyof M$1 ? ZodNonOptional<Shape$1[k]> : Shape$1[k] }, Config>;
}
declare const ZodObject: $constructor<ZodObject>;
interface ZodUnion<T$1 extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T$1>>, $ZodUnion<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  options: T$1;
}
declare const ZodUnion: $constructor<ZodUnion>;
interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends ZodUnion<Options>, $ZodDiscriminatedUnion<Options, Disc> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
  def: $ZodDiscriminatedUnionDef<Options, Disc>;
}
declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
  "~standard": ZodStandardSchemaWithJSON<this>;
}
declare const ZodIntersection: $constructor<ZodIntersection>;
interface ZodTuple<T$1 extends TupleItems = readonly $ZodType[], Rest$1 extends SomeType | null = $ZodType | null> extends _ZodType<$ZodTupleInternals<T$1, Rest$1>>, $ZodTuple<T$1, Rest$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  rest<Rest$1 extends SomeType = $ZodType>(rest: Rest$1): ZodTuple<T$1, Rest$1>;
}
declare const ZodTuple: $constructor<ZodTuple>;
interface ZodRecord<Key$1 extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key$1, Value>>, $ZodRecord<Key$1, Value> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  keyType: Key$1;
  valueType: Value;
}
declare const ZodRecord: $constructor<ZodRecord>;
interface ZodEnum< /** @ts-ignore Cast variance */
out T$1 extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T$1>>, $ZodEnum<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  enum: T$1;
  options: Array<T$1[keyof T$1]>;
  extract<const U$1 extends readonly (keyof T$1)[]>(values: U$1, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T$1, U$1[number]>>>;
  exclude<const U$1 extends readonly (keyof T$1)[]>(values: U$1, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T$1, U$1[number]>>>;
}
declare const ZodEnum: $constructor<ZodEnum>;
interface ZodLiteral<T$1 extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T$1>>, $ZodLiteral<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  values: Set<T$1>;
  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
  value: T$1;
}
declare const ZodLiteral: $constructor<ZodLiteral>;
interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
  "~standard": ZodStandardSchemaWithJSON<this>;
}
declare const ZodTransform: $constructor<ZodTransform>;
interface ZodOptional<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T$1>>, $ZodOptional<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
}
declare const ZodOptional: $constructor<ZodOptional>;
interface ZodExactOptional<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T$1>>, $ZodExactOptional<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
}
declare const ZodExactOptional: $constructor<ZodExactOptional>;
interface ZodNullable<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T$1>>, $ZodNullable<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
}
declare const ZodNullable: $constructor<ZodNullable>;
interface ZodDefault<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T$1>>, $ZodDefault<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
  /** @deprecated Use `.unwrap()` instead. */
  removeDefault(): T$1;
}
declare const ZodDefault: $constructor<ZodDefault>;
interface ZodPrefault<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T$1>>, $ZodPrefault<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
}
declare const ZodPrefault: $constructor<ZodPrefault>;
interface ZodNonOptional<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T$1>>, $ZodNonOptional<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
}
declare const ZodNonOptional: $constructor<ZodNonOptional>;
interface ZodCatch<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T$1>>, $ZodCatch<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
  /** @deprecated Use `.unwrap()` instead. */
  removeCatch(): T$1;
}
declare const ZodCatch: $constructor<ZodCatch>;
interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  in: A;
  out: B;
}
declare const ZodPipe: $constructor<ZodPipe>;
interface ZodReadonly<T$1 extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T$1>>, $ZodReadonly<T$1> {
  "~standard": ZodStandardSchemaWithJSON<this>;
  unwrap(): T$1;
}
declare const ZodReadonly: $constructor<ZodReadonly>;
interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {
  "~standard": ZodStandardSchemaWithJSON<this>;
}
declare const ZodCustom: $constructor<ZodCustom>;
//#endregion
//#region ../2d-labels-markers/lib/esm/collision-ranking.d.ts
declare const collisionRankingTierSchema: ZodUnion<readonly [ZodEnum<{
  low: "low";
  medium: "medium";
  high: "high";
  "always-visible": "always-visible";
}>, ZodNumber]>;
type CollisionRankingTier = output<typeof collisionRankingTierSchema>;
//#endregion
//#region ../2d-labels-markers/lib/esm/components/label-utils.d.ts
declare const LABEL_TEXT_PLACEMENT: {
  readonly RIGHT: "right";
  readonly LEFT: "left";
  readonly TOP: "top";
  readonly HIDDEN: "hidden";
  readonly CENTER: "center";
};
declare const LABEL_LOW_PRIORITY = "low-priority";
type LabelTextPlacement = (typeof LABEL_TEXT_PLACEMENT)[keyof typeof LABEL_TEXT_PLACEMENT];
type LabelTextPlacementInternal = LabelTextPlacement | typeof LABEL_LOW_PRIORITY;
type EasingCurve$1 = string;
type Interpolation$2<T$1 extends string, U$1 extends unknown[]> = {
  on: T$1;
  input: number[];
  output: U$1;
  easing?: EasingCurve$1;
};
declare const labelAppearanceSchemaBase: ZodObject<{
  margin: ZodDefault<ZodNumber>;
  maxLines: ZodDefault<ZodNumber>;
  textSize: ZodDefault<ZodNumber>;
  maxWidth: ZodDefault<ZodNumber>;
  lineHeight: ZodDefault<ZodNumber>;
  color: ZodDefault<ZodString>;
  outlineColor: ZodDefault<ZodString>;
  textColor: ZodOptional<ZodString>;
  textOutlineColor: ZodOptional<ZodString>;
  pinColor: ZodOptional<ZodString>;
  pinOutlineColor: ZodOptional<ZodString>;
  pinColorInactive: ZodOptional<ZodString>;
  pinOutlineColorInactive: ZodOptional<ZodString>;
  icon: ZodOptional<ZodString>;
  iconSize: ZodDefault<ZodNumber>;
  iconScale: ZodDefault<ZodUnion<readonly [ZodNumber, ZodObject<{
    on: ZodLiteral<"zoom-level">;
    input: ZodTuple<[ZodNumber], ZodNumber>;
    output: ZodTuple<[ZodNumber], ZodNumber>;
    easing: ZodDefault<ZodString>;
  }, $strip>]>>;
  iconPadding: ZodDefault<ZodNumber>;
  iconFit: ZodDefault<ZodEnum<{
    fill: "fill";
    contain: "contain";
    cover: "cover";
  }>>;
  iconOverflow: ZodDefault<ZodEnum<{
    hidden: "hidden";
    visible: "visible";
  }>>;
  iconVisible: ZodDefault<ZodUnion<readonly [ZodBoolean, ZodNumber]>>;
  opacity: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperBackgroundColor: ZodOptional<ZodString>;
  __EXPERIMENTAL_wrapperPaddingX: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperPaddingY: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperBorderRadius: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperDotSize: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperShadowColor: ZodOptional<ZodString>;
  __EXPERIMENTAL_wrapperShadowOffsetX: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperShadowOffsetY: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperShadowBlur: ZodDefault<ZodNumber>;
}, $strip>;
type LabelAppearance = Partial<input<typeof labelAppearanceSchemaBase>> & {
  iconScale?: number | Interpolation$2<'zoom-level', number[]>;
};
type LabelAppearanceWithDefaults = output<typeof labelAppearanceSchema>;
declare const labelAppearanceSchema: ZodPipe<ZodObject<{
  margin: ZodDefault<ZodNumber>;
  maxLines: ZodDefault<ZodNumber>;
  textSize: ZodDefault<ZodNumber>;
  maxWidth: ZodDefault<ZodNumber>;
  lineHeight: ZodDefault<ZodNumber>;
  color: ZodDefault<ZodString>;
  outlineColor: ZodDefault<ZodString>;
  textColor: ZodOptional<ZodString>;
  textOutlineColor: ZodOptional<ZodString>;
  pinColor: ZodOptional<ZodString>;
  pinOutlineColor: ZodOptional<ZodString>;
  pinColorInactive: ZodOptional<ZodString>;
  pinOutlineColorInactive: ZodOptional<ZodString>;
  icon: ZodOptional<ZodString>;
  iconSize: ZodDefault<ZodNumber>;
  iconScale: ZodDefault<ZodUnion<readonly [ZodNumber, ZodObject<{
    on: ZodLiteral<"zoom-level">;
    input: ZodTuple<[ZodNumber], ZodNumber>;
    output: ZodTuple<[ZodNumber], ZodNumber>;
    easing: ZodDefault<ZodString>;
  }, $strip>]>>;
  iconPadding: ZodDefault<ZodNumber>;
  iconFit: ZodDefault<ZodEnum<{
    fill: "fill";
    contain: "contain";
    cover: "cover";
  }>>;
  iconOverflow: ZodDefault<ZodEnum<{
    hidden: "hidden";
    visible: "visible";
  }>>;
  iconVisible: ZodDefault<ZodUnion<readonly [ZodBoolean, ZodNumber]>>;
  opacity: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperBackgroundColor: ZodOptional<ZodString>;
  __EXPERIMENTAL_wrapperPaddingX: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperPaddingY: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperBorderRadius: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperDotSize: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperShadowColor: ZodOptional<ZodString>;
  __EXPERIMENTAL_wrapperShadowOffsetX: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperShadowOffsetY: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_wrapperShadowBlur: ZodDefault<ZodNumber>;
}, $strip>, ZodTransform<Required<LabelAppearance>, {
  margin: number;
  maxLines: number;
  textSize: number;
  maxWidth: number;
  lineHeight: number;
  color: string;
  outlineColor: string;
  iconSize: number;
  iconScale: number | {
    on: "zoom-level";
    input: [number, ...number[]];
    output: [number, ...number[]];
    easing: string;
  };
  iconPadding: number;
  iconFit: "fill" | "contain" | "cover";
  iconOverflow: "hidden" | "visible";
  iconVisible: number | boolean;
  opacity: number;
  __EXPERIMENTAL_wrapperPaddingX: number;
  __EXPERIMENTAL_wrapperPaddingY: number;
  __EXPERIMENTAL_wrapperBorderRadius: number;
  __EXPERIMENTAL_wrapperDotSize: number;
  __EXPERIMENTAL_wrapperShadowOffsetX: number;
  __EXPERIMENTAL_wrapperShadowOffsetY: number;
  __EXPERIMENTAL_wrapperShadowBlur: number;
  textColor?: string | undefined;
  textOutlineColor?: string | undefined;
  pinColor?: string | undefined;
  pinOutlineColor?: string | undefined;
  pinColorInactive?: string | undefined;
  pinOutlineColorInactive?: string | undefined;
  icon?: string | undefined;
  __EXPERIMENTAL_wrapperBackgroundColor?: string | undefined;
  __EXPERIMENTAL_wrapperShadowColor?: string | undefined;
}>>;
type AddLabelOptionsInternal$1 = {
  rank?: CollisionRankingTier;
  appearance?: LabelAppearance;
  interactive?: boolean;
  textPlacement?: LabelTextPlacement | LabelTextPlacement[];
  occlude?: boolean;
  id?: string;
  occluderId?: number;
  verticalOffset?: number;
  enabled?: boolean;
  attachTo?: string | number | Record<string, unknown> | null;
};
//#endregion
//#region ../2d-labels-markers/lib/esm/components/label.d.ts
type TStyle = {
  top?: number;
  left?: number;
  textLabelVisible?: boolean;
  pinVisibility: PINVISIBILITY;
  textAlign?: TEXTALIGN;
  cachedSymbol?: HTMLCanvasElement;
};
type LabelStrategy = {
  name: LabelTextPlacementInternal;
  getBoundingBox: () => number[];
  onStrategySelected: () => void;
};
/**
 * Label component ported from geojson/src. Replaces Three.js Vector2
 * with a plain Vec2 interface for the projection field.
 */
declare class LabelComponent {
  lines: number;
  id: string;
  rank: number;
  readonly type = "label";
  initialRank: number;
  contextConfigured: boolean;
  fillText: TDrawFn | undefined;
  newStyle: TStyle;
  currentOpacity: number;
  visibilityNeedsUpdate: 'show' | 'hide' | false;
  activePlacement: LabelTextPlacementInternal;
  text: string;
  style: TStyle;
  projection: Vec2;
  labelCacheId?: string;
  _cache: {};
  appearance: LabelAppearanceWithDefaults;
  options: AddLabelOptionsInternal$1;
  /**
   * Whether the anchored parent is visible.
   */
  visible: boolean;
  enabled: boolean;
  /** Whether this label participates in interaction hit-testing (set by renderer-three) */
  interactive: boolean;
  isOccluded: boolean;
  offscreen: boolean;
  /**
   * Whether the label can be shown, which is decided by the collision engine
   */
  canShow: boolean;
  activeBoundingBox: {
    x: number;
    y: number;
    w: number;
    h: number;
  };
  dimensions: {
    width: number;
    height: number;
  };
  currentStrategyIndex: number;
  totalPinSize: number;
  iconScale: number;
  get scaledPinSize(): number;
  iconPadding: number;
  get scaledIconPadding(): number;
  get textVisible(): boolean;
  dirty: boolean;
  textDirty: boolean;
  pinDirty: boolean;
  /** Flag used in 2d-projection system to determine if the parent has changed */
  attachedDirty: boolean;
  collisionDirty: boolean;
  lastTextAlign: any;
  imageHash?: number;
  pinSize: number;
  iconVisible: boolean;
  static testId: number;
  dp: (v?: number) => number;
  /**
   * @param text - Label text
   * @param options - Label options
   * @param pixelRatio - Device pixel ratio from the host renderer
   */
  constructor(text: string, options: AddLabelOptionsInternal$1, pixelRatio: number);
  calculatePinSize(): void;
  /**
   * Get the bounding box when the label has no text.
   * @param margin - The margin to apply to the bounding box.
   */
  private getNoTextBbox;
  /**
   * Get the bounding box for the hidden text placement.
   * @param margin - The margin to apply to the bounding box.
   */
  private getHiddenTextPlacementBbox;
  private getBoundingBoxForPlacement;
  private getStrategyStyleForPlacement;
  private _cachedStrategies;
  invalidateStrategies(): void;
  get strategies(): LabelStrategy[];
  animate: boolean;
  recomputeCurrentStrategy(scale?: number): void;
  onStrategySelected: (strategyIndex: number) => void;
  private packedMessage;
  toPackedMessage(isPanning?: boolean): PackedJsonMessage;
  destroy(): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/components/marker-utils.d.ts
declare const MARKER_PLACEMENT: {
  readonly TOP: "top";
  readonly BOTTOM: "bottom";
  readonly LEFT: "left";
  readonly RIGHT: "right";
  readonly CENTER: "center";
  readonly TOP_LEFT: "top-left";
  readonly TOP_RIGHT: "top-right";
  readonly BOTTOM_LEFT: "bottom-left";
  readonly BOTTOM_RIGHT: "bottom-right";
  readonly HIDDEN: "hidden";
};
type MarkerPlacement = (typeof MARKER_PLACEMENT)[keyof typeof MARKER_PLACEMENT];
//#endregion
//#region ../2d-labels-markers/lib/esm/components/marker.d.ts
type LowPriorityPinConfig = {
  /** @default 2 */
  size: number;
  /** @default '#666' */
  color: string;
};
/**
 * Options for creating a new Marker
 */
type AddMarkerOptions = {
  /** Determines the collision ranking tier of the marker. See {@link CollisionRankingTier}. */
  rank?: CollisionRankingTier;
  /**
   * Whether the marker should be clickable.
   * If `true` the marker will be registered in the SDK interaction events.
   * If `'pointer-events-auto'` the marker will receive browser pointer events.
   * @default false
   */
  interactive?: boolean | 'pointer-events-auto';
  /** @internal */
  id?: string;
  /** Alignment of the marker relative to the anchor. A list will use the first collision-free placement. */
  placement?: MarkerPlacement | MarkerPlacement[];
  /** If true, the marker will resize based on the content. */
  dynamicResize?: boolean;
  /**
   * Whether the marker can be occluded by 3D geometry.
   * @default true
   */
  occlude?: boolean;
  /** @internal */
  occluderId?: number;
  /** The z-index of the marker. Use with rank: 'always-visible' to layer markers. */
  zIndex?: number;
  /** The vertical position of the marker relative to the floor. */
  verticalOffset?: number;
  /**
   * Whether the marker is enabled.
   * @default true
   */
  enabled?: boolean;
  /** The entity to attach the marker to. */
  attachTo?: string | number | null;
  /**
   * Configuration for the low priority pin fallback strategy.
   * @default { size: 2, color: '#666' }
   */
  lowPriorityPin?: Partial<LowPriorityPinConfig>;
  /**
   * Whether the marker should animate visibility transitions.
   * When false, opacity is set directly without transitions.
   * @default true
   */
  animated?: boolean;
};
type MarkerStrategy = {
  name: MarkerPlacement;
  getBoundingBox: () => number[];
};
/**
 * Marker component ported from geojson/src. Replaces Three.js Vector2
 * with a plain Vec2 interface for the projection field.
 */
declare class MarkerComponent {
  id: string | number;
  readonly type = "marker";
  static testId: number;
  rank: number;
  initialRank: number;
  activePlacement: MarkerPlacement;
  pointerEvents: 'auto' | 'none';
  options: Required<Omit<AddMarkerOptions, 'zIndex' | 'attachTo' | 'enabled'> & {
    lowPriorityPin: Required<LowPriorityPinConfig>;
  }> & {
    zIndex?: number;
  };
  projection: Vec2;
  enabled: boolean;
  /** Whether this marker participates in interaction hit-testing (set by renderer-three) */
  interactive: boolean;
  /**
   * Whether the marker can be shown, which is decided by the collision engine
   */
  canShow: boolean;
  visible: boolean;
  isOccluded: boolean;
  offscreen: boolean;
  strategyIndex: number;
  activeBoundingBox: {
    x: number;
    y: number;
    w: number;
    h: number;
  };
  private dimensions;
  markerContainer: Entity2DHTMLDivElement;
  containerEl: HTMLElement;
  contentEl: HTMLElement | null;
  contentHtml: string;
  style: {
    top: string;
    left: string;
  };
  dirty: boolean;
  /** Flag used in 2d-projection system to determine if the parent has changed */
  attachedDirty: boolean;
  collisionDirty: boolean;
  visibilityNeedsUpdate: 'show' | 'hide' | false;
  constructor(contentHtml: string, options?: AddMarkerOptions);
  updateDimensionsIfZeroWidthHeight(width?: number, height?: number): void;
  updateDimensions(width?: number, height?: number): void;
  animation: Animation | null;
  currentStrategyIndex: number;
  onStrategySelected: (strategyIndex: number, force?: boolean) => void;
  private _cachedStrategies;
  invalidateStrategies(): void;
  private getBoundingBoxForPlacement;
  get strategies(): MarkerStrategy[];
  private packedMessage;
  toPackedMessage(isPanning?: boolean): PackedJsonMessage;
  private _cachedLowPriorityPinIndex;
  /** Get the index of the low priority pin strategy */
  get lowPriorityPinStrategyIndex(): number;
  destroy(): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/entity.d.ts
/**
 * Lightweight 2D entity that replaces the ThreeJS-dependent Geometry2D.
 * Holds a world-space position and a UI component (label or marker).
 */
declare class Entity2D {
  id: string | number;
  type: 'label' | 'marker';
  component: LabelComponent | MarkerComponent;
  worldPosition: {
    x: number;
    y: number;
    z: number;
  };
  verticalOffset: number;
  disposed: boolean;
  positionDirty: boolean;
  /** ID of the parent container this entity belongs to (for visibility tracking) */
  parentId?: string | number;
  /**
   * @param component - The label or marker component
   * @param position - World-space position
   * @param verticalOffset - Vertical offset applied to Z
   * @param parentId - Optional parent container ID for visibility tracking
   */
  constructor(component: LabelComponent | MarkerComponent, position: {
    x: number;
    y: number;
    z: number;
  }, verticalOffset?: number, parentId?: string | number);
  /**
   * Updates the entity's world position.
   * @param x - World X
   * @param y - World Y
   * @param z - World Z
   */
  updatePosition(x: number, y: number, z: number): void;
  /**
   * Sets the altitude (Z) component.
   * @param z - New Z value
   */
  setAltitude(z: number): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/types.d.ts
interface Vec2 {
  x: number;
  y: number;
}
/**
 * Minimal state the pipeline needs from the host renderer.
 * Each renderer populates this from its own entity tracking.
 */
interface TwoDPipelineState {
  /** All 2D entities currently in the scene */
  entities: Set<Entity2D>;
  /** Full entity map for lookups by id */
  entityMap: Map<string | number, Entity2D>;
  /** IDs of entities in the scene (kept for collision system compat) */
  entityIds: Set<string | number>;
  /** Device pixel ratio */
  pixelRatio: number;
}
/**
 * Function type for projecting world coordinates to screen pixels.
 * The host renderer provides this to the pipeline during construction.
 * @param worldX - X coordinate in world space
 * @param worldY - Y coordinate in world space
 * @param worldZ - Z coordinate in world space
 * @returns Screen-space position or null if off-screen
 */
type ProjectFn = (worldX: number, worldY: number, worldZ: number) => Vec2 | null;
type Entity2DHTMLDivElement = HTMLDivElement & {
  userData: {
    entityId: string | number;
  };
};
//#endregion
//#region ../packages/common/pubsub.d.ts
/**
 * Generic PubSub class implementing the Publish-Subscribe pattern for event handling.
 *
 * @template EVENT_PAYLOAD - The type of the event payload.
 * @template EVENT - The type of the event.
 */
declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EVENT_PAYLOAD> {
  /**
   * @private
   * @internal
   */
  private _subscribers;
  /**
   * @private
   * @internal
   * AbortController for managing lifecycle and cleanup
   */
  private _abortController;
  /**
   * Returns the AbortSignal for this PubSub instance.
   * Use this signal with APIs that support cancellation (fetch, addEventListener, etc.)
   * When the PubSub is destroyed, the signal will be aborted and all listeners using it will be automatically removed.
   *
   * @example
   * ```typescript
   * // Automatically cleaned up when PubSub is destroyed
   * pubsub.addEventListener(window, 'resize', handler, { signal: pubsub.signal });
   * ```
   */
  get signal(): AbortSignal;
  /**
   * @private
   * @internal
   */
  publish<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, data?: EVENT_PAYLOAD[EVENT_NAME]): void;
  /**
   * Subscribe a function to be called when the signal is aborted.
   * @param fn The function to call when the signal is aborted.
   */
  onAbort<T$1 extends (...args: any[]) => void>(fn: T$1): void;
  /**
   * Subscribe a function to an event.
   *
   * @param eventName An event name which, when fired, will call the provided
   * function.
   * @param fn A callback that gets called when the corresponding event is fired. The
   * callback will get passed an argument with a type that's one of event payloads.
   * @param options Optional options object. If a signal is provided, the subscription will be
   * automatically cleaned up when that signal is aborted.
   * @returns A cleanup function that unsubscribes the event listener when called.
   * @example
   * // Subscribe to the 'click' event
   * const handler = (event) => {
   *  const { coordinate } = event;
   *  const { latitude, longitude } = coordinate;
   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
   * };
   * map.on('click', handler);
   */
  on<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
    data: null;
  } ? EVENT_PAYLOAD[EVENT_NAME]['data'] : EVENT_PAYLOAD[EVENT_NAME]) => void, options?: {
    signal?: AbortSignal;
  }): () => void;
  /**
   * Unsubscribe a function previously subscribed with {@link on}
   *
   * @param eventName An event name to which the provided function was previously
   * subscribed.
   * @param fn A function that was previously passed to {@link on}. The function must
   * have the same reference as the function that was subscribed.
   * @example
   * // Unsubscribe from the 'click' event
   * const handler = (event) => {
   * 	console.log('Map was clicked', event);
   * };
   * map.off('click', handler);
   */
  off<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
    data: null;
  } ? EVENT_PAYLOAD[EVENT_NAME]['data'] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
  /**
   * @private
   * @internal
   * Destroys the PubSub instance and automatically unsubscribes all listeners registered via on().
   */
  destroy(): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/systems/collision/system.d.ts
type TCollisionSystemEvent = {
  'visibility-changed': undefined;
};
/**
 * Collision system for 2D labels and markers.
 * Manages collision detection using a quad-tree and web worker (or sync fallback).
 */
declare class CollisionSystem extends PubSub<TCollisionSystemEvent, keyof TCollisionSystemEvent> {
  #private;
  private worker;
  collidersDirty: boolean;
  packedMessage: PackedMessage;
  visibleCollidersQTree: QuadTree<{
    entityId: string | number;
  }>;
  interactiveCollidersQTree: QuadTree<{
    entityId: string | number;
  }>;
  /**
   * @param state - Pipeline state
   * @param canvasWidth - Width of the collision canvas
   * @param canvasHeight - Height of the collision canvas
   * @param workerUrl - Optional URL to a collision worker script. Falls back to SyncWorker.
   * @param useWorker - Whether to use a Web Worker for collision processing
   * @param container - Optional DOM container for the debug overlay canvas
   */
  constructor(state: TwoDPipelineState, canvasWidth: number, canvasHeight: number, workerUrl?: string, useWorker?: boolean, container?: HTMLElement);
  working: boolean;
  componentArray: (MarkerComponent | LabelComponent)[];
  /**
   * Resizes the collision area dimensions.
   * @param width - New width
   * @param height - New height
   */
  resizeCanvas(width: number, height: number): void;
  /**
   * Runs the collision update, packing components and posting to worker.
   */
  update: (watermarkWidth: number, watermarkHeight: number, watermarkPosition?: WatermarkPosition$1, lockStrategies?: boolean, staticColliders?: Rectangle[]) => void;
  resize(watermarkWidth: number, watermarkHeight: number, watermarkPosition: WatermarkPosition$1): void;
  /**
   * Resolves collision results from the worker and updates component visibility state.
   */
  resolve: (e: MessageEvent<{
    msgId: string;
    colliders: TSerializedColliderResponse[];
    staticColliders: Rectangle[];
  }>) => void;
  /** Enables the debug overlay that draws visible collision boxes. */
  showCollisionBoxes(): void;
  /** Disables the debug overlay and clears the canvas. */
  hideCollisionBoxes(): void;
  destroy: () => void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/systems/draw/system.d.ts
type TransformImageRequest$1 = (url: string) => Promise<{
  url: string;
}>;
/**
 * 2D canvas draw system for labels.
 * Renders label pins, icons, and text to a canvas overlay.
 */
declare class TwoDDrawSystem extends PubSub<{
  'img:loaded': undefined;
}> {
  dirty: boolean;
  state: TwoDPipelineState;
  colliderContext: CanvasRenderingContext2D;
  colliderCanvas: HTMLCanvasElement;
  transformRequestFunc?: TransformImageRequest$1;
  constructor(state: TwoDPipelineState, colliderCanvas: HTMLCanvasElement, transformImageRequest?: TransformImageRequest$1);
  transformRequest: (url: string) => Promise<{
    url: string;
  }>;
  pinCache: Record<string, [HTMLCanvasElement | OffscreenCanvas, HTMLCanvasElement | OffscreenCanvas]>;
  /**
   * Caches pre-rasterized experimental wrapper sprites (shape + baked shadow)
   * keyed by geometry + color + shadow params. Blitting the sprite with
   * `drawImage` sidesteps per-frame path construction and shadow
   * rasterization — the hot cost in the wrapper render path. Cleared on
   * full-redraw (`this.dirty`) to match `pinCache`/`textCache` invalidation.
   */
  wrapperCache: Record<string, OffscreenCanvas | HTMLCanvasElement>;
  /** Stores the loaded images ready to be drawn. */
  imageCache: Record<number, HTMLImageElement | ImageBitmap>;
  /** Stores the promises for each image fetch. */
  imagePromiseCache: Record<number, Promise<HTMLImageElement | ImageBitmap>>;
  imageDimensionsCache: Record<string, {
    width: number;
    height: number;
  }>;
  textCache: Record<string, {
    left?: OffscreenCanvas | HTMLCanvasElement;
    center?: OffscreenCanvas | HTMLCanvasElement;
    right?: OffscreenCanvas | HTMLCanvasElement;
  }>;
  /** Number of labels that cleared the `canShow && visible` gate this frame. */
  private drawCount;
  /**
   * Number of `project()` calls issued this frame. Owned and written by the
   * pipeline (which performs the actual projection loop); read-only here.
   */
  projectionCount: number;
  /**
   * Number of labels currently in `visibilitySystem.animating`. Owned and
   * written by the pipeline right before the draw pass; read-only here.
   */
  animatingCount: number;
  /** Number of labels that reached `recomputeCurrentStrategy` this frame. */
  private drawAttemptCount;
  /** Lazily-mounted DOM overlay that renders per-frame stats. */
  private statsElement?;
  /**
   * Runs the draw pass for all label entities.
   * @param zoomLevel - Current zoom level (for icon scale interpolation)
   */
  update: (zoomLevel: number) => void;
  processText: (text: string, size: number, maxWidth: number, maxLines: number, lineHeight: number) => {
    textDrawFn: (ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, x: number, y: number) => void;
    width: number;
    height: number;
  };
  textToCanvas: (textDrawFn: (ctx: CanvasRenderingContext2D, x: number, y: number) => void, size: number, textAlign: TEXTALIGN, width: number, height: number, foregroundColor: string, backgroundColor: string) => HTMLCanvasElement | OffscreenCanvas | undefined;
  cacheImage: (label: LabelComponent) => void;
  createPinCanvas: (label: LabelComponent, pinSize: number, backgroundColor: string, foregroundColor: string, maxIconScale?: number) => HTMLCanvasElement | OffscreenCanvas;
  prepare: (label: LabelComponent, labelCacheId: string, context: CanvasRenderingContext2D) => void;
  /**
   * Lazily mounts (and updates) a small DOM overlay reporting per-frame
   * label-pipeline stats:
   *
   * - `projections` — raw count of `project()` calls issued by the pipeline
   *   (every entity, regardless of whether it lands on-screen).
   * - `draw-attempts` — labels that reached `recomputeCurrentStrategy`, i.e.
   *   survived the `offscreen`/`visible` cull and had their layout/strategy
   *   recomputed.
   * - `draws` — labels that cleared the final `canShow && visible` gate in
   *   `draw()` and issued canvas draw calls.
   *
   * Intended as a lightweight diagnostic for tuning visibility strategies
   * and culling.
   */
  private updateStatsOverlay;
  /**
   * Creates an offscreen sprite containing a filled wrapper shape with its
   * drop shadow pre-rasterized. The shape is drawn at `(marginX, marginY)`
   * inside a canvas sized to fully contain the shadow spread.
   *
   * @param w - Shape width in canvas pixels (integer, excludes shadow margin).
   * @param h - Shape height in canvas pixels (integer, excludes shadow margin).
   * @param marginX - Horizontal padding added to the sprite to hold the shadow.
   * @param marginY - Vertical padding added to the sprite to hold the shadow.
   * @param drawShape - Callback that issues the path for the shape at the
   *   provided top-left `(x, y)` with dimensions `(w, h)`. The caller already
   *   set `fillStyle` + shadow properties; `beginPath` is the callback's
   *   responsibility.
   * @param bgColor - Fill color for the shape.
   * @param shadowColor - Drop-shadow color; `''`/`undefined` disables shadow.
   * @param shadowOffsetX - Drop-shadow X offset in canvas pixels.
   * @param shadowOffsetY - Drop-shadow Y offset in canvas pixels.
   * @param shadowBlur - Drop-shadow blur radius in canvas pixels.
   * @returns An OffscreenCanvas (preferred) or HTMLCanvasElement fallback.
   */
  private createWrapperSprite;
  /**
   * Draws the experimental wrapper background shape behind the label.
   *
   * Shape varies with the active strategy:
   * - Text visible → rounded rectangle union of pin + text, expanded by
   *   `__EXPERIMENTAL_wrapperPaddingX` / `__EXPERIMENTAL_wrapperPaddingY`.
   * - No text, pin ACTIVE (HIDDEN placement with visible icon) → filled
   *   circle with radius `visiblePinRadius + max(paddingX, paddingY)` so the
   *   icon sits inside a colored chip.
   * - No text, pin INACTIVE (LOW_PRIORITY / HIDDEN without icon) → tiny
   *   filled dot. Radius is half of `__EXPERIMENTAL_wrapperDotSize` (CSS
   *   pixels) when set, otherwise the intrinsic inactive pin fill radius.
   *
   * The pin contribution to the rect / chip uses the *visible* pin radius
   * (`(pinSize + PIN_STROKE_SIZE * pixelRatio) / 2`) rather than `drawSize`.
   * `drawSize` reflects the pin's padded canvas extent (includes transparent
   * margin for shadow / stroke headroom), which would otherwise inflate the
   * wrapper to ~2× the visible pin — making small padding values read as
   * much larger than requested.
   *
   * Hot-path optimization: the shape + shadow are rasterized once into an
   * offscreen sprite keyed by geometry/color/shadow params (see
   * `wrapperCache`) and blitted with `drawImage` on subsequent frames,
   * avoiding per-frame path construction and shadow rasterization.
   *
   * No-op unless the appearance sets `__EXPERIMENTAL_wrapperBackgroundColor`.
   * All coordinates are in canvas pixels (already multiplied by pixelRatio).
   */
  private drawWrapperBackground;
  /**
   * Draws a single label to the canvas.
   */
  draw(label: LabelComponent, labelCacheId: string, context: CanvasRenderingContext2D): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/systems/dom-draw/system.d.ts
/**
 * DOM draw system that positions marker DOM elements on screen.
 * Handles visibility animations and pointer-event toggling.
 */
declare class DOMDrawSystem {
  state: TwoDPipelineState;
  constructor(state: TwoDPipelineState);
  /**
   * Updates marker positions and visibility in the DOM.
   * @param isUserInteracting - Whether the user is currently panning/zooming
   */
  update(isUserInteracting: boolean): void;
}
//#endregion
//#region ../2d-labels-markers/lib/esm/pipeline.d.ts
interface TwoDPipelineOptions {
  /** Optional URL for a dedicated collision worker (falls back to sync) */
  workerUrl?: string;
  /** When false, skip Web Worker creation and use synchronous collision processing */
  useCollisionWorker?: boolean;
  /** Optional image transform function (e.g. for SAS tokens) */
  transformImageRequest?: TransformImageRequest$1;
  /** Watermark configuration for collision avoidance */
  watermark?: {
    width: number;
    height: number;
    position: WatermarkPosition$1;
  };
}
/**
 * Orchestrates the 2D label/marker pipeline: projection, draw, collision, visibility, and animation.
 * Owns the canvas and DOM overlay elements and all sub-systems.
 *
 * Usage:
 * 1. `new TwoDPipeline(container, state, project, options)`
 * 2. Call `update(zoomLevel, isUserInteracting)` each frame
 * 3. Call `cancelPendingFrames()` before sync renders
 * 4. Call `destroy()` on cleanup
 */
declare class TwoDPipeline {
  #private;
  /**
   * When true, the next collision update will perform a full strategy recompute.
   * Set to false by the host renderer on camera-start events so that collision
   * locks to current strategies during movement (cheap). Set back to true on
   * camera-end events to trigger a fresh recompute once movement finishes.
   * Resets to false automatically at the end of each {@link update} call.
   */
  collidersNeedRecomputing: boolean;
  get collisionSystem(): CollisionSystem;
  get drawSystem(): TwoDDrawSystem;
  /** Exposed for testing; DOM draw is internal to the pipeline */
  get domDrawSystem(): DOMDrawSystem;
  /** @internal Canvas used for rendering 2D labels. */
  get labelCanvas(): HTMLCanvasElement;
  constructor(container: HTMLElement, state: TwoDPipelineState, project: ProjectFn, options?: TwoDPipelineOptions);
  /**
   * Registers an entity in the lookup map without activating it.
   * Use {@link activateEntity} to also add it to the active set.
   * @param entity - The 2D entity to register
   */
  registerEntity(entity: Entity2D): void;
  /**
   * Registers and activates an entity (adds to all three collections).
   * @param entity - The 2D entity to add
   */
  addEntity(entity: Entity2D): void;
  /**
   * Activates a previously registered entity (adds to the active set).
   * @param entity - The 2D entity to activate
   */
  activateEntity(entity: Entity2D): void;
  /**
   * Deactivates an entity (removes from active set but keeps in entityMap).
   * @param entity - The 2D entity to deactivate
   */
  deactivateEntity(entity: Entity2D): void;
  /**
   * Fully removes an entity from the pipeline (all collections).
   * @param entity - The 2D entity to remove
   */
  removeEntity(entity: Entity2D): void;
  /**
   * Removes all entities from the pipeline.
   */
  clearEntities(): void;
  /**
   * Looks up an entity by id.
   * @param id - The entity id
   * @returns The entity or undefined
   */
  getEntity(id: string | number): Entity2D | undefined;
  /**
   * Checks whether an entity is in the active set.
   * @param entity - The entity to check
   * @returns true if active
   */
  hasActiveEntity(entity: Entity2D): boolean;
  /**
   * Resizes the label canvas and collision area to match the container.
   * Called by the host renderer on init and container resize.
   */
  resize(): void;
  /**
   * Main update entry point. Called by the host renderer each frame.
   *
   * @param zoomLevel - Current mercator zoom level
   * @param isUserInteracting - Whether user is panning/zooming
   * @param isCameraMoving - Whether the camera is animating
   * @param imageScreenBBoxes - Bounding boxes of images on screen for collision avoidance
   */
  update(zoomLevel: number, isUserInteracting: boolean, isCameraMoving?: boolean, imageScreenBBoxes?: Rectangle[]): void;
  /**
   * Updates the watermark configuration at runtime.
   * @param watermark - New watermark dimensions and position
   */
  updateWatermark(watermark: {
    width: number;
    height: number;
    position: WatermarkPosition$1;
  }): void;
  /**
   * Marks the 2D state as dirty, triggering re-population of the entity set
   * and collision recalculation.
   */
  markDirty(): void;
  /**
   * Cancels all pending requestAnimationFrame callbacks.
   * Call this before a synchronous render to avoid double-drawing.
   */
  cancelPendingFrames(): void;
  /**
   * Creates a LabelComponent and returns it (caller wraps in Entity2D).
   * @param text - Label text
   * @param options - Label options
   * @returns The created LabelComponent
   */
  createLabel(text: string, options: AddLabelOptionsInternal$1): LabelComponent;
  /**
   * Creates a MarkerComponent and returns it (caller wraps in Entity2D).
   * @param contentHtml - HTML string for the marker
   * @param options - Marker options
   * @returns The created MarkerComponent
   */
  createMarker(contentHtml: string, options?: AddMarkerOptions): MarkerComponent;
  /** Enables the debug overlay that draws visible collision boxes. */
  showCollisionBoxes(): void;
  /** Disables the debug overlay and clears the canvas. */
  hideCollisionBoxes(): void;
  /**
   * Cleans up all resources, removes overlays from the DOM.
   */
  destroy(): void;
}
//#endregion
//#region src/map-view-objects/label.d.ts
/**
 * Class representing a label on the {@link MapView}.
 *
 * Labels contain text and an image that are anchored to a specific point on the map. They automatically rotate and show and hide based on priority and zoom level.
 * Use them to inform users about location names, points of interest and more!
 *
 * Effective use of labels allows an app to convey additional information to the user.
 * For example labels can be used to show room names, important points of interest, main entrances or any other piece of contextual information that is useful to the user.
 *
 * Refer to the [Labels Guide](https://developer.mappedin.com/web-sdk/labels) for more information and interactive examples.
 */
declare class Label implements IFocusable, INavigatable {
  /**
   * The label's id
   */
  readonly id: string;
  /**
   * The label's text
   */
  readonly text: string;
  /**
   * The target object where the label is anchored.
   */
  readonly target: IAnchorable;
  /**
   * @internal
   */
  static readonly __type = "label";
  /**
   * @internal
   */
  readonly __type = "label";
  /**
   * Checks if the provided instance is of type Label.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Label, false otherwise.
   */
  static is(instance: object): instance is Label;
  /** @internal */
  get focusTarget(): Coordinate;
  /**
   * @internal
   */
  constructor(id: string, text: string, target: IAnchorable);
  /** @internal */
  get navigationTarget(): Coordinate;
}
//#endregion
//#region src/map-view-objects/marker.d.ts
/**
 * Mappedin JS allows adding and removing Markers on a map using the {@link Markers} class. Markers are elements containing HTML that Mappedin JS anchors to a {@link Door}, {@link Space}, {@link Coordinate} or {@link Node}.
 * They are automatically rotated and repositioned when the camera moves.
 *
 * Refer to the [Markers Guide](https://developer.mappedin.com/web-sdk/markers) for more information and interactive examples.
 */
declare class Marker implements IFocusable, INavigatable {
  #private;
  /**
   * The marker's id
   */
  id: string;
  /**
   * @internal
   */
  static readonly __type = "marker";
  get target(): IAnchorable;
  get coordinate(): Coordinate;
  /** @internal */
  get navigationTarget(): Coordinate;
  toJSON(): {
    id: string;
    __type: string;
    target: IAnchorable;
    coordinate: Coordinate;
  };
  /**
   * @internal
   */
  readonly __type = "marker";
  /**
   * The HTML element that represents the marker.
   */
  readonly contentEl: HTMLElement;
  /**
   * Checks if the provided instance is of type Marker"
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Marker, false otherwise.
   */
  static is(instance: object): instance is Marker;
  /**
   * @internal
   */
  constructor(id: string, contentEl: HTMLElement, target: IAnchorable);
  /** @internal */
  get focusTarget(): Coordinate;
  /**
   * @internal
   */
  updateTarget(target: IAnchorable): void;
}
//#endregion
//#region ../packages/mvf-utils/tokens/token-manager.d.ts
type TokenWithExpiration = {
  token: string;
  expires?: number;
};
type TokenManagerOptions = {
  baseUri?: string;
  baseAuthUri?: string;
  customAuthUri?: string;
  key?: string;
  secret?: string;
  accessToken?: string;
  enterprise?: boolean;
};
type TokenManagerEvents = {
  'access-token-refreshed': {
    accessToken: TokenWithExpiration;
  };
  'sas-tokens-refreshed': {
    sasTokens: Record<string, TokenWithExpiration>;
  };
};
type TokenManagerPubSub = PubSub<TokenManagerEvents>;
/**
 * Class for retrieving and refreshing tokens.
 */
declare class TokenManager {
  #private;
  constructor(mapIds: string[], options: TokenManagerOptions);
  /**
   * Set the map IDs that the token manager will manage.
   */
  setMapIds(mapIds: string[]): void;
  /**
   * Set the enterprise flag.
   */
  setEnterprise(enterprise: boolean): void;
  /**
   * Preload tokens so they can be retrieved synchronously. This will also refresh tokens on an
   * interval so they remain valid synchronously.
   */
  readySync(): Promise<void>;
  /**
   * Get a promise that resolves when the tokens are refreshed, but does not trigger token
   * refreshing.
   */
  refreshing(): Promise<unknown[]>;
  /**
   * Get an access token for the current set of API keys. If an access token was passed in, that
   * will be returned instead.
   */
  getAccessTokenAsync(): Promise<TokenWithExpiration>;
  /**
   * Get SAS tokens for all maps. If any SAS token are expired, all SAS tokens will be refreshed.
   */
  getSasTokensAsync(): Promise<{
    tokens: Record<string, TokenWithExpiration>;
    expires: number;
  }>;
  /**
   * Get an access token synchronously. `readySync()` must be called first.
   */
  getAccessToken(): TokenWithExpiration;
  /**
   * Get a SAS token for a specific map synchronously. `readySync()` must be called first.
   */
  getSasToken(mapId: string): TokenWithExpiration;
  /**
   * Check if the token manager is in enterprise mode.
   */
  isEnterpriseMode(): boolean;
  /**
   * Subscribe to events emitted by the token manager.
   */
  on: TokenManagerPubSub['on'];
  /**
   * Unsubscribe from events emitted by the token manager.
   */
  off: TokenManagerPubSub['off'];
  /**
   * Clean up the token manager.
   */
  destroy(): void;
}
//#endregion
//#region src/map-view-objects/image3d.d.ts
/**
 * Class representing an Image on the {@link MapView}.
 */
declare class Image3DView {
  #private;
  /**
   * The image's target
   */
  readonly target: IAnchorable;
  /**
   * @internal
   */
  static readonly __type = "image-3d";
  /**
   * @internal
   */
  readonly __type = "image-3d";
  /**
   * Checks if the provided instance is of type Image3DView.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is an Image3DView, false otherwise.
   */
  static is(instance: object): instance is Image3DView;
  /**
   * @internal
   */
  constructor(id: string, url: string, target: IAnchorable, tokenManager?: TokenManager);
  /**
   * The image's id
   */
  get id(): string;
  /**
   * Gets the url of the image with SAS token if available.
   *
   * @returns {string} The url of the image.
   */
  get url(): string;
}
//#endregion
//#region src/map-view-objects/model.d.ts
/**
 * Class representing a 3D model on the {@link MapView}.
 *
 * Adding 3D models to a map can be a great way to represent landmarks to help users find key locations. They could also be used to show the location of assets or represent furniture to provide a rich indoor layout.

 * Mappedin JS supports models in Graphics Library Transmission Format (GLTF) and GL Transmission Format Binary (GLB) format. Models with nested meshes are not supported and should not be used.
 *
 * 3D Models can be added to a {@link Coordinate}, {@link Door} or {@link Space}.
 * When adding the same model to multiple locations at the same time always use an array instead of calling the add method multiple times.
 * This allows the SDK to re-use the same instance of the model to reduce RAM usage and rendering time, resulting in better performance.
 *
 * Models are added using {@link Models.add}.
 *
 * Refer to the [3D Models Guide](https://developer.mappedin.com/web-sdk/3d-models) for more information and interactive examples.
 */
declare class Model implements INavigatable {
  #private;
  /**
   * The model's id
   */
  id: string;
  /**
   * The group's id
   */
  groupId: string;
  /**
   * @internal
   */
  static readonly __type = "model";
  /**
   * @internal
   */
  readonly __type = "model";
  get target(): IAnchorable;
  /**
   * Checks if the provided instance is of type Model
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Marker, false otherwise.
   */
  static is(instance: object): instance is Model;
  /**
   * @internal
   */
  constructor(id: string, groupId: string, target: IAnchorable);
  /**
   * @internal
   */
  updateTarget(target: IAnchorable): void;
  toJSON(): {
    id: string;
    __type: string;
    groupId: string;
    target: IAnchorable;
  };
  /** @internal */
  get navigationTarget(): Coordinate;
}
//#endregion
//#region src/map-view-objects/path.d.ts
/**
 * @experimental
 *
 * A segment of a complete path. This can be a continuous portion of the path on a single floor, or
 * the transition of a path between two floors, or a transition between indoors and outdoors.
 */
declare class PathSegment$1 implements IFocusable {
  #private;
  readonly id: string;
  readonly coordinates: Coordinate[];
  /**
   * @internal
   */
  static readonly __type = "path-segment";
  /**
   * @internal
   */
  readonly __type = "path-segment";
  /**
   * Checks if the provided instance is a PathSegment.
   */
  static is(instance: object): instance is PathSegment$1;
  constructor(id: string, coordinates: Coordinate[]);
  /**
   * Whether the path segment is a connection segment between two floors.
   */
  get isConnectionSegment(): boolean;
  /**
   * The distance of the path segment in meters.
   */
  get distance(): number;
  /** @internal */
  get focusTarget(): Coordinate[];
}
/**
 * Class representing a path on the {@link MapView}.
 *
 * Paths are used to indicate a route on the map and can be added and removed using {@link Paths.add} and {@link Paths.remove}.
 */
declare class Path implements IFocusable {
  #private;
  /**
   * The path's id
   */
  id: string;
  /**
   * The promise that resolves when the current path animation is complete.
   */
  animation: Promise<void>;
  /**
   * The coordinates of the path.
   */
  coordinates: Coordinate[];
  /**
   * @experimental
   *
   * The segments of the path.
   */
  segments: PathSegment$1[];
  /**
   * @internal
   */
  static readonly __type = "path";
  /**
   * @internal
   */
  readonly __type = "path";
  /**
   * Checks if the provided instance is a Path.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Path, false otherwise.
   */
  static is(instance: object): instance is Path;
  /** @internal */
  get focusTarget(): Coordinate[];
  /**
   * @internal
   */
  constructor(id: string, drawAnimation: Promise<void>, coordinates: Coordinate[], segments: {
    id: string | number;
    coordinates: Coordinate[];
  }[]);
  /**
   * The distance of the path in meters.
   */
  get distance(): number;
  toJSON(): {
    __type: string;
    id: string;
    coordinates: Coordinate[];
    segments: PathSegment$1[];
  };
}
//#endregion
//#region ../packages/common/interpolate.d.ts
declare const EASING_CURVES: readonly ["ease-in", "ease-out", "ease-in-out", "linear", "ease-out-cubic"];
type EasingCurve = (typeof EASING_CURVES)[number];
//#endregion
//#region src/navigation/tethered.d.ts
/**
 * Preset visual styles for the connector line drawn from the tracked
 * coordinate to the path when outside the tether threshold.
 *
 * - `'dashed-boxes'` — chunky 1m absolute dashes (default). Reads loudly as
 *   "off-route".
 * - `'dashed-stripes'` — long dashes with tiny gaps. Almost-solid striped look.
 * - `'dashed-sparse'` — same dash size as `dashed-boxes` but with a much
 *   bigger gap. Quieter, more breathable rhythm.
 * - `'solid'` — continuous solid line, no dashing. A plain leader line.
 * - `'bordered'` — ribbon geometry with darkened edges. Reads as a
 *   warning ribbon. Forces ribbon geometry on the connector.
 *
 * For fine-grained control (custom colour, exact width, etc.) use
 * `outsideThresholdPathOptions` — it is merged on top of the preset and
 * wins on any conflicting properties.
 */
type TOutsideThresholdPathStyle = 'solid' | 'dashed-boxes' | 'dashed-stripes' | 'dashed-sparse' | 'bordered';
/**
 * Options for tethering to a coordinate.
 */
type TTetheredOptions = {
  /**
   * The distance threshold within which the coordinate will be tethered to the path (meters).
   * @default 10
   */
  tetherThresholdDistance?: number;
  /**
   * Visual preset for the connector line drawn from the tracked coordinate
   * to the path when outside the tether threshold. See
   * {@link TOutsideThresholdPathStyle} for the list of presets.
   *
   * For finer control, use {@link outsideThresholdPathOptions} which is
   * merged on top of the preset.
   *
   * @default 'dashed-boxes'
   */
  outsideThresholdPathStyle?: TOutsideThresholdPathStyle;
  /**
   * Low-level overrides applied on top of {@link outsideThresholdPathStyle}.
   * Anything specified here wins over the preset.
   */
  outsideThresholdPathOptions?: Partial<TAddPathOptions>;
  /**
   * Options for the tether path (solid path from threshold point to destination).
   */
  tetherPathOptions?: Partial<TAddPathOptions>;
  /**
   * Controls behavior when the coordinate is outside the threshold distance from the path.
   * - `'tether-and-dash'`: Creates both the tethered path and a dashed line from user to threshold point (default)
   * - `'tether-only'`: Creates only the tethered path, no dashed line
   * - `'untether'`: Untethers from the path until a coordinate within threshold is provided
   * @default 'tether-and-dash'
   */
  coordinateOutsideThresholdMode?: 'tether-and-dash' | 'tether-only' | 'untether';
  /**
   * Whether to hide markers on the portion of the path the user has already travelled past.
   * Markers on the remaining path (current segment ahead of the user and all subsequent
   * segments, including the destination marker) stay enabled.
   * @default false
   */
  hideMarkersOutsideThreshold?: boolean;
};
//#endregion
//#region src/navigation/travelled.d.ts
/**
 * Options for updating travelled path state.
 */
type TTravelledOptions = {
  /**
   * The color to use for the travelled portion of the path.
   * @default '#999'
   */
  color?: string;
};
//#endregion
//#region src/navigation/index.d.ts
/**
 * Options for tracking a coordinate on the navigation path.
 */
type TTrackCoordinateOptions = {
  /**
   * The tracking mode to use.
   * - 'tethered': Connect the user's position to the closest point on the path
   * - 'travelled': Show the travelled portion of the path with a different color
   */
  mode: 'tethered' | 'travelled';
} & (({
  mode: 'tethered';
} & TTetheredOptions) | ({
  mode: 'travelled';
} & TTravelledOptions));
/**
 * Controls marker creation for navigation points.
 *
 * - If `true`, a default marker is created.
 * - If `false`, no marker is created.
 * - If a function is provided, it will be called with the direction instruction and should return a custom {@link Marker} instance.
 *
 * @example
 * ```ts
 * // Use default markers
 * createMarkers: { departure: true, destination: true }
 *
 * // Disable markers
 * createMarkers: { departure: false }
 *
 * // Create custom markers
 * createMarkers: {
 *   departure: (instruction) => {
 *     return mapView.Markers.add(instruction.coordinate, '<div>Custom</div>');
 *   }
 * }
 * ```
 */
type TCreateMarker = boolean | ((instruction: TDirectionInstruction) => Marker);
/**
 * Path options extended with connection-specific overrides for Navigation.
 * Connection paths inherit all base path options unless overridden with `__EXPERIMENTAL__CONNECTION_*` properties.
 */
type TNavigationPathOptions = TAddPathOptions & {
  /**
   * @experimental Override color for connection paths (vertical paths between floors).
   * If not specified, connection paths use the main `color` property.
   */
  __EXPERIMENTAL__CONNECTION_COLOR?: string;
  /**
   * @experimental Amount in meters to shorten connection path from each end.
   * Prevents visual overlap with floor paths at junctions.
   *
   * @defaultValue 0
   */
  __EXPERIMENTAL__CONNECTION_JUNCTION_INSET?: number;
  /**
   * @experimental Override dashed styling for connection paths.
   * If not specified, connection paths use the main `dashed` property.
   */
  __EXPERIMENTAL__CONNECTION_DASHED?: boolean;
  /**
   * @experimental Override geometry type for connection paths.
   * - 'tube': Original tube geometry with 8 radial segments
   * - 'ribbon': Flat ribbon geometry with 2 vertices per segment
   * If not specified, connection paths use the main `__EXPERIMENTAL_GEOMETRY` property.
   */
  __EXPERIMENTAL__CONNECTION_GEOMETRY?: 'tube' | 'ribbon';
  /**
   * @experimental
   * @deprecated Use `__EXPERIMENTAL_BILLBOARDING` instead. With per-vertex angle gating in the shader,
   * billboarding applies to all path segments but only affects vertices above the angle threshold.
   * A numeric value (degrees) naturally billboards only steep connection segments while leaving floor paths flat.
   */
  __EXPERIMENTAL__CONNECTION_BILLBOARDING?: boolean | number;
};
/**
 * Options for navigation.
 */
type TNavigationOptions = {
  /**
   * Controls whether the map should be set to the floor of the connection point when a connection point is clicked.
   * @default true
   */
  setMapOnConnectionClick?: boolean;
  /**
   * Controls whether the map should be set to the floor of the departure point when the path is drawn.
   * @default true
   */
  setMapToDeparture?: boolean;
  /**
   * Controls whether markers are created for the departure, destination, and connection points.
   */
  createMarkers?: {
    /**
     * Controls whether a marker is created for the departure point and allows a custom marker to be created.
     * @default true
     */
    departure?: TCreateMarker;
    /**
     * Controls whether a marker is created for the destination point and allows a custom marker to be created.
     * @default true
     */
    destination?: TCreateMarker;
    /**
     * Controls whether markers are created for connection points and allows a custom marker to be created.
     * @default true
     */
    connection?: TCreateMarker;
  };
  /**
   * Path Options for the non-current path in multi-destination mode.
   */
  inactivePathOptions?: Partial<TNavigationPathOptions>;
  /**
   * Controls whether the path drawing is animated across floors.
   * @default true
   */
  animatePathDrawing?: boolean;
  /**
   * Options for the path. Connection paths inherit these options unless overridden
   * with `__EXPERIMENTAL__CONNECTION_*` properties.
   */
  pathOptions?: Partial<TNavigationPathOptions>;
  /**
   * Options for the markers at the departure and destination.
   */
  markerOptions?: {
    /**
     * The color of the departure marker.
     * @default '#1890FF'
     */
    departureColor?: string;
    /**
     * The color of the destination marker.
     * @default '#722ED1'
     */
    destinationColor?: string;
    /**
     * Whether markers should animate (CSS bounce, pin drop, opacity transitions).
     * Set to false for deterministic rendering in e2e tests.
     * @default true
     */
    animated?: boolean;
  };
};
type NavigationState = {
  isMultiFloor: boolean;
  floorStacks: FloorStack[];
  floors: Floor[];
  activeDirections?: Directions;
  activePath?: Path;
  paths: Path[];
};
/**
 * Navigation-specific event types.
 */
type TNavigationEvents = {
  /**
   * Emitted when the navigation state changes.
   */
  'navigation-state-change': NavigationState;
  /**
   * Emitted when a connection point is clicked.
   */
  'navigation-connection-click': {
    fromFloor?: Floor;
    toFloor: Floor;
    instruction: TDirectionInstruction;
  };
  /**
   * Emitted when the active path changes.
   */
  'navigation-active-path-change': {
    directions: Directions;
    path: Path;
  };
};
/**
 * When a user needs to get from point A to point B, drawing a path on the map helps them to navigate to their destination. It can help them to visualize the route they'll need to take, like a good treasure map.

 * Navigation is a helper class to display wayfinding easily on the map. Functionality of Navigation could be replicated by drawing the paths using {@link Paths} and adding well designed tooltips at connection points.
 *
 * This class is accessed using {@link MapView.Navigation}.
 *
 * {@link Navigation.draw} allows for easily drawing multiple components that make up a wayfinding illustration. It shows a human figure to mark the start point, a path with animated directional arrows, pulses in the direction of travel and a pin to mark the destination. Each of these components can be customized to match an app's style.
 *
 * Refer to the [Drawing Navigation](https://developer.mappedin.com/web-sdk/wayfinding#drawing-navigation) in the Wayfinding Guide for more information and interactive examples.
 */
declare class Navigation {
  #private;
  /**
   * Returns true if the navigation is for a multi-floor path.
   */
  get isMultiFloor(): boolean;
  /**
   * @internal
   */
  constructor(geoJSONApi: GeoJsonApi);
  /**
   * @internal
   */
  getPathById(id: string): Path | undefined;
  /**
   * @internal
   */
  getMarkerById(id: string): {
    instruction: TDirectionInstruction;
    marker: Marker;
  } | undefined;
  /**
   * @internal
   */
  get paths(): Path[];
  /**
   * The currently active directions.
   */
  get activeDirections(): Directions | undefined;
  /**
   * The currently active path.
   */
  get activePath(): Path | undefined;
  /**
   * The current list of floor stacks along the navigation paths.
   */
  get floorStacks(): FloorStack[];
  /**
   * The current list of floors along the navigation paths.
   */
  get floors(): Floor[];
  /**
   * Sets the active path by index.
   */
  setActivePathByIndex(target: number): void;
  /**
   * Sets the active path.
   */
  setActivePath(target: Path): void;
  /**
   * Sets the active path by directions.
   */
  setActivePathByDirections(target: Directions): void;
  clearHighlightedPathSection(): void;
  /**
   * Tracks the user's position on the navigation path using the specified mode.
   * Only one tracking mode can be active at a time — switching modes auto-clears
   * the previous mode's visual state.
   *
   * Call this on every position update (e.g. from BlueDot's `dot-position-update`
   * event). Use {@link stopTracking} to tear down all tracking state.
   *
   * @param coordinate - The user's current coordinate
   * @param options - Tracking options including mode ('tethered' or 'travelled') and mode-specific options
   * @returns For 'tethered' mode: path coordinates if successful, null otherwise.
   *          For 'travelled' mode: the travelled fraction (0-1) if successful, null otherwise.
   * @experimental
   *
   * @example
   * ```ts
   * // 'tethered' — snap user position onto the closest point on the active path
   * blueDot.on('dot-position-update', e => {
   *   mapView.Navigation.trackCoordinate(e.position, {
   *     mode: 'tethered',
   *     tetherThresholdDistance: 10,
   *     coordinateOutsideThresholdMode: 'tether-and-dash',
   *     outsideThresholdPathStyle: 'dashed-boxes',
   *   });
   * });
   *
   * // 'travelled' — recolour the portion of the path the user has walked past
   * blueDot.on('dot-position-update', e => {
   *   mapView.Navigation.trackCoordinate(e.position, {
   *     mode: 'travelled',
   *     color: '#999',
   *   });
   * });
   * ```
   */
  trackCoordinate(coordinate: Coordinate, options: TTrackCoordinateOptions): Coordinate[] | number | null;
  /**
   * Stops any active coordinate tracking (tethering or travelled path visualization).
   * @experimental
   */
  stopTracking(): void;
  /**
   * Returns the current tracking mode, or `null` if no tracking is active.
   *
   * - `'tethered'` — coordinate is being snapped onto the active path.
   * - `'travelled'` — the traversed portion of the path is being recoloured.
   *
   * The mode is set as soon as {@link trackCoordinate} is called (even before
   * the first coordinate is matched). For a stricter "is the visualisation
   * currently active" check, use {@link isTracking}.
   *
   * @experimental
   */
  get currentTrackingMode(): 'tethered' | 'travelled' | null;
  /**
   * Returns true while a coordinate is actively being tracked and visualized
   * on the path.
   *
   * - In `'tethered'` mode this is true whenever a tethered path is drawn or
   *   path segments behind the user have been hidden.
   * - In `'travelled'` mode this is true once one or more segments have been
   *   marked as travelled.
   *
   * This is more precise than checking {@link currentTrackingMode}: the mode
   * is set as soon as {@link trackCoordinate} is called, but `isTracking`
   * only becomes true once the coordinate is successfully matched to the
   * path. It also becomes false again if `coordinateOutsideThresholdMode` is
   * `'untether'` and a coordinate falls outside the threshold.
   *
   * @experimental
   */
  get isTracking(): boolean;
  /**
   * Returns true while the dashed connector line from the tracked coordinate
   * to the path is being drawn. This only happens in `'tethered'` mode when
   * the coordinate is outside the tether threshold and
   * `coordinateOutsideThresholdMode` is `'tether-and-dash'` (the default).
   *
   * @experimental
   */
  get isShowingOutsideThresholdPath(): boolean;
  /**
   * Returns the fraction (0–1) of the active path that has been travelled
   * while in `'travelled'` mode. Returns `null` when not currently tracking
   * in travelled mode.
   *
   * Multiply by {@link Navigation.activePath}'s `distance` to get the
   * travelled distance in meters.
   *
   * In multi-destination mode this reflects progress along the currently
   * active destination's path only — it resets when the active path
   * changes.
   *
   * @experimental
   */
  get travelledFraction(): number | null;
  /**
   * Highlights path section between two coordinates. This can be used to highlight any section of the path or indicated the currently traveled path.
   */
  highlightPathSection(from: Coordinate, to: Coordinate, options?: TPathSectionHighlightOptions): {
    animation: Promise<unknown>;
  } | undefined;
  /**
   * @internal
   */
  drawSync(directions: Directions | Directions[], options?: TNavigationOptions): void;
  /**
   * Draws the specified directions on the map.
   * @param directions The directions to be drawn.
   * @param options Optional additional options for the navigation.
   */
  draw(directions: Directions | Directions[], options?: TNavigationOptions): Promise<void>;
  /**
   * Clears any drawn navigation paths or directions from the map.
   */
  clear(): void;
}
//#endregion
//#region src/api-geojson/utils/index.d.ts
type StyleCollectionWithId = {
  [groupId: string]: WithId<PolygonStyle> | WithId<LineStringStyle> | WithId<PointStyle> | undefined;
};
type AggregatedStyleMap = {
  [id: string]: StyleCollectionWithId[keyof StyleCollectionWithId];
};
type WithId<T$1> = T$1 & {
  id?: string;
};
//#endregion
//#region src/api-geojson/footprint.d.ts
interface FootprintConfig$1 {
  floorId: string;
  externalId: string;
  elevation: number;
  floorStackId: string;
  footprintGeometry: Feature$1<Polygon$1 | MultiPolygon$1, any>;
  obstructions?: any;
  styleMap: AggregatedStyleMap;
  multiFloorView?: TShow3DMapOptions['multiFloorView'];
  /** When set, overrides the computed effective height (used for gap footprints with fixed height) */
  fixedHeight?: number;
}
interface FootprintState {
  altitude?: number;
  visible?: boolean;
  opacity?: number;
  side?: 'auto' | 'back' | 'front' | 'double';
  color?: string;
  height?: number;
  ceilingVisible?: boolean;
  basementMaskEnabled?: boolean;
  outline?: boolean;
  ceilingThickness?: number;
}
/**
 * Manages the footprint geometry for a floor, including walls, ceiling, and basement mask.
 *
 * A note on basement masks. In order to create a cutout in the outdoor world to show each basement, we need to create a mask for each basement and toggle their visibility based on the current floor's elevation.
 *
 * Also, when viewing any over ground floors, we need to use the mask of the above ground floor closest to elevation 0, so you can stil see voids, but not the rest of the basement showing through the outdoor world.
 */
declare class Footprint {
  private renderer;
  private mapObject;
  private config;
  private wallsId?;
  private maskedWallsId?;
  private voidWallsId?;
  private maskedVoidWallsId?;
  private ceilingId?;
  private ceilingMaskId?;
  private basementMaskId?;
  private extrudedPolygonId?;
  private footprintColor;
  layer: EntityId<GroupContainerState>;
  groupContainer: EntityId<GroupContainerState>;
  constructor(renderer: RendererCore, mapObject: GeojsonApiMapObject, parentContainerId: string, config: FootprintConfig$1);
  /**
   * Gets the floor altitude data for this floor
   */
  private getFloorAltitudes;
  /**
   * Gets the visual height for this floor.
   * If fixedHeight is set in config (e.g. for gap footprints), returns that directly.
   */
  private getVisualHeight;
  /**
   * The footprint geometry used by this footprint.
   * Exposed for reuse when building gap footprints with the same outline.
   */
  get footprintGeometry(): Feature$1<Polygon$1 | MultiPolygon$1, any>;
  /**
   * Builds the footprint walls
   */
  buildWalls(): void;
  /**
   * Builds walls around void polygons (holes in the footprint)
   * @param voidPolygons Array of polygon features representing voids
   */
  buildVoidWalls(voidPolygons: Feature$1<Polygon$1, any>[]): void;
  /**
   * Builds the footprint as a single extruded polygon (no separate walls or ceiling).
   *
   * Used as the "simple mode" alternative to `buildWalls` + `buildVoidWalls` + `buildCeiling`
   * when no ceiling cuts are needed (i.e. `spacesOpenToBelowEnabled` is false, or it is
   * enabled but neither this floor nor the floor above contributes any cuts). Collapses
   * three feature collections into one, reducing draw calls per floor.
   *
   * The extruded mesh's top face acts as the "ceiling" — there is no separate ceiling
   * layer, so `ceilingVisible` and `ceilingThickness` are not honoured in simple mode.
   *
   * Holes are stripped from the source geometry before extrusion. The footprint may carry
   * void holes from MVF data, but in simple mode the user has opted out of "spaces open to
   * below" (or there are no cuts to apply), so the top and bottom faces must be solid —
   * matching the legacy `buildCeiling` path which also calls `removeHoles` before rendering.
   */
  buildExtrudedPolygon(): void;
  /**
   * Builds the ceiling with voids from the floor above
   */
  buildCeiling(ceilingCuts: Feature$1<Polygon$1, SpaceProperties>[]): void;
  /**
   * Builds the basement mask for elevation 0 floors
   */
  buildBasementMask(): void;
  /**
   * Updates the state of the footprint geometry (walls and ceiling)
   * @param state Partial state to update
   */
  update(state: FootprintState): void;
  /**
   * Gets the current state of the footprint geometry
   * @returns The current footprint state
   */
  getState(): FootprintState;
}
//#endregion
//#region src/api-geojson/floor-object.d.ts
type LineStringStyleWithTopColor = Omit<LineStringStyle, 'lineStrings'> & {
  id?: string;
  topColor?: string;
};
declare class Layer {
  containerId: string;
  layers: Map<string, string>;
  renderer: RendererCore;
  constructor(renderer: RendererCore, containerId: string, layers?: Map<any, any>);
  get visible(): boolean;
  setVisible(visible: boolean): void;
}
declare class FloorObject implements FloorProperties {
  #private;
  id: string;
  name?: string;
  elevation: number;
  maxHeight?: number;
  containerId: string;
  externalId: string;
  metadata?: Partial<Record<string, unknown>> | undefined;
  shortName?: string | undefined;
  subtitle?: string | undefined;
  occluderId?: number;
  private loaded;
  private styleMap;
  private obstructions?;
  private entrances?;
  private spaces?;
  private floorImages?;
  private floorText?;
  private areas?;
  private renderer;
  private mapObject;
  private options;
  layers: Map<string, Layer>;
  footprint?: Feature$1<Polygon$1 | MultiPolygon$1 | null, FloorProperties>;
  ceiling?: Feature$1<Polygon$1 | MultiPolygon$1 | null, FloorProperties>;
  floorStackId: string;
  private multiFloorView?;
  private mapDataInternal?;
  /** Maximum geometry height computed from space altitude + height during load */
  private _computedMaxHeight?;
  /** The maximum geometry height computed from actual space extrusion data during load. */
  get geometryMaxHeight(): number | undefined;
  /** Whether spaces open to below (ceiling cutouts) are enabled for this floor */
  get spacesOpenToBelowEnabled(): boolean;
  /**
   * Void polygons for this floor from mapDataInternal.
   * These are holes extracted from the footprint geometry.
   */
  get voids(): Feature$1<Polygon$1, SpaceProperties>[];
  /**
   * Spaces open to below polygons for this floor.
   * These are spaces with kind "void" or "otb".
   */
  get spacesOpenToBelow(): Feature$1<Polygon$1, SpaceProperties>[];
  /** Map of styleId to array of facadeIds for styling */
  facadesByStyleId: Map<string, string[]>;
  footprintObject?: Footprint;
  /** Footprint representing missing floors below this floor (gap filling) */
  gapFootprintObject?: Footprint;
  get geoJSONBoundingBox(): BBox | undefined;
  constructor(parentId: string, floor: FloorProperties, mapObject: GeojsonApiMapObject, multiFloorView: TShow3DMapOptions['multiFloorView'], options: TShow3DMapOptions, mvf?: ParsedMVF, styleMap?: AggregatedStyleMap, mapDataInternal?: MapDataInternal);
  /**
   * @param focusable - Whether the floor is part of a building and should be focusable. This will be set on the geometry layer.
   */
  load: (focusable?: boolean) => this;
  /**
   * Add an occluder to the floor if it has a footprint.
   */
  addOccluder(): void;
  /**
   * Whether the floor contains facade geometry.
   */
  get hasFacadeGeometry(): boolean;
  get visible(): boolean;
  setVisible(visible: boolean): void;
  buildCeiling(ceilingCuts: Feature$1<Polygon$1, any>[]): void;
  buildExtrudedPolygon(): void;
  buildBasementMask(): void;
  /**
   * Builds a gap footprint representing missing floors below this floor.
   * The gap footprint is a child of this floor's container, placed at -gapHeight
   * so it sits directly below and extrudes upward to meet the floor.
   * @param gapHeight - Total height of the gap in meters
   * @param ceilingCuts - Polygons to cut from the gap ceiling (spacesOpenToBelow from this floor)
   */
  buildGapFootprint(gapHeight: number, ceilingCuts: Feature$1<Polygon$1, any>[]): void;
  getFootprintStyle(): LineStringStyleWithTopColor;
  buildFootprint(): void;
  setBatchedTextVisible(visible: boolean): void;
}
//#endregion
//#region src/api-geojson/floor-stack-object.d.ts
declare class FloorStackObject implements Omit<FloorStack$1, 'maps' | 'floors' | 'defaultFloor' | 'footprint'> {
  #private;
  id: FloorStack$1['id'];
  externalId: FloorStack$1['externalId'];
  name: FloorStack$1['name'];
  type: FloorStack$1['type'];
  floorIds: FloorId[];
  defaultFloorId?: FloorStack$1['defaultFloor'];
  /** Sorted floor objects by elevation */
  floorObjects: FloorObject[];
  floorObjectsByElevation: Map<number, FloorObject>;
  metadata?: FloorStack$1['metadata'];
  containerId: string;
  facade?: Facade$1;
  renderer: RendererCore;
  /** Pre-computed map of floor elevation to visual altitude and visual height */
  altitudeMap: Map<number, TFloorAltitudeData>;
  constructor(floorStack: FloorStack$1, parentId: string, renderer: RendererCore, facade?: Facade$1);
  get defaultFloor(): FloorObject;
  /**
   * Whether the floorstack is an outdoor stack.
   * This may not be accurate if the type property is incorrect or if the building contains another facade.
   *
   * A floor stack being outdoors is determined by the following:
   * - The type is 'outdoor'
   * - It does not have a facade
   * - One of the floors contains facades
   */
  get isOutdoors(): boolean;
  addFloor(floor: FloorObject): void;
  /**
   * Loads all floors, computes altitude data, applies altitudes, and builds footprints/masks.
   * @param multiFloorView - Multi-floor view configuration for altitude computation
   */
  loadAllFloors(multiFloorView?: {
    enabled?: boolean;
    floorGap?: number | 'auto';
    floorGapMultiplier?: number;
    floorGapFallback?: number;
    __EXPERIMENTAL_disableGapFilling?: boolean;
  }): void;
}
//#endregion
//#region src/api-geojson/map-object.d.ts
declare class GeojsonApiMapObject extends PubSub<{
  'floor-change': {
    reason?: TFloorChangeReason;
    floorId: string;
    previousFloorId: string;
  };
  'floor-change-start': {
    reason?: TFloorChangeReason;
    floorId: string;
    previousFloorId: string;
  };
}> {
  #private;
  floorStacksById: Map<string, FloorStackObject>;
  floorsById: Map<string, FloorObject>;
  startingFloorId: string;
  currentFloorId: string;
  currentFloorStackId: string;
  outdoorFloorStacks: Set<string>;
  id: string;
  renderer: RendererCore;
  api: GeoJsonApi;
  mvf: ParsedMVF;
  options: TShow3DMapOptions;
  styleMap: AggregatedStyleMap;
  private animations;
  get currentFloorStack(): FloorStackObject;
  setFloorStack(floorStackId: string, reason?: TFloorChangeReason): void;
  get currentFloor(): FloorObject;
  /** @deprecated use `currentFloorStack.floorObjects` or `floorsById` instead */
  get floors(): FloorObject[];
  processFloorChange(floorId: string): void;
  /**
   * Merges the given effect fields into the stored multiFloorView options
   * and re-applies floor states so the change is visible immediately.
   * @param update - Partial effect fields to merge
   */
  updateMultiFloorViewEffects(update: Partial<MultiFloorViewEffectState>): void;
  /**
   * Returns the current resolved effect values from multiFloorView options.
   */
  getMultiFloorViewEffects(): MultiFloorViewEffectState;
  setFloor(floorId: string, reason?: TFloorChangeReason): void;
  /**
   * Legacy behavior where the outdoor path gets hidden if current floor doesn't match
   */
  updateOutdoorPathLayerVisibility(): void;
  /**
   * Returns the altitude map for a given floor stack, delegating to FloorStackObject.
   * @param floorStackId - The floor stack ID
   * @returns The altitude map for the floor stack
   */
  getFloorStackAltitudeData(floorStackId: string): Map<number, TFloorAltitudeData>;
  private cancelAnimation;
  Models: {
    add: (id: string, targets: Coordinate[], opts: TAddModelOptions & {
      floorId?: string;
      url: string;
    }) => (string | number)[];
    remove: (_id: string, _groupId: string) => void;
  };
  Image3D: {
    add: (target: Position$1, url: string, opts: TAddImageOptions & {
      floorId?: string;
    }) => EntityId<_mappedin_renderer_three0.ImageState> | undefined;
    remove: (id: string) => void;
    removeAll: () => void;
  };
  Markers: {
    add: (coordinate: Coordinate, html: string, opts: TAddMarkerOptions & {
      attachTo?: string;
    }) => EntityId<MarkerState>;
    remove: (id: string) => void;
    getContentEl: (id: string) => HTMLElement | undefined;
    removeAll: () => void;
    setPosition: (id: string, coordinate: Position$1, targetFloorId: string) => void;
    animateTo: (id: string, coordinate: Position$1, targetFloorId: string, options?: TAnimationOptions) => Promise<void>;
  };
  Exporter: {
    getCurrentSceneGLTF: (options: GLTFExportOptions$1) => Promise<Blob>;
  };
  Shapes: {
    add: <T$1 extends FeatureCollection<Polygon | MultiPolygon | LineString, any>>(geometry: T$1, style: T$1 extends FeatureCollection<LineString, any> ? LineStyle$1 : PaintStyle$1, opts: {
      floorId?: string;
    }) => string;
    remove: (customGeometry: Shape) => string;
  };
  Text3D: {
    label: (target: Space, content?: string, options?: TAddText3DOptions) => Text3DInfo | undefined;
    labelAll: (option?: TAddText3DOptions) => Text3DInfo[];
    add: (coordinate: Coordinate, content: string, options: TAddText3DAnchorableOptions) => EntityId<Text3DState> | undefined;
    remove: (id: string) => string;
  };
  Labels: {
    all: ({
      onCreate,
      labelOptions
    }: {
      onCreate: (labelId: string | number, text: string, target: IAnchorable) => void;
      labelOptions?: TAddLabelOptions;
    }) => void;
    add: (coordinate: Coordinate, text: string, opts?: AddLabelOptionsInternal & {
      attachTo?: string;
      verticalOffset?: number;
    }) => {
      id: string | number;
    };
    remove: ({
      entityId
    }: {
      entityId: string;
    }) => void;
    removeAll: () => void;
  };
  Paths: {
    add: (coordinates: Coordinate[], options?: TAddPathOptions & {
      id?: string;
    }, connectionOptions?: TConnectionPathOptions) => {
      paths: (EntityId<PathState> & {
        coordinates: Coordinate[];
      })[];
      animation: Promise<void>;
    };
    remove: (entityIds: string[]) => void;
  };
  constructor(id: string, mapDataInternal: MapDataInternal | undefined, options: TShow3DMapOptions | undefined, api: GeoJsonApi);
  loadAllFloors(): void;
}
type Text3DInfo = {
  target: Space;
  textInfo: EntityId<Text3DState>;
};
//#endregion
//#region src/api-geojson/shapes.d.ts
/**
 * ## Shapes in Mappedin JS
 *
 * The Shapes class allows you to draw custom 3D geometry on the map using GeoJSON. You can create polygons, multi-polygons, and line strings to highlight areas, create custom boundaries, or add visual overlays to your indoor map.
 *
 * ### Features
 * - Support for GeoJSON geometry (Polygon, MultiPolygon, LineString)
 * - Customizable styling with colors, opacity, and materials
 * - 3D rendering with height and altitude control
 * - Interactive shapes with click/hover events
 * - Floor-specific placement
 *
 * > **Best Practice:** Use shapes to highlight areas of interest, create custom zones, or add visual overlays. Keep shapes simple for better performance, especially on mobile devices.
 *
 * ### Example Usage
 * ```ts
 * // Create a simple polygon shape
 * const polygon = {
 *   type: 'FeatureCollection',
 *   features: [{
 *     type: 'Feature',
 *     geometry: {
 *       type: 'Polygon',
 *       coordinates: [[[lng1, lat1], [lng2, lat2], [lng3, lat3], [lng1, lat1]]]
 *     }
 *   }]
 * };
 *
 * const shape = mapView.Shapes.add(polygon, { color: 'red' }, mapView.currentFloor);
 *
 * // Create a line string
 * const lineString = {
 *   type: 'FeatureCollection',
 *   features: [{
 *     type: 'Feature',
 *     geometry: {
 *       type: 'LineString',
 *       coordinates: [[lng1, lat1], [lng2, lat2]]
 *     }
 *   }]
 * };
 *
 * const line = mapView.Shapes.add(lineString, { color: 'blue', width: 2 });
 *
 * // Remove a shape
 * mapView.Shapes.remove(shape);
 *
 * // Remove all shapes
 * mapView.Shapes.removeAll();
 * ```
 *
 * ### Styling Options
 * - **Polygons/MultiPolygons**: Use `PaintStyle` with color, opacity, height
 * - **LineStrings**: Use `LineStyle` with color, width, opacity
 * - **Interactive**: Set `interactive: true` for click/hover events
 *
 * ### Advanced
 * - Use `altitude` to position shapes at specific heights.
 * - Use `height` to create 3D extruded shapes.
 * - Use `interactive: true` to make shapes clickable.
 * - Use `floor` parameter to place shapes on specific floors.
 *
 * ### More Information
 * - [Shapes Guide](https://developer.mappedin.com/web-sdk/shapes)
 *
 * This class is accessed using {@link MapView.Shapes}.
 */
declare class Shapes {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter$7;
  });
  /**
   * @internal
   */
  getById(id: string): Shape | undefined;
  /**
   * Adds a custom GeoJSON geometry ({@link Shape}) to the map.
   *
   * @param geometry A valid GeoJSON feature collection containing Polygon, MultiPolygon, or LineString features.
   * @param style Styling options for the geometry (see {@link PaintStyle} for polygons, {@link LineStyle} for lines).
   * @param floor Optional floor to add the geometry to. If not specified, uses the current floor.
   * @returns {Shape | undefined} The created shape, or undefined if creation failed.
   *
   * @example Add a red polygon shape
   * ```ts
   * const polygon = {
   *   type: 'FeatureCollection',
   *   features: [{
   *     type: 'Feature',
   *     geometry: {
   *       type: 'Polygon',
   *       coordinates: [[[lng1, lat1], [lng2, lat2], [lng3, lat3], [lng1, lat1]]]
   *     }
   *   }]
   * };
   *
   * const shape = mapView.Shapes.add(polygon, { color: 'red' }, mapView.currentFloor);
   * ```
   *
   * @example Add a blue line string
   * ```ts
   * const lineString = {
   *   type: 'FeatureCollection',
   *   features: [{
   *     type: 'Feature',
   *     geometry: {
   *       type: 'LineString',
   *       coordinates: [[lng1, lat1], [lng2, lat2]]
   *     }
   *   }]
   * };
   *
   * const line = mapView.Shapes.add(lineString, { color: 'blue', width: 2 });
   * ```
   *
   * @example Add an interactive shape with custom styling
   * ```ts
   * const shape = mapView.Shapes.add(geometry, {
   *   color: 'green',
   *   opacity: 0.7,
   *   height: 2,
   *   interactive: true
   * }, mapView.currentFloor);
   * ```
   *
   * @see [Shapes Guide](https://developer.mappedin.com/web-sdk/shapes)
   */
  add<T$1 extends FeatureCollection<Polygon | MultiPolygon | LineString, any>>(geometry: T$1, style: T$1 extends FeatureCollection<LineString, any> ? LineStyle$1 : PaintStyle$1, floor?: Floor): Shape;
  /**
   * Removes a specific shape ({@link Shape}) from the map.
   * @param shape The shape to be removed.
   * @example
   * mapView.Shapes.remove(shape);
   */
  remove(shape: Shape): void;
  /**
   * Removes all Shapes ({@link Shape}) from the map.
   *
   * @returns An array of all removed shape IDs.
   * @example
   * const removedShapeIds = mapView.Shapes.removeAll();
   */
  removeAll(): string[];
}
type CurrentMapGetter$7 = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/inspector/inspector.d.ts
type InspectorState = {
  camera: {
    focusOnClick: boolean;
    padding: [number, number, number, number];
  };
};
type InspectorOption = Partial<InspectorState>;
//#endregion
//#region src/debug.d.ts
declare class Debug {
  #private;
  state: DebugState$1;
  constructor(core: RendererCore);
  update: (updateState: Partial<DebugState$1>) => void;
  /**
   * Returns the current camera state as a JSON object that can be passed directly to `mapView.Camera.set()`.
   * @returns The current camera state including center, zoomLevel, bearing, and pitch.
   * @example
   * ```ts
   * const state = mapView.Debug.getCameraState();
   * console.log(state);
   * // Later restore the camera position:
   * mapView.Camera.set(state);
   * ```
   */
  getCameraState(): TCameraTarget;
}
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/primitive.d.ts
/**
Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).

@category Type
*/
type Primitive = null | undefined | string | number | boolean | symbol | bigint;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/is-any.d.ts
/**
Returns a boolean for whether the given type is `any`.

@link https://stackoverflow.com/a/49928360/1490091

Useful in type utilities, such as disallowing `any`s to be passed to a function.

@example
```
import type {IsAny} from 'type-fest';

const typedObject = {a: 1, b: 2} as const;
const anyObject: any = {a: 1, b: 2};

function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
	return object[key];
}

const typedA = get(typedObject, 'a');
//=> 1

const anyA = get(anyObject, 'a');
//=> any
```

@category Type Guard
@category Utilities
*/
type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/is-optional-key-of.d.ts
/**
Returns a boolean for whether the given key is an optional key of type.

This is useful when writing utility types or schema validators that need to differentiate `optional` keys.

@example
```
import type {IsOptionalKeyOf} from 'type-fest';

type User = {
	name: string;
	surname: string;

	luckyNumber?: number;
};

type Admin = {
	name: string;
	surname?: string;
};

type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
//=> true

type T2 = IsOptionalKeyOf<User, 'name'>;
//=> false

type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
//=> boolean

type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
//=> false

type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
//=> boolean
```

@category Type Guard
@category Utilities
*/
type IsOptionalKeyOf<Type extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[Key$1]> ? false : true : false;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/optional-keys-of.d.ts
/**
Extract all optional keys from the given type.

This is useful when you want to create a new type that contains different type values for the optional keys only.

@example
```
import type {OptionalKeysOf, Except} from 'type-fest';

type User = {
	name: string;
	surname: string;

	luckyNumber?: number;
};

const REMOVE_FIELD = Symbol('remove field symbol');
type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
};

const update1: UpdateOperation<User> = {
	name: 'Alice',
};

const update2: UpdateOperation<User> = {
	name: 'Bob',
	luckyNumber: REMOVE_FIELD,
};
```

@category Utilities
*/
type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
: never;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/required-keys-of.d.ts
/**
Extract all required keys from the given type.

This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...

@example
```
import type {RequiredKeysOf} from 'type-fest';

declare function createValidation<
	Entity extends object,
	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;

type User = {
	name: string;
	surname: string;
	luckyNumber?: number;
};

const validator1 = createValidation<User>('name', value => value.length < 25);
const validator2 = createValidation<User>('surname', value => value.length < 25);

// @ts-expect-error
const validator3 = createValidation<User>('luckyNumber', value => value > 0);
// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
```

@category Utilities
*/
type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/is-never.d.ts
/**
Returns a boolean for whether the given type is `never`.

@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
@link https://stackoverflow.com/a/53984913/10292952
@link https://www.zhenghao.io/posts/ts-never

Useful in type utilities, such as checking if something does not occur.

@example
```
import type {IsNever, And} from 'type-fest';

type A = IsNever<never>;
//=> true

type B = IsNever<any>;
//=> false

type C = IsNever<unknown>;
//=> false

type D = IsNever<never[]>;
//=> false

type E = IsNever<object>;
//=> false

type F = IsNever<string>;
//=> false
```

@example
```
import type {IsNever} from 'type-fest';

type IsTrue<T> = T extends true ? true : false;

// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
type A = IsTrue<never>;
//=> never

// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
type IsTrueFixed<T> =
	IsNever<T> extends true ? false : T extends true ? true : false;

type B = IsTrueFixed<never>;
//=> false
```

@category Type Guard
@category Utilities
*/
type IsNever<T$1> = [T$1] extends [never] ? true : false;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/if.d.ts
/**
An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.

Use-cases:
- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.

Note:
- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.

@example
```
import type {If} from 'type-fest';

type A = If<true, 'yes', 'no'>;
//=> 'yes'

type B = If<false, 'yes', 'no'>;
//=> 'no'

type C = If<boolean, 'yes', 'no'>;
//=> 'yes' | 'no'

type D = If<any, 'yes', 'no'>;
//=> 'yes' | 'no'

type E = If<never, 'yes', 'no'>;
//=> 'no'
```

@example
```
import type {If, IsAny, IsNever} from 'type-fest';

type A = If<IsAny<unknown>, 'is any', 'not any'>;
//=> 'not any'

type B = If<IsNever<never>, 'is never', 'not never'>;
//=> 'is never'
```

@example
```
import type {If, IsEqual} from 'type-fest';

type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;

type A = IfEqual<string, string, 'equal', 'not equal'>;
//=> 'equal'

type B = IfEqual<string, number, 'equal', 'not equal'>;
//=> 'not equal'
```

Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:

@example
```
import type {If, IsEqual, StringRepeat} from 'type-fest';

type HundredZeroes = StringRepeat<'0', 100>;

// The following implementation is not tail recursive
type Includes<S extends string, Char extends string> =
	S extends `${infer First}${infer Rest}`
		? If<IsEqual<First, Char>,
			'found',
			Includes<Rest, Char>>
		: 'not found';

// Hence, instantiations with long strings will fail
// @ts-expect-error
type Fails = Includes<HundredZeroes, '1'>;
//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Error: Type instantiation is excessively deep and possibly infinite.

// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
type IncludesWithoutIf<S extends string, Char extends string> =
	S extends `${infer First}${infer Rest}`
		? IsEqual<First, Char> extends true
			? 'found'
			: IncludesWithoutIf<Rest, Char>
		: 'not found';

// Now, instantiations with long strings will work
type Works = IncludesWithoutIf<HundredZeroes, '1'>;
//=> 'not found'
```

@category Type Guard
@category Utilities
*/
type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/internal/type.d.ts
/**
Matches any primitive, `void`, `Date`, or `RegExp` value.
*/
type BuiltIns = Primitive | void | Date | RegExp;
/**
Test if the given function has multiple call signatures.

Needed to handle the case of a single call signature with properties.

Multiple call signatures cannot currently be supported due to a TypeScript limitation.
@see https://github.com/microsoft/TypeScript/issues/29732
*/
type HasMultipleCallSignatures<T$1 extends (...arguments_: any[]) => unknown> = T$1 extends {
  (...arguments_: infer A): unknown;
  (...arguments_: infer B): unknown;
} ? B extends A ? A extends B ? false : true : true : false;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/simplify.d.ts
/**
Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.

@example
```
import type {Simplify} from 'type-fest';

type PositionProps = {
	top: number;
	left: number;
};

type SizeProps = {
	width: number;
	height: number;
};

// In your editor, hovering over `Props` will show a flattened object with all the properties.
type Props = Simplify<PositionProps & SizeProps>;
```

Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.

If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.

@example
```
import type {Simplify} from 'type-fest';

interface SomeInterface {
	foo: number;
	bar?: string;
	baz: number | undefined;
}

type SomeType = {
	foo: number;
	bar?: string;
	baz: number | undefined;
};

const literal = {foo: 123, bar: 'hello', baz: 456};
const someType: SomeType = literal;
const someInterface: SomeInterface = literal;

declare function fn(object: Record<string, unknown>): void;

fn(literal); // Good: literal object type is sealed
fn(someType); // Good: type is sealed
// @ts-expect-error
fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
```

@link https://github.com/microsoft/TypeScript/issues/15300
@see {@link SimplifyDeep}
@category Object
*/
type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/omit-index-signature.d.ts
/**
Omit any index signatures from the given object type, leaving only explicitly defined properties.

This is the counterpart of `PickIndexSignature`.

Use-cases:
- Remove overly permissive signatures from third-party types.

This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).

It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.

(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)

```
const indexed: Record<string, unknown> = {}; // Allowed

// @ts-expect-error
const keyed: Record<'foo', unknown> = {}; // Error
// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
```

Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:

```
type Indexed = {} extends Record<string, unknown>
	? '✅ `{}` is assignable to `Record<string, unknown>`'
	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';

type IndexedResult = Indexed;
//=> '✅ `{}` is assignable to `Record<string, unknown>`'

type Keyed = {} extends Record<'foo' | 'bar', unknown>
	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';

type KeyedResult = Keyed;
//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
```

Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...

```
type OmitIndexSignature<ObjectType> = {
	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
};
```

...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...

```
type OmitIndexSignature<ObjectType> = {
	[KeyType in keyof ObjectType
	// Is `{}` assignable to `Record<KeyType, unknown>`?
	as {} extends Record<KeyType, unknown>
		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
	]: ObjectType[KeyType];
};
```

If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.

@example
```
import type {OmitIndexSignature} from 'type-fest';

type Example = {
	// These index signatures will be removed.
	[x: string]: any;
	[x: number]: any;
	[x: symbol]: any;
	[x: `head-${string}`]: string;
	[x: `${string}-tail`]: string;
	[x: `head-${string}-tail`]: string;
	[x: `${bigint}`]: string;
	[x: `embedded-${number}`]: string;

	// These explicitly defined keys will remain.
	foo: 'bar';
	qux?: 'baz';
};

type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
//=> {foo: 'bar'; qux?: 'baz'}
```

@see {@link PickIndexSignature}
@category Object
*/
type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/pick-index-signature.d.ts
/**
Pick only index signatures from the given object type, leaving out all explicitly defined properties.

This is the counterpart of `OmitIndexSignature`.

@example
```
import type {PickIndexSignature} from 'type-fest';

declare const symbolKey: unique symbol;

type Example = {
	// These index signatures will remain.
	[x: string]: unknown;
	[x: number]: unknown;
	[x: symbol]: unknown;
	[x: `head-${string}`]: string;
	[x: `${string}-tail`]: string;
	[x: `head-${string}-tail`]: string;
	[x: `${bigint}`]: string;
	[x: `embedded-${number}`]: string;

	// These explicitly defined keys will be removed.
	['kebab-case-key']: string;
	[symbolKey]: string;
	foo: 'bar';
	qux?: 'baz';
};

type ExampleIndexSignature = PickIndexSignature<Example>;
// {
// 	[x: string]: unknown;
// 	[x: number]: unknown;
// 	[x: symbol]: unknown;
// 	[x: `head-${string}`]: string;
// 	[x: `${string}-tail`]: string;
// 	[x: `head-${string}-tail`]: string;
// 	[x: `${bigint}`]: string;
// 	[x: `embedded-${number}`]: string;
// }
```

@see {@link OmitIndexSignature}
@category Object
*/
type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/merge.d.ts
// Merges two objects without worrying about index signatures.
type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;

/**
Merge two types into a new type. Keys of the second type overrides keys of the first type.

@example
```
import type {Merge} from 'type-fest';

type Foo = {
	[x: string]: unknown;
	[x: number]: unknown;
	foo: string;
	bar: symbol;
};

type Bar = {
	[x: number]: number;
	[x: symbol]: unknown;
	bar: Date;
	baz: boolean;
};

export type FooBar = Merge<Foo, Bar>;
//=> {
// 	[x: string]: unknown;
// 	[x: number]: number;
// 	[x: symbol]: unknown;
// 	foo: string;
// 	bar: Date;
// 	baz: boolean;
// }
```

Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.

@see {@link ObjectMerge}
@category Object
*/
type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
? Source extends unknown // For distributing `Source`
? Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>> : never // Should never happen
: never;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/internal/object.d.ts
/**
Merges user specified options with default options.

@example
```
type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
type SpecifiedOptions = {leavesOnly: true};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//=> {maxRecursionDepth: 10; leavesOnly: true}
```

@example
```
// Complains if default values are not provided for optional options

type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10};
type SpecifiedOptions = {};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//                                              ~~~~~~~~~~~~~~~~~~~
// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
```

@example
```
// Complains if an option's default type does not conform to the expected type

type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
type SpecifiedOptions = {};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//                                              ~~~~~~~~~~~~~~~~~~~
// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
```

@example
```
// Complains if an option's specified type does not conform to the expected type

type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
type SpecifiedOptions = {leavesOnly: 'yes'};

type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
//                                                                   ~~~~~~~~~~~~~~~~
// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
```
*/
type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/partial-deep.d.ts
/**
@see {@link PartialDeep}
*/
type PartialDeepOptions = {
  /**
  Whether to affect the individual elements of arrays and tuples.
  	@default false
  */
  readonly recurseIntoArrays?: boolean;

  /**
  Allows `undefined` values in non-tuple arrays.
  	- When set to `true`, elements of non-tuple arrays can be `undefined`.
  - When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
  	@default false
  	@example
  You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
  	```
  import type {PartialDeep} from 'type-fest';
  	type Settings = {
  	languages: string[];
  };
  	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
  	partialSettings.languages = [undefined]; // OK
  ```
  */
  readonly allowUndefinedInNonTupleArrays?: boolean;
};
type DefaultPartialDeepOptions = {
  recurseIntoArrays: false;
  allowUndefinedInNonTupleArrays: false;
};

/**
Create a type from another type with all keys and nested keys set to optional.

Use-cases:
- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.

@example
```
import type {PartialDeep} from 'type-fest';

let settings = {
	textEditor: {
		fontSize: 14,
		fontColor: '#000000',
		fontWeight: 400,
	},
	autocomplete: false,
	autosave: true,
};

const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
);

settings = applySavedSettings({textEditor: {fontWeight: 500}});
```

By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:

```
import type {PartialDeep} from 'type-fest';

type Shape = {
	dimensions: [number, number];
};

const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
	dimensions: [], // OK
};

partialShape.dimensions = [15]; // OK
```

@see {@link PartialDeepOptions}

@category Object
@category Array
@category Set
@category Map
*/
type PartialDeep<T$1, Options extends PartialDeepOptions = {}> = _PartialDeep<T$1, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
type _PartialDeep<T$1, Options extends Required<PartialDeepOptions>> = T$1 extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T$1 : T$1 extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T$1 extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T$1 extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T$1 extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T$1 extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T$1> extends true ? T$1 // For functions with no properties
: HasMultipleCallSignatures<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & PartialObjectDeep<T$1, Options> : T$1 extends object ? T$1 extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
? Options['recurseIntoArrays'] extends true ? ItemType[] extends T$1 // Test for arrays (non-tuples) specifically
? readonly ItemType[] extends T$1 // Differentiate readonly and mutable arrays
? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T$1, Options> // Tuples behave properly
: T$1 // If they don't opt into array testing, just use the original type
: PartialObjectDeep<T$1, Options> : unknown;

/**
Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
*/
type PartialMapDeep<KeyType$1, ValueType$1, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType$1, Options>, _PartialDeep<ValueType$1, Options>>;

/**
Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
*/
type PartialSetDeep<T$1, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T$1, Options>>;

/**
Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
*/
type PartialReadonlyMapDeep<KeyType$1, ValueType$1, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType$1, Options>, _PartialDeep<ValueType$1, Options>>;

/**
Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
*/
type PartialReadonlySetDeep<T$1, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T$1, Options>>;

/**
Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
*/
type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = { [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options> };
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/literal-union.d.ts
/**
Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.

Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.

This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.

@example
```
import type {LiteralUnion} from 'type-fest';

// Before

type Pet = 'dog' | 'cat' | string;

const petWithoutAutocomplete: Pet = '';
// Start typing in your TypeScript-enabled IDE.
// You **will not** get auto-completion for `dog` and `cat` literals.

// After

type Pet2 = LiteralUnion<'dog' | 'cat', string>;

const petWithAutoComplete: Pet2 = '';
// You **will** get auto-completion for `dog` and `cat` literals.
```

@category Type
*/
type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/readonly-deep.d.ts
/**
Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.

This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.

Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.

@example
```
import type {ReadonlyDeep} from 'type-fest';

declare const foo: {
	a: string;
	b: {c: number};
	d: Array<{e: number}>;
};

foo.a = 'bar'; // Allowed

foo.b = {c: 3}; // Allowed

foo.b.c = 4; // Allowed

foo.d = [{e: 5}]; // Allowed

foo.d.push({e: 6}); // Allowed

const last = foo.d.at(-1);
if (last) {
	last.e = 7; // Allowed
}

declare const readonlyFoo: ReadonlyDeep<typeof foo>;

// @ts-expect-error
readonlyFoo.a = 'bar';
// Error: Cannot assign to 'a' because it is a read-only property.

// @ts-expect-error
readonlyFoo.b = {c: 3};
// Error: Cannot assign to 'b' because it is a read-only property.

// @ts-expect-error
readonlyFoo.b.c = 4;
// Error: Cannot assign to 'c' because it is a read-only property.

// @ts-expect-error
readonlyFoo.d = [{e: 5}];
// Error: Cannot assign to 'd' because it is a read-only property.

// @ts-expect-error
readonlyFoo.d.push({e: 6});
// Error: Property 'push' does not exist on type 'ReadonlyArray<{readonly e: number}>'.

const readonlyLast = readonlyFoo.d.at(-1);
if (readonlyLast) {
	// @ts-expect-error
	readonlyLast.e = 8;
	// Error: Cannot assign to 'e' because it is a read-only property.
}
```

Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).

@category Object
@category Array
@category Set
@category Map
*/
type ReadonlyDeep<T$1> = T$1 extends BuiltIns ? T$1 : T$1 extends (new (...arguments_: any[]) => unknown) ? T$1 // Skip class constructors
: T$1 extends ((...arguments_: any[]) => unknown) ? {} extends _ReadonlyObjectDeep<T$1> ? T$1 : HasMultipleCallSignatures<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & _ReadonlyObjectDeep<T$1> : T$1 extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T$1 extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> :
// Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
T$1 extends readonly [] | readonly [...never[]] ? readonly [] : T$1 extends readonly [infer U, ...infer V] ? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>] : T$1 extends readonly [...infer U, infer V] ? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>] : T$1 extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T$1 extends object ? _ReadonlyObjectDeep<T$1> : unknown;
/**
Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
*/
type ReadonlyMapDeep<KeyType$1, ValueType$1> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType$1>, ReadonlyDeep<ValueType$1>>>;

/**
Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
*/
type ReadonlySetDeep<ItemType$1> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType$1>>>;

/**
Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
*/
type _ReadonlyObjectDeep<ObjectType extends object> = { readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]> };
//#endregion
//#region ../../node_modules/.pnpm/type-fest@5.4.2/node_modules/type-fest/source/value-of.d.ts
/**
Create a union of the given object's values, and optionally specify which keys to get the values from.

Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.

@example
```
import type {ValueOf} from 'type-fest';

type A = ValueOf<{id: number; name: string; active: boolean}>;
//=> string | number | boolean

type B = ValueOf<{id: number; name: string; active: boolean}, 'name'>;
//=> string

type C = ValueOf<{id: number; name: string; active: boolean}, 'id' | 'name'>;
//=> string | number
```

@category Object
*/
type ValueOf<ObjectType, ValueType$1 extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType$1];
//#endregion
//#region ../packages/common/type-utils.d.ts
type PartialExcept<T$1, K$1 extends string> = { [P in keyof T$1 as P extends K$1 ? P : never]: T$1[P] } & { [P in keyof T$1 as P extends K$1 ? never : P]?: T$1[P] extends Primitive ? T$1[P] : T$1[P] extends (infer U)[] ? PartialExcept<U, K$1>[] : PartialExcept<T$1[P], K$1> };
/**
 * Utility type that extracts nested values matching a specific type with recursion depth limit
 * @example
 * type A = ExtractDeep<{ a: { b: string; c: number; }; d: string; e: number; }, number>;
 * // { a: { c: number; } e: number; }
 */
type ExtractDeep<T$1, U$1, Depth extends readonly number[] = []> = Depth['length'] extends 3 ? any : { [K in keyof T$1 as T$1[K] extends U$1 ? K : T$1[K] extends object | undefined ? ExtractDeep<NonNullable<T$1[K]>, U$1, [...Depth, 0]> extends never ? never : K : never]: T$1[K] extends object | undefined ? undefined extends T$1[K] ? ExtractDeep<NonNullable<T$1[K]>, U$1, [...Depth, 0]> | undefined : ExtractDeep<NonNullable<T$1[K]>, U$1, [...Depth, 0]> : T$1[K] extends U$1 ? T$1[K] : never };
//#endregion
//#region src/api-geojson/auto/index.d.ts
type AutoElements = {
  labels: Label[];
  markers: Marker[];
};
//#endregion
//#region src/map-view.d.ts
/**
 * ## MapView in Mappedin JS
 *
 * MapView is the main rendering and interaction class for Mappedin maps. It provides comprehensive controls for manipulating map elements, camera, styling, and user interactions.
 *
 * ### Features
 * - **Rendering Control**: Camera, labels, markers, models, paths, and more
 * - **Interactive Elements**: Hover effects, click handling, and state management
 * - **Animation System**: Smooth transitions and state animations
 * - **Multi-floor Support**: Floor switching and stacked maps
 * - **Navigation**: Built-in wayfinding and directions
 * - **Styling**: Dynamic theme and style customization
 * - **Event System**: Comprehensive event handling for user interactions
 *
 * > **Best Practice:** Use the specialized API classes (Camera, Markers, Labels, etc.) for specific functionality.
 *
 * ### Example Usage
 * ```ts
 * // Initialize MapView
 * const mapData = await getMapData({key: 'your-key', secret: 'your-secret', mapId: 'your-map-id'});
 * const mapView = await show3dMap(container, mapData);
 * mapView.on('click', (event) => {
 *   console.log('Clicked:', event.coordinate);
 * });
 * ```
 *
 * ### Core Components
 * - **Camera**: View control, zoom, pan, and rotation
 * - **Markers**: Point-based visual elements
 * - **Labels**: Text overlays on the map
 * - **Paths**: Route visualization and navigation
 * - **Models**: 3D model rendering
 * - **Style**: Theme and appearance customization
 * - **Navigation**: Wayfinding and directions
 *
 * ### State Management
 * - `updateState()`: Immediate state changes
 * - `animateState()`: Smooth animated transitions
 * - `getState()`: Retrieve current element states
 * - `updateGlobalState()`: Apply global styling changes
 *
 * ### Event Handling
 * ```ts
 * // Listen for user interactions
 * mapView.on('click', (event) => {
 *   console.log('Clicked:', event.coordinate);
 * });
 *
 * mapView.on('hover', (event) => {
 *   console.log('Hovered:', event.coordinate);
 * });
 *
 * mapView.on('floorChanged', (event) => {
 *   console.log('Floor changed to:', event.floor);
 * });
 * ```
 *
 * ### More Information
 * - [Getting Started Guide](https://developer.mappedin.com/web-sdk/getting-started)
 * - [Camera Guide](https://developer.mappedin.com/web-sdk/camera)
 * - [Markers Guide](https://developer.mappedin.com/web-sdk/markers)
 * - [Labels Guide](https://developer.mappedin.com/web-sdk/labels)
 * - [Paths Guide](https://developer.mappedin.com/web-sdk/wayfinding#drawing-a-path)
 *
 * The MapView class is the main class for rendering and interacting with the map.
 *
 * It provides a set of controls for manipulating the map's elements and state.
 *
 * For help getting started, refer to the [Getting Started Guide](https://developer.mappedin.com/web-sdk/getting-started).
 */
declare class MapView {
  #private;
  /**
   * Controls for the map's camera.
   *
   * Provides methods for camera positioning, zooming, panning, and view control.
   *
   * @example
   * ```ts
   * // Set camera position
   * mapView.Camera.setPosition(coordinate, { duration: 1000 });
   *
   * // Zoom to fit all spaces
   * mapView.Camera.fitToElements(spaces);
   *
   * // Animate camera movement
   * mapView.Camera.animateTo(coordinate, { duration: 2000 });
   * ```
   *
   * @see [Camera Guide](https://developer.mappedin.com/web-sdk/camera)
   */
  Camera: Camera;
  /**
   * Controls for the map's labels.
   *
   * Manages text overlays, tooltips, and label visibility on the map.
   *
   * @example
   * ```ts
   * // Add a label
   * const label = mapView.Labels.add(coordinate, 'Welcome!');
   *
   * // Update label style
   * mapView.Labels.update(label, { color: 'red', fontSize: 16 });
   *
   * // Remove label
   * mapView.Labels.remove(label);
   * ```
   *
   * @see [Labels Guide](https://developer.mappedin.com/web-sdk/labels)
   */
  Labels: Labels;
  /**
   * @experimental
   * Controls for the map's 3D texts.
   *
   * Provides 3D text rendering capabilities for enhanced visual effects.
   *
   * @example
   * ```ts
   * // Add 3D text
   * const text3d = mapView.Text3D.add(coordinate, '3D Text', {
   *   height: 10,
   *   color: 'blue'
   * });
   * ```
   */
  Text3D: Text3D;
  /**
   * Controls for the map's markers.
   *
   * Manages point-based visual elements like pins, icons, and custom markers.
   *
   * @example
   * ```ts
   * // Add a marker
   * const marker = mapView.Markers.add(coordinate, {
   *   color: 'red',
   *   size: 20,
   *   label: 'Important Location'
   * });
   *
   * // Update marker
   * mapView.Markers.update(marker, { color: 'blue' });
   *
   * // Remove marker
   * mapView.Markers.remove(marker);
   * ```
   *
   * @see [Markers Guide](https://developer.mappedin.com/web-sdk/markers)
   */
  Markers: Markers;
  /**
   * Controls for the map's 3D images.
   *
   * Manages image overlays and custom image elements on the map.
   *
   * @example
   * ```ts
   * // Add an image
   * const image = mapView.Image3D.add(coordinate, 'path/to/image.png', {
   *   width: 100,
   *   height: 100
   * });
   * ```
   */
  Image3D: Image3D;
  /**
   * Controls for the map's models.
   *
   * Manages 3D model rendering and positioning on the map.
   *
   * @example
   * ```ts
   * // Add a 3D model
   * const model = mapView.Models.add(coordinate, 'path/to/model.glb', {
   *   scale: 1.0,
   *   rotation: { x: 0, y: 0, z: 0 }
   * });
   * ```
   */
  Models: Models;
  /**
   * Controls for the map's paths.
   *
   * Manages route visualization, navigation paths, and custom path rendering.
   *
   * @example
   * ```ts
   * // Add a path
   * const path = mapView.Paths.add(coordinates, {
   *   color: 'blue',
   *   width: 3,
   *   animated: true
   * });
   *
   * // Show navigation route
   * const directions = mapData.getDirections(space1, space2);
   * if (directions) {
   *   mapView.Paths.show(directions);
   * }
   * ```
   *
   * @see [Paths Guide](https://developer.mappedin.com/web-sdk/wayfinding#drawing-a-path)
   */
  Paths: Paths;
  /**
   * Controls for the map's 3D exporter.
   * @hidden
   */
  Exporter: Exporter;
  /**
   * Controls for the map's navigation.
   */
  Navigation: Navigation;
  /**
   * Controls for the indoor map's style.
   */
  Style: Style;
  /**
   * Controls custom GeoJSON geometry on the map.
   *
   * Allows adding custom geometric shapes and overlays to the map.
   *
   * @example
   * ```ts
   * // Add custom shape
   * const shape = mapView.Shapes.add(geoJSON, {
   *   color: 'red',
   *   opacity: 0.5
   * });
   * ```
   */
  Shapes: Shapes;
  /**
   * Controls for the outdoor map.
   *
   * Manages outdoor map integration and outdoor tile rendering.
   *
   * @example
   * ```ts
   * // Enable outdoor map
   * mapView.Outdoor.enable();
   *
   * // Set outdoor style
   * mapView.Outdoor.setStyle('satellite');
   * ```
   */
  Outdoor: Outdoor;
  /**
   * @internal
   */
  constructor(rendererCore: RendererCore);
  /**
   * Updates the state of a map element immediately.
   *
   * This method provides direct control over the visual properties of map elements. Use `animateState()` for smooth transitions.
   *
   * The following table maps targets to their available states:
   *
   * | Target | State Type | Description |
   * |--------|------------|-------------|
   * | {@link Door} | {@link TDoorsUpdateState} | Open/closed state, color |
   * | {@link Floor} | {@link TFloorUpdateState} | Color, opacity, visibility |
   * | {@link Label} | {@link TLabelUpdateState} | Text, color, visibility |
   * | {@link Marker} | {@link TMarkerUpdateState} | Color, size, icon |
   * | {@link Model} | {@link TModelUpdateState} | Scale, rotation, visibility |
   * | {@link Path} | {@link TPathUpdateState} | Color, width, visibility |
   * | {@link Shape} | {@link TShapeUpdateState} | Color, opacity, geometry |
   * | {@link Space} | {@link TGeometryUpdateState} | Color, opacity, visibility |
   * | {@link Text3DView} | {@link TText3DUpdateState} | Text, color, height |
   * | {@link DOORS} | {@link TDoorsUpdateState} | Global door settings |
   * | {@link WALLS} | {@link TWallsUpdateState} | Global wall settings |
   *
   * @param target The map element to update.
   * @param state The new state to apply.
   *
   * @example Update space color
   * ```ts
   * const space = mapData.getById('space', 'space-123');
   * if (space) {
   *   mapView.updateState(space, { color: 'red' });
   * }
   * ```
   *
   * @example Update marker properties
   * ```ts
   * const marker = mapView.Markers.add(coordinate);
   * mapView.updateState(marker, {
   *   contentHTML: 'Updated Content'
   * });
   * ```
   *
   * @example Update global door settings
   * ```ts
   * mapView.updateState('DOORS', {
   *   color: 'green',
   *   opacity: 0.8
   * });
   * ```
   *
   * @example Update path appearance
   * ```ts
   * const path = mapView.Paths.add(coordinates);
   * mapView.updateState(path, {
   *   color: 'yellow',
   * });
   * ```
   */
  updateState<T$1 extends MapElementsWithState>(target: T$1, state: TUpdateState<T$1>): void;
  /**
   * Animate the state of a given target on the map from the current state to a new state. Only numeric properties and
   * colors can be animated.
   *
   * Use `updateState()` for immediate updates.
   *
   * The following table maps targets to their available states:
   *
   * | Target | State Type | Description |
   * |--------|------------|-------------|
   * | {@link Door} | {@link TDoorsUpdateState} | Open/closed state, color |
   * | {@link Floor} | {@link TFloorUpdateState} | Color, opacity, visibility |
   * | {@link Label} | {@link TLabelUpdateState} | Text, color, visibility |
   * | {@link Marker} | {@link TMarkerUpdateState} | Color, size, icon |
   * | {@link Model} | {@link TModelUpdateState} | Scale, rotation, visibility |
   * | {@link Path} | {@link TPathUpdateState} | Color, width, visibility |
   * | {@link Shape} | {@link TShapeUpdateState} | Color, opacity, geometry |
   * | {@link Space} | {@link TGeometryUpdateState} | Color, opacity, visibility |
   * | {@link Text3DView} | {@link TText3DUpdateState} | Text, color, height |
   * | {@link DOORS} | {@link TDoorsUpdateState} | Global door settings |
   * | {@link WALLS} | {@link TWallsUpdateState} | Global wall settings |
   *
   * @param target The map element to animate.
   * @param state The target state to animate to.
   * @param options Animation configuration options.
   * @param options.duration The duration of the animation in milliseconds (default: 1000).
   * @param options.easing The easing function to use for the animation.
   * @returns A cancellable promise that resolves when the animation completes.
   *
   * @example Animate label text size and color
   * ```ts
   * mapView.animateState(label, {
   *   appearance: {
   *     textSize: state.appearance.textSize! + 1,
   *     textColor: state.appearance.textColor! === '#000000' ? 'purple' : '#000000',
   *   },
   * });
   * ```
   *
   * @example When a space is clicked it sets it to non-interactive and animates its height and color and then sets it back
   * to interactive when the animation completes.
   *
   * ```ts
   * mapView.on('click', ({ spaces }) => {
   *   if (!spaces) return;
   *   spaces.forEach(space => {
   *     const state = mapView.getState(space)!;
   *     mapView.updateState(space, {
   *       interactive: false,
   *     });
   *     currentAnimation = mapView.animateState(space, {
   *       height: state.height + 1,
   *       color: state.color === 'rgb(255, 0, 0)' ? 'blue' : 'rgb(255, 0, 0)',
   *     });
   *     currentAnimation.finally(() => {
   *       mapView.updateState(space, {
   *         interactive: true,
   *       });
   *     });
   *   });
   * });
   * ```
   */
  animateState<T$1 extends MapElementsWithState>(target: T$1, state: PartialDeep<ExtractDeep<TGetState<T$1>, number | string | undefined>>, options?: {
    duration?: number;
    easing?: EasingCurve;
  }): TCancellablePromise<TAnimateStateResult>;
  /**
   * Update global state of the MapView
   */
  updateGlobalState(update: UpdateGlobalState): void;
  /**
   * The options passed in to the {@link show3dMap} method during initialization.
   */
  get options(): ReadonlyDeep<TShow3DMapOptions>;
  /**
   * Get global state of the MapView
   */
  getGlobalState(): ReadonlyDeep<GlobalState>;
  /**
   * Triggers a manual update of the map view.
   *
   * Forces the map to re-render. This is typically not needed as the map updates automatically, but can be useful in certain edge cases.
   *
   * @example
   * ```ts
   * // Force map update after external changes
   * mapView.update();
   * ```
   */
  update: () => void;
  /**
   * Gets the current map data associated with this view.
   *
   * @returns The current MapData instance, or undefined if no map is loaded.
   * @example
   * ```ts
   * const mapData = mapView.getMapData();
   * if (mapData) {
   *   console.log('Map name:', mapData.mapName);
   *   const spaces = mapData.getByType('space');
   *   console.log('Number of spaces:', spaces.length);
   * }
   * ```
   */
  getMapData(): MapData;
  /**
   * Gets the current dimensions of the map container.
   *
   * @returns An object containing the width and height of the map container.
   * @example
   * ```ts
   * const dimensions = mapView.getDimensions();
   * console.log(`Map size: ${dimensions.width}x${dimensions.height}`);
   * ```
   */
  getDimensions(): {
    width: number;
    height: number;
  };
  /**
   * Adds a map to the MapView.
   * @param mapData The map data to add.
   * @returns A promise that resolves with the added map data.
   * @hidden
   */
  addMap(mapData: MapData, options?: TShow3DMapOptions): Promise<MapData>;
  /**
   * Sets the current floor of the map.
   *
   * Changes the visible floor and updates the camera to focus on the new floor.
   *
   * @param floor The floor to set, either as a Floor object or floor ID string.
   * @param options Optional configuration for the floor change.
   * @returns A promise that resolves when the floor change is complete.
   *
   * @example Set floor by object
   * ```ts
   * const floors = mapData.getByType('floor');
   * const groundFloor = floors.find(f => f.elevation === 0);
   * if (groundFloor) {
   *   await mapView.setFloor(groundFloor);
   * }
   * ```
   *
   * @example Set floor by ID
   * ```ts
   * await mapView.setFloor('floor-1');
   * ```
   */
  setFloor(floor: Floor | string, options?: TSetFloorOptions): void;
  /**
   * Sets the current ({@link FloorStack}) of the map.
   *
   * Changes to a specific floor stack, which may contain multiple floors for complex buildings.
   *
   * @param floorStack The floor stack to set, either as a ({@link FloorStack}) object or ID string.
   * @param options Optional configuration for the floor stack change defined in ({@link TSetFloorOptions}).
   * @returns A promise that resolves when the floor stack change is complete.
   *
   * @example Set floor stack
   * ```ts
   * const floorStacks = mapData.getByType('floor-stack');
   * const mainBuilding = floorStacks.find(fs => fs.name === 'Main Building');
   * if (mainBuilding) {
   *   await mapView.setFloorStack(mainBuilding);
   * }
   * ```
   */
  setFloorStack(floorStack: FloorStack | string, options?: TSetFloorOptions): void;
  /**
   * Preload floor geometry and outlines for the map at runtime. Can be used when anticipating a large number of floors will be visible at once to
   * keep the map responsive.
   * @param floors The floors to preload.
   */
  preloadFloors(floors: Floor[]): void;
  /**
   * Create a tween object that will be updated on every render frame.
   * See https://tweenjs.github.io/tween.js/docs/user_guide.html for more information.
   *
   * When creating a large number of tween objects, it may be important to call {@link MapView.removeTween | removeTween} to prevent memory leaks.
   *
   * @param object The data to be tweened.
   * @returns The tween object.
   */
  tween<T$1 extends Record<string, unknown>>(object: T$1): Tween<T$1>;
  /**
   * Remove a tween created with {@link MapView.tween | tween}.
   * @param tween The tween to remove.
   */
  removeTween(tween: Tween<any>): void;
  /**
   * The group which manages all tweens created with {@link MapView.tween | tween} or {@link MapView.animateState | animateState}.
   */
  get tweenGroup(): _tweenjs_tween_js0.Group;
  /**
   * Gets the current ({@link FloorStack}).
   *
   * @returns The current FloorStack, or undefined if no floor stack is set.
   * @example
   * ```ts
   * const currentStack = mapView.currentFloorStack;
   * if (currentStack) {
   *   console.log('Current floor stack:', currentStack.name);
   * }
   * ```
   */
  get currentFloorStack(): FloorStack;
  /**
   * Gets the current ({@link Floor}) of the map.
   *
   * @returns The current Floor, or undefined if no floor is set.
   * @example
   * ```ts
   * const currentFloor = mapView.currentFloor;
   * if (currentFloor) {
   *   console.log('Current floor:', currentFloor.name);
   *   console.log('Floor level:', currentFloor.level);
   * }
   * ```
   */
  get currentFloor(): Floor;
  /**
   * Updates the watermark on the map.
   *
   * @param options {WatermarkOptions}
   * @hidden
   */
  updateWatermark(options: WatermarkUpdateOptions): void;
  /**
   * Gets the current state of a map element.
   *
   * Retrieves the current visual properties and state of a map element.
   *
   * @param target The map element to get the state for.
   * @returns The current state of the element.
   *
   * @example Get space state
   * ```ts
   * const space = mapData.getById('space', 'space-123');
   * if (space) {
   *   const state = mapView.getState(space);
   *   console.log('Space color:', state.color);
   *   console.log('Space opacity:', state.opacity);
   * }
   * ```
   *
   * @example Get marker state
   * ```ts
   * const marker = mapView.Markers.add(coordinate);
   * const state = mapView.getState(marker);
   * console.log('Marker rank:', state.rank);
   * console.log('Marker placement:', state.placement);
   * ```
   */
  getState<T$1 extends MapElementsWithState>(target: T$1): TGetState<T$1>;
  /**
   * Returns the pre-computed altitude map for a given floor stack.
   * The map is keyed by floor elevation and contains the visual altitude and visual height
   * used for multi-floor rendering (floor positioning and footprints).
   *
   * @param floorStack - The floor stack (or its ID) to get altitude data for
   * @returns A map of floor elevation to altitude and visual height data
   *
   * @example
   * ```ts
   * const altitudeMap = mapView.getFloorStackAltitudeData(floorStack);
   * const groundFloor = altitudeMap.get(0);
   * console.log('Ground floor altitude:', groundFloor?.altitude);
   * console.log('Ground floor visual height:', groundFloor?.visualHeight);
   * ```
   */
  getFloorStackAltitudeData(floorStack: FloorStack | string): Map<number, TFloorAltitudeData>;
  /**
   * Gets the rendered state of a map element.
   *
   * Retrieves runtime rendering state that changes frequently, such as text visibility for labels.
   *
   * @param target The map element to get the rendered state for.
   * @returns An object containing the requested rendered state keys, or undefined if not found.
   *
   * @example Get label text visibility
   * ```ts
   * const label = mapView.Labels.add(space, 'Hello');
   * const renderedState = mapView.__EXPERIMENTAL__getRenderedState(label);
   * console.log('Text visible:', renderedState?.textVisible);
   * ```
   */
  __EXPERIMENTAL__getRenderedState<T$1 extends MapElementWithRenderedState>(target: T$1): TGetRenderedState<T$1> | undefined;
  /**
   * Sets the hover color for map elements.
   *
   * @param c The color to use for hover effects.
   * @example
   * ```ts
   * mapView.setHoverColor('#ff0000');
   * ```
   */
  setHoverColor(c: string): void;
  /**
   * Gets the current hover color.
   *
   * @returns The current hover color.
   * @example
   * ```ts
   * const hoverColor = mapView.getHoverColor();
   * console.log('Hover color:', hoverColor);
   * ```
   */
  getHoverColor(): string | undefined;
  /**
   * @internal
   */
  convertAltitudeToMercatorZoomLevel(altitude: number): number;
  /**
   * @internal
   */
  convertMercatorZoomLevelToAltitude(zoomLevel: number): number;
  /**
   * Determines if a given target is within the viewport.
   *
   * This method checks if the specified target, such as a Space, MapObject, Label, Marker, or string identifier,
   * is currently within the visible area of the map viewport. Note that this method returns `true` even if the
   * target is not visible (e.g., its visibility is set to false).
   *
   * @param target - The target to check for viewport inclusion. This can be a Space, MapObject, Label, Marker, or string identifier.
   * @returns A boolean indicating whether the target is within the viewport.
   */
  isInView(target: Space | MapObject | Label | Marker | string): boolean;
  /**
   * Gets the map elements that are currently in view.
   *
   * @param type The type of map element to get.
   * @param options Optional configuration for the in view check.
   * @returns An array of map elements that are currently in view.
   */
  getInView<T$1 extends string>(type: T$1, options?: TGetInViewOptions): MapFeatureOfType<T$1>[];
  /**
   * Returns the current scale of the map in meters per pixel.
   * @returns
   * @example
   * ```ts
   * const metersPerPixel = mapView.getMetersPerPixel();
   * console.log('Meters per pixel:', metersPerPixel);
   * ```
   */
  getMetersPerPixel(): number;
  /**
   * @deprecated Use the async version instead. This method will be made truly async in the upcoming future.
   * @internal
   */
  __LEGACY_GET_DIRECTIONS_SYNC: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], options?: TGetDirectionsOptions) => Directions | undefined;
  /**
   * Calculates ({@link Directions}) from one navigable point ({@link TNavigationTarget}) to another on the map.
   *
   * Provides turn-by-turn navigation instructions and route visualization. This method delegates to the MapData instance.
   *
   * @remarks In enterprise mode, path smoothing is disabled by default. Use the `smoothing` option to explicitly enable it if needed.
   *
   * @param from The starting location(s).
   * @param to The destination location(s).
   * @param options Optional configuration for the directions calculation.
   * @returns A Promise resolving to a {@link Directions} object containing the route, or undefined if no route is found.
   *
   * @example Get directions between spaces
   * ```ts
   * const space1 = mapData.getById('space', 'space-123');
   * const space2 = mapData.getById('space', 'space-456');
   *
   * if (space1 && space2) {
   *   const directions = await mapView.getDirections(space1, space2);
   *   if (directions) {
   *     // Show the route on the map
   *     mapView.Paths.show(directions);
   *     console.log(`Distance: ${directions.distance}m`);
   *   }
   * }
   * ```
   *
   * @see [Wayfinding Guide](https://developer.mappedin.com/web-sdk/wayfinding)
   */
  getDirections: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], options?: TGetDirectionsOptions) => Promise<Directions | undefined>;
  /**
   * Calculates directions ({@link Directions}) from one navigable point ({@link TNavigationTarget}) to multiple destination points on the map synchronously.
   *
   * Provides routes from a single starting point to multiple destinations. This method delegates to the MapData instance.
   *
   * @param from The starting location.
   * @param to An array of destination locations or arrays of destinations.
   * @param options Optional configuration for the directions calculation.
   * @returns An array of {@link Directions} objects, one for each destination.
   *
   * @example Get directions to multiple destinations
   * ```ts
   * const start = mapData.getById('space', 'entrance');
   * const destinations = [
   *   mapData.getById('space', 'store-1'),
   *   mapData.getById('space', 'store-2'),
   *   mapData.getById('space', 'restaurant')
   * ].filter(Boolean);
   *
   * const allDirections = mapView.getDirectionsMultiDestinationSync(start, destinations);
   * allDirections.forEach((directions, index) => {
   *   console.log(`Route ${index + 1}: ${directions.distance}m`);
   * });
   * ```
   *
   * @deprecated Use the async version instead. This method will be made truly async in the upcoming future.
   * @internal
   */
  __LEGACY_GET_DIRECTIONS_MULTI_DESTINATION_SYNC: (from: TNavigationTarget, to: (TNavigationTarget | TNavigationTarget[])[], options?: TGetDirectionsOptions) => Directions[] | undefined;
  /**
   * Calculates directions ({@link Directions}) from one navigable point ({@link TNavigationTarget}) to multiple destination points on the map.
   *
   * Provides routes from a single starting point to multiple destinations. This method delegates to the MapData instance.
   *
   * @remarks In enterprise mode, path smoothing is disabled by default. Use the `smoothing` option to explicitly enable it if needed.
   *
   * @param from The starting location.
   * @param to An array of destination locations or arrays of destinations.
   * @param options Optional configuration for the directions calculation.
   * @returns A Promise resolving to an array of {@link Directions} objects, one for each destination.
   *
   * @example Get directions to multiple destinations
   * ```ts
   * const start = mapData.getById('space', 'entrance');
   * const destinations = [
   *   mapData.getById('space', 'store-1'),
   *   mapData.getById('space', 'store-2'),
   *   mapData.getById('space', 'restaurant')
   * ].filter(Boolean);
   *
   * const allDirections = await mapView.getDirectionsMultiDestination(start, destinations);
   * allDirections.forEach((directions, index) => {
   *   console.log(`Route ${index + 1}: ${directions.distance}m`);
   * });
   * ```
   */
  getDirectionsMultiDestination: (from: TNavigationTarget, to: (TNavigationTarget | TNavigationTarget[])[], options?: TGetDirectionsOptions) => Promise<Directions[] | undefined>;
  /**
   * Calculates the walking distance between two navigable points ({@link TNavigationTarget}) on the map.
   *
   * Returns the walking distance between two points. This method delegates to the MapData instance.
   *
   * @param from The starting location.
   * @param to The destination location.
   * @returns The distance in meters.
   *
   * @example Calculate distance between spaces
   * ```ts
   * const space1 = mapData.getById('space', 'space-123');
   * const space2 = mapData.getById('space', 'space-456');
   *
   * if (space1 && space2) {
   *   const distance = mapView.getDistance(space1, space2);
   *   console.log(`Direct distance: ${distance}m`);
   * }
   * ```
   *
   * @example Calculate distance from coordinate
   * ```ts
   * const coordinate = mapData.mapCenter;
   * const space = mapData.getByType('space')[0];
   * const distance = mapView.getDistance(coordinate, space);
   * console.log(`Distance from center: ${distance}m`);
   * ```
   */
  getDistance(from: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node | EnterpriseLocation, to: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node | EnterpriseLocation): number | undefined;
  /**
   * Creates a {@link Coordinate} on the map.
   *
   * @param latitude The latitude of the coordinate.
   * @param longitude The longitude of the coordinate.
   * @param floor Optional floor information if applicable.
   * @returns The created Coordinate object.
   * @example
   * // Create a coordinate at the CN Tower.
   * const coord = map.createCoordinate(43.642567, -79.387054);
   *
   * // Alternatively, you can directly use the Coordinate constructor:
   * import { Coordinate } from '@mappedin/mappedin-js';
   * const coord = new Coordinate(43.642567, -79.387054, floor?.id);
   */
  createCoordinate(latitude: number, longitude: number, floor?: Floor): Coordinate;
  /**
   * Creates a {@link Coordinate} on the map using a params object.
   *
   * @param params An object containing the coordinate parameters.
   * @param params.latitude The latitude of the coordinate in decimal degrees.
   * @param params.longitude The longitude of the coordinate in decimal degrees.
   * @param params.floorId Optional ID of the floor this coordinate is on.
   * @param params.verticalOffset Optional vertical offset from the floor in meters.
   * @returns The created Coordinate object.
   * @example
   * // Create a coordinate at the CN Tower using params object.
   * const coord = map.createCoordinate({
   *   latitude: 43.642567,
   *   longitude: -79.387054
   * });
   *
   * // Alternatively, you can directly use the Coordinate constructor:
   * import { Coordinate } from '@mappedin/mappedin-js';
   * const coord = new Coordinate({
   *   latitude: 43.642567,
   *   longitude: -79.387054,
   *   floorId: 'floor1',
   *   verticalOffset: 10
   * });
   */
  createCoordinate(params: TCoordinateParams): Coordinate;
  /**
   * Create a {@link Coordinate} from an X and Y position measured in pixels from the top left
   * corner of the map canvas.
   *
   * @experimental
   */
  createCoordinateFromScreenCoordinate(x: number, y: number, floor?: Floor): Coordinate | undefined;
  /**
   * Get the X and Y of a {@link Coordinate} measured from the top left corner of the map canvas.
   *
   * @experimental
   */
  getScreenCoordinateFromCoordinate(coordinate: Coordinate): {
    x: number;
    y: number;
  };
  /**
   * @experimental
   *
   * This is an experimental feature that may undergo significant changes,
   * including breaking changes, renaming, or complete removal in future versions.
   * Do not rely on this API in production environments.
   *
   * Automatically creates labels, markers, and updates state of map elements provided with default settings.
   * @param mapElements - A custom array of map elements to automatically create labels, markers, and update state of.
   * If not provided, all map elements will be used.
   *
   * @returns An object containing auto-created labels and markers.
   */
  __EXPERIMENTAL__auto(mapElements?: MapDataElements[]): Promise<AutoElements>;
  /**
   * Subscribe a function to an event.
   *
   * @param eventName An event name which, when fired, will call the provided
   * function.
   * @param fn A callback that gets called when the corresponding event is fired. The
   * callback will get passed an argument with a type that's one of event payloads.
   * @example
   * // Subscribe to the 'click' event
   * const handler = (event) => {
   *  const { coordinate } = event;
   *  const { latitude, longitude } = coordinate;
   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
   * };
   * mapView.on('click', handler);
   */
  on: <EventName extends keyof TEvents>(eventName: EventName, fn: (payload: TEventPayload<EventName>) => void) => void;
  /**
   * Unsubscribe a function previously subscribed with {@link on}
   *
   * @param eventName An event name to which the provided function was previously
   * subscribed.
   * @param fn A function that was previously passed to {@link on}. The function must
   * have the same reference as the function that was subscribed.
   * @example
   * // Unsubscribe from the 'click' event
   * const handler = (event) => {
   *  const { coordinate } = event;
   *  const { latitude, longitude } = coordinate;
   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
   * };
   * mapView.off('click', handler);
   */
  off: <EventName extends keyof TEvents>(eventName: EventName, fn: (payload: TEventPayload<EventName>) => void) => void;
  /**
   * @internal
   */
  get __core(): RendererCore;
  /**
   * The container element of the map.
   */
  get container(): HTMLElement;
  /**
   * @internal
   */
  publishAllState(): void;
  /**
   * Clears all added elements from the map.
   */
  clear(): void;
  /**
   * Destroys the MapView.
   */
  destroy(): void;
  /**
   * @experimental
   * Enable debug interface. Learn more about the debug interface in the [Debug Mode Guide](https://developer.mappedin.com/web-sdk/getting-started#debug-mode).
   */
  enableDebug(opitons?: InspectorOption): Promise<void>;
  /**
   * @experimental
   * @internal
   */
  Debug: Debug;
  /**
   * Takes a screenshot of the current scene and returns it as a data URL.
   *
   * This captures the 3D scene and can optionally include outdoor tiles, labels, and HTML markers.
   * This does not cause the screenshot to be saved to the user's device, it only returns the data.
   *
   * @param options - Options for taking a screenshot.
   * @param options.withOutdoorContext - Whether to include the outdoor MapLibre tiles in the screenshot.
   * @default false
   * @param options.withLabels - Whether to include map labels in the screenshot.
   * @default false
   * @param options.captureMarkers - Optional. Function to capture HTML marker elements as canvas.
   * When provided with withLabels, also includes markers in the screenshot.
   * Use html2canvas, modern-screenshot, or your own implementation.
   *
   * @returns A Promise that resolves with the screenshot as a base64-encoded data URL string
   *
   * @example Basic indoor screenshot
   * ```typescript
   * const screenshot = await mapView.takeScreenshot();
   * ```
   *
   * @example Screenshot with outdoor tiles
   * ```typescript
   * const screenshot = await mapView.takeScreenshot({
   *   withOutdoorContext: true
   * });
   * ```
   *
   * @example Screenshot with labels and markers using html2canvas
   * ```typescript
   * import html2canvas from "html2canvas";
   *
   * const screenshot = await mapView.takeScreenshot({
   *   withOutdoorContext: true,
   *   withLabels: true,
   *   captureMarkers: (el) => html2canvas(el, { backgroundColor: null })
   * });
   * ```
   *
   * @example Screenshot with labels and markers using modern-screenshot
   * ```typescript
   * import { domToCanvas } from "modern-screenshot";
   *
   * const screenshot = await mapView.takeScreenshot({
   *   withLabels: true,
   *   captureMarkers: (el) => domToCanvas(el)
   * });
   * ```
   *
   * @experimental
   */
  takeScreenshot(options?: TTakeScreenshotOptions): Promise<string>;
  /**
   * @internal
   * @hidden
   * Whether the floor visibility is being self managed or automatically handled by the SDK.
   */
  get manualFloorVisibility(): boolean;
  /**
   * @internal
   * @hidden
   * Disables the default behavior of the SDK to automatically hide floors on setFloor.
   */
  set manualFloorVisibility(value: boolean);
  /**
   * @internal
   * @hidden
   * @experimental
   * Computes the optimal visual distance between floors
   */
  getOptimalVisualDistanceBetweenFloors(floors: Floor[]): number | undefined;
  /**
   * @internal
   * @deprecated For legacy use only
   *
   * If true, the map will hide paths not on the current floor.
   *
   * @default false
   */
  get __INTERNAL__hidePathsNotOnCurrentFloor(): boolean;
  /**
   * @internal
   * @deprecated For legacy use only
   *
   * If true, the map will hide paths not on the current floor.
   *
   * @default false
   */
  set __INTERNAL__hidePathsNotOnCurrentFloor(value: boolean);
  /**
   * **Super experimental — this API may change or be removed in any release without notice.
   * Do not depend on it in production.**
   *
   * Registers a plugin that runs every frame in the render loop.
   *
   * The plugin's {@link ISystemPlugin.update | update()} method receives the full
   * {@link TRendererState} — including the Three.js scene, camera, renderer, lighting,
   * and all ECS geometry entities — allowing you to inject custom Three.js objects,
   * apply per-frame effects, or read scene state.
   *
   * Plugins execute during the finalization phase of the render loop (after camera,
   * path, and 2D systems, but before `DrawSystem` and `paint()`).
   *
   * @param plugin - An object implementing {@link ISystemPlugin}. Must have an
   *   `update(state: TRendererState)` method.
   *
   * @example
   * ### Standalone mode — add a spinning cube
   * ```ts
   * import { type ISystemPlugin, type TRendererState } from '@mappedin/mappedin-js';
   * import { BoxGeometry, Mesh, MeshStandardMaterial } from 'three';
   *
   * class CubePlugin implements ISystemPlugin {
   *   private cube: Mesh | null = null;
   *
   *   update(state: TRendererState): void {
   *     if (!this.cube) {
   *       this.cube = new Mesh(
   *         new BoxGeometry(5, 5, 5),
   *         new MeshStandardMaterial({ color: 0x00ff88 }),
   *       );
   *       this.cube.position.set(0, 0, 10);
   *       state.threeJSScene.add(this.cube);
   *     }
   *     this.cube.rotation.y += 0.01;
   *   }
   * }
   *
   * mapView.registerPlugin(new CubePlugin());
   * ```
   *
   * @example
   * ### MapLibre overlay mode — add a floating sphere
   * ```ts
   * import { type ISystemPlugin, type TRendererState } from '@mappedin/mappedin-js';
   * import { Mesh, MeshStandardMaterial, SphereGeometry } from 'three';
   *
   * class SpherePlugin implements ISystemPlugin {
   *   private sphere: Mesh | null = null;
   *
   *   update(state: TRendererState): void {
   *     if (!this.sphere) {
   *       this.sphere = new Mesh(
   *         new SphereGeometry(3, 32, 32),
   *         new MeshStandardMaterial({ color: 0xff4444 }),
   *       );
   *       // In overlay mode, add to geometryScene (not threeJSScene)
   *       state.geometryScene.add(this.sphere);
   *     }
   *   }
   * }
   *
   * // Inside the overlay's 'loaded' callback:
   * overlay.on('loaded', ({ mapView }) => {
   *   mapView.registerPlugin(new SpherePlugin());
   * });
   * ```
   *
   * @see {@link unregisterPlugin} to remove a plugin.
   * @see {@link ISystemPlugin} for the plugin interface and lifecycle details.
   *
   * @experimental
   */
  registerPlugin(plugin: ISystemPlugin$1): void;
  /**
   * **Super experimental — this API may change or be removed in any release without notice.
   * Do not depend on it in production.**
   *
   * Removes a previously registered plugin from the render loop.
   *
   * After removal, the plugin's `update()` method will no longer be called.
   * Any Three.js objects the plugin added to the scene are **not** automatically
   * removed — the plugin is responsible for its own cleanup before or after
   * unregistration.
   *
   * @param plugin - The same plugin instance that was passed to {@link registerPlugin}.
   *
   * @example
   * ```ts
   * const plugin = new CubePlugin();
   *
   * mapView.registerPlugin(plugin);
   *
   * // Later, when the plugin is no longer needed:
   * mapView.unregisterPlugin(plugin);
   * ```
   *
   * @see {@link registerPlugin} to add a plugin.
   *
   * @experimental
   */
  unregisterPlugin(plugin: ISystemPlugin$1): void;
}
//#endregion
//#region src/api-geojson/camera.d.ts
/**
 * ## Camera in Mappedin JS
 *
 * The Camera class controls the map's viewpoint, including position, pitch, bearing, and zoom. It can instantly reposition or animate to a new location, and can focus on one or more map elements.
 *
 * ### Features
 * - Focus on any map element (space, coordinate, marker, etc.)
 * - Smooth animation and custom easing
 * - Control pan, zoom, bearing, and pitch
 * - Set safe screen areas (insets) for UI overlays
 *
 * > **Best Practice:** Use `focusOn` for user-driven navigation (e.g., "Show this store"), and `animateTo` for smooth transitions between known camera states.
 *
 * ### Example Usage
 * ```ts
 * // Focus on a single space
 * mapView.Camera.focusOn(space, { minZoomLevel: 5 });
 *
 * // Animate to a specific camera target
 * mapView.Camera.animateTo({ center: coordinate, zoomLevel: 6, bearing: 45 });
 *
 * // Set the camera instantly
 * mapView.Camera.set({ center: coordinate, zoomLevel: 7 });
 *
 * // Set safe screen insets (e.g., for a sidebar)
 * mapView.Camera.setScreenOffsets({ left: 300, top: 0, right: 0, bottom: 0 });
 * ```
 *
 * ### Advanced
 * - Use `getFocusOnTransform` to calculate the camera transform before applying it.
 * - Use `interactions.set` to enable/disable pan, zoom, or rotation.
 *
 * ### More Information
 * - [Camera Guide](https://developer.mappedin.com/web-sdk/camera)
 *
 * This class is accessed using {@link MapView.Camera}.
 */
declare class Camera {
  #private;
  /**
   * @internal
   */
  constructor(api: GeoJsonApi);
  /**
   * Controls which camera interactions are enabled/disabled.
   *
   * @example
   * ```ts
   * // Disable zoom and rotation
   * mapView.Camera.interactions.set({ zoom: false, bearingAndPitch: false });
   *
   * // Enable all interactions
   * mapView.Camera.interactions.enable();
   *
   * // Disable all interactions
   * mapView.Camera.interactions.disable();
   * ```
   */
  interactions: {
    set: (options: TCameraInteractionsSetOptions) => void;
    enable: () => void;
    disable: () => void;
  };
  /**
   * Define an area of the screen that is safe for the camera. Anything outside the safe area is assumed to be covered in some way. The camera will not place any map elements there when calling {@link Camera.focusOn}.
   *
   * @param padding The padding to apply. Can specify individual sides and optionally the type.
   * - `type`: 'pixel' (absolute pixels) or 'portion' (fraction of canvas, 0-1). Defaults to 'pixel'.
   * - When updating without specifying type, the existing type is preserved.
   * @example
   * // Reserve 300px on the left for a sidebar
   * mapView.Camera.setScreenOffsets({ left: 300, top: 0, right: 0, bottom: 0 });
   *
   * @example
   * // Reserve 20% of the screen height at the top using portion type
   * mapView.Camera.setScreenOffsets({ top: 0.2, type: 'portion' });
   *
   * @example
   * // Update only the bottom padding, preserving existing type and other values
   * mapView.Camera.setScreenOffsets({ bottom: 50 });
   */
  setScreenOffsets(padding: Partial<InsetPadding$1>): void;
  get screenOffsets(): InsetPadding$1;
  /**
   * The camera's current pan mode.
   */
  get panMode(): "elevation" | "default";
  /**
   * Set the camera's pan mode. 'elevation' moves the camera up and down, while 'default' allows the camera to pan in all directions.
   * @experimental
   * @param panMode The new pan mode.
   */
  setPanMode(panMode: 'default' | 'elevation'): void;
  /**
   * Get the camera transform that can be used to focus on a target or array of targets. Similar to {@link Camera.focusOn} but returns the transform directly.
   * @param target The target(s) to get the camera transform for.
   * @param options Optional settings for the camera transform.
   * @returns The camera transform which can then be passed to {@link Camera.set} or {@link Camera.animateTo}.
   *
   * @example
   * // Focus on a single space
   * const transform = mapView.Camera.getFocusOnTransform(space, { minZoomLevel: 5 });
   * mapView.Camera.animateTo(transform);
   */
  getFocusOnTransform(target: IFocusable | IFocusable[], options?: TFocusOnOptions): TCameraTarget;
  /**
   * Focuses the camera on a specific target or array of targets.
   *
   * @param target The target(s) to focus on, either a single element or an array of elements.
   * @param options Optional settings for focusing the camera (see {@link TFocusOnOptions}).
   * @returns A promise that resolves when the camera animation is complete.
   *
   * @example Focus on a single space
   * ```ts
   * mapView.Camera.focusOn(space, { minZoomLevel: 5 });
   * ```
   *
   * @example Focus on multiple elements
   * ```ts
   * mapView.Camera.focusOn([space1, space2], { pitch: 45 });
   * ```
   *
   * @see [Camera Guide](https://developer.mappedin.com/web-sdk/camera)
   */
  focusOn(target: IFocusable | IFocusable[], options?: TFocusOnOptions): Promise<void>;
  /**
   * Animates the camera to a specific target.
   *
   * @param target The camera target ({@link TCameraTarget}) to animate to.
   * @param options Optional animation options (see {@link TCameraAnimationOptions}).
   * @returns A promise that resolves when the animation is complete.
   *
   * @example
   * mapView.Camera.animateTo({ center: coordinate, zoomLevel: 6, bearing: 45 }, { duration: 1000 });
   */
  animateTo(target: TCameraTarget, options?: TCameraAnimationOptions): Promise<void>;
  /**
   * Instantly sets the camera to a specific target.
   *
   * @param target The camera target ({@link TCameraTarget}) to set.
   *
   * @example
   * mapView.Camera.set({ center: coordinate, zoomLevel: 7 });
   */
  set(target: TCameraTarget): void;
  /**
   * The current center coordinate ({@link Coordinate}) of the camera.
   */
  get center(): Coordinate;
  /**
   * Toggle the mode of the camera to automatically set the minimum zoom level based on the size of the scene.
   * It will be automatically disabled when the minimum zoom level is set manually.
   * @param value The new value for the auto min zoom level mode.
   */
  setAutoMinZoomLevel(value: boolean): void;
  /**
   * The mode of the camera to automatically set the minimum zoom level based on the size of the scene.
   */
  get autoMinZoomLevel(): boolean;
  /**
   * The current zoom level of the camera in mercator zoom levels.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  get zoomLevel(): number;
  /**
   * The current pitch of the camera in degrees.
   */
  get pitch(): number;
  /**
   * The minimum pitch of the camera in degrees.
   */
  get minPitch(): number;
  /**
   * The maximum pitch of the camera in degrees.
   */
  get maxPitch(): number;
  /**
   * Update the minimum pitch of the camera in degrees.
   * @param minPitch The new minimum pitch.
   */
  setMinPitch: (minPitch: number) => void;
  /**
   * Update the maximum pitch of the camera in degrees.
   * @param maxPitch The new maximum pitch.
   */
  setMaxPitch: (maxPitch: number) => void;
  /**
   * The current bearing of the camera in degrees clockwise from North. 0 degrees is North, 90 degrees is East, 180 degrees is South, and 270 degrees is West.
   */
  get bearing(): number;
  /**
   * The minimum zoom level of the camera in mercator zoom levels.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  get minZoomLevel(): number;
  /**
   * Update the minimum zoom level of the camera in mercator zoom levels.
   * @param zoomLevel The new minimum zoom level.
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  setMinZoomLevel: (zoomLevel: number) => void;
  /**
   * The maximum zoom level of the camera in mercator zoom levels.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  get maxZoomLevel(): number;
  /**
   * Update the maximum zoom level of the camera in mercator zoom levels.
   * @param zoomLevel The new maximum zoom level.
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   * @default 22
   * @max 24
   * @min 0
   */
  setMaxZoomLevel: (zoomLevel: number) => void;
  /**
   * Set the camera's elevation in meters.
   * @experimental
   * @param elevation The new elevation in meters.
   */
  setElevation(elevation: number): void;
  /**
   * The current elevation of the camera in meters.
   */
  get elevation(): number;
  /**
   * Animate the camera's elevation to a specified elevation.
   * @experimental
   * @param elevation The target elevation in meters.
   * @param options Optional settings for the camera animation.
   */
  animateElevation(elevation: number, options?: TCameraAnimationOptions): Promise<void>;
  /**
   * The current pan boundary of the camera.
   */
  get bounds(): CameraBounds;
  get isAnimating(): boolean;
  cancelAnimation(): void;
  /**
   * @internal
   * @experimental
   * Force an update of the facades in view.
   */
  updateFacadesInView(): void;
}
//#endregion
//#region src/api-geojson/exporter.d.ts
/**
 * API to export the scene.
 *
 * @hidden
 */
declare class Exporter {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter$6;
  });
  /**
   * Exports the current scene as a GLTF file.
   *
   * @hidden
   */
  getCurrentSceneGLTF(userOptions: GLTFExportOptions$1): Promise<Blob>;
}
type CurrentMapGetter$6 = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/labels.d.ts
/**
 * ## Labels in Mappedin JS
 *
 * Labels are text elements anchored to map objects that automatically rotate, show/hide based on priority and zoom level, and manage collisions with other labels. They're perfect for displaying location names, points of interest, and contextual information.
 *
 * ### Features
 * - Automatic collision management and visibility ranking
 * - Customizable appearance (color, font, background, etc.)
 * - Support for interactivity (click, hover)
 * - Automatic rotation and positioning
 * - Batch operations for adding all labels at once
 *
 * > **Best Practice:** Use the `rank` option to control label visibility priority. Use `interactive: true` to enable click/hover events for important labels.
 *
 * ### Example Usage
 * ```ts
 * // Add a single label
 * mapView.Labels.add(space, 'Welcome', { appearance: { color: 'blue' } });
 *
 * // Add a label with high priority
 * mapView.Labels.add(space, 'Main Entrance', { rank: 'always-visible' });
 *
 * // Add all labels automatically (experimental)
 * mapView.Labels.__EXPERIMENTAL__all();
 *
 * // Remove a specific label
 * mapView.Labels.remove(label);
 *
 * // Remove all labels
 * mapView.Labels.removeAll();
 * ```
 *
 * ### Advanced
 * - Use `appearance` to customize colors, fonts, and backgrounds.
 * - Use `rank` to control collision priority ('low', 'medium', 'high', 'always-visible').
 * - Use `__EXPERIMENTAL__all()` to automatically add labels for all map objects with predefined text (experimental feature).
 *
 * ### More Information
 * - [Labels Guide](https://developer.mappedin.com/web-sdk/labels)
 *
 * This class is accessed using {@link MapView.Labels}.
 */
declare class Labels {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter$5;
  });
  getAll(): Label[];
  /**
   * @internal
   */
  getById(id: string): {
    label: Label;
    entityId: string;
  } | undefined;
  /**
   * Adds a label ({@link Label}) to the map.
   *
   * @param target The target object ({@link IAnchorable}) where the label should be added (e.g., {@link Space}, {@link Door}, {@link Coordinate}, or {@link Node}).
   * @param text The text content of the label.
   * @param options Optional additional options for the label (see {@link TAddLabelOptions}).
   * @returns {Label | undefined} The created label, or undefined if creation failed.
   *
   * @example Add a simple label
   * ```ts
   * mapView.Labels.add(space, 'Welcome', { appearance: { color: 'blue' } });
   * ```
   *
   * @example Add a high-priority interactive label
   * ```ts
   * mapView.Labels.add(space, 'Main Entrance', {
   *   rank: 'always-visible',
   *   interactive: true,
   *   appearance: {
   *     color: 'red',
   *     backgroundColor: 'white',
   *     fontSize: 14
   *   }
   * });
   * ```
   *
   * @see [Labels Guide](https://developer.mappedin.com/web-sdk/labels)
   */
  add(target: IAnchorable, text: string, options?: TAddLabelOptions | undefined): Label;
  /**
   * @experimental
   * @warning **EXPERIMENTAL FEATURE UNDER CONSTRUCTION**
   *
   * This is an experimental feature that may undergo significant changes,
   * including breaking changes, renaming, or complete removal in future versions.
   * Do not rely on this API in production environments.
   *
   * Automatically adds all the labels ({@link Label}) to the map.
   *
   * The text, appearance, priority, etc. of the labels will be automatically determined based on the external data from the map.
   *
   * @param options Optional additional options for the labels, similar to those in the `add` method (see {@link TAddLabelOptions}).
   * @returns An array of all created {@link Label} instances.
   *
   * @example Add all labels with default settings
   * ```ts
   * const labels = mapView.Labels.__EXPERIMENTAL__all();
   * ```
   *
   * @example Add all labels with custom appearance
   * ```ts
   * const labels = mapView.Labels.__EXPERIMENTAL__all({
   *   appearance: { color: 'darkblue' },
   *   rank: 'high'
   * });
   * ```
   */
  __EXPERIMENTAL__all(options?: TAddLabelOptions): Label[];
  /**
   * Removes a label ({@link Label}) from the map.
   *
   * @param label The label which should be removed.
   * @example
   * mapView.Labels.remove(label);
   */
  remove(label: Label): void;
  /**
   * Removes all the labels ({@link Label}) from the map.
   *
   * @returns An array of all removed {@link Label} instances.
   * @example
   * const removedLabels = mapView.Labels.removeAll();
   */
  removeAll(): Label[];
}
type CurrentMapGetter$5 = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/markers.d.ts
/**
 * ## Markers in Mappedin JS
 *
 * Markers are interactive HTML elements anchored to a {@link Door}, {@link Space}, {@link Coordinate}, or {@link Node} on the map. They automatically rotate and reposition as the camera moves, making them ideal for highlighting points of interest, custom icons, or interactive UI overlays.
 *
 * ### Features
 * - Fully customizable HTML content
 * - Automatic collision management and visibility ranking
 * - Support for interactivity (click, hover, etc.)
 * - Dynamic resizing and animation
 *
 * > **Best Practice:** Use the `rank` option to control marker visibility priority. Use `interactive: true` to enable SDK-level click/hover events, or `'pointer-events-auto'` for native browser pointer events.
 *
 * ### Example Usage
 * ```ts
 * // Add a simple marker
 * mapView.Markers.add(coordinate, '<div>Marker Content</div>', { interactive: true });
 *
 * // Add a marker with custom placement and high priority
 * mapView.Markers.add(space, '<div>Shop</div>', { placement: 'top', rank: 'always-visible' });
 *
 * // Remove a marker
 * mapView.Markers.remove(marker);
 *
 * // Remove all markers
 * mapView.Markers.removeAll();
 *
 * // Move a marker to a new coordinate
 * mapView.Markers.setPosition(marker, newCoordinate);
 *
 * // Animate a marker to a new coordinate
 * mapView.Markers.animateTo(marker, newCoordinate, { duration: 1000 });
 * ```
 *
 * ### Advanced
 * - Dynamic resizing is enabled by default - use `dynamicResize: false` for static content.
 * - Use `zIndex` and `rank: 'always-visible'` to keep important markers on top.
 *
 * ### More Information
 * - [Markers Guide](https://developer.mappedin.com/web-sdk/markers)
 *
 * This class is accessed using {@link MapView.Markers}.
 */
declare class Markers {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter$4;
  });
  getAll(): Marker[];
  /**
   * @internal
   */
  getById(id: string): {
    marker: Marker;
    entityId: string;
  } | undefined;
  /**
   * Adds a marker to the map.
   *
   * @param target The target object ({@link IAnchorable}) for the marker (e.g., {@link Space}, {@link Door}, {@link Coordinate}, or {@link Node}).
   * @param html The HTML content for the {@link Marker}.
   * @param options Optional additional options for the {@link Marker} (see {@link TAddMarkerOptions}).
   * @returns {Marker | undefined} The created {@link Marker}, or undefined if creation failed.
   *
   * @example Add an interactive marker with custom HTML
   * ```ts
   * mapView.Markers.add(coordinate, '<div>Marker Content</div>', { interactive: true });
   * ```
   *
   * @example Add a marker with high priority and custom placement
   * ```ts
   * mapView.Markers.add(space, '<div>Shop</div>', { placement: 'top', rank: 'always-visible' });
   * ```
   *
   * @see [Markers Guide](https://developer.mappedin.com/web-sdk/markers)
   */
  add(target: IAnchorable, html: string, options?: TAddMarkerOptions): Marker;
  /**
   * Removes a marker from the map.
   *
   * @param marker {Marker} The {@link Marker} which should be removed.
   * @example
   * mapView.Markers.remove(marker);
   */
  remove(marker: Marker): void;
  /**
   * Remove all the markers from the map.
   *
   * @example
   * mapView.Markers.removeAll();
   */
  removeAll(): Marker[];
  /**
   * Update the position of a marker.
   * @param marker The {@link Marker} which should be moved.
   * @param target The new target object ({@link Space}, {@link Door}, or {@link Coordinate}) for the marker.
   * @example
   * const marker = mapView.Markers.add(coordinate, '<div>Marker Content</div>');
   * mapView.Markers.setPosition(marker, newCoordinate);
   */
  setPosition(marker: Marker, target: IAnchorable): void;
  /**
   * Update the position of a marker with an animation.
   * @param marker The {@link Marker} which should be updated.
   * @param target The new target object ({@link Space}, {@link Door}, or {@link Coordinate}) for the marker.
   * @param options Optional additional options for the animation (see {@link TAnimationOptions}).
   * @returns {Promise<void>} A promise that resolves when the animation is complete.
   * @example
   * const marker = mapView.Markers.add(coordinate, '<div>Marker Content</div>');
   * mapView.Markers.animateTo(marker, newCoordinate, { duration: 1000 });
   */
  animateTo(marker: Marker, target: IAnchorable, options?: TAnimationOptions): Promise<void>;
}
type CurrentMapGetter$4 = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/images.d.ts
/**
 * ## 3D images in Mappedin JS
 *
 * Images can enhance indoor maps by adding custom branding, highlighting important features, or providing additional visual information. They can be placed on any {@link Door}, {@link Space}, or {@link Coordinate} and support various positioning and styling options.
 *
 * ### Features
 * - Support for JPEG and PNG formats
 * - Automatic caching and reuse of identical URLs
 * - Customizable size, rotation, and vertical offset
 * - Option to face the camera automatically
 * - Memory-efficient rendering
 *
 * > **Best Practice:** Consider image memory usage carefully. The SDK caches images with the same URL, so reuse images when possible. Large images can impact performance on mobile devices.
 *
 * ### Memory Usage Calculation
 * Formula: `width * height * 4 bytes/pixel = memory used`
 * - 512 x 512 Pixel Image: `512px * 512px * 4 bytes/pixel = 1MB`
 * - 4096 x 4096 Pixel Image: `4096px * 4096px * 4 bytes/pixel = 64MB`
 *
 * ### Example Usage
 * ```ts
 * // Add a simple image
 * mapView.Image3D.add(coordinate, 'https://example.com/logo.png', { width: 2, height: 1 });
 *
 * // Add an image with custom positioning
 * mapView.Image3D.add(space, 'https://example.com/banner.jpg', {
 *   width: 3,
 *   height: 1.5,
 *   rotation: 45,
 *   verticalOffset: 2
 * });
 *
 * // Add an image that faces the camera
 * mapView.Image3D.add(coordinate, 'https://example.com/icon.png', {
 *   width: 1,
 *   height: 1,
 *   flipImageToFaceCamera: true
 * });
 *
 * // Remove an image
 * mapView.Image3D.remove(image);
 *
 * // Remove all images
 * mapView.Image3D.removeAll();
 * ```
 *
 * ### Advanced
 * - Use `flipImageToFaceCamera: true` for billboard-style images that always face the user.
 * - Use `verticalOffset` to position images above or below the anchor point.
 * - Use `rotation` to orient images in specific directions.
 *
 * ### Performance Tips
 * - Reuse image URLs to take advantage of caching.
 * - Use appropriately sized images for your use case.
 * - Consider using smaller images on mobile devices.
 *
 * ### More Information
 * - [Images Guide](https://developer.mappedin.com/web-sdk/images-textures)
 *
 * This class is accessed using {@link MapView.Image3D}.
 */
declare class Image3D {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter,
    mapDataInternalGetter
  }: {
    currentMapGetter: CurrentMapGetter$3;
    mapDataInternalGetter?: MapDataInternalGetter$1;
  });
  /**
   * @internal
   */
  getById(id: string): {
    image: Image3DView;
    entityId: string;
    anchorId?: string;
  } | undefined;
  /**
   * Adds an image to the map.
   *
   * @param target The target object ({@link IAnchorable}) for the image (e.g., {@link Space}, {@link Door}, or {@link Coordinate}).
   * @param url The URL of the image (JPEG or PNG format).
   * @param options Configuration options for the image (see {@link TAddImageOptions}).
   * @returns The created {@link Image3DView} instance.
   *
   * @example Add a simple image
   * ```ts
   * mapView.Image3D.add(coordinate, 'https://example.com/logo.png', { width: 2, height: 1 });
   * ```
   *
   * @example Add an image with custom positioning
   * ```ts
   * mapView.Image3D.add(space, 'https://example.com/banner.jpg', {
   *   width: 3,
   *   height: 1.5,
   *   rotation: 45,
   *   verticalOffset: 2
   * });
   * ```
   *
   * @example Add a billboard-style image
   * ```ts
   * mapView.Image3D.add(coordinate, 'https://example.com/icon.png', {
   *   width: 1,
   *   height: 1,
   *   flipImageToFaceCamera: true
   * });
   * ```
   *
   * @see [Images Guide](https://developer.mappedin.com/web-sdk/images-textures)
   */
  add(target: IAnchorable, url: string, options: TAddImageOptions): Image3DView;
  /**
   * Removes an image from the map.
   *
   * @param image The {@link Image3DView} instance to remove.
   * @example
   * ```ts
   * mapView.Image3D.remove(image);
   * ```
   */
  remove(image: Image3DView): void;
  /**
   * Remove all the images from the map.
   *
   * @returns An array of all removed {@link Image3DView} instances.
   * @example
   * ```ts
   * const removedImages = mapView.Image3D.removeAll();
   * ```
   */
  removeAll(): Image3DView[];
}
type CurrentMapGetter$3 = () => GeojsonApiMapObject | undefined;
type MapDataInternalGetter$1 = () => MapDataInternal | undefined;
//#endregion
//#region src/api-geojson/types.d.ts
type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/models.d.ts
type MapDataInternalGetter = () => MapDataInternal | undefined;
/**
 * ## 3D Models in Mappedin JS
 *
 * 3D models can be used to represent landmarks, assets, or furniture, providing a rich and interactive indoor map experience. Mappedin JS supports models in GLTF and GLB formats. **Models with nested meshes are not supported.**
 *
 * ### Supported Formats
 * - GLTF (.gltf)
 * - GLB (.glb)
 * - Inline base64 models (from the Mappedin 3D Assets Library)
 *
 * ### Adding 3D Models
 * Use the `add` method to place a model at a specific {@link Coordinate}.
 *
 * ### Mappedin 3D Assets Library
 * Mappedin provides a library of ready-to-use 3D models for common indoor objects. You can install it via npm:
 *
 * ```bash
 * npm install @mappedin/3d-assets
 * ```
 *
 * - [Mappedin 3D Assets on npm](https://www.npmjs.com/package/@mappedin/3d-assets)
 *
 * #### Usage (Self-hosted GLB files)
 * ```ts
 * const coordinate = mapView.createCoordinate(45, -75);
 * mapView.Models.add(coordinate, 'https://your-domain.com/assets/model.glb');
 * ```
 *
 * #### Usage (Direct base64 imports)
 * ```ts
 * import { bed } from '@mappedin/3d-assets/inline';
 * const coordinate = mapView.createCoordinate(45, -75);
 * mapView.Models.add(coordinate, bed);
 * ```
 *
 * > **Best Practice:** Use self-hosted GLB files for smaller download size and better caching. Use direct imports for convenience and rapid prototyping.
 *
 * ### Performance Tips
 * - Avoid using models with nested meshes.
 *
 * ### More Information
 * - [3D Models Guide](https://developer.mappedin.com/web-sdk/3d-models)
 * - [Mappedin 3D Assets Library](https://www.npmjs.com/package/@mappedin/3d-assets)
 *
 * This class is accessed using {@link MapView.Models}.
 */
declare class Models {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter,
    mapDataInternalGetter
  }: {
    currentMapGetter: CurrentMapGetter;
    mapDataInternalGetter?: MapDataInternalGetter;
  });
  /**
   * @internal
   */
  getById(id: string): {
    model: Model;
    entityId: string;
    groupId: string;
  } | undefined;
  /**
   * Adds a 3D model to the map at the specified coordinate.
   *
   * @param coordinate - The {@link Coordinate} where the model will be placed.
   * @param url - The URL to the GLTF or GLB model file, or an inline base64 encoded 3D asset from the [Mappedin 3D Assets Library](https://www.npmjs.com/package/@mappedin/3d-assets).
   * @param options - Configuration options for the model using {@link TAddModelOptions}.
   * @returns A {@link Model} instance representing the added 3D model.
   *
   * @example Add a model from a self-hosted GLB file
   * ```ts
   * const coordinate = mapView.createCoordinate(45, -75);
   * mapView.Models.add(coordinate, 'https://your-domain.com/assets/model.glb', {
   *   scale: [1, 1, 1],
   *   rotation: [0, 0, 0],
   *   interactive: true
   * });
   * ```
   *
   * @example Add a model from the Mappedin 3D Assets Library (base64 import)
   * ```ts
   * import { bed } from '@mappedin/3d-assets/inline';
   * const coordinate = mapView.createCoordinate(45, -75);
   * mapView.Models.add(coordinate, bed, {
   *   scale: [0.5, 0.5, 0.5],
   *   rotation: [0, 90, 0],
   *   interactive: true
   * });
   * ```
   *
   * @see [3D Models Guide](https://developer.mappedin.com/web-sdk/3d-models)
   * @see [Mappedin 3D Assets Library](https://www.npmjs.com/package/@mappedin/3d-assets)
   */
  add(coordinate: Coordinate, url: string, options?: TAddModelOptions): Model;
  /**
   * Automatically adds all 3D models defined in the venue.
   *
   * Reads model data from the venue's map data and adds
   * each model to the map at its configured coordinate with the specified
   * rotation, scale, color, and clipping settings.
   *
   * @returns An array of {@link Model} instances that were added to the map.
   * Returns an empty array when the venue has no model data
   * or none of the model entries are valid.
   *
   * @example
   * ```ts
   * const models = mapView.Models.all();
   * console.log(`Added ${models.length} models to the map`);
   * ```
   */
  all(): Model[];
  /**
   * Removes a model from the map.
   *
   * @param model - The {@link Model} instance which should be removed.
   * @example
   * mapView.Models.remove(model);
   */
  remove(model: Model): void;
  /**
   * Remove all the models from the map.
   *
   * @returns An array of all removed {@link Model} instances.
   * @example
   * const removedModels = mapView.Models.removeAll();
   */
  removeAll(): Model[];
}
//#endregion
//#region src/api-geojson/paths.d.ts
/**
 * ## Paths in Mappedin JS
 *
 * Paths allow you to draw custom routes on the map, from simple straight lines between coordinates to complex navigation paths that avoid obstacles. While {@link Navigation} provides complete turn-by-turn directions, Paths give you fine-grained control over route visualization.
 *
 * ### Features
 * - Draw paths between any coordinates
 * - Customizable styling (color, width, animation, etc.)
 * - Integration with navigation directions
 * - Animated path drawing and pulse effects
 * - Support for dashed lines and arrows
 *
 * > **Best Practice:** Use `MapData.getDirections()` to generate navigation-aware paths that avoid walls and follow walkable routes, rather than drawing straight lines between coordinates.
 *
 * ### Example Usage
 * ```ts
 * // Draw a simple straight path
 * const path = mapView.Paths.add([coord1, coord2], { color: '#ff0000' });
 *
 * // Draw a navigation path using directions
 * const directions = await mapView.getDirections(space1, space2);
 * if (directions) {
 *   const path = mapView.Paths.add(directions.path, {
 *     color: '#4b90e2',
 *     showPulse: true,
 *     animateDrawing: true
 *   });
 * }
 *
 * // Remove a path
 * mapView.Paths.remove(path);
 *
 * // Remove all paths
 * mapView.Paths.removeAll();
 * ```
 *
 * ### Path Styling Options
 * - `color`: Path color (default: '#4b90e2')
 * - `width`: Path width. Can be a number or an {@link Interpolation}.
 * - `showPulse`: Animated pulse indicating direction
 * - `animateDrawing`: Animate path drawing
 * - `displayArrowsOnPath`: Show direction arrows
 * - `dashed`: Use dashed line style
 *
 * ### Advanced
 * - Use `interactive: true` to make paths clickable.
 *
 * ### More Information
 * - [Wayfinding Guide](https://developer.mappedin.com/web-sdk/wayfinding#drawing-a-path)
 *
 * This class is accessed using {@link MapView.Paths}.
 */
declare class Paths {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter$2;
  });
  /**
   * @internal
   */
  getById(id: string): Path | undefined;
  /**
   * Adds a path ({@link Path}) to the map.
   * @param coordinates Array of coordinates ({@link Coordinate}) to form the path.
   * @param options Optional styling and behavior options (see {@link TAddPathOptions}).
   * @returns A {@link Path} instance representing the created path.
   *
   * @example Draw a simple red path
   * ```ts
   * const path = mapView.Paths.add([coord1, coord2], { color: '#ff0000' });
   * ```
   *
   * @example Draw a navigation path with animation
   * ```ts
   * const directions = await mapView.getDirections(space1, space2);
   * if (directions) {
   *   const path = mapView.Paths.add(directions.path, {
   *     color: '#4b90e2',
   *     showPulse: true,
   *     animateDrawing: true,
   *     displayArrowsOnPath: true
   *   });
   * }
   * ```
   *
   * @example Draw a dashed path with custom width
   * ```ts
   * const path = mapView.Paths.add(coordinates, {
   *   color: '#00ff00',
   *   dashed: true,
   *   width: 1,
   * });
   * ```
   *
   * @see [Wayfinding Guide](https://developer.mappedin.com/web-sdk/wayfinding#drawing-a-path)
   */
  add(coordinates: Coordinate[], options?: {
    id?: string;
  } & TAddPathOptions): Path;
  /**
   *
   * Highlights a section of a path between two coordinates.
   *
   * @param path The path to highlight.
   * @param start The start coordinate.
   * @param end The end coordinate.
   * @param options The options for the highlight.
   */
  highlightPathSection(path: Path, start: Coordinate, end: Coordinate, options?: TPathSectionHighlightOptions): {
    animation: Promise<unknown>;
  } | undefined;
  /**
   * Clears the highlighted section of a path.
   * @param path The path to clear the highlight from.
   */
  clearHighlightedPathSection(path: Path): void;
  /**
   * Clears the highlighted section of all paths.
   */
  clearAllHighlightedPathSections(): void;
  /**
   * Removes a specific path ({@link Path}) from the map.
   * @param path The path to be removed.
   * @example
   * mapView.Paths.remove(path);
   */
  remove(path: Path): void;
  /**
   * Removes all paths ({@link Path}) from the map.
   *
   * @returns An array of all removed {@link Path} instances.
   * @example
   * const removedPaths = mapView.Paths.removeAll();
   */
  removeAll(): Path[];
}
type CurrentMapGetter$2 = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/style.d.ts
declare class Style {
  #private;
  /**
   * @internal
   */
  get currentMap(): GeojsonApiMapObject | undefined;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter$1;
  });
  setFromStyleCollection(styleCollection: StyleCollection): void;
}
type CurrentMapGetter$1 = () => GeojsonApiMapObject | undefined;
//#endregion
//#region src/api-geojson/outdoor.d.ts
type HiddenOutdoorGeometry = [polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[], layers: string[]];
/**
 * The outdoor map shown around the Mappedin indoor map can be manipulated to show or hide additional information. It can be used to add GeoJSON based geometry, images, deck.gl layers and more.
 *
 * The outdoor map is accessed using {@link MapView.Outdoor}, which returns a maplibregl.Map object.
 * [MapLibre GL JS](https://maplibre.org/maplibre-gl-js/docs/) is a TypeScript library that uses WebGL to render interactive maps from vector tiles in a browser. The Mappedin SDK makes use of it to display the outdoor map.
 *
 * By providing access to the MapLibre map used to draw the outdoor map, the Mappedin SDK enables developers to draw on and manipulate the outdoor map.
 * Developers can use most capabilities of MapLibre GL JS with key exceptions being Interactivity and Camera, which are not available.
 *
 * User touch and click events are handled by Mappedin JS and are not propagated to the outdoor map layer. Camera movement is also handled by Mappedin JS and cannot be manipulated using MapLibre controls.
 *
 * Refer to the [Outdoor Map Guide](https://developer.mappedin.com/web-sdk/outdoor-map) for more information and interactive examples.
 */
declare class Outdoor {
  #private;
  /**
   * @internal
   */
  constructor(core: RendererCore, hiddenOutdoorGeometry?: HiddenOutdoorGeometry[]);
  /**
   * Set the style of the outdoor map. Use one of [Mappedin's predefined styles](https://developer.mappedin.com/web-sdk/outdoor-map#styles) or link to a custom style.
   * @param style {any}
   */
  setStyle(style: any): void;
  /**
   * Returns a Maplibre map for advanced usage.
   *
   * @returns {object} Maplibre map instance
   *
   * Limitations:
   * - Maplibre interaction events are not supported, use Mappedin JS interaction events.
   * - Maplibre markers and labels may overlap as they are not integrated with the Mappedin JS collision engine.
   */
  get map(): Map$1 | undefined;
  /**
   * Whether the outdoorView is enabled.
   */
  get enabled(): boolean;
  /**
   * Whether the outdoorView is visible.
   */
  get visible(): boolean;
  /**
   * Show the outdoor map.
   */
  show(): void;
  /**
   * Hide the outdoor map.
   * @param excludedStyleLayerIds {string[]}
   */
  hide(excludedStyleLayerIds?: string[]): void;
  /**
   * Set outdoor view opacity.
   * @param targetOpacity {number | 'initial'}
   * @param excludedStyleLayerIds {string[]}
   */
  setOpacity(targetOpacity: number | 'initial', excludedStyleLayerIds?: string[]): void;
}
//#endregion
//#region src/api-geojson/text3d.d.ts
/**
 * Disables the Text3D web worker and falls back to processing on the main thread.
 *
 * This function should be called when using Text3D features in environments
 * with strict Content Security Policy (CSP) that blocks web workers from
 * being created using blob: URLs or unsafe-eval directives.
 *
 * While disabling the worker may slightly impact performance for complex text
 * rendering, it enables Text3D functionality in CSP-restricted environments.
 *
 * Ensure calling this before calling preloadFont
 *
 * @example
 * ```typescript
 * import {disableText3DWorker} from '@mappedin/mappedin-js';
 * // Disable Text3D worker for CSP compatibility
 * disableText3DWorker();
 *
 * // Then use Text3D features as normal
 * mapView.Text3D.labelAll();
 * ```
 */
declare function disableText3DWorker(): void;
/**
 * ## Text3D in Mappedin JS
 *
 * Text3D creates three-dimensional text labels that are rendered directly in the 3D scene. These labels are perfect for displaying space names, room numbers, or any text that needs to be visible from any angle in the 3D environment.
 *
 * ### Features
 * - 3D text rendering with depth and perspective
 * - Automatic text wrapping and sizing
 * - Customizable fonts, colors, and materials
 * - Performance-optimized with web worker support
 *
 * ### Example Usage
 * ```ts
 * // Create labels for all spaces
 * const labels = mapView.Text3D.labelAll();
 *
 * // Create a label for a specific space
 * const label = mapView.Text3D.label(space, "Room 101", { fontSize: 12 });
 *
 * // Remove a specific label
 * mapView.Text3D.remove(label);
 *
 * // Remove all labels
 * mapView.Text3D.removeAll();
 * ```
 *
 * ### Performance Considerations
 * - Use `labelAll()` for better performance when creating multiple labels.
 *
 * ### Advanced
 * - Customize text appearance with fonts, colors, and materials.
 * - Use `labelAll()` with options to apply consistent styling to all labels.
 * - Text3D labels are automatically positioned and sized based on space geometry.
 *
 * This class is accessed using {@link MapView.Text3D}.
 */
declare class Text3D {
  #private;
  /**
   * @internal
   */
  constructor({
    currentMapGetter
  }: {
    currentMapGetter: CurrentMapGetter;
  });
  /**
   * Creates polygon labels for all spaces.
   *
   * @param options Configuration options for text label creation (see {@link AddText3DOptions}).
   * @returns An array of Text3DView instances representing the created labels. If a space is already labeled, the existing Text3D instance will be returned.
   *
   * @example Create labels for all spaces with default settings
   * ```ts
   * const labels = mapView.Text3D.labelAll();
   * ```
   *
   * @example Create labels with custom styling
   * ```ts
   * const labels = mapView.Text3D.labelAll({
   *   fontSize: 14,
   *   color: 'white',
   *   backgroundColor: 'rgba(0, 0, 0, 0.7)'
   * });
   * ```
   *
   * @see [Text3D Guide](https://developer.mappedin.com/web-sdk/text3d)
   */
  labelAll(options?: TAddText3DOptions): Text3DView[];
  /**
   * Creates a 3D text label for a given space.
   *
   * @param target The target space to label.
   * @param content The content of the label. If not provided, target.name will be used.
   * @param options Configuration options for the text label creation (see {@link AddText3DOptions}).
   * @returns A Text3DView instance representing the created label, or undefined if creation failed.
   *
   * @throws {Error} If the target is not a Space.
   *
   * @example Create a label with custom text
   * ```ts
   * const label = mapView.Text3D.label(space, "Conference Room A", { fontSize: 12 });
   * ```
   *
   * @example Create a label using space name
   * ```ts
   * const label = mapView.Text3D.label(space); // Uses space.name
   * ```
   *
   * @example Create a label with custom styling
   * ```ts
   * const label = mapView.Text3D.label(space, "VIP Room", {
   *   fontSize: 16,
   *   color: 'gold',
   *   backgroundColor: 'rgba(0, 0, 0, 0.8)'
   * });
   * ```
   *
   * @see [Text3D Guide](https://developer.mappedin.com/web-sdk/text3d)
   */
  label(target: Space, content?: string, options?: TAddText3DOptions): Text3DView | undefined;
  /**
   * Adds a 3D text label at a {@link Coordinate}.
   *
   * @param target The target Coordinate to place the text.
   * @param content The text content to display.
   * @param options Configuration options for the text label creation (see {@link TAddText3DAnchorableOptions}).
   * @returns A Text3DView instance representing the created label, or undefined if creation failed.
   *
   * @example Add text at a coordinate
   * ```ts
   * const label = mapView.Text3D.add(coordinate, "Hello World", {
   *   appearance: { fontSize: 12 }
   * });
   * ```
   *
   * @example Add text with rotation and custom styling
   * ```ts
   * const label = mapView.Text3D.add(coordinate, "Rotated Text", {
   *   rotation: 45,
   *   appearance: {
   *     fontSize: 16,
   *     color: 'red'
   *   }
   * });
   * ```
   *
   * @see [Text3D Guide](https://developer.mappedin.com/web-sdk/text3d)
   */
  add(target: Coordinate, content: string, options?: TAddText3DAnchorableOptions): Text3DView;
  /**
   * Removes one or more Text3D labels from the map.
   *
   * @param target Can be either:
   * - A single Text3DView instance
   * - An array of Text3DView instances
   * - A string ID of the Text3DView to remove
   *
   * @example Remove a single text label
   * ```ts
   * mapView.Text3D.remove(text3dView);
   * ```
   *
   * @example Remove multiple text labels
   * ```ts
   * mapView.Text3D.remove([text3dView1, text3dView2]);
   * ```
   *
   * @example Remove by ID
   * ```ts
   * mapView.Text3D.remove("text3d-123");
   * ```
   */
  remove(target: Text3DView): void;
  remove(target: string): void;
  /**
   * Removes all Text3D labels from the current map.
   *
   * @example
   * ```ts
   * mapView.Text3D.removeAll();
   * ```
   */
  removeAll(): void;
}
//#endregion
//#region src/states/doors-state.d.ts
declare const doorsStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"doors">>>;
  color: ZodOptional<ZodDefault<ZodString>>;
  topColor: ZodOptional<ZodOptional<ZodString>>;
  texture: ZodOptional<ZodOptional<ZodObject<{
    url: ZodOptional<ZodString>;
  }, $strip>>>;
  topTexture: ZodOptional<ZodOptional<ZodObject<{
    url: ZodOptional<ZodString>;
  }, $strip>>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
}, $strip>;
declare const doorsStateSchemaStrict: ZodObject<{
  type: ZodDefault<ZodLiteral<"doors">>;
  color: ZodDefault<ZodString>;
  topColor: ZodOptional<ZodString>;
  texture: ZodOptional<ZodObject<{
    url: ZodOptional<ZodString>;
  }, $strip>>;
  topTexture: ZodOptional<ZodObject<{
    url: ZodOptional<ZodString>;
  }, $strip>>;
  visible: ZodDefault<ZodBoolean>;
  opacity: ZodDefault<ZodNumber>;
}, $strict>;
type TDoorsState = output<typeof doorsStateSchemaStrict>;
type TDoorsUpdateState = output<typeof doorsStateSchemaPartial>;
//#endregion
//#region src/states/facade-state.d.ts
declare const facadeStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"facade">>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
}, $strip>;
declare const facadeStateSchemaStrict: ZodObject<{
  type: ZodDefault<ZodLiteral<"facade">>;
  opacity: ZodDefault<ZodNumber>;
  visible: ZodDefault<ZodBoolean>;
}, $strict>;
type TFacadeState = output<typeof facadeStateSchemaStrict>;
type TFacadeUpdateState = output<typeof facadeStateSchemaPartial>;
//#endregion
//#region src/states/floor-state.d.ts
declare const floorStateSchemaPartial: ZodObject<{
  geometry: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.geometry">>>;
    opacity: ZodOptional<ZodDefault<ZodNumber>>;
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
    maskId: ZodOptional<ZodDefault<ZodNullable<ZodNumber>>>;
    maskEffect: ZodOptional<ZodDefault<ZodEnum<{
      hide: "hide";
      reveal: "reveal";
    }>>>;
    maskMode: ZodOptional<ZodDefault<ZodEnum<{
      mask: "mask";
      "masked-object": "masked-object";
    }>>>;
    maskEnabled: ZodOptional<ZodDefault<ZodBoolean>>;
    effectStart: ZodOptional<ZodDefault<ZodNumber>>;
    effectDistance: ZodOptional<ZodDefault<ZodNumber>>;
    darkenAmount: ZodOptional<ZodDefault<ZodNumber>>;
    darkenUseDepth: ZodOptional<ZodDefault<ZodBoolean>>;
    desaturateAmount: ZodOptional<ZodDefault<ZodNumber>>;
    desaturateUseDepth: ZodOptional<ZodDefault<ZodBoolean>>;
    washOutAmount: ZodOptional<ZodDefault<ZodNumber>>;
    washOutUseDepth: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  labels: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.labels">>>;
    enabled: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  markers: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.markers">>>;
    enabled: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  images: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.images">>>;
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
    collisionsEnabled: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  footprint: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.footprint">>>;
    altitude: ZodOptional<ZodDefault<ZodNumber>>;
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
    height: ZodOptional<ZodDefault<ZodNumber>>;
    opacity: ZodOptional<ZodDefault<ZodNumber>>;
    side: ZodOptional<ZodDefault<ZodEnum<{
      back: "back";
      front: "front";
      double: "double";
    }>>>;
    color: ZodOptional<ZodDefault<ZodString>>;
    ceilingVisible: ZodOptional<ZodDefault<ZodBoolean>>;
    basementMaskEnabled: ZodOptional<ZodDefault<ZodBoolean>>;
    outline: ZodOptional<ZodDefault<ZodBoolean>>;
    ceilingThickness: ZodOptional<ZodDefault<ZodNumber>>;
  }, $strip>>;
  occlusion: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.occlusion">>>;
    enabled: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  paths: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.paths">>>;
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  areas: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.areas">>>;
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  text3d: ZodOptional<ZodObject<{
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  models: ZodOptional<ZodObject<{
    type: ZodOptional<ZodDefault<ZodLiteral<"floor.models">>>;
    visible: ZodOptional<ZodDefault<ZodBoolean>>;
  }, $strip>>;
  type: ZodOptional<ZodDefault<ZodLiteral<"floor">>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  altitude: ZodOptional<ZodDefault<ZodNumber>>;
}, $strip>;
declare const floorStateSchemaStrict: ZodObject<{
  geometry: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.geometry">>;
    opacity: ZodDefault<ZodNumber>;
    visible: ZodDefault<ZodBoolean>;
    maskId: ZodDefault<ZodNullable<ZodNumber>>;
    maskEffect: ZodDefault<ZodEnum<{
      hide: "hide";
      reveal: "reveal";
    }>>;
    maskMode: ZodDefault<ZodEnum<{
      mask: "mask";
      "masked-object": "masked-object";
    }>>;
    maskEnabled: ZodDefault<ZodBoolean>;
    effectStart: ZodDefault<ZodNumber>;
    effectDistance: ZodDefault<ZodNumber>;
    darkenAmount: ZodDefault<ZodNumber>;
    darkenUseDepth: ZodDefault<ZodBoolean>;
    desaturateAmount: ZodDefault<ZodNumber>;
    desaturateUseDepth: ZodDefault<ZodBoolean>;
    washOutAmount: ZodDefault<ZodNumber>;
    washOutUseDepth: ZodDefault<ZodBoolean>;
  }, $strict>;
  labels: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.labels">>;
    enabled: ZodDefault<ZodBoolean>;
  }, $strict>;
  markers: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.markers">>;
    enabled: ZodDefault<ZodBoolean>;
  }, $strict>;
  images: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.images">>;
    visible: ZodDefault<ZodBoolean>;
    collisionsEnabled: ZodDefault<ZodBoolean>;
  }, $strict>;
  footprint: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.footprint">>;
    altitude: ZodDefault<ZodNumber>;
    visible: ZodDefault<ZodBoolean>;
    height: ZodDefault<ZodNumber>;
    opacity: ZodDefault<ZodNumber>;
    side: ZodDefault<ZodEnum<{
      back: "back";
      front: "front";
      double: "double";
    }>>;
    color: ZodDefault<ZodString>;
    ceilingVisible: ZodDefault<ZodBoolean>;
    basementMaskEnabled: ZodDefault<ZodBoolean>;
    outline: ZodDefault<ZodBoolean>;
    ceilingThickness: ZodDefault<ZodNumber>;
  }, $strict>;
  occlusion: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.occlusion">>;
    enabled: ZodDefault<ZodBoolean>;
  }, $strict>;
  paths: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.paths">>;
    visible: ZodDefault<ZodBoolean>;
  }, $strict>;
  areas: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.areas">>;
    visible: ZodDefault<ZodBoolean>;
  }, $strict>;
  text3d: ZodObject<{
    visible: ZodDefault<ZodBoolean>;
  }, $strict>;
  models: ZodObject<{
    type: ZodDefault<ZodLiteral<"floor.models">>;
    visible: ZodDefault<ZodBoolean>;
  }, $strict>;
  type: ZodDefault<ZodLiteral<"floor">>;
  visible: ZodDefault<ZodBoolean>;
  altitude: ZodDefault<ZodNumber>;
}, $strict>;
type TFloorState = output<typeof floorStateSchemaStrict>;
type TFloorUpdateState = output<typeof floorStateSchemaPartial>;
//#endregion
//#region src/states/geometry-state.d.ts
declare const geometryStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"geometry">>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  color: ZodOptional<ZodDefault<ZodUnion<readonly [ZodString, ZodLiteral<"initial">]>>>;
  topColor: ZodOptional<ZodOptional<ZodUnion<readonly [ZodString, ZodLiteral<"initial">]>>>;
  hoverColor: ZodOptional<ZodOptional<ZodUnion<readonly [ZodString, ZodLiteral<"initial">]>>>;
  interactive: ZodOptional<ZodDefault<ZodBoolean>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
  height: ZodOptional<ZodDefault<ZodNumber>>;
  altitude: ZodOptional<ZodDefault<ZodNumber>>;
  texture: ZodOptional<ZodOptional<ZodObject<{
    url: ZodString;
  }, $strip>>>;
  topTexture: ZodOptional<ZodOptional<ZodObject<{
    url: ZodString;
  }, $strip>>>;
  flipImageToFaceCamera: ZodOptional<ZodDefault<ZodBoolean>>;
  enableImageCollisions: ZodOptional<ZodDefault<ZodBoolean>>;
  borderVisible: ZodOptional<ZodDefault<ZodBoolean>>;
  borderColor: ZodOptional<ZodOptional<ZodString>>;
  borderWidth: ZodOptional<ZodOptional<ZodNumber>>;
}, $strip>;
declare const geometryStateSchemaStrict: ZodObject<{
  type: ZodDefault<ZodLiteral<"geometry">>;
  visible: ZodDefault<ZodBoolean>;
  color: ZodDefault<ZodUnion<readonly [ZodString, ZodLiteral<"initial">]>>;
  topColor: ZodOptional<ZodUnion<readonly [ZodString, ZodLiteral<"initial">]>>;
  hoverColor: ZodOptional<ZodUnion<readonly [ZodString, ZodLiteral<"initial">]>>;
  interactive: ZodDefault<ZodBoolean>;
  opacity: ZodDefault<ZodNumber>;
  height: ZodDefault<ZodNumber>;
  altitude: ZodDefault<ZodNumber>;
  texture: ZodOptional<ZodObject<{
    url: ZodString;
  }, $strip>>;
  topTexture: ZodOptional<ZodObject<{
    url: ZodString;
  }, $strip>>;
  flipImageToFaceCamera: ZodDefault<ZodBoolean>;
  enableImageCollisions: ZodDefault<ZodBoolean>;
  borderVisible: ZodDefault<ZodBoolean>;
  borderColor: ZodOptional<ZodString>;
  borderWidth: ZodOptional<ZodNumber>;
}, $strict>;
/**
 * Defines the state for geometry elements like {@link Space} when updated.
 */
type TGeometryState = output<typeof geometryStateSchemaStrict>;
type TGeometryUpdateState = output<typeof geometryStateSchemaPartial>;
//#endregion
//#region src/states/label-state.d.ts
declare const labelStateSchema: ZodObject<{
  type: ZodDefault<ZodLiteral<"label">>;
  text: ZodString;
  rank: ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>;
  appearance: ZodCustom<LabelAppearance, LabelAppearance>;
  interactive: ZodDefault<ZodBoolean>;
  enabled: ZodDefault<ZodBoolean>;
  textPlacement: ZodDefault<ZodUnion<readonly [ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
  }>, ZodArray<ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
  }>>]>>;
  occlude: ZodDefault<ZodBoolean>;
}, $strip>;
declare const labelStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"label">>>;
  text: ZodOptional<ZodString>;
  rank: ZodOptional<ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>>;
  appearance: ZodOptional<ZodCustom<LabelAppearance, LabelAppearance>>;
  interactive: ZodOptional<ZodDefault<ZodBoolean>>;
  enabled: ZodOptional<ZodDefault<ZodBoolean>>;
  textPlacement: ZodOptional<ZodDefault<ZodUnion<readonly [ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
  }>, ZodArray<ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
  }>>]>>>;
  occlude: ZodOptional<ZodDefault<ZodBoolean>>;
}, $strip>;
type TLabelState = output<typeof labelStateSchema>;
type TLabelUpdateState = output<typeof labelStateSchemaPartial>;
//#endregion
//#region src/states/marker-state.d.ts
declare const markerStateSchema: ZodObject<{
  type: ZodDefault<ZodLiteral<"marker">>;
  rank: ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>;
  placement: ZodOptional<ZodUnion<readonly [ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
    bottom: "bottom";
    "top-left": "top-left";
    "top-right": "top-right";
    "bottom-left": "bottom-left";
    "bottom-right": "bottom-right";
  }>, ZodArray<ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
    bottom: "bottom";
    "top-left": "top-left";
    "top-right": "top-right";
    "bottom-left": "bottom-left";
    "bottom-right": "bottom-right";
  }>>]>>;
  interactive: ZodDefault<ZodUnion<readonly [ZodBoolean, ZodLiteral<"pointer-events-auto">]>>;
  dynamicResize: ZodDefault<ZodBoolean>;
  enabled: ZodDefault<ZodBoolean>;
  zIndex: ZodOptional<ZodNumber>;
  lowPriorityPin: ZodOptional<ZodObject<{
    enabled: ZodOptional<ZodBoolean>;
    size: ZodOptional<ZodNumber>;
    color: ZodOptional<ZodString>;
  }, $strip>>;
  element: ZodCustom<HTMLElement, HTMLElement>;
  contentHTML: ZodString;
  occlude: ZodDefault<ZodBoolean>;
  animated: ZodDefault<ZodBoolean>;
}, $strip>;
declare const markerStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"marker">>>;
  enabled: ZodOptional<ZodDefault<ZodBoolean>>;
  interactive: ZodOptional<ZodDefault<ZodUnion<readonly [ZodBoolean, ZodLiteral<"pointer-events-auto">]>>>;
  rank: ZodOptional<ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>>;
  occlude: ZodOptional<ZodDefault<ZodBoolean>>;
  placement: ZodOptional<ZodOptional<ZodUnion<readonly [ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
    bottom: "bottom";
    "top-left": "top-left";
    "top-right": "top-right";
    "bottom-left": "bottom-left";
    "bottom-right": "bottom-right";
  }>, ZodArray<ZodEnum<{
    hidden: "hidden";
    top: "top";
    left: "left";
    center: "center";
    right: "right";
    bottom: "bottom";
    "top-left": "top-left";
    "top-right": "top-right";
    "bottom-left": "bottom-left";
    "bottom-right": "bottom-right";
  }>>]>>>;
  dynamicResize: ZodOptional<ZodDefault<ZodBoolean>>;
  zIndex: ZodOptional<ZodOptional<ZodNumber>>;
  lowPriorityPin: ZodOptional<ZodOptional<ZodObject<{
    enabled: ZodOptional<ZodBoolean>;
    size: ZodOptional<ZodNumber>;
    color: ZodOptional<ZodString>;
  }, $strip>>>;
  contentHTML: ZodOptional<ZodString>;
  animated: ZodOptional<ZodDefault<ZodBoolean>>;
}, $strip>;
type TMarkerState = output<typeof markerStateSchema>;
type TMarkerUpdateState = output<typeof markerStateSchemaPartial>;
//#endregion
//#region src/states/path-state.d.ts
/** Border color - 'darken' auto-darkens main color, or explicit hex color string */
type BorderColor = LiteralUnion<'darken', string>;
declare const pathStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"path">>>;
  color: ZodOptional<ZodDefault<ZodString>>;
  width: ZodOptional<ZodType<PathWidth$2, unknown, $ZodTypeInternals<PathWidth$2, unknown>>>;
  completeFraction: ZodOptional<ZodDefault<ZodNumber>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  verticalOffset: ZodOptional<ZodDefault<ZodNumber>>;
  highlightStartFraction: ZodOptional<ZodDefault<ZodNumber>>;
  highlightEndFraction: ZodOptional<ZodDefault<ZodNumber>>;
  highlightColor: ZodOptional<ZodDefault<ZodString>>;
  highlightWidthMultiplier: ZodOptional<ZodDefault<ZodNumber>>;
  highlightCompleteFraction: ZodOptional<ZodDefault<ZodNumber>>;
  xrayOpacity: ZodOptional<ZodDefault<ZodNumber>>;
  travelledEndFraction: ZodOptional<ZodDefault<ZodNumber>>;
  travelledColor: ZodOptional<ZodDefault<ZodString>>;
  __EXPERIMENTAL_SMOOTHING_TENSION: ZodOptional<ZodDefault<ZodNumber>>;
  __EXPERIMENTAL_SMOOTHING_CORNER_RADIUS: ZodOptional<ZodDefault<ZodNumber>>;
  dashed: ZodOptional<ZodDefault<ZodBoolean>>;
  __EXPERIMENTAL_DASH_OPTIONS: ZodOptional<ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
    __EXPERIMENTAL_DASH_MODE: ZodLiteral<"length-scaling">;
    __EXPERIMENTAL_DASH_LENGTH: ZodDefault<ZodNumber>;
    __EXPERIMENTAL_DASH_GAP: ZodDefault<ZodNumber>;
  }, $strip>, ZodObject<{
    __EXPERIMENTAL_DASH_MODE: ZodLiteral<"width-scaling">;
    __EXPERIMENTAL_DASH_SIZE: ZodDefault<ZodNumber>;
    __EXPERIMENTAL_GAP_SIZE: ZodDefault<ZodNumber>;
  }, $strip>, ZodObject<{
    __EXPERIMENTAL_DASH_MODE: ZodLiteral<"absolute">;
    __EXPERIMENTAL_DASH_METERS: ZodDefault<ZodNumber>;
    __EXPERIMENTAL_GAP_METERS: ZodDefault<ZodNumber>;
  }, $strip>], "__EXPERIMENTAL_DASH_MODE">>>;
  __EXPERIMENTAL_GEOMETRY: ZodOptional<ZodDefault<ZodEnum<{
    tube: "tube";
    ribbon: "ribbon";
  }>>>;
  __EXPERIMENTAL_ENDCAP_EXTENSION: ZodOptional<ZodDefault<ZodTuple<[ZodNumber, ZodNumber], null>>>;
  __EXPERIMENTAL_BILLBOARDING: ZodOptional<ZodDefault<ZodUnion<readonly [ZodBoolean, ZodNumber]>>>;
  __EXPERIMENTAL_BORDER: ZodOptional<ZodOptional<ZodObject<{
    enabled: ZodBoolean;
    color: ZodCustom<BorderColor, BorderColor>;
    width: ZodOptional<ZodNumber>;
  }, $strip>>>;
  __EXPERIMENTAL_PREVENT_SELF_OVERLAP: ZodOptional<ZodDefault<ZodBoolean>>;
  __EXPERIMENTAL_XRAY_STYLE: ZodOptional<ZodOptional<ZodObject<{
    opacity: ZodOptional<ZodNumber>;
    color: ZodOptional<ZodString>;
    tint: ZodOptional<ZodNumber>;
    dithering: ZodOptional<ZodNumber>;
  }, $strip>>>;
}, $strip>;
declare const pathStateSchemaStrict: ZodObject<{
  type: ZodDefault<ZodLiteral<"path">>;
  color: ZodDefault<ZodString>;
  width: ZodType<PathWidth$2>;
  completeFraction: ZodDefault<ZodNumber>;
  visible: ZodDefault<ZodBoolean>;
  verticalOffset: ZodDefault<ZodNumber>;
  highlightStartFraction: ZodDefault<ZodNumber>;
  highlightEndFraction: ZodDefault<ZodNumber>;
  highlightColor: ZodDefault<ZodString>;
  highlightWidthMultiplier: ZodDefault<ZodNumber>;
  highlightCompleteFraction: ZodDefault<ZodNumber>;
  xrayOpacity: ZodDefault<ZodNumber>;
  travelledEndFraction: ZodDefault<ZodNumber>;
  travelledColor: ZodDefault<ZodString>;
  __EXPERIMENTAL_SMOOTHING_TENSION: ZodDefault<ZodNumber>;
  __EXPERIMENTAL_SMOOTHING_CORNER_RADIUS: ZodDefault<ZodNumber>;
  dashed: ZodDefault<ZodBoolean>;
  __EXPERIMENTAL_DASH_OPTIONS: ZodOptional<ZodDiscriminatedUnion<[ZodObject<{
    __EXPERIMENTAL_DASH_MODE: ZodLiteral<"length-scaling">;
    __EXPERIMENTAL_DASH_LENGTH: ZodDefault<ZodNumber>;
    __EXPERIMENTAL_DASH_GAP: ZodDefault<ZodNumber>;
  }, $strip>, ZodObject<{
    __EXPERIMENTAL_DASH_MODE: ZodLiteral<"width-scaling">;
    __EXPERIMENTAL_DASH_SIZE: ZodDefault<ZodNumber>;
    __EXPERIMENTAL_GAP_SIZE: ZodDefault<ZodNumber>;
  }, $strip>, ZodObject<{
    __EXPERIMENTAL_DASH_MODE: ZodLiteral<"absolute">;
    __EXPERIMENTAL_DASH_METERS: ZodDefault<ZodNumber>;
    __EXPERIMENTAL_GAP_METERS: ZodDefault<ZodNumber>;
  }, $strip>], "__EXPERIMENTAL_DASH_MODE">>;
  __EXPERIMENTAL_GEOMETRY: ZodDefault<ZodEnum<{
    tube: "tube";
    ribbon: "ribbon";
  }>>;
  __EXPERIMENTAL_ENDCAP_EXTENSION: ZodDefault<ZodTuple<[ZodNumber, ZodNumber], null>>;
  __EXPERIMENTAL_BILLBOARDING: ZodDefault<ZodUnion<readonly [ZodBoolean, ZodNumber]>>;
  __EXPERIMENTAL_BORDER: ZodOptional<ZodObject<{
    enabled: ZodBoolean;
    color: ZodCustom<BorderColor, BorderColor>;
    width: ZodOptional<ZodNumber>;
  }, $strip>>;
  __EXPERIMENTAL_PREVENT_SELF_OVERLAP: ZodDefault<ZodBoolean>;
  __EXPERIMENTAL_XRAY_STYLE: ZodOptional<ZodObject<{
    opacity: ZodOptional<ZodNumber>;
    color: ZodOptional<ZodString>;
    tint: ZodOptional<ZodNumber>;
    dithering: ZodOptional<ZodNumber>;
  }, $strip>>;
}, $strict>;
type TPathState = output<typeof pathStateSchemaStrict>;
type TPathUpdateState = input<typeof pathStateSchemaPartial>;
//#endregion
//#region src/states/shape-state.d.ts
declare const shapeStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"shape">>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  altitude: ZodOptional<ZodDefault<ZodNumber>>;
  color: ZodOptional<ZodDefault<ZodString>>;
  height: ZodOptional<ZodDefault<ZodNumber>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
  interactive: ZodOptional<ZodDefault<ZodBoolean>>;
  bevel: ZodOptional<ZodOptional<ZodObject<{
    enabled: ZodOptional<ZodBoolean>;
    thickness: ZodOptional<ZodNumber>;
    size: ZodOptional<ZodNumber>;
    offset: ZodOptional<ZodNumber>;
    segments: ZodOptional<ZodNumber>;
  }, $strip>>>;
  position: ZodOptional<ZodCustom<Coordinate, Coordinate>>;
}, $strip>;
declare const shapeStateSchemaStrict: ZodObject<{
  type: ZodDefault<ZodLiteral<"shape">>;
  visible: ZodDefault<ZodBoolean>;
  altitude: ZodDefault<ZodNumber>;
  color: ZodDefault<ZodString>;
  height: ZodDefault<ZodNumber>;
  opacity: ZodDefault<ZodNumber>;
  interactive: ZodDefault<ZodBoolean>;
  bevel: ZodOptional<ZodObject<{
    enabled: ZodOptional<ZodBoolean>;
    thickness: ZodOptional<ZodNumber>;
    size: ZodOptional<ZodNumber>;
    offset: ZodOptional<ZodNumber>;
    segments: ZodOptional<ZodNumber>;
  }, $strip>>;
  position: ZodCustom<Coordinate, Coordinate>;
}, $strict>;
/**
 * Represents the state of a shape.
 */
type TShapeState = output<typeof shapeStateSchemaStrict>;
type TShapeUpdateState = output<typeof shapeStateSchemaPartial>;
//#endregion
//#region src/states/image-state.d.ts
declare const imageStateSchema: ZodObject<{
  type: ZodDefault<ZodLiteral<"image3d">>;
  visible: ZodDefault<ZodBoolean>;
  opacity: ZodDefault<ZodNumber>;
  position: ZodCustom<Coordinate, Coordinate>;
  width: ZodDefault<ZodNumber>;
  height: ZodDefault<ZodNumber>;
  rotation: ZodDefault<ZodNumber>;
  verticalOffset: ZodDefault<ZodNumber>;
  flipImagesToFaceCamera: ZodDefault<ZodBoolean>;
  interactive: ZodDefault<ZodBoolean>;
}, $strip>;
declare const imageStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"image3d">>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
  position: ZodOptional<ZodCustom<Coordinate, Coordinate>>;
  width: ZodOptional<ZodDefault<ZodNumber>>;
  height: ZodOptional<ZodDefault<ZodNumber>>;
  rotation: ZodOptional<ZodDefault<ZodNumber>>;
  verticalOffset: ZodOptional<ZodDefault<ZodNumber>>;
  flipImagesToFaceCamera: ZodOptional<ZodDefault<ZodBoolean>>;
  interactive: ZodOptional<ZodDefault<ZodBoolean>>;
}, $strip>;
type TImage3DState = output<typeof imageStateSchema>;
type TImage3DUpdateState = output<typeof imageStateSchemaPartial>;
//#endregion
//#region src/states/model-state.d.ts
declare const modelStateUpdateSchema: ZodObject<{
  altitude: ZodOptional<ZodOptional<ZodNumber>>;
  id: ZodOptional<ZodOptional<ZodUnion<readonly [ZodNumber, ZodString]>>>;
  type: ZodOptional<ZodDefault<ZodLiteral<"model">>>;
  color: ZodOptional<ZodOptional<ZodString>>;
  position: ZodOptional<ZodCustom<Coordinate, Coordinate>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  verticalOffset: ZodOptional<ZodDefault<ZodNumber>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
  material: ZodOptional<ZodOptional<ZodRecord<ZodString, ZodObject<{
    color: ZodString;
  }, $strip>>>>;
  interactive: ZodOptional<ZodDefault<ZodBoolean>>;
  clippingPlaneZOffset: ZodOptional<ZodDefault<ZodCustom<number, number>>>;
  clippingPlaneTopColor: ZodOptional<ZodDefault<ZodString>>;
  clippingPlaneTopVisible: ZodOptional<ZodDefault<ZodBoolean>>;
  scale: ZodOptional<ZodUnion<readonly [ZodNumber, ZodTuple<[ZodNumber, ZodNumber, ZodNumber], null>]>>;
  rotation: ZodOptional<ZodUnion<readonly [ZodNumber, ZodTuple<[ZodNumber, ZodNumber, ZodNumber], null>]>>;
}, $strip>;
declare const modelStateSchemaStrict: ZodObject<{
  altitude: ZodOptional<ZodNumber>;
  id: ZodOptional<ZodUnion<readonly [ZodNumber, ZodString]>>;
  type: ZodDefault<ZodLiteral<"model">>;
  color: ZodOptional<ZodString>;
  position: ZodCustom<Coordinate, Coordinate>;
  visible: ZodDefault<ZodBoolean>;
  rotation: ZodDefault<ZodTuple<[ZodNumber, ZodNumber, ZodNumber], null>>;
  scale: ZodDefault<ZodTuple<[ZodNumber, ZodNumber, ZodNumber], null>>;
  verticalOffset: ZodDefault<ZodNumber>;
  opacity: ZodDefault<ZodNumber>;
  material: ZodOptional<ZodRecord<ZodString, ZodObject<{
    color: ZodString;
  }, $strip>>>;
  interactive: ZodDefault<ZodBoolean>;
  clippingPlaneZOffset: ZodDefault<ZodCustom<number, number>>;
  clippingPlaneTopColor: ZodDefault<ZodString>;
  clippingPlaneTopVisible: ZodDefault<ZodBoolean>;
}, $strict>;
/**
 * Represents the state of a model.
 */
type TModelState = output<typeof modelStateSchemaStrict>;
type TModelUpdateState = output<typeof modelStateUpdateSchema>;
//#endregion
//#region src/states/text3d-state.d.ts
declare const text3DUpdateStateSchema: ZodObject<{
  visible: ZodOptional<ZodOptional<ZodBoolean>>;
  color: ZodOptional<ZodOptional<ZodString>>;
  flipToFaceCamera: ZodOptional<ZodOptional<ZodBoolean>>;
  font: ZodOptional<ZodOptional<ZodOptional<ZodString>>>;
  fontSize: ZodOptional<ZodOptional<ZodNumber>>;
  outlineColor: ZodOptional<ZodOptional<ZodString>>;
  outlineOpacity: ZodOptional<ZodOptional<ZodNumber>>;
  outlineBlur: ZodOptional<ZodOptional<ZodUnion<readonly [ZodNumber, ZodString]>>>;
  outlineWidth: ZodOptional<ZodOptional<ZodNumber>>;
  outlineOffsetX: ZodOptional<ZodOptional<ZodNumber>>;
  outlineOffsetY: ZodOptional<ZodOptional<ZodNumber>>;
  strokeWidth: ZodOptional<ZodOptional<ZodNumber>>;
  strokeOpacity: ZodOptional<ZodOptional<ZodNumber>>;
  strokeColor: ZodOptional<ZodOptional<ZodString>>;
  fillOpacity: ZodOptional<ZodOptional<ZodNumber>>;
  hoverColor: ZodOptional<ZodOptional<ZodOptional<ZodString>>>;
  type: ZodOptional<ZodDefault<ZodLiteral<"text3d">>>;
  position: ZodOptional<ZodCustom<Coordinate, Coordinate>>;
}, $strict>;
declare const text3DStateSchemaStrict: ZodObject<{
  visible: ZodBoolean;
  color: ZodString;
  flipToFaceCamera: ZodBoolean;
  font: ZodOptional<ZodString>;
  fontSize: ZodNumber;
  margin: ZodUnion<readonly [ZodNumber, ZodTuple<[ZodNumber, ZodNumber, ZodNumber, ZodNumber], null>]>;
  outlineColor: ZodString;
  outlineOpacity: ZodNumber;
  outlineBlur: ZodUnion<readonly [ZodNumber, ZodString]>;
  outlineWidth: ZodNumber;
  outlineOffsetX: ZodNumber;
  outlineOffsetY: ZodNumber;
  strokeWidth: ZodNumber;
  maxWidth: ZodOptional<ZodNumber>;
  maxHeight: ZodOptional<ZodNumber>;
  strokeOpacity: ZodNumber;
  strokeColor: ZodString;
  fillOpacity: ZodNumber;
  hoverColor: ZodOptional<ZodString>;
  id: ZodUnion<readonly [ZodString, ZodNumber]>;
  content: ZodString;
  rotation: ZodNumber;
  type: ZodDefault<ZodLiteral<"text3d">>;
  position: ZodCustom<Coordinate, Coordinate>;
}, $strict>;
type TText3DState = output<typeof text3DStateSchemaStrict>;
type TText3DUpdateState = output<typeof text3DUpdateStateSchema>;
//#endregion
//#region src/states/walls-state.d.ts
declare const wallsStateSchemaPartial: ZodObject<{
  type: ZodOptional<ZodDefault<ZodLiteral<"walls">>>;
  color: ZodOptional<ZodDefault<ZodString>>;
  topColor: ZodOptional<ZodOptional<ZodString>>;
  texture: ZodOptional<ZodUnion<[ZodObject<{
    url: ZodString;
  }, $strip>, ZodUndefined]>>;
  topTexture: ZodOptional<ZodUnion<[ZodObject<{
    url: ZodString;
  }, $strip>, ZodUndefined]>>;
  visible: ZodOptional<ZodDefault<ZodBoolean>>;
  height: ZodOptional<ZodDefault<ZodNumber>>;
  opacity: ZodOptional<ZodDefault<ZodNumber>>;
}, $strip>;
declare const wallsStateSchemaStrict: ZodObject<{
  type: ZodDefault<ZodLiteral<"walls">>;
  color: ZodDefault<ZodString>;
  topColor: ZodOptional<ZodString>;
  texture: ZodUnion<[ZodObject<{
    url: ZodString;
  }, $strip>, ZodUndefined]>;
  topTexture: ZodUnion<[ZodObject<{
    url: ZodString;
  }, $strip>, ZodUndefined]>;
  visible: ZodDefault<ZodBoolean>;
  height: ZodDefault<ZodNumber>;
  opacity: ZodDefault<ZodNumber>;
}, $strict>;
type TWallsState = output<typeof wallsStateSchemaStrict>;
type TWallsUpdateState = output<typeof wallsStateSchemaPartial>;
//#endregion
//#region src/states/state-utils.d.ts
/**
 * Centralized mapping of element types to their get state types.
 */
type MapElementToGetState = {
  [Marker.__type]: ReadonlyDeep<TMarkerState>;
  [Label.__type]: ReadonlyDeep<TLabelState>;
  [Shape.__type]: ReadonlyDeep<TShapeState>;
  [Model.__type]: ReadonlyDeep<TModelState>;
  [Path.__type]: ReadonlyDeep<TPathState>;
  [PathSegment$1.__type]: ReadonlyDeep<TPathState>;
  [Text3DView.__type]: ReadonlyDeep<TText3DState>;
  [Image3DView.__type]: ReadonlyDeep<TImage3DState>;
  [Space.__type]: ReadonlyDeep<TGeometryState>;
  [MapObject.__type]: ReadonlyDeep<TGeometryState>;
  [Floor.__type]: ReadonlyDeep<TFloorState>;
  [Facade.__type]: ReadonlyDeep<TFacadeState>;
  [Door.__type]: ReadonlyDeep<TDoorsState>;
  [Area.__type]: ReadonlyDeep<TGeometryState>;
  [WALLS.Exterior]: ReadonlyDeep<TWallsState>;
  [WALLS.Interior]: ReadonlyDeep<TWallsState>;
  [DOORS.Exterior]: ReadonlyDeep<TDoorsState>;
  [DOORS.Interior]: ReadonlyDeep<TDoorsState>;
};
/**
 * Centralized mapping of element types to their update state types.
 */
type MapElementToUpdateState = {
  [Marker.__type]: TMarkerUpdateState;
  [Label.__type]: TLabelUpdateState;
  [Shape.__type]: TShapeUpdateState;
  [Model.__type]: TModelUpdateState;
  [Path.__type]: TPathUpdateState;
  [PathSegment$1.__type]: TPathUpdateState;
  [Text3DView.__type]: TText3DUpdateState;
  [Image3DView.__type]: TImage3DUpdateState;
  [Space.__type]: TGeometryUpdateState;
  [MapObject.__type]: TGeometryUpdateState;
  [Floor.__type]: TFloorUpdateState;
  [Facade.__type]: TFacadeUpdateState;
  [Door.__type]: TDoorsUpdateState;
  [Area.__type]: TGeometryUpdateState;
  [WALLS.Exterior]: TWallsUpdateState;
  [WALLS.Interior]: TWallsUpdateState;
  [DOORS.Exterior]: TDoorsUpdateState;
  [DOORS.Interior]: TDoorsUpdateState;
};
//#endregion
//#region src/api-geojson/api.d.ts
declare class GeoJsonApi extends PubSub<TNavigationEvents> {
  #private;
  core: RendererCore;
  mapObjects: GeojsonApiMapObject[];
  id: string;
  mapDataExternal: { [key in string]: MapData };
  private mapsByFloorId;
  mapData?: MapData;
  currentMap: GeojsonApiMapObject;
  hiddenOutdoorGeometries: [polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[], layers: string[]][];
  private lastFacadeIntersected?;
  mapView: MapView;
  /**
   * External event bus for MapView - bridges internal API events to public API.
   *
   * Internal systems publish events here which are then exposed to developers via
   * MapView.on() and MapView.off().
   */
  externalPubSub: PubSub<TEvents>;
  get manualFloorVisibility(): boolean;
  set manualFloorVisibility(value: boolean);
  get hidePathsNotOnCurrentFloor(): boolean;
  set hidePathsNotOnCurrentFloor(value: boolean);
  Camera: Camera;
  Labels: Labels;
  Text3D: Text3D;
  Markers: Markers;
  Models: Models;
  Paths: Paths;
  Exporter: Exporter;
  Navigation: Navigation;
  Outdoor: Outdoor;
  Shapes: Shapes;
  Style: Style;
  Image3D: Image3D;
  constructor(rendererCore: RendererCore, mapView: MapView, externalPubSub: PubSub<TEvents>);
  preloadFloors(floors: Floor[]): void;
  updateState<T$1 extends MapElementsWithState>(target: T$1, state: TUpdateState<T$1>): void;
  updateState<T$1 extends string & NonNullable<unknown>>(target: T$1, state: ValueOf<MapElementToUpdateState>): void;
  updateState<T$1 extends MapElementsWithState | string>(target: T$1, state: TUpdateState<T$1>): void;
  private getMapDataObject;
  update: () => void;
  getMapDataInternal(): MapDataInternal | undefined;
  getMapData(): MapData | undefined;
  addMap(mapData: MapData, options?: TShow3DMapOptions): Promise<MapData>;
  setFloor(floor: Floor | string, reason?: TFloorChangeReason): void;
  setFloorStack(floorStack: FloorStack | string, reason?: TFloorChangeReason): void;
  updateWatermark(options: WatermarkUpdateOptions): void;
  get currentFloorStack(): FloorStack;
  get currentFloor(): Floor;
  getState<T$1 extends MapElementsWithState | string>(target: T$1): TGetState<T$1>;
  __EXPERIMENTAL__getRenderedState<T$1 extends MapElementWithRenderedState>(target: T$1): TGetRenderedState<T$1> | undefined;
  setHoverColor(c: string): void;
  getHoverColor(): string | undefined;
  /**
   * Returns the pre-computed altitude map for a floor stack.
   * @param floorStackId - The floor stack ID
   * @returns A map of floor elevation to altitude and effective height data
   */
  getFloorStackAltitudeData(floorStackId: string): Map<number, TFloorAltitudeData>;
  /**
   * Create a coordinate from a screen coordinate
   * @param x - The x coordinate of the screen
   * @param y - The y coordinate of the screen
   * @param floor - The floor to use for the coordinate
   * @returns The coordinate
   */
  createCoordinateFromScreenCoordinate(x: number, y: number, floor?: Floor): Coordinate | undefined;
  getScreenCoordinateFromCoordinate(coordinate: Coordinate): {
    x: number;
    y: number;
  };
  isInView(target: Space | MapObject | Label | Marker | string): boolean;
  getInView<T$1 extends string>(type: T$1, options?: TGetInViewOptions): MapFeatureOfType<T$1>[];
  __EXPERIMENTAL__auto(mapElements?: MapDataElements[]): Promise<AutoElements>;
  tween<T$1 extends Record<string, unknown>>(object: T$1): Tween<T$1>;
  removeTween(tween: Tween<any>): void;
  tweenGroup(): _tweenjs_tween_js0.Group;
  /**
   * @internal
   */
  get __core(): RendererCore;
  /**
   * Get camera state for synchronization
   * @private
   */
  private getCameraState;
  /**
   * Get navigation state for synchronization
   * @private
   */
  private getNavigationState;
  /**
   * Get all current state information for synchronization
   * @internal
   */
  getAllState(): Partial<{
    currentFloor: Floor;
    currentFloorStack: FloorStack;
    Camera: TCameraStateChangePayload;
    Navigation: NavigationState;
    manualFloorVisibility: boolean;
  }>;
  /**
   * Publish all current state information
   * @internal
   */
  publishAllState(): void;
  clear(): void;
  destroy(): void;
  getOptimalVisualDistanceBetweenFloors(floors: Floor[], debug?: boolean): number | undefined;
}
/**
 * Sets the base URL directory where worker scripts are hosted for CSP compatibility.
 *
 * This function configures both the MapLibre and collision system workers to load from
 * external URLs instead of using inline blob URLs. The SDK expects two specific worker
 * files to be available in the provided directory:
 * - `maplibre-worker.csp.js` - For MapLibre map rendering
 * - `collision-worker.csp.js` - For the collision detection system
 *
 * Using this approach enables compatibility with strict Content Security Policies
 * that block unsafe-eval and blob: URLs.
 *
 * @param baseUrl - Base URL directory where worker scripts are hosted (without trailing slash)
 *                  Example: "https://cdn.example.com/workers"
 *
 * @example
 * ```typescript
 * import { setWorkersUrl } from '@mappedin/mappedin-js';
 *
 * // Call before initializing any maps
 * setWorkersUrl('https://cdn.example.com/workers');
 * // This will load:
 * // - https://cdn.example.com/workers/maplibre-worker.csp.js
 * // - https://cdn.example.com/workers/collision-worker.csp.js
 * ```
 *
 * @remarks
 * - The worker files can be found in the published package at:
 *   `node_modules/@mappedin/mappedin-js/lib/esm/workers/`
 * - For deployment, copy these files to your web server or CDN
 * - A better approach is to add these files to your build process to ensure
 *   they're always in sync with your application
 * - Call this function before creating any map instances
 */
declare function setWorkersUrl(baseUrl: string): void;
//#endregion
//#region ../packages/geojson-navigator/src/types/node.d.ts
/**
 * The neighboring node with associated weight.
 */
type NodeNeighbor = {
  id: string;
  weight: number;
};
/**
 * Properties specific to node features in a geospatial context.
 * Each node includes a mandatory unique identifier and supports additional custom properties.
 */
type NodeProperties = {
  /**
   * Unique identifier for the node.
   */
  id: string;
  /**
   * An array of neighboring nodes with associated weights.
   */
  neighbors: NodeNeighbor[];
  /**
   * Additional property specific to the navigator based on the 'groupBy' option.
   * */
  [name: string]: any;
};
/**
 * A GeoJSON feature collection that groups multiple nodes, each represented as a point.
 * This structure is commonly used in mapping, routing, and network analysis applications.
 */
type NodeCollection$1 = FeatureCollection<Point, NodeProperties>;
/**
 * A GeoJSON feature representing a node as a point with associated properties.
 * Nodes are critical for defining specific locations in network-based analyses, such as transportation networks,
 * utility networks, or any kind of spatial network analysis.
 */
type NodeFeature = Feature<Point, NodeProperties>;
//#endregion
//#region ../packages/geojson-navigator/src/edge/edge.d.ts
/**
 * Represents an edge in a graph, containing data about its endpoints and metrics like distance and angle.
 * @hidden
 */
declare class Edge {
  /** The originating node of the edge */
  origin: NodeFeature;
  /** The destination node of the edge */
  destination: NodeFeature;
  /** The distance between the origin and the destination nodes */
  distance: number;
  /** The angle of the edge with respect to some reference, in degrees */
  angle: number;
  /** A composite weight of the edge, combining distance and a custom path weight */
  weight: number;
  /**
   * Constructs a new Edge instance.
   * @param {NodeFeature} origin - The originating node of the edge.
   * @param {NodeFeature} destination - The destination node of the edge.
   * @param {number} [distance=0] - The physical distance between the origin and destination.
   * @param {number} [angle=0] - The angle of the edge in degrees.
   * @param {number} [pathWeight=0] - An additional weight factor for the path.
   */
  constructor({
    origin,
    destination,
    distance,
    angle,
    pathWeight,
    multiplicativeDistanceWeightScaling
  }: {
    origin: NodeFeature;
    destination: NodeFeature;
    distance?: number;
    angle?: number;
    pathWeight?: number;
    multiplicativeDistanceWeightScaling?: boolean;
  });
}
//#endregion
//#region ../packages/geojson-navigator/src/navigation-graph/navigation-graph.d.ts
/**
 * Represents a navigation graph for pathfinding operations, holding nodes and edges with utilities to perform routing.
 * @see {@link https://mappedin.atlassian.net/wiki/spaces/SDK/pages/234487854/A+Search+Algorithm+in+Navigation+Graph}
 * @hidden
 */
declare class NavigationGraph {
  #private;
  readonly edges: {
    [propName: string]: Edge[];
  };
  readonly nodesById: {
    [propName: string]: NodeFeature;
  };
  readonly nodesByGroup: Map<string, NodeFeature[]>;
  constructor({
    nodes,
    groupBy,
    multiplicativeDistanceWeightScaling
  }: {
    nodes: NodeCollection$1;
    groupBy: string;
    multiplicativeDistanceWeightScaling?: boolean;
  });
  /**
   * Calculates the shortest Euclidean distance from the origin node to any of the destination nodes.
   *
   * @param origin - The origin node.
   * @param destinations - An array of destination nodes.
   * @returns The shortest Euclidean distance.
   */
  getShortestEuclideanDistance(origin: NodeFeature, destinations: NodeFeature[]): number;
  hasLineOfSight: (origin: Position, destination: Position, edges?: Position[][], bufferRadius?: number) => boolean;
  /**
   * Performs a Dijkstra search to find nodes within a given travel distance that satisfy a goal function, sorted by distance.
   *
   * @param originId - Origin node ID.
   * @param maxTravelDistance - The maximum travel distance.
   * @param includedNodeIds - Array of node IDs to include in the search.
   * @param obstructionEdges - Array of obstruction edges for line of sight calculations.
   * @param useLineOfSight - Whether to use line of sight checking.
   * @returns An Array of nodes within the travel distance that satisfy the goal function.
   * - feature: The node feature.
   * - distance: The distance to the node.
   * - edges: The edges to the node.
   */
  dijkstraFindWithinTravelDistance(originId: string, maxTravelDistance: number, includedNodeIds: string[], obstructionEdges: Position[][], useLineOfSight: boolean, limitNumberOfResults: number): {
    feature: NodeFeature;
    distance: number;
  }[];
  /**
   * Performs A* pathfinding from specified origins to destinations, considering optional constraints like accessibility.
   *
   * @param {string[]} originIds - Array of origin node IDs.
   * @param {string[]} destinationNodeIds - Array of destination node IDs.
   * @param {Set<string>} [disabledConnectionNodeIds] - Optional set of connection node IDs that are disabled (ie. act as regular nodes).
   * @param {Set<string>} [disabledNodeIds] - Optional set of node IDs which are ignored during pathfinding.
   * @returns {Edge[]} An array of edges representing the shortest path, or an empty array if no path is found.
   */
  aStar({
    originIds,
    destinationNodeIds,
    disabledConnectionNodeIds,
    zones,
    overrideEdgeWeights,
    disabledNodeIds
  }: {
    originIds: string[];
    destinationNodeIds: string[];
    zones: DirectionsZone[];
    disabledConnectionNodeIds?: Set<string>;
    overrideEdgeWeights?: Map<Edge, number>;
    disabledNodeIds?: Set<string>;
  }): Edge[];
}
//#endregion
//#region ../packages/geojson-navigator/src/types/directions.d.ts
/**
 * Properties specific to directional features in a navigation context.
 * Includes an identifier, optional angle and distance, and allows for any additional properties.
 */
type DirectionProperties = {
  /**
   * Unique identifier for the direction.
   */
  id: string;
  /**
   * An angle between this point and the destination, in radians.
   */
  angle?: number;
  /**
   * Distance to the next point, in meters.
   */
  distance?: number;
  /**
   * Group id which the direction belongs to (e.g. floor, building, etc).
   * It's based on the groupBy property of the navigator.
   */
  groupBy?: string;
  destination?: string;
  edges: Edge[];
};
/**
 * A GeoJSON feature representing a point with properties tailored for navigation directions.
 */
type DirectionFeature = Feature<Point, DirectionProperties>;
/**
 * A GeoJSON feature collection that groups multiple directional features, often used to represent a route or path.
 */
type DirectionsCollection = FeatureCollection<Point, DirectionProperties>;
//#endregion
//#region ../packages/geojson-navigator/src/navigator/create-door-buffer-nodes.d.ts
/**
 * Door geometry structure with coordinates
 */
interface DoorGeometry {
  geoJSON: {
    geometry: {
      coordinates: [[number, number], [number, number]];
    };
  };
}
//#endregion
//#region ../packages/geojson-navigator/src/navigator/navigator.d.ts
/**
 * Base options common to all simplification methods.
 */
type BaseSimplifyOptions = {
  /**
   * Enable or disable simplifying.
   */
  enabled: boolean;
  /**
   * The radius of the buffer around the path to consider when simplifying, in meters.
   * @default 0.4
   */
  radius?: number;
};
/**
 * Options for greedy line-of-sight simplification method (default).
 */
type GreedyLosOptions = BaseSimplifyOptions & {
  __EXPERIMENTAL_METHOD?: 'greedy-los';
};
/**
 * Options for RDP (Ramer-Douglas-Peucker) simplification method.
 */
type RdpOptions = BaseSimplifyOptions & {
  __EXPERIMENTAL_METHOD: 'rdp';
  /**
   * Whether to include door-adjacent nodes (predecessor/successor of doors) in the must-include set.
   * When true, nodes immediately before and after doors are preserved during simplification.
   * @default true
   */
  mustIncludeDoorBufferNodes?: boolean;
};
/**
 * Options for DP (Dynamic Programming) optimal simplification method.
 */
type DpOptimalOptions = BaseSimplifyOptions & {
  __EXPERIMENTAL_METHOD: 'dp-optimal';
  /**
   * Whether to include door buffer nodes in DP simplification.
   * When true, predecessor and successor nodes of doors are marked with preventSmoothing.
   * @default false
   */
  includeDoorBufferNodes?: boolean;
};
/**
 * Options for simplifying directions in the Navigator class.
 * Discriminated union based on the '__EXPERIMENTAL_METHOD' field.
 */
type SimplifyDirectionsOptions = GreedyLosOptions | RdpOptions | DpOptimalOptions;
/**
 * Defines the special zone for navigation operations.
 */
type DirectionsZone = {
  geometry: Feature<MultiPolygon | Polygon>;
  /**
   * The additional cost for navigation through the zone.
   */
  cost: number;
  /**
   *
   *  Additional property specific to the navigator based on the 'groupBy' option.
   */
  [index: string]: any;
};
declare class Navigator {
  private groupBy;
  graph: NavigationGraph;
  private geometryEdgesByMapId;
  private flagDeclarations;
  private getDoorByNodeId;
  private nonPublicNodeIds;
  /**
   * Constructs a Navigator instance to manage pathfinding with optional obstructions and grouping features.
   *
   * @param {NodeCollection} nodes - Collection of nodes for the navigation graph.
   * @param {ObstructionCollection} [obstructions] - Optional collection of obstructions that could block paths.
   * @param {SpaceCollection} [spaces] - Optional collection of spaces that could block paths.
   * @param {string} [groupBy] - Optional property name to group nodes and paths for differentiated processing.
   * @param {Function} getDoorByNodeId - Function to get door object by node ID.
   */
  constructor({
    nodes,
    geojsonCollection,
    groupBy,
    multiplicativeDistanceWeightScaling,
    flagDeclarations,
    getDoorByNodeId
  }: {
    nodes: NodeCollection$1;
    geojsonCollection?: ObstructionCollection$1 | SpaceCollection$1;
    groupBy?: string;
    multiplicativeDistanceWeightScaling?: boolean;
    flagDeclarations?: NavigationFlagDeclarations;
    getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
  });
  /**
   * Build the set of node IDs that do not have the well-known `public` flag
   * set. Returns an empty set when the MVF does not declare the flag.
   */
  private getNonPublicNodeIds;
  /**
   * Calculates and returns a set of directions from origin nodes to destination nodes, including detailed properties.
   *
   * @param {DirectionsZone[]} zones - special zones for navigation operations.
   * @param {string[]} originIds - IDs of origin nodes.
   * @param {string[]} destinationNodeIds - IDs of destination nodes.
   * @param {string[]} [disabledConnectionNodeIds] - IDs of connection nodes that are disabled (ie. act as regular nodes).
   * @param {SimplifyDirectionsOptions} [simplify] - Options to simplify the pathfinding result.
   * @param {boolean} [includeNonPublic] - When true, nodes lacking the MVF `public` flag are routable. Defaults to false.
   * @returns {DirectionsCollection} A collection of directional features representing the path.
   */
  getDirections({
    zones: directionsZones,
    originIds,
    from,
    to,
    destinationNodeIds,
    disabledConnectionNodeIds,
    simplify,
    multiplicativeDistanceWeightScaling,
    overrideEdgeWeights,
    includeNonPublic
  }: {
    originIds: string[];
    destinationNodeIds: string[];
    from: NodeFeature[];
    to: NodeFeature[];
    zones?: DirectionsZone[];
    disabledConnectionNodeIds?: string[];
    simplify?: SimplifyDirectionsOptions;
    multiplicativeDistanceWeightScaling?: boolean;
    overrideEdgeWeights?: Map<Edge, number>;
    includeNonPublic?: boolean;
  }): DirectionsCollection;
  /**
   * Generates a path from a series of edges, constructing a feature collection of directional steps.
   *
   * @param {Edge[]} steps - An array of edges representing the path.
   * @returns {DirectionsCollection} A collection of directional features.
   */
  private generatePath;
  /**
   * Simplifies a sequence of steps by reducing unnecessary nodes using line-of-sight checks.
   *
   * Method Selection:
   * - 'greedy-los': Greedy forward scan with line-of-sight validation. Fastest, O(n) time complexity. Good default choice.
   * - 'rdp': Uses Ramer-Douglas-Peucker preprocessing + line-of-sight validation + door buffer nodes.
   *   Better for paths with doors and complex geometry. Medium speed.
   * - 'dp-optimal': Dynamic Programming for globally optimal simplification. Slowest but highest quality, O(n²) complexity.
   *   Best when path quality is critical (e.g., indoor navigation with many turns).
   *
   * Performance: greedy-los < rdp < dp-optimal
   * Quality: greedy-los < rdp < dp-optimal
   *
   * @param {Edge[]} steps - The steps to simplify.
   * @param {SimplifyDirectionsOptions} options - Simplification options.
   * @param {boolean} multiplicativeDistanceWeightScaling - Distance weight scaling option.
   * @returns {Edge[]} An array of simplified edges representing a more direct path.
   */
  private simplifyAllSteps;
  /**
   * Finds the nearest nodes on the graph within a given travel distance.
   *
   * @param originId - The ID of the origin node.
   * @param maxDistance - The maximum distance to search.
   * @param floorId - The ID of the floor.
   * @param includedNodeIds - The IDs of the nodes to include.
   * @param useLineOfSight - Whether to use line of sight.
   * @returns An array of nodes within the travel distance that satisfy the goal function.
   */
  findNearestNodesOnGraph: (originId: string, maxDistance: number, floorId: string, includedNodeIds: string[], useLineOfSight?: boolean, limitNumberOfResults?: number) => {
    feature: NodeFeature;
    distance: number;
  }[];
  /**
   * Checks if there is a line of sight between two points on the map.
   *
   * @param origin - The origin point.
   * @param destination - The destination point.
   * @param floorId - The ID of the floor.
   * @param bufferRadius - The buffer radius to use when checking for line of sight.
   * @returns True if there is a line of sight, false otherwise.
   */
  hasLineOfSight: (origin: [number, number], destination: [number, number], floorId: string, bufferRadius?: number) => boolean;
  /**
   * Simplifies a section of steps by checking direct lines of sight between steps and eliminating intermediate nodes if unobstructed.
   *
   * @param {Edge[]} steps - The steps to potentially simplify.
   * @param {[number, number][][]} geometryEdges - The geometrical edges of the map used to check for line of sight.
   * @param {number} bufferRadius - The buffer radius to use when simplifying.
   * @returns {Edge[]} An array of simplified edges.
   */
  private simplifySteps;
  private simplifyStepsImprovedWithSimplifyBeforeLoSChecks;
  private simplifyStepsWithDPMethod;
  /**
   * Calculates the approximate distance between two geographic coordinates on Earth's surface.
   *
   * This function uses the equirectangular approximation method to compute the distance, which simplifies
   * the math and speeds up calculations, but is less accurate over long distances compared to other methods
   * like the haversine formula.
   *
   * @param {Position} point1 - The first point's longitude and latitude as [longitude, latitude].
   * @param {Position} point2 - The second point's longitude and latitude as [longitude, latitude].
   * @return
   * @return {number} The approximate distance between the two points in meters.
   */
  getDistance: (point1: Position, point2: Position) => number;
  /**
   * Calculates the angle between two geographic coordinates.
   *
   * @param {Position} point1 - The first point's longitude and latitude as [longitude, latitude].
   * @param {Position} point2 - The second point's longitude and latitude as [longitude, latitude].
   * @hidden
   *
   * @return {number} The angle in radians, calculated clockwise from the north between the two points specified.
   */
  getAngle: (point1: Position, point2: Position) => number;
}
//#endregion
//#region src/api-geojson/directions/directions.d.ts
/**
 * Represents a set of directions between two points.
 *
 * Directions are used to represent the path between two points on the map,
 * as well as the instructions to follow the path.
 */
declare class Directions {
  #private;
  id: string;
  /**
   * @internal
   */
  constructor(directions: DirectionsCollection, mapData: MapDataInternal, departure: TNavigationTarget, destination: TNavigationTarget, options?: {
    id?: string;
  });
  /**
   * @internal
   */
  get path(): Node[];
  /**
   * The selected departure.
   */
  departure: TNavigationTarget;
  /**
   * The selected destination.
   */
  destination: TNavigationTarget;
  /**
   * All the coordinates ({@link Coordinate}) of the directions.
   */
  get coordinates(): Coordinate[];
  /**
   * The total distance of the path in meters.
   */
  get distance(): number;
  /**
   * The array of instructions ({@link TDirectionInstruction}).
   */
  get instructions(): TDirectionInstruction[];
  /**
   * Serializes the directions to JSON.
   * All getter properties are evaluated and included in the serialized output.
   *
   * @returns An object representing the directions with all properties evaluated.
   */
  toJSON(): {
    id: string;
    directions: DirectionFeature[];
    __type: string;
    from: TNavigationTarget;
    to: TNavigationTarget;
    coordinates: Coordinate[];
    distance: number;
    instructions: TDirectionInstruction[];
  };
}
//#endregion
//#region src/api-geojson/directions/directions-internal.d.ts
declare class DirectionsInternal {
  #private;
  navigator: Navigator;
  private readonly connections;
  /**
   * @hidden
   */
  constructor({
    nodes,
    geojsonCollection,
    connections,
    groupBy,
    multiplicativeDistanceWeightScaling,
    flagDeclarations,
    getDoorByNodeId
  }: {
    nodes: ParsedMVF['node.geojson'];
    geojsonCollection: ParsedMVF['obstruction'] | ParsedMVF['space'];
    connections: ParsedMVF['connection.json'];
    groupBy?: string;
    multiplicativeDistanceWeightScaling?: boolean;
    flagDeclarations?: ParsedMVF['navigationFlags.json'];
    getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
  });
  processTargets(fromNodesByTarget: Map<TNavigationTarget, string[]>, toNodesByTarget: Map<TNavigationTarget, string[]>, mapData: MapDataInternal): {
    originIds: string[];
    destinationNodeIds: string[];
    featureToNodeIdsMap: Map<TNavigationTarget, string[]>;
  };
  getDirections: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
    accessible: boolean;
    smoothing: SimplifyDirectionsOptions;
    zones: TDirectionZone[];
    excludedConnections: Connection[];
    connectionIdWeightMap: Record<string, number>;
    includeNonPublic: boolean;
  }, mapData: MapDataInternal) => Promise<Directions | undefined>;
  /** @deprecated use getDirections instead */
  getDirectionsSync: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
    accessible: boolean;
    smoothing: SimplifyDirectionsOptions;
    zones: TDirectionZone[];
    excludedConnections: Connection[];
    connectionIdWeightMap: Record<string, number>;
    includeNonPublic: boolean;
  }, mapData: MapDataInternal) => Directions | undefined;
  /**
   * Get the node IDs of connections that do not match the accessibility setting provided.
   * A disabled connection node is a connection node that acts as a regular node
   * (ie. the edges that would cause a floor change are ignored).
   *
   * @hidden
   * @param accessible {boolean}
   */
  getDisabledConnectionNodeIds: (accessible: boolean) => string[];
  /**
   * If the navigation targets are coordinates, make sure to include them in the final directions. For other
   * data types (e.g. POIs, Doors, Spaces), the coordinate should have a coincidental node generated in the
   * navigation graph already, so this is unnecessary.
   *
   * @hidden
   * @param directions
   * @param from {TNavigationTarget[]}
   * @param to {TNavigationTarget[]}
   */
  private addCoordinateDirections;
  /**
   * Create an geojson collection from the parsed MVF.
   *
   * @hidden
   * @param obstructions
   */
  private createCollection;
  /**
   * Create a direction feature.
   *
   * @hidden
   * @param coordinate
   * @param angle
   * @param distance
   */
  private createDirectionFeature;
}
//#endregion
//#region src/map-view-objects/camera-transform.d.ts
/**
 * Configuration options for CameraTransform precision.
 */
interface CameraTransformOptions {
  /**
   * Number of decimal places for coordinate precision.
   * Default: 7 (centimeter accuracy)
   * Set to -1 to disable coordinate rounding.
   *
   * Note: ZoomLevel is always rounded to 5 decimal places for consistency
   */
  precision?: number;
}
/**
 * Class representing camera transformation data.
 */
declare class CameraTransform {
  #private;
  /**
   * @internal
   */
  constructor(camera: Camera, options?: CameraTransformOptions);
  toJSON(): {
    center: Coordinate;
    bearing: number;
    pitch: number;
    zoomLevel: number;
  };
  /**
   * Getter for the center coordinate of the camera.
   *
   * @returns Center Coordinate with precision applied (default: 7 decimal places for centimeter accuracy).
   */
  get center(): Coordinate;
  /**
   * Getter for the camera's bearing in degrees.
   *
   * @returns Camera bearing in degrees.
   */
  get bearing(): number;
  /**
   * Getter for the camera's pitch in degrees.
   *
   * @returns Camera pitch in degrees.
   */
  get pitch(): number;
  /**
   * Getter for the camera's zoom level in mercator zoom levels.
   * Rounded to 5 decimal places for consistency.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   *
   * @returns Zoom level in mercator zoom levels, rounded to 5 decimal places.
   */
  get zoomLevel(): number;
}
//#endregion
//#region src/map-view-objects/shape.d.ts
/**
 * Class representing GeoJSON shape on the {@link MapView}.
 *
 * Refer to the [Shapes Guide](https://developer.mappedin.com/web-sdk/shapes) for more information and interactive examples.
 */
declare class Shape implements IFocusable {
  /**
   * id of Shape
   */
  readonly id: string;
  /**
   * @internal
   */
  static readonly __type = "shape";
  /**
   * @internal
   */
  readonly __type = "shape";
  /**
   * Checks if the provided instance is of type Shape.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Shape, false otherwise.
   */
  static is(instance: object): instance is Shape;
  /** @internal */
  get focusTarget(): this;
  /**
   * @internal
   */
  constructor(id: string);
}
//#endregion
//#region src/map-view-objects/text3d.d.ts
/**
 * Class representing an Text3D on the {@link MapView}.
 */
declare class Text3DView {
  /**
   * The text3d's id
   */
  readonly id: string;
  /**
   * @internal
   */
  constructor(id: string, target: Space | EnterpriseLocation | Coordinate);
  /**
   * The text3d's target
   */
  readonly target: Space | EnterpriseLocation | Coordinate;
  /**
   * @internal
   */
  static readonly __type = "text-3d";
  readonly __type = "text-3d";
  /**
   * Checks if the provided instance is of type Text3D
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a text3d, false otherwise.
   */
  static is(instance: object): instance is Text3DView;
}
//#endregion
//#region ../packages/common/errors.d.ts
/**
 * @internal
 */
declare class MappedinError extends Error {
  constructor(message: string, label?: string);
}
/**
 * @internal
 */
declare class MappedinRenderError extends MappedinError {
  constructor(message: string, label?: string);
}
//#endregion
//#region src/events.d.ts
type TFloorChangeReason = string;
/**
 * The payload for a user click event on the map.
 *
 * Contains detailed information about all visible interactive map elements that were under the pointer
 * at the time of the event.
 *
 * Properties are optional and included only when corresponding objects are present at the pointer location.
 */
type TClickPayload = {
  /**
   * The geographic {@link Coordinate} of the pointer event.
   */
  coordinate: Coordinate;
  /**
   * Interactive {@link Path}s under the pointer.
   */
  paths?: Path[];
  /**
   * Interactive {@link Space}s under the pointer.
   */
  spaces?: Space[];
  /**
   * Interactive {@link MapObject | Object}s under the pointer.
   */
  objects?: MapObject[];
  /**
   * Interactive {@link Area}s under the pointer.
   */
  areas?: Area[];
  /**
   * Interactive {@link Marker}s under the pointer.
   */
  markers?: Marker[];
  /**
   * Interactive {@link Model}s under the pointer.
   */
  models?: Model[];
  /**
   * Interactive {@link Image3DView | 3D Image}s under the pointer.
   */
  images?: Image3DView[];
  /**
   * Interactive {@link Label}s under the pointer.
   */
  labels?: Label[];
  /**
   * Interactive {@link Floor}s under the pointer.
   */
  floors?: Floor[];
  /**
   * Details about the pointer event triggering this click, containing only the pointer button.
   */
  pointerEvent: Pick<PointerEvent, 'button'>;
  /**
   * Interactive {@link Facade}s under the pointer.
   */
  facades?: Facade[];
  /**
   * Interactive {@link Shape}s under the pointer.
   */
  shapes?: Shape[];
};
/**
 * Represents the payload for a hover event on the map.
 * This contains the interactive objects that the user's pointer is over,
 * but omits the `pointerEvent` property from {@link TClickPayload}.
 *
 * @see {@link TClickPayload}
 */
type THoverPayload = Omit<TClickPayload, 'pointerEvent'>;
/**
 * used to sync state to RN SDK
 * @internal
 */
type TCameraStateChangePayload = CameraSystemState & {
  autoMinZoomLevel: RendererCore['camera']['autoMinZoomLevel'];
  screenOffsets: RendererCore['camera']['insetsPadding'];
  panMode: RendererCore['camera']['panMode'];
};
/**
 * Consolidated state payload for React Native SDK internal use
 * @internal
 */
type TStateChangedInternalPayload = Partial<{
  currentFloor: Floor;
  currentFloorStack: FloorStack;
  Camera: TCameraStateChangePayload;
  Navigation: NavigationState;
  manualFloorVisibility: boolean;
}>;
/**
 * Describes the payload delivered with floor change events.
 *
 * This type provides context when a floor change occurs within the map,
 * such as user-initiated level switches, programmatic navigation, or automatic changes.
 * It specifies both the current and previous floors for the transition, as well as an optional reason.
 */
type TFloorChangePayload = {
  /**
   * The {@link Floor} which the map is changing to.
   */
  floor: Floor;
  /**
   * The {@link Floor} that was active before the change.
   */
  previousFloor: Floor;
  /**
   * The reason for the floor change.
   */
  reason?: TFloorChangeReason;
};
/**
 * The pan bounds of the camera.
 */
type CameraBounds = {
  /**
   * Center point of the bounds. The radius expands from this point.
   */
  center: Coordinate;
  /**
   * The radius of the bounds in meters.
   */
  radius: number;
};
/**
 * Defines the structure and types of events emitted in the context of the map.
 */
type TEvents = {
  /**
   * Emitted when the map is clicked or tapped on a touch screen.
   */
  click: TClickPayload;
  /**
   * Emitted when the map is hovered over with a mouse.
   */
  hover: THoverPayload;
  /**
   * Emitted when the camera's view changes.
   */
  'camera-change': CameraTransform;
  /**
   * Emitted when the pan bounds of the camera changes.
   */
  'camera-bounds-change': CameraBounds;
  /**
   * Emitted when the camera's screen offsets change.
   */
  'camera-screen-offsets-change': InsetPadding$1;
  /**
   * Emitted when a floor change starts.
   */
  'floor-change-start': TFloorChangePayload;
  /**
   * Emitted after the floor change is complete.
   */
  'floor-change': TFloorChangePayload;
  /**
   *
   * Emitted when a different facade recieves focus due to the camera moving.
   * This always occurs when the active floor changes to a different floor stack,
   * but may also occur when the camera moves without the active floor changing.
   *
   * @property {Facade[]} facades - The facades that are in focus.
   *
   */
  'facades-in-view-change': {
    facades: Facade[];
  };
  /**
   * Emitted when the outdoor view is fully loaded and displayed.
   */
  'outdoor-view-loaded': undefined;
  /**
   * Emitted when the outdoor style is loaded or changed.
   */
  'outdoor-style-loaded': undefined;
  /**
   * Emitted when a user interaction with the map starts (e.g., dragging the map).
   */
  'user-interaction-start': undefined;
  /**
   * Emitted when a user interaction with the map ends.
   */
  'user-interaction-end': undefined;
  /**
   * Emitted when a navigation connection is clicked.
   */
  'navigation-connection-click': {
    fromFloor?: Floor;
    toFloor: Floor;
    instruction: TDirectionInstruction;
  };
  /**
   * Emitted when the active path changes.
   */
  'navigation-active-path-change': {
    directions: Directions;
    path: Path;
  };
  /**
   * Consolidated state change event for React Native SDK internal use
   * @internal
   */
  'state-change-internal': TStateChangedInternalPayload;
  /**
   * Emitted before the scene is drawn to the screen.
   */
  'pre-render': undefined;
  /**
   * Emitted when resize happened.
   */
  resize: undefined;
  /**
   * Emitted after the scene is drawn to the screen.
   */
  'post-render': undefined;
  /**
   * Emitted when global state is updated via `updateGlobalState`.
   */
  'global-state-change': undefined;
  /**
   * Emitted when the MapView is about to be destroyed.
   */
  destroy: undefined;
  /**
   * Emitted when a render error occurs.
   * @internal
   */
  'render-error': {
    /**
     * The render error that occurred.
     */
    error: MappedinRenderError;
  };
};
type TEventPayload<EventName extends keyof TEvents> = TEvents[EventName] extends {
  data: null;
} ? TEvents[EventName]['data'] : TEvents[EventName];
type TMapDataEvents = {
  'language-change': {
    code: string;
    name: string;
  };
};
//#endregion
//#region src/types/interfaces/anchorable.d.ts
/**
 * A class that implements IAnchorable can have 2D elements like {@link Label}s and {@link Marker}s anchored to it.
 */
interface IAnchorable {
  get anchorTarget(): Coordinate;
}
//#endregion
//#region src/types/interfaces/focusable.d.ts
/**
 * A class that implements IFocusable can be focused on by the camera.
 */
interface IFocusable {
  get focusTarget(): TFocusTarget | TFocusTarget[];
}
//#endregion
//#region src/types/interfaces/navigable.d.ts
/**
 * A class that implements INavigatable can be navigated to via directions.
 */
interface INavigatable {
  get navigationTarget(): TNavigationTarget | TNavigationTarget[];
}
//#endregion
//#region src/types/interfaces/geojson.d.ts
/**
 * A class that implements IGeoJSONData has a underlying GeoJSON datathat can be accessed.
 */
interface IGeoJSONData {
  /** Gets the underlying GeoJSON Feature representation of this object. */
  geoJSON: Feature<any, null>;
}
//#endregion
//#region src/types/index.d.ts
type TAnimateStateResult = {
  result: 'completed' | 'cancelled';
};
type TCancellablePromise<T$1> = Promise<T$1> & {
  cancel: () => void;
};
declare enum ACTION_TYPE {
  Departure = "Departure",
  TakeConnection = "TakeConnection",
  ExitConnection = "ExitConnection",
  Turn = "Turn",
  Arrival = "Arrival",
}
type TActionType = keyof typeof ACTION_TYPE;
declare enum BEARING_TYPE {
  Straight = "Straight",
  Right = "Right",
  SlightRight = "SlightRight",
  Left = "Left",
  SlightLeft = "SlightLeft",
  Back = "Back",
}
type TBearingType = keyof typeof BEARING_TYPE;
declare enum CONNECTION_TYPE {
  stairs = "stairs",
  elevator = "elevator",
  escalator = "escalator",
  door = "door",
  ramp = "ramp",
  slide = "slide",
  portal = "portal",
  security = "security",
  shuttle = "shuttle",
  ladder = "ladder",
}
type TConnectionType = keyof typeof CONNECTION_TYPE;
/**
 * Represents an action within a direction instruction.
 */
type TDirectionInstructionAction = {
  /**
   * Type of action required at this step (e.g., 'Departure', 'Arrival', 'Turn').
   */
  type: TActionType;
  /**
   * Bearing direction for this action (e.g., 'Straight', 'Right', 'Left').
   */
  bearing?: TBearingType;
  /**
   * A reference position for the action.
   *
   * @internal
   */
  referencePosition?: string;
  /**
   * The {@link Floor} from which this action starts.
   */
  fromFloor?: Floor;
  /**
   * The target {@link Floor}  for this action.
   */
  toFloor?: Floor;
  /**
   * Connection object related to the action.
   * This represents the specific connection (e.g., elevator, stairs) involved in the current direction step.
   */
  connection?: Connection;
  /**
   * The direction of the connection (e.g., 'up', 'down').
   */
  direction?: 'up' | 'down' | 'none';
  /**
   * The type of the connection (e.g., 'elevator', 'escalator').
   * @deprecated in favor of `connection.type`
   */
  connectionType?: TConnectionType;
};
/**
 * Represents a single instruction in a set of directions between two points.
 */
type TDirectionInstruction = {
  /**
   * The action ({@link TDirectionInstructionAction}) to be taken for this instruction.
   */
  action: TDirectionInstructionAction;
  /**
   * Distance in meters covered in this instruction step.
   */
  distance: number;
  /**
   * The {@link Coordinate} at which this instruction applies.
   */
  coordinate: Coordinate;
  /**
   * @internal
   */
  node: Node;
};
declare enum WALLS {
  Exterior = "exterior-walls",
  Interior = "interior-walls",
}
declare enum DOORS {
  Interior = "interior-doors",
  Exterior = "exterior-doors",
}
/**
 * Elements created by the MapData.
 */
type MapDataElements = Space | MapObject | Door | Facade | Floor | FloorStack | Connection | Annotation | Area | PointOfInterest | EnterpriseLocation | EnterpriseCategory | LocationProfile | Node | EnterpriseVenue;
/**
 * Elements created by the MapView.
 */
type MapViewElements = Label | Marker | Model | Shape | Text3DView | Path | PathSegment$1 | Image3DView;
/**
 * Options for {@link Camera} animations on the map.
 */
type TCameraAnimationOptions = {
  /**
   * Duration of the animation in milliseconds.
   */
  duration?: number;
  /**
   * Easing function to use for the animation.
   */
  easing?: TEasingFunction;
  /**
   * Whether the current animation will be interrupted, or must complete before starting any new animations
   * @default: true
   */
  interruptible?: boolean;
};
/**
 * Options for controlling animations on the map.
 */
type TAnimationOptions = {
  /**
   * Duration of the animation in milliseconds.
   * @default 1000
   */
  duration?: number;
  /**
   * Easing function to use for the animation.
   * @default 'ease-in-out'
   */
  easing?: TEasingFunction;
};
/**
 * Types of easing for animations.
 *
 * Linear: This function implies a constant rate of change. It means the animation proceeds at the same speed from start to end. There's no acceleration or deceleration, giving a very mechanical feel.
 *
 * Ease-in: This function causes the animation to start slowly and then speed up as it progresses. Initially, there's gradual acceleration, and as the function moves forward, the rate of change increases.
 *
 * Ease-out: Contrary to ease-in, ease-out makes the animation start quickly and then slow down towards the end. It begins with a faster rate of change and gradually decelerates.
 *
 * Ease-in-out: This function combines both ease-in and ease-out. The animation starts slowly, speeds up in the middle, and then slows down again towards the end. It offers a balance of acceleration and deceleration.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-timing-function
 */
type TEasingFunction = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
/**
 * Options for focusing the {@link Camera} on a target.
 */
type TFocusOnOptions = TCameraAnimationOptions & {
  /**
   * Minimum zoom level when focusing on a target in mercator zoom levels.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  minZoomLevel?: number;
  /**
   * Maximum zoom level when focusing on a target in mercator zoom levels.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  maxZoomLevel?: number;
  /**
   * Camera bearing when focusing on a target in degrees clockwise from North. 0 degrees is North, 90 degrees is East, 180 degrees is South, and 270 degrees is West.
   */
  bearing?: number;
  /**
   * Camera pitch when focusing on a target, in degrees.
   */
  pitch?: number;
  /**
   * Axis aligned padding to add to the bounding box in meters.
   */
  axisAlignedPadding?: {
    /**
     * Vertical padding to add to the bounding box in meters along the elevation axis.
     */
    vertical?: number;
  };
  screenOffsets?: InsetPaddingOption$1;
  /**
   * Whether the current animation will be interrupted, or must complete before starting any new animations
   * @default: true
   */
  interruptible?: boolean;
  /** @internal @experimental Debug color override (CSS color string) for this point cloud. */
  debugColor?: string;
};
/**
 * Defines the target for camera operations.
 */
type TCameraTarget = {
  /**
   * Center {@link Coordinate} for the camera target.
   */
  center?: Coordinate;
  /**
   * Zoom level for the camera target in mercator zoom levels.
   *
   * @see https://wiki.openstreetmap.org/wiki/Zoom_levels
   */
  zoomLevel?: number;
  /**
   * Bearing for the camera target in degrees clockwise from North. 0 degrees is North, 90 degrees is East, 180 degrees is South, and 270 degrees is West.
   */
  bearing?: number;
  /**
   * Pitch for the camera target in degrees.
   */
  pitch?: number;
};
/**
 * Defines the target for navigation operations.
 */
type TNavigationTarget = LocationProfile | Annotation | Space | MapObject | Coordinate | Door | PointOfInterest | Connection | EnterpriseLocation | Node | Area | Facade;
/**
 * Defines the special zone for navigation operations.
 */
type TDirectionZone = {
  /**
   * The zone geometry.
   */
  geometry: Feature<MultiPolygon | Polygon>;
  /**
   * The additional cost for navigation through the zone, from 0 to Infinity.
   * The final cost is calculated as the sum of basic cost that comes from the {@link MapData}
   * and the additional zone cost.
   * A additional zone cost of 0 will make the zone free to navigate through
   * A additional zone cost of Infinity will make the zone impossible to navigate through
   */
  cost: number;
  /**
   * The zone's floor, defaults to the all floors if not provided.
   */
  floor?: Floor;
};
/**
 * @experimental
 * Dash configuration options for dashed paths.
 * Uses discriminated union - mode determines which properties are valid.
 */
type TExperimentalDashOptions = {
  /**
   * Length-scaling mode: dash/gap as fractions of path length (0-1)
   */
  __EXPERIMENTAL_DASH_MODE: 'length-scaling';
  /**
   * Dash length as fraction of path (0-1).
   * @default 0.1
   */
  __EXPERIMENTAL_DASH_LENGTH?: number;
  /**
   * Gap length as fraction of path (0-1).
   * @default 0.1
   */
  __EXPERIMENTAL_DASH_GAP?: number;
} | {
  /**
   * Width-scaling mode: dash/gap as multiples of path width (deck.gl style)
   */
  __EXPERIMENTAL_DASH_MODE: 'width-scaling';
  /**
   * Dash size as multiple of path width.
   * @default 3.0
   */
  __EXPERIMENTAL_DASH_SIZE?: number;
  /**
   * Gap size as multiple of path width.
   * @default 2.0
   */
  __EXPERIMENTAL_GAP_SIZE?: number;
} | {
  /**
   * Absolute mode: dash/gap in meters (deterministic regardless of path length)
   */
  __EXPERIMENTAL_DASH_MODE: 'absolute';
  /**
   * Dash length in meters.
   * @default 1.0
   */
  __EXPERIMENTAL_DASH_METERS?: number;
  /**
   * Gap length in meters.
   * @default 0.5
   */
  __EXPERIMENTAL_GAP_METERS?: number;
};
/**
 * Options for controlling the behavior of a {@link Path}.
 */
type TAddPathOptions = {
  /**
   * Path Colour. Color can be set using CSS colors names `DarkGoldenRod`, as Hex strings `#0000FF` or the rgb values `rgb(255,0,0)`.
   *
   * @defaultValue #4b90e2
   */
  color?: string;
  /**
   * Accent color that is applied to the path pulse and path arrows
   *
   * @defaultValue '#ffffff'
   */
  accentColor?: string;
  /**
   * Number of iterations to pulse to indicate direction.
   *
   * @defaultValue 1
   */
  pulseIterations?: number;
  /**
   * How many milliseconds to wait before starting the next pulse after the current pulse travels the entirety of the path.
   *
   * @defaultValue 750
   */
  pulsePauseDuration?: number;
  /**
   * The width of the path.
   * - `number` — meters (e.g. `1.5`)
   * - `'Npx'` — screen-space pixels (e.g. `'20px'`), ribbon geometry only
   * - `Interpolation` — zoom-interpolated meters
   * - `Interpolation<'zoom-level', PixelWidth[]>` — zoom-interpolated pixels (e.g. `output: ['10px', '20px']`), ribbon geometry only
   *
   * @defaultValue Interpolation { on: 'zoom-level', input: [17, 22], output: [0.8, 0.4] }
   */
  width?: PathWidth$1;
  /**
   * Duration of path drawing in milliseconds.
   *
   * @defaultValue 1500
   */
  drawDuration?: number;
  /**
   * Show arrows on path.
   *
   * @defaultValue false
   */
  displayArrowsOnPath?: boolean;
  /**
   * Animate arrows on path.
   *
   * @defaultValue true
   */
  animateArrowsOnPath?: boolean;
  /**
   * Flatten the path to a 2D line.
   *
   * @defaultValue false
   */
  flattenPath?: boolean;
  /**
   * Show an animated pulse indicating the direction of travel.
   *
   * @defaultValue true
   */
  showPulse?: boolean;
  /**
   * Animate the drawing of the path in the direction of travel.
   *
   * @defaultValue true
   */
  animateDrawing?: boolean;
  /**
   * Whether the path should be clickable.
   *
   * @defaultValue false
   */
  interactive?: boolean;
  /**
   * How much the path hovers above the floor plane in meters.
   *
   * @defaultValue 0.1
   */
  verticalOffset?: number;
  /**
   * Whether the path should be dashed.
   *
   * @defaultValue false
   */
  dashed?: boolean;
  /**
   * Whether the path should be visible.
   *
   * @defaultValue true
   */
  visible?: boolean;
  /**
   * @internal
   *
   * Whether the path should be visible through geometry. Can be used to create paths that are visible through walls and floors.
   *
   * @defaultValue false
   */
  visibleThroughGeometry?: boolean;
  /**
   * The opacity of the path when it's behind geometry (x-ray effect). Value from 0 to 1.
   *
   * Prefer {@link __EXPERIMENTAL_XRAY_STYLE}.opacity instead.
   * If both are set, `__EXPERIMENTAL_XRAY_STYLE.opacity` takes precedence.
   *
   * @defaultValue 0.25
   */
  xrayOpacity?: number;
  /**
   * @experimental
   * Consolidated x-ray appearance configuration. Controls how paths look when behind geometry.
   */
  __EXPERIMENTAL_XRAY_STYLE?: {
    /** The opacity when behind geometry (0-1). @default 0.25 */
    opacity?: number;
    /** Explicit color override for the x-ray portion. Omit to auto-compute from path color. */
    color?: string;
    /** Tint strength (0-1). 0 = no muting, 1 = fully muted. @default 0.3 */
    tint?: number;
    /** Dithering cell size in screen pixels (e.g. 4 = 4x4px checkerboard). 0 or undefined = off. */
    dithering?: number;
  };
  /**
   * @experimental Controls the smoothness of path corners using CatmullRom curve tension. Higher values create smoother curves.
   * Values between 0.1-0.3 provide subtle smoothing suitable for most use cases.
   *
   * @defaultValue 0.0
   */
  __EXPERIMENTAL_SMOOTHING_TENSION?: number;
  /**
   * @experimental Distance in meters from corners where control points are inserted for smoothing. Higher values create smoother curves around corners.
   * Only applies when __EXPERIMENTAL_SMOOTHING_TENSION > 0. Typical values are 0.5-2.0 meters for subtle smoothing.
   *
   * @defaultValue 0.5
   */
  __EXPERIMENTAL_SMOOTHING_CORNER_RADIUS?: number;
  /**
   * @experimental
   * Dash configuration. When dashed=true, controls dash/gap sizing.
   * Uses discriminated union - mode determines which properties are valid.
   * @see TExperimentalDashOptions
   */
  __EXPERIMENTAL_DASH_OPTIONS?: TExperimentalDashOptions;
  /**
   * @experimental Geometry type for path rendering.
   * - 'tube': Original tube geometry with 8 radial segments (default)
   * - 'ribbon': Flat ribbon geometry with 2 vertices per segment
   *
   * @defaultValue 'tube'
   */
  __EXPERIMENTAL_GEOMETRY?: 'tube' | 'ribbon';
  /**
   * @experimental Endcap extension for ribbon geometry as [start, end] tuple in meters.
   * - Value > 0: extends path and renders rounded cap
   * - Value = 0: square/flat end (no extension, no rounded cap)
   *
   * @defaultValue [0.5, 0.5]
   */
  __EXPERIMENTAL_ENDCAP_EXTENSION?: [number, number];
  /**
   * @experimental Controls billboarding for ribbon path geometry.
   * - `true`: Every vertex faces the camera (unconditional billboard)
   * - `false`: Flat world-space orientation
   * - `number`: Angle threshold in degrees (0-90). Billboard only when path tangent
   *   verticality >= threshold. E.g. 80 means billboard only nearly-vertical segments.
   *
   * @defaultValue 80
   */
  __EXPERIMENTAL_BILLBOARDING?: boolean | number;
  /**
   * @experimental Border configuration for ribbon path geometry.
   * Renders darkened edges along both sides of the ribbon.
   */
  __EXPERIMENTAL_BORDER?: {
    /** Whether the border is enabled */
    enabled: boolean;
    /** Border color - 'darken' to auto-darken main color, or explicit hex color string */
    color: 'darken' | string;
    /** Border width as fraction of total ribbon width (0-0.5). @default 0.1 */
    width?: number;
  };
  /**
   * @experimental When true, prevents the xray path from rendering multiple overlapping pixels
   * when the path crosses over itself. Uses stencil buffer to ensure single-pixel rendering.
   *
   * @defaultValue false
   */
  __EXPERIMENTAL_PREVENT_SELF_OVERLAP?: boolean;
};
/**
 * @experimental Options specific to connection paths (vertical paths between floors).
 * Extends TAddPathOptions with junction inset control.
 */
type TConnectionPathOptions = TAddPathOptions & {
  /**
   * @experimental Amount in meters to shorten connection path from each end.
   * Prevents visual overlap with floor paths at junctions.
   *
   * Note: May not work consistently for vertical paths.
   *
   * @defaultValue 0
   */
  __EXPERIMENTAL_JUNCTION_INSET?: number;
};
/**
 * Defines the priority levels for collider collision handling, allowing customization of collider visibility in congested areas.
 *
 * | Value  | Description                                                                                                                             |
 * |--------|-----------------------------------------------------------------------------------------------------------------------------------------|
 * | low    | Colliders with this ranking have a low visibility priority and will be hidden in favor of higher-ranked colliders in crowded areas.     |
 * | medium | Colliders with this ranking have a standard visibility priority and may be hidden in favor of higher-ranked colliders in crowded areas. |
 * | high   | These colliders are given higher visibility priority than 'medium' priority.                                                            |
 * | always-visible | Colliders with this ranking will not be hidden, ensuring their constant visibility regardless of crowding. |
 *
 * Use this type to fine-tune the visibility of colliders, enhancing map readability and user experience by prioritizing important information.
 */
type TCollisionRankingTier = 'low' | 'medium' | 'high' | 'always-visible';
/**
 * Defines the placement position for a Marker, offering a selection of intuitive string options to pinpoint how the marker should be aligned. Choose from:
 *
 * | Value    | Description                                                                   |
 * |----------|-------------------------------------------------------------------------------|
 * | 'center' | Aligns the marker at its center, offering a balanced and centered appearance.|
 * | 'top'    | Aligns the marker at the top, ideal for marking locations from above.        |
 * | 'left'   | Aligns the marker on the left side, useful for when space is limited on the right.|
 * | 'bottom' | Aligns the marker at the bottom, suitable for hanging markers or when space is limited above.|
 * | 'top-left'  | Aligns the marker at the top-left corner. |
 * | 'top-right'  | Aligns the marker at the top-right corner. |
 * | 'bottom-left'  | Aligns the marker at the bottom-left corner. |
 * | 'bottom-right'  | Aligns the marker at the bottom-right corner. |
 *
 */
type TMarkerPlacement = MarkerPlacement;
/**
 * Options for controlling the behavior of the {@link Directions}.
 */
type TGetDirectionsOptions = {
  /**
   * If true directions will only take accessible routes
   *
   * @default false
   */
  accessible?: boolean;
  /**
   * When true, routing may traverse nodes that do not have the MVF `public`
   * flag set. Intended for emergency or staff-only pathing scenarios.
   *
   * Has no effect if the MVF does not declare a `public` navigation flag.
   *
   * @default false
   */
  includeNonPublic?: boolean;
  /**
   * Enable or disable path smoothing for directions.
   * When enabled, the path is simplified using line-of-sight checks to provide a more visually appealing route and shorter instructions.
   *
   * Can be a boolean to enable or disable smoothing, or an object with configuration options.
   *
   * **Available methods:**
   * - `'greedy-los'` (default): Greedy forward scan with line-of-sight validation. Fastest, O(n) time complexity. Good default choice.
   * - `'rdp'`: Uses Ramer-Douglas-Peucker preprocessing + line-of-sight validation + door buffer nodes. Better for paths with doors and complex geometry. Medium speed.
   * - `'dp-optimal'`: Dynamic Programming for globally optimal simplification. Slowest but highest quality, O(n²) complexity. Best when path quality is critical.
   *
   * @default true for non-enterprise mode, false for enterprise mode
   *
   * @example
   * ```ts
   * // Enable smoothing with default settings
   * mapView.getDirections(firstSpace, secondSpace, {
   *   smoothing: true
   * })
   *
   * // Enable smoothing with custom radius (in meters)
   * mapView.getDirections(firstSpace, secondSpace, {
   *   smoothing: {
   *     radius: 1.5,
   *   }
   * })
   *
   * // Use greedy line-of-sight method (default, explicit)
   * mapView.getDirections(firstSpace, secondSpace, {
   *   smoothing: {
   *     enabled: true,
   *     __EXPERIMENTAL_METHOD: 'greedy-los',
   *     radius: 0.4,
   *   }
   * })
   *
   * // Use RDP method (always uses line-of-sight)
   * mapView.getDirections(firstSpace, secondSpace, {
   *   smoothing: {
   *     enabled: true,
   *     __EXPERIMENTAL_METHOD: 'rdp',
   *     radius: 0.4,
   *   }
   * })
   *
   * // Use DP-optimal method with door buffer nodes
   * mapView.getDirections(firstSpace, secondSpace, {
   *   smoothing: {
   *     enabled: true,
   *     __EXPERIMENTAL_METHOD: 'dp-optimal',
   *     __EXPERIMENTAL_INCLUDE_DOOR_BUFFER_NODES: true,
   *     radius: 0.4,
   *   }
   * })
   * ```
   */
  smoothing?: boolean | {
    /**
     * Enable or disable path smoothing.
     * @default true for non-enterprise mode, false for enterprise mode
     */
    enabled?: boolean;
    /**
     * The radius of the buffer around the path to consider when simplifying, in meters.
     * @default 0.75
     */
    radius?: number;
    /**
     * @experimental
     * Path smoothing method using greedy line-of-sight algorithm.
     * Fastest method with O(n) time complexity. Good default choice.
     * @default 'greedy-los'
     */
    __EXPERIMENTAL_METHOD?: 'greedy-los';
  } | {
    /**
     * Enable or disable path smoothing.
     * @default true for non-enterprise mode, false for enterprise mode
     */
    enabled?: boolean;
    /**
     * The radius of the buffer around the path to consider when simplifying, in meters.
     * @default 0.75
     */
    radius?: number;
    /**
     * @experimental
     * Path smoothing method using Ramer-Douglas-Peucker preprocessing with line-of-sight validation.
     * Better for paths with doors and complex geometry. Medium speed.
     * Always uses line-of-sight validation (cannot be disabled).
     */
    __EXPERIMENTAL_METHOD: 'rdp';
    /**
     * @experimental
     * Whether to include door-adjacent nodes (predecessor/successor of doors) in the must-include set.
     * When true (default), nodes immediately before and after doors are preserved during simplification.
     * @default true
     */
    __EXPERIMENTAL_MUST_INCLUDE_DOOR_BUFFER_NODES?: boolean;
  } | {
    /**
     * Enable or disable path smoothing.
     * @default true for non-enterprise mode, false for enterprise mode
     */
    enabled?: boolean;
    /**
     * The radius of the buffer around the path to consider when simplifying, in meters.
     * @default 0.75
     */
    radius?: number;
    /**
     * @experimental
     * Path smoothing method using Dynamic Programming for globally optimal simplification.
     * Slowest but highest quality, O(n²) complexity. Best when path quality is critical.
     */
    __EXPERIMENTAL_METHOD: 'dp-optimal';
    /**
     * @experimental
     * Whether to include 0.5m buffer nodes perpendicular to doors in DP simplification.
     * When true, predecessor and successor nodes of doors are marked with preventSmoothing.
     * @default false
     */
    __EXPERIMENTAL_INCLUDE_DOOR_BUFFER_NODES?: boolean;
  };
  /**
   * Defines the special zones for navigation operations.
   *
   * @example
   * ```ts
   * mapView.getDirections(firstSpace, secondSpace, {
   *   zones: [
   *     {
   *       geometry: polygon as Feature<Polygon>,
   *       // The additional cost for navigation through the zone, from 0 to Infinity.
   *       // The final cost is calculated as the sum of basic cost that comes from the {@MapData}
   *       // and the additional zone cost.
   *       // A additional cost of 0 will make the zone free to navigate through
   *       // A additional cost of Infinity will make the zone impossible to navigate through
   *       cost: Infinity,
   *       floor: mapView.currentFloor,
   *     },
   *   ],
   * });
   * ```
   */
  zones?: TDirectionZone[];
  /**
   * @experimental
   * Enterprise only. Connections that should not be used for directions.
   *
   * If a connection is excluded, it will not be used in the directions even if it is the shortest (or only) path.
   * If there is no path that does not include the these connections, the directions will be undefined.
   */
  excludedConnections?: Connection[];
  /**
   * Override the default weights for specific connection ids.
   */
  connectionIdWeightMap?: Record<string, number>;
};
/**
 * The target for the add model operation.
 */
type TAddModel = {
  /**
   * The target for the model to be placed on.
   */
  target: IAnchorable;
  /**
   * Optional. Determines the opacity of the model.
   * @default 1
   */
  opacity?: number;
  /**
   * Optional. Determines the rotation of the model, in degrees.
   * @default [0, 0, 0]
   */
  rotation?: [number, number, number];
  /**
   * Optional. Determines the scale of the model. Can be a single number to scale uniformly in all dimensions,
   * or an array of three numbers [x, y, z] to scale differently in each dimension.
   * @default [1, 1, 1]
   */
  scale?: number | [number, number, number];
  /**
   * Whether the Model should be clickable
   * @default false
   */
  interactive?: boolean;
  /**
   * Vertical offset of the model in meters.
   * @deprecated Use the `verticalOffset` property on the Coordinate passed to `Models.add()` instead.
   * This property will be removed in a future version.
   */
  verticalOffset?: number;
};
/**
 * Options for controlling the behavior of a {@link Model}.
 */
type TAddModelOptions = Omit<InitializeModelState$1, 'scale' | 'url'> & {
  scale?: number | [number, number, number];
};
/**
 * @interface
 */
type TAddText3DOptions = AddText3DOptions$1;
/**
 * Options for adding 3D text at an anchorable target (e.g., Coordinate).
 */
type TAddText3DAnchorableOptions = AddText3DPointOptions;
/**
 * Options for controlling the behavior of an {@link Image3DView}.
 */
type TAddImageOptions = {
  /**
   * @internal
   */
  id?: string;
  /**
   * @internal
   * Used to register floor images by their anchor ID for lookup via map data objects.
   */
  anchorId?: string;
  /**
   * Width of the image in meters.
   */
  width: number;
  /**
   * Height of the image in meters.
   */
  height: number;
  /**
   * Rotation of the image in degrees clockwise from North. 0 degrees is North, 90 degrees is East, 180 degrees is South, and 270 degrees is West.
   *
   * @default 0
   */
  rotation?: number;
  /**
   * Vertical offset of the image in meters.
   *
   * @default 0
   */
  verticalOffset?: number;
  /**
   * If true, the image will automatically rotate to face the camera, creating a billboard effect.
   *
   * @default false
   */
  flipImageToFaceCamera?: boolean;
  /**
   * Maximum image width or height in pixels. If the image's largest dimension exceeds
   * this value, it will be scaled down proportionally. This helps prevent VRAM exhaustion
   * on mobile devices.
   *
   * @default 1024
   */
  maxImageSize?: number;
  /**
   * Whether the {@link Image3DView} should be clickable. When `true`, click and hover events
   * for the image will be dispatched via `MapView.on('click')` and `MapView.on('hover')` under
   * the `images` property of the event payload. Can be toggled at runtime via
   * `MapView.updateState(image, { interactive })`.
   *
   * @default false
   */
  interactive?: boolean;
};
/**
 * Options for controlling the behavior of a {@link Marker}.
 */
type TAddMarkerOptions = {
  /**
   * Optional. Determines the collision ranking tier of the marker, which influences its visibility in relation to other colliders.
   * For the possible values ('medium', 'high', 'always-visible') and their impact on label visibility, see {@link TCollisionRankingTier}.
   */
  rank?: TCollisionRankingTier | 'initial';
  /**
   * Optional. Specifies the placement of the marker, determining its position relative to its coordinates.
   * If a list is provided, the marker will be aligned to the first placement that is available.
   *
   * The active placement will be exposed as a DOM attribute `data-placement` on the marker element.
   *
   * For the possible values and their descriptions, see {@link TMarkerPlacement}.
   */
  placement?: TMarkerPlacement | TMarkerPlacement[];
  /**
   * Whether the {@link Marker} should be clickable.
   * If `true` the marker will be registered in the SDK interaction events.
   * If `'pointer-events-auto'` the marker will receive browser pointer events.
   * @default false
   */
  interactive?: boolean | 'pointer-events-auto';
  /**
   * @internal
   */
  id?: string;
  /**
   * When true, the marker's collision boundary automatically adjusts when the marker's content or size changes.
   * Set to false for markers with static content that won't change after creation to improve performance.
   * @default true
   */
  dynamicResize?: boolean;
  /**
   * Whether the marker is enabled.
   * @default true
   */
  enabled?: boolean;
  /**
   * The z-index of the marker. Can be used used in conjunction with rank: 'always-visible' override the default distance from the camera based
   * sorting of markers and show certain markers always in front
   */
  zIndex?: number;
  /**
   * Configuration for the low priority pin fallback strategy.
   * When enabled, shows a smaller pin version of the marker when all anchor positions have collisions.
   * @default { enabled: true, size: 2, color: '#666' }
   */
  lowPriorityPin?: {
    /**
     * Whether to enable low priority pin strategy when all anchor positions have collisions.
     * @default true
     * @deprecated add 'hidden' to the placement array instead
     */
    enabled?: boolean;
    /**
     * Size of the low priority pin in pixels.
     * @default 2
     */
    size?: number;
    /**
     * Color of the low priority pin.
     * @default '#666'
     */
    color?: string;
  };
  /**
   * Whether the marker should be occluded by 3D geometry.
   * @default true
   */
  occlude?: boolean;
  /**
   * Whether the marker should animate visibility transitions.
   * When false, opacity is set directly without transitions.
   * @default true
   */
  animated?: boolean;
};
/**
 * Options for creating a new {@link Label} with {@link Labels.add}.
 */
type TAddLabelOptions = {
  /**
   * Optional. Determines the collision ranking tier of the label, which influences its visibility in relation to other colliders.
   * For the possible values ('medium', 'high', 'always-visible') and their impact on label visibility, see {@link TCollisionRankingTier}.
   */
  rank?: TCollisionRankingTier | 'initial';
  /**
   * Customize the appearance of the {@link Label} and its pin
   */
  appearance?: LabelAppearance$1;
  /**
   * Whether the Label should be clickable.
   * @default false
   */
  interactive?: boolean;
  /**
   * @internal
   */
  id?: string;
  /**
   * Whether the label is enabled.
   */
  enabled?: boolean;
  /**
   * The placement of the text relative to the pin.
   */
  textPlacement?: LabelTextPlacement$1[];
  /**
   * Whether the label should be occluded by 3D geometry.
   * @default true
   */
  occlude?: boolean;
};
type LanguagePackHydrationItem = {
  language: Language;
  localePack: ParsedMVFLocalePack;
};
/**
 * All map elements which have state.
 */
type MapElementsWithState = WithState<MapDataElements | MapViewElements | DOORS | WALLS>;
/**
 * Filter type that extracts only elements which have state.
 */
type WithState<T$1> = T$1 extends {
  __type: infer U;
} ? U extends keyof MapElementToGetState ? T$1 : never : T$1 extends string ? T$1 extends keyof MapElementToGetState ? T$1 : never : never;
/**
 * The type for updating the state of map elements (colors, texts, etc.).
 * Accepts partial state updates for all element types.
 */
type TUpdateState<T$1 extends MapElementsWithState | string> = T$1 extends {
  __type: infer U;
} ? U extends keyof MapElementToUpdateState ? MapElementToUpdateState[U] : never : T$1 extends string ? T$1 extends keyof MapElementToUpdateState ? MapElementToUpdateState[T$1] : Record<string, any> : never;
type MapElementToGetRenderedState = {
  [Label.__type]: ReadonlyDeep<LabelRenderedState>;
};
/**
 * The type for getting the state of map elements.
 * Returns the full state type for all element types.
 */
type TGetState<T$1 extends MapElementsWithState | string> = T$1 extends {
  __type: infer U;
} ? U extends keyof MapElementToGetState ? MapElementToGetState[U] : never : T$1 extends string ? T$1 extends keyof MapElementToGetState ? MapElementToGetState[T$1] : Record<string, any> : never;
type MapElementWithRenderedState = WithState<Label>;
type TGetRenderedState<T$1 extends MapElementWithRenderedState | string> = T$1 extends {
  __type: infer U;
} ? U extends keyof MapElementToGetRenderedState ? MapElementToGetRenderedState[U] : never : T$1 extends string ? T$1 extends keyof MapElementToGetRenderedState ? MapElementToGetRenderedState[T$1] : Record<string, any> : never;
type GlobalState = {
  /**
   * The color of the background, in hex format(#000000).
   */
  backgroundColor: string;
  /**
   * The alpha value of the background, between 0 and 1.
   * @default 1
   */
  backgroundAlpha: number;
  /**
   * environment map for reflections.
   * @default 'basic'
   */
  environment: EnvMapOptions$1;
  text3d: {
    /**
     * hover color of the text3d
     */
    hoverColor: string;
  };
  geometry: {
    /**
     * hover color of the geometries
     */
    hoverColor: string;
  };
  /**
   * Visual effect settings for floors visible through open-to-below spaces below the current floor.
   */
  multiFloorView: MultiFloorViewEffectState;
};
/**
 * Visual effect settings for floors visible through open-to-below spaces in multi-floor view.
 */
type MultiFloorViewEffectState = {
  /** Whether the effects are enabled. */
  spacesOpenToBelowVisualEffectEnabled: boolean;
  /** How much to darken (0 = none, 1 = fully towards #333). */
  spacesOpenToBelowVisualEffectDarkenAmount: number;
  /** Whether darkening intensifies with depth. */
  spacesOpenToBelowVisualEffectDarkenUseDepth: boolean;
  /** How much to desaturate (0 = full color, 1 = grayscale). */
  spacesOpenToBelowVisualEffectDesaturateAmount: number;
  /** Whether desaturation intensifies with depth. */
  spacesOpenToBelowVisualEffectDesaturateUseDepth: boolean;
  /** How much to wash out towards white (0 = none, 1 = fully white). */
  spacesOpenToBelowVisualEffectWashOutAmount: number;
  /** Whether wash-out intensifies with depth. */
  spacesOpenToBelowVisualEffectWashOutUseDepth: boolean;
};
/**
 * Partial version of {@link GlobalState} used to update the global state of the MapView.
 * All properties are optional.
 */
interface UpdateGlobalState {
  /**
   * The color of the background, in hex format(#000000).
   */
  backgroundColor?: string;
  /**
   * The alpha value of the background, between 0 and 1.
   * @default 1
   */
  backgroundAlpha?: number;
  /**
   * environment map for reflections.
   * @default 'basic'
   */
  environment?: EnvMapOptions$1;
  text3d?: {
    /**
     * hover color of the text3d
     */
    hoverColor?: string;
  };
  geometry?: {
    /**
     * hover color of the geometries
     */
    hoverColor?: string;
  };
  /**
   * Update visual effect settings for floors visible through open-to-below spaces.
   * Only the provided fields are updated; omitted fields keep their current values.
   */
  multiFloorView?: Partial<MultiFloorViewEffectState>;
}
/**
 * A map element that can be focused on by the camera.
 */
type TFocusTarget = Coordinate | Space | Area | MapObject | Floor | FloorStack | Shape;
/**
 * Associates MapData type strings with their corresponding classes.
 */
type TMapDataObjectTypes = {
  [LocationProfile.__type]: LocationProfile;
  [LocationCategory.__type]: LocationCategory;
  [Node.__type]: Node;
  [Space.__type]: Space;
  [Door.__type]: Door;
  [Floor.__type]: Floor;
  [FloorStack.__type]: FloorStack;
  [Connection.__type]: Connection;
  [MapObject.__type]: MapObject;
  [PointOfInterest.__type]: PointOfInterest;
  [Annotation.__type]: Annotation;
  [EnterpriseLocation.__type]: EnterpriseLocation;
  [EnterpriseCategory.__type]: EnterpriseCategory;
  [EnterpriseVenue.__type]: EnterpriseVenue;
  [Area.__type]: Area;
  [Facade.__type]: Facade;
};
/**
 * Associates MapView type strings with their corresponding classes.
 */
type TMapViewObjectTypes = {
  [Label.__type]: Label;
  [Marker.__type]: Marker;
  [Model.__type]: Model;
  [Shape.__type]: Shape;
  [Path.__type]: Path;
  [PathSegment$1.__type]: PathSegment$1;
  [Image3DView.__type]: Image3DView;
  [Text3DView.__type]: Text3DView;
};
/**
 * Associates MapData and MapView type strings with their corresponding classes.
 *
 * This is a union of {@link TMapDataObjectTypes} and {@link TMapViewObjectTypes}, providing
 * a complete mapping of all map feature type strings to their class types.
 */
type TMapFeatureTypes = TMapDataObjectTypes & TMapViewObjectTypes;
/**
 * Returns the class type for a given type string.
 */
type MapFeatureOfType<T$1 extends string> = T$1 extends keyof TMapFeatureTypes ? TMapFeatureTypes[T$1] : never;
/**
 * @interface
 * @internal
 */
type TImagePlacementOptions = ImagePlacementOptions;
/**
 * Options to control which camera interactions are enabled in the MapView.
 *
 * All values are optional; if omitted, the corresponding interaction will not be changed.
 */
type TCameraInteractionsSetOptions = {
  /**
   * Whether to enable panning (dragging the map).
   */
  pan?: boolean;
  /**
   * Whether to enable zooming (scroll or pinch).
   */
  zoom?: boolean;
  /**
   * Whether to enable bearing (rotation) and pitch (tilting).
   */
  bearingAndPitch?: boolean;
};
type TSetFloorOptions = {
  /**
   * Optionally provide the context for the floor change which will be published as the `reason` for the `floor-change` event.
   */
  context?: TFloorChangeReason;
};
/**
 * Options for controlling multi-floor view.
 * When enabled, displays all floors in a building stacked vertically below the active floor,
 * allowing users to see the building's vertical structure and navigate between floors.
 * The active floor is fully rendered while lower floors appear as semi-transparent footprints.
 */
type TMultiFloorViewOptions = {
  /**
   * Enable multi-floor view to show floors stacked vertically below the active floor.
   * @default true
   */
  enabled?: boolean;
  /**
   * The vertical spacing between floors in meters (before `floorGapMultiplier`).
   *
   * - **number** — base gap in meters × `floorGapMultiplier`, applied uniformly to all floors.
   * - **'auto'** — each floor's gap is derived from its data:
   *   1. `maxHeight` from venue data × `floorGapMultiplier`
   *   2. Computed geometry height as a guard (prevents tall geometry from poking through)
   *   3. `floorGapFallback` × `floorGapMultiplier` if provided
   *   4. Internal default (3m × `floorGapMultiplier`)
   *
   * @default 'auto'
   */
  floorGap?: number | 'auto';
  /**
   * Multiplier applied to all floor height sources: `maxHeight`, `floorGap` (number),
   * `floorGapFallback`, and the internal default height (3m).
   *
   * @default 1 (heights are used as-is)
   *
   * @example
   * ```typescript
   * // Double all floor heights for wider separation
   * multiFloorView: { floorGapMultiplier: 2 }
   *
   * // Works with explicit floorGap too: 5m × 2 = 10m per floor
   * multiFloorView: { floorGap: 5, floorGapMultiplier: 2 }
   * ```
   */
  floorGapMultiplier?: number;
  /**
   * Fallback floor height in meters, used when `floorGap` is `'auto'` and a floor
   * has no `maxHeight` in the venue data. This value is multiplied by `floorGapMultiplier`.
   *
   * When not provided, `DEFAULT_FLOOR_HEIGHT × floorGapMultiplier` (3m × 1 = 3m) is used.
   *
   * @example
   * ```typescript
   * // 4-meter base gap for floors without maxHeight data (× floorGapMultiplier)
   * multiFloorView: { floorGap: 'auto', floorGapFallback: 4 }
   * ```
   */
  floorGapFallback?: number;
  /**
   * Automatically adjust the camera elevation when switching floors to match the floor's altitude.
   * @default true
   */
  updateCameraElevationOnFloorChange?: boolean;
  /**
   * The color of the floor footprints when in multi-floor view.
   * Accepts either:
   * - A CSS color string (hex, rgb, rgba, named colors) applied to all floors
   * - An object mapping floor IDs to color strings for per-floor coloring
   *
   * When using an object, floors without a specified color will use the internal default ('#ffffff').
   *
   * @example
   * // Single color for all floors
   * footprintColor: '#ff0000'
   *
   * @example
   * // Per-floor colors
   * footprintColor: {
   *   'floor-1': '#ff0000',
   *   'floor-2': '#00ff00',
   *   'floor-3': '#0000ff'
   * }
   *
   * @default '#ffffff'
   */
  footprintColor?: string | Partial<Record<Floor['id'], string>>;
  /**
   * The opacity of the floor footprints when in multi-floor view.
   * @default 1
   */
  footprintOpacity?: number;
  /**
   * The outline of the floor footprints when in multi-floor view.
   * @default true
   */
  footprintOutline?: boolean;
  /**
   * When true, footprints remain hidden and ignore all state updates.
   * This prevents footprint geometry from interfering with raycasting.
   * @default false
   */
  footprintsHidden?: boolean;
  /**
   * Whether to enable spaces open to below (ceiling cutouts that expose lower floors).
   *
   * When this is enabled, and spaces that have kind "void" or "otb" will be cut out of the ceiling
   * exposing the floor below. Any holes in the footprint will also be cut out but will have walls built around them.
   *
   * @default false
   * @experimental
   */
  spacesOpenToBelowEnabled?: boolean;
  /**
   * Enable visual effects on floors visible through open-to-below spaces below the current floor.
   * Only applies when `spacesOpenToBelowEnabled` is true.
   * @default true
   */
  spacesOpenToBelowVisualEffectEnabled?: boolean;
  /**
   * How much to darken floors visible through open-to-below spaces (0 = no darkening, 1 = fully darkened towards #333).
   * @default 0.2
   */
  spacesOpenToBelowVisualEffectDarkenAmount?: number;
  /**
   * Whether the darkening effect intensifies as floors are further below the current floor.
   * @default true
   */
  spacesOpenToBelowVisualEffectDarkenUseDepth?: boolean;
  /**
   * How much to desaturate floors visible through open-to-below spaces (0 = full color, 1 = fully grayscale).
   * Recommended value: `0.7`.
   * @default 0
   */
  spacesOpenToBelowVisualEffectDesaturateAmount?: number;
  /**
   * Whether the desaturation effect intensifies as floors are further below the current floor.
   * @default true
   */
  spacesOpenToBelowVisualEffectDesaturateUseDepth?: boolean;
  /**
   * How much to wash out (fade to white) floors visible through open-to-below spaces (0 = no wash out, 1 = fully white).
   * Recommended value: `0.7`.
   * @default 0
   */
  spacesOpenToBelowVisualEffectWashOutAmount?: number;
  /**
   * Whether the wash out effect intensifies as floors are further below the current floor.
   * @default false
   */
  spacesOpenToBelowVisualEffectWashOutUseDepth?: boolean;
  /**
   * When true, disables the automatic gap-filling footprints that are created
   * between floors with missing elevations. This prevents the SDK from building
   * `gapFootprint` geometry in `FloorObject`, which can be useful when the venue
   * data does not have reliable elevation gaps or when gap filling is not desired.
   *
   * @default false
   * @experimental
   */
  __EXPERIMENTAL_disableGapFilling?: boolean;
  /**
   * Debug option to show void polygons (holes in the footprint).
   * @experimental
   * @internal
   */
  __EXPERIMENTAL_DEBUG_showVoids?: boolean;
  /**
   * Debug option to show spaces open to below polygons.
   * @experimental
   * @internal
   */
  __EXPERIMENTAL_DEBUG_showOpenToBelow?: boolean;
  /**
   * Space IDs to exclude when computing the automatic floor height (`geometryMaxHeight`).
   * Useful for ignoring tall outlier spaces (e.g. atriums, voids) that would otherwise
   * inflate the floor gap in `'auto'` mode.
   *
   * @default []
   * @experimental
   */
  __EXPERIMENTAL_excludeSpaceIdsInAutoHeightCalculation?: readonly string[];
};
type TGetInViewOptions = Partial<{
  screenOffsets: Partial<InsetPadding$1>;
  fullyContains: boolean;
}>;
/**
 * Configuration options for highlighting a specific section of a path on the map.
 * These options allow you to visually emphasize a segment of a path using custom color, width,
 * and animation duration for user interaction or navigation purposes.
 */
type TPathSectionHighlightOptions = {
  /**
   * The highlight color for the path section (CSS color string).
   * @default 'red'
   */
  color?: string;
  /**
   * Multiplies the base path width by this factor for the duration of the highlight.
   * @default 1
   */
  widthMultiplier?: number;
  /**
   * Duration of the highlight animation in milliseconds.
   * @default 1500
   */
  animationDuration?: number;
};
/**
 * Altitude and visual height data for a single floor elevation.
 * Used by multi-floor rendering to position floors and footprints.
 */
type TFloorAltitudeData = {
  /** Visual altitude (vertical position) of the floor in meters */
  altitude: number;
  /** Visual height of the floor gap in meters */
  visualHeight: number;
};
/**
 * Options for taking a screenshot.
 */
type TTakeScreenshotOptions = {
  /**
   * Whether to include the outdoor context in the screenshot.
   * @default false
   */
  withOutdoorContext?: boolean;
  /**
   * Whether to include map labels in the screenshot.
   * @default false
   */
  withLabels?: boolean;
  /**
   * Optional. Function to capture HTML marker elements as canvas.
   * When provided with withLabels, also includes markers in the screenshot.
   *
   * If the returned canvas is tainted (contains cross-origin images without CORS),
   * the marker layer will be skipped and the screenshot will still succeed.
   *
   * To include all content, ensure:
   * - Use `useCORS: true` in html2canvas options
   * - Images have proper CORS headers (`Access-Control-Allow-Origin`)
   * - Use `scale: window.devicePixelRatio` for crisp output
   * - Set `backgroundColor: null` for transparency
   *
   * @example html2canvas
   * ```typescript
   * captureMarkers: (el) => html2canvas(el, {
   *   backgroundColor: null,
   *   scale: window.devicePixelRatio,
   *   useCORS: true,
   * })
   * ```
   */
  captureMarkers?: (element: HTMLElement) => Promise<HTMLCanvasElement>;
};
//#endregion
//#region src/map-data-objects/coordinate.d.ts
/**
 * Parameters for creating a {@link Coordinate}.
 *
 * Used with the {@link Coordinate} constructor or {@link MapView.createCoordinate} method to create a coordinate on the map.
 */
type TCoordinateParams = {
  /**
   * The latitude of the {@link Coordinate}.
   */
  latitude: number;
  /**
   * The longitude of the {@link Coordinate}.
   */
  longitude: number;
  /**
   * Optional ID of the {@link Floor} this {@link Coordinate} is on.
   */
  floorId?: string;
  /**
   * Optional vertical offset from the {@link Floor} in meters.
   */
  verticalOffset?: number;
};
/**
 * Class representing a pseudo-mercator coordinate.
 *
 * The Pseudo-Mercator projection is a type of cylindrical and conformal map projection.
 * It is identified as EPSG:3857 ({@link https://epsg.io/3857}).
 * This projection is a modified version of the traditional Mercator projection,
 * which is commonly used in marine navigation.
 */
declare class Coordinate implements IFocusable, IAnchorable, IGeoJSONData, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "coordinate";
  /**
   * @internal
   */
  readonly __type = "coordinate";
  id: string;
  /**
   * The latitude of the coordinate.
   * @type {number}
   */
  readonly latitude: number;
  /**
   * The longitude of the coordinate.
   * @type {number}
   */
  readonly longitude: number;
  /**
   * The floor ID of the coordinate.
   */
  readonly floorId?: string;
  /**
   * The vertical position of the coordinate, offset from the floor.
   */
  readonly verticalOffset: number;
  /**
   * Checks if the provided instance is of type Coordinate.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Coordinate, false otherwise.
   */
  static is(instance: object): instance is Coordinate;
  /**
   * Creates a new Coordinate instance.
   *
   * @param latitudeOrParams Either a latitude number or a TCoordinateParams object containing coordinate details
   */
  constructor(latitudeOrParams: TCoordinateParams);
  /**
   * @deprecated
   * @internal
   */
  constructor(latitudeOrParams: number, longitude: number, floorId?: string);
  /**
   * @internal
   */
  get anchorTarget(): this;
  /**
   * @internal
   */
  get focusTarget(): this;
  /**
   * @internal
   */
  get navigationTarget(): this;
  /**
   * Checks if this coordinate is equal to another coordinate.
   *
   * @param coordinate The coordinate to compare with.
   * @returns {boolean} True if coordinates are equal, false otherwise.
   */
  isEqual(coordinate: Coordinate): boolean;
  /**
   * Serializes the coordinate data to JSON.
   *
   * @returns An object representing the coordinate.
   */
  toJSON(): {
    __type: string;
    latitude: number;
    longitude: number;
    floorId: string | undefined;
    verticalOffset: number;
  };
  /**
   * Gets the underlying GeoJSON Feature representation of this Coordinate.
   */
  get geoJSON(): Feature$1<Point$1, null>;
  /**
   * @deprecated Use {@link geoJSON} instead.
   */
  toGeoJSON(): Point$1;
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/base-metadata-object.d.ts
declare abstract class BaseMetaData {
  /**
   * The identity of the map metadata.
   */
  readonly id: string;
  constructor(id: string);
}
//#endregion
//#region src/map-data-objects/opening-hours.d.ts
/**
 * Represents the opening hours of a location.
 */
declare class OpeningHours {
  #private;
  constructor(mvfData: OpeningHoursSpecification[]);
  /**
   * Gets the raw opening hours data.
   */
  get raw(): OpeningHoursSpecification[];
}
//#endregion
//#region src/map-data-objects/hyperlink.d.ts
/**
 * A class representing hyperlink link data within the map.
 */
declare class Hyperlink extends BaseMetaData {
  #private;
  /**
   * @internal
   */
  static readonly __type = "hyperlink";
  /**
   * @internal
   */
  readonly __type = "hyperlink";
  /**
   * Checks if the provided instance is of type Hyperlink.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Hyperlink, false otherwise.
   */
  static is(instance: object): instance is Hyperlink;
  /**
   * @internal
   */
  constructor(options: {
    mvfData: Hyperlink$1 | LocationLink;
  });
  /**
   * Gets the url of the hyperlink.
   *
   * @returns {string} The url of the hyperlink.
   */
  get url(): string;
  /**
   * Gets the name of the hyperlink.
   *
   * @returns {string | undefined } The name of the hyperlink.
   */
  get name(): string | undefined;
  /**
   * Serializes the hyperlink data to JSON.
   *
   * @returns An object representing the hyperlink.
   */
  toJSON(): {
    __type: string;
    id: string;
    url: string;
    name: string | undefined;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/image.d.ts
/**
 * A class representing image link data within the map.
 */
declare class ImageMetaData extends BaseMetaData {
  #private;
  /**
   * @internal
   */
  static readonly __type = "image";
  /**
   * @internal
   */
  readonly __type = "image";
  /**
   * Checks if the provided instance is of type Image.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Image, false otherwise.
   */
  static is(instance: object): instance is ImageMetaData;
  /**
   * @internal
   */
  constructor(options: {
    mvfData: Image;
    mapData: MapDataInternal;
  });
  /**
   * Gets the url of the image.
   *
   * @returns {string | undefined} The url of the image.
   */
  get url(): string | undefined;
  /**
   * Gets the alt text of the image.
   *
   * @returns {string | undefined } The alt text of the image.
   * @deprecated Use {@link altText} instead.
   */
  get name(): string | undefined;
  /**
   * Gets the alt text of the image.
   *
   * @returns {string | undefined } The alt text of the image.
   */
  get altText(): string | undefined;
  /**
   * Serializes the image data to JSON.
   *
   * @returns An object representing the image.
   */
  toJSON(): {
    __type: string;
    id: string;
    url: string | undefined;
    name: string | undefined;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/location-profile.d.ts
type MVF3Location = Required<MVFv2_STANDARD_MVFv3>['locations'][number];
/**
 * @internal
 * This type helps us know we have all the properties we need
 */
type LocationData = Omit<Location, 'categories' | 'spaces' | 'obstructions' | 'entrances' | 'shapes' | 'connections' | 'annotations' | 'areas' | 'openingHoursSpecification' | 'links' | 'pictures' | 'website' | 'icon'> & {
  links: Hyperlink[];
  images: ImageMetaData[];
  icon?: ImageMetaData;
};
/**
 * A LocationProfile contains metadata about a location, such as its name, description, logo, phone number, social media links, hours of operation and more.
 * They can be accessed using the {@link MapData.getByType} method as shown below.
 *
 * ```typescript
 * const allLocations = mapData.getByType('location-profile');
 * ```
 *
 * @remarks
 * **Data Source: Maker** - This class is only available when using Maker credentials
 * (API keys starting with `mik_`). When using CMS/Enterprise credentials (clientId/clientSecret
 * or keys that do NOT start with `mik_`), use {@link EnterpriseLocation} instead.
 *
 * @see {@link EnterpriseLocation} for the CMS/Enterprise equivalent.
 */
declare class LocationProfile extends BaseMetaData implements LocationData, IFocusable, INavigatable {
  #private;
  /**
   * Checks if the provided instance is of type LocationProfile.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a EnterpriseLocation, false otherwise.
   */
  static is(instance: object): instance is LocationProfile;
  /**
   * @internal
   */
  static readonly __type = "location-profile";
  /**
   * @internal
   */
  readonly __type = "location-profile";
  id: LocationId;
  name: string;
  externalId?: string;
  description?: string;
  /**
   * The location's logo
   *
   * @format uri
   * @deprecated Use the {@link logoImage} property instead
   */
  logo?: string;
  /**
   * An image representing the location's logo
   */
  logoImage?: ImageMetaData;
  phone?: string;
  /**
   * The location's social media links.
   */
  social: LocationSocial$1[];
  /**
   * The location's pictures
   */
  images: ImageMetaData[];
  /**
   * Web links for the location
   */
  links: Hyperlink[];
  /**
   * The location's website
   */
  website?: Hyperlink;
  /**
   * The location's icon to display. Will be either a logo, category, or image
   *
   * @format uri
   */
  icon?: ImageMetaData;
  /**
   * Additional user defined data. The type is unknown, so it is recommended to validate the data before use.
   *
   * _Only available when loading MVFv3 data._
   *
   * ```ts
   * const mapData = await getMapData({
   *   ...
   *   mvfVersion: '3.0.0',
   * });
   *
   * const locationProfile = mapData.getById('location-profile', id);
   * if (typeof locationProfile?.extra?.myProperty === 'string') {
   * 	// Do something
   * }
   * ```
   */
  extra?: Record<string, unknown>;
  /**
   * Additional keywords to match against when searching. These should not be used for display.
   */
  searchTags?: string[];
  /** @internal */
  constructor(data: MapDataInternal, options: {
    mvf2Data: Location;
    mvf3Data?: MVF3Location;
  });
  /**
   * Gets the {@link Space}s associated with the location.
   *
   * @returns {Space[]} The spaces array.
   */
  get spaces(): Space[];
  /**
   * Gets the {@link PointOfInterest}s associated with the location.
   *
   * @returns {PointOfInterest[]} The points of interest array.
   */
  get points(): PointOfInterest[];
  /**
   * Gets the {@link Door}s associated with the location.
   *
   * @returns {Door[]} The doors array.
   */
  get doors(): Door[];
  /**
   * Gets the {@link Connection}s associated with the location.
   *
   * @returns {Connection[]} The connections array.
   */
  get connections(): Connection[];
  /**
   * Gets the {@link Annotation}s associated with the location.
   *
   * @returns {Annotation[]} The annotations array.
   */
  get annotations(): Annotation[];
  /**
   * Gets the {@link LocationCategory}s associated with the location.
   *
   * @remarks
   * **Data Source: Maker** - This property is only available when using Maker credentials.
   *
   * @returns {LocationCategory[]} The location categories array.
   */
  get categories(): LocationCategory[];
  /**
   * Gets the {@link MapObject}s associated with the location.
   *
   * @returns {MapObject[]} The map objects array.
   */
  get mapObjects(): MapObject[];
  /**
   * Gets the {@link Area}s associated with the location.
   *
   * @returns {Area[]} The areas array.
   */
  get areas(): Area[];
  /** @internal */
  get focusTarget(): TFocusTarget[];
  /**
   * Gets the {@link OpeningHours} associated with the location.
   *
   * @returns {OpeningHours} The opening hours.
   */
  get openingHours(): OpeningHours;
  /**
   * @internal
   */
  get navigationTarget(): TNavigationTarget[];
  toJSON(): {
    __type: string;
    id: string;
    name: string;
  };
}
//#endregion
//#region src/map-data-objects/base-object.d.ts
declare abstract class BaseMapData {
  #private;
  /**
   * The identity of the map data.
   */
  readonly id: string;
  constructor(id: string, _data: MapDataInternal);
  /**
   * Gets the bounding box of the geoJSON geometry.
   *
   * @returns {BBox} The bounding box of the geoJSON geometry
   */
  get geoJSONBoundingBox(): BBox | undefined;
  get geoJSON(): Feature<Polygon | MultiPolygon | LineString | Point, null>;
}
//#endregion
//#region src/map-data-objects/detailed-map-data.d.ts
declare abstract class DetailedMapData<MVFData extends Feature$1<Geometry$1, {
  id: string;
  externalId?: string;
  details?: Details;
}>> extends BaseMapData {
  #private;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, mvfData: MVFData);
  /**
   * Gets the external identifier of the map feature.
   *
   * @returns {string} The external ID of the map feature, or an empty string if no external ID exists.
   */
  get externalId(): string;
  /**
   * Gets the name of the map feature.
   *
   * @returns {string} The name of the map feature.
   */
  get name(): string;
  /**
   * Gets the URL of the icon for the map feature.
   *
   * @returns {ImageMetaData | undefined} The icon of the map feature.
   */
  get icon(): ImageMetaData | undefined;
  /**
   * Gets the description of the map feature.
   *
   * @returns {string} The description of the map feature, or an empty string if no description exists.
   */
  get description(): string;
  /**
   * Gets the array of {@link ImageMetaData}s associated with this map feature.
   *
   * @returns {ImageMetaData[]} An array of Image objects, or an empty array if no images exist.
   */
  get images(): ImageMetaData[];
  /**
   * Gets the array of {@link Hyperlink}s associated with this map feature.
   *
   * @returns {Hyperlink[]} An array of Hyperlink objects, or an empty array if no links exist.
   */
  get links(): Hyperlink[];
  /**
   * Gets the {@link LocationProfile}s attached to this feature.
   *
   * @remarks
   * **Data Source: Maker** - This property is only populated when using Maker credentials
   * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise credentials.
   * For Enterprise data, use {@link Space.enterpriseLocations} or {@link MapObject.enterpriseLocations} instead.
   *
   * @returns {LocationProfile[]} An array of location profiles.
   */
  get locationProfiles(): LocationProfile[];
  /**
   * Serializes DetailedMapData fields to a plain object.
   * Internal method for use by bridge serialization.
   *
   * @internal
   */
  _serializeDetailedMapData(): {
    externalId: string;
    name: string;
    description: string;
    images: ImageMetaData[];
    links: Hyperlink[];
    locationProfiles: LocationProfile[];
  };
}
//#endregion
//#region src/map-data-objects/area.d.ts
/**
 * An Area represents some grouping of multiple pieces of geometry, not
 * necessarily bounded by walls or any other physical feature of the map.
 *
 * Areas are currently in a preview state, and may have changes to existing
 * functionality or new features added in the future.
 */
declare class Area extends DetailedMapData<AreaCollection['features'][number]> implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "area";
  /**
   * @internal
   */
  readonly __type = "area";
  /**
   * Checks if the provided instance is of type Area.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Area, false otherwise.
   */
  static is(instance: object): instance is Area;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: AreaCollection['features'][number];
  });
  /**
   * Gets the center {@link Coordinate} of the area.
   *
   * @returns {Coordinate} The area's center coordinate.
   */
  get center(): Coordinate;
  /**
   * Gets the {@link Floor} object associated with the area.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Gets the 3D images anchored to this area.
   *
   * @returns {Image3DView[]} An array of Image3DView objects representing 3D images attached to this area.
   */
  get images3D(): Image3DView[];
  /**
   * Gets the underlying GeoJSON Feature representation of this Area.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: _mappedin_mvf_v22.Polygon;
  };
  /** @internal */
  get focusTarget(): this;
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get navigationTarget(): this;
  /**
   * Serializes the space data to JSON.
   *
   * @returns An object representing the space.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    floor: string;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/door.d.ts
/**
 * A class representing door data within the map.
 *
 * Doors are hidden by default. Doors can be made visible by setting their `visible` property to `true`.
 *
 * ```typescript
 * //Make interior doors visible and brown.
 * mapView.updateState(DOORS.Interior, {
 * 	visible: true,
 * 	color: '#5C4033',
 * 	opacity: 0.6,
 * });

 * //Make exterior doors visible and black.
 * mapView.updateState(DOORS.Exterior, {
 * 	visible: true,
 * 	color: 'black',
 * 	opacity: 0.6,
 * });
 * ```
 * Doors can also be made visible on an individual basis by passing in a {@link Door} object to {@link MapView.updateState}.
 *
 * Refer to the [Door Guide](https://developer.mappedin.com/web-sdk/spaces#doors) for more information and interactive examples.
 *
 * Door appearance can be customized by changing the color or adding a texture to the top or sides of a door.
 * Refer to the [Textures & Colors Guide](https://developer.mappedin.com/web-sdk/images-textures#textures--colors) for more information and interactive examples.
 *
 */
declare class Door extends DetailedMapData<EntranceFeature> implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "door";
  /**
   * @internal
   */
  readonly __type = "door";
  /**
   * Checks if the provided instance is of type Door.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Door, false otherwise.
   */
  static is(instance: object): instance is Door;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: EntranceFeature;
  });
  /**
   * Gets the {@link Floor} object associated with the door.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Calculates and gets the center {@link Coordinate} of the door.
   *
   * @returns {Coordinate} The center coordinate.
   */
  get center(): Coordinate;
  /**
   * Gets whether this door is an exterior door.
   */
  get isExterior(): boolean;
  /**
   * Gets the underlying GeoJSON Feature representation of this Door.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: _mappedin_mvf_v22.LineString;
  };
  /** @internal */
  get focusTarget(): Coordinate;
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get navigationTarget(): this;
  /**
   * Converts the door information to a JSON object.
   *
   * @returns An object representing the door.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    floor: string;
    center: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    };
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/space.d.ts
/**
 * Represents the various types of spaces that can be defined within a map.
 * - 'room': A standard room or enclosed area.
 * - 'hallway': A passageway connecting rooms.
 * - 'exterior': An outdoor area.
 * - 'void': An undefined or non-specific space.
 */
type TSpaceType = 'room' | 'hallway' | 'exterior' | 'void' | 'gate' | 'otb';
/**
 * A Space represents an area enclosed by walls, such as a hall or room. Spaces can be Interactive and have Labels and Markers added to them.
 * Spaces can also be customized with a color, texture and hover color.
 *
 * Refer to the [Spaces Guide](https://developer.mappedin.com/web-sdk/spaces) for more information and interactive examples.
 */
declare class Space extends DetailedMapData<SpaceFeature> implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "space";
  /**
   * @internal
   */
  readonly __type = "space";
  /**
   * Checks if the provided instance is of type Space.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Space, false otherwise.
   */
  static is(instance: object): instance is Space;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: SpaceFeature;
  });
  /**
   * Gets the type/kind of the space.
   *
   * @returns {TSpaceType} The type of the space.
   */
  get type(): TSpaceType;
  /**
   * Gets the {@link EnterpriseLocation}s attached to this space.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials
   * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty array when
   * using Maker credentials. For Maker data, access locations via {@link LocationProfile.spaces}
   * instead.
   *
   * @returns {EnterpriseLocation[]} An array of enterprise locations.
   */
  get enterpriseLocations(): EnterpriseLocation[];
  /**
   * Gets the {@link EnterpriseLocation}s attached to this space.
   *
   * @deprecated Use {@link enterpriseLocations} instead. This property will be removed in a future release.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials.
   *
   * @returns {EnterpriseLocation[]} An array of enterprise locations.
   */
  get locations(): EnterpriseLocation[];
  /**
   * Gets the {@link Floor} object associated with the space.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Gets the array of {@link Door}s associated with the space.
   *
   * @remarks
   * **Data Source: Maker** - This property is only populated when using Maker credentials
   * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise credentials.
   *
   * @returns {Door[]} The doors array.
   */
  get doors(): Door[];
  /**
   * Gets the 3D images anchored to this space.
   *
   * @returns {Image3DView[]} An array of Image3DView objects representing 3D images attached to this space.
   */
  get images3D(): Image3DView[];
  /**
   * Gets the center {@link Coordinate} of the space.
   *
   * @returns {Coordinate} The space's center coordinate.
   */
  get center(): Coordinate;
  /**
   * Gets the underlying GeoJSON Feature representation of this Space.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: _mappedin_mvf_v22.Point | _mappedin_mvf_v22.LineString | _mappedin_mvf_v22.Polygon;
  };
  /** @internal */
  get focusTarget(): this | Coordinate;
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get navigationTarget(): this;
  /**
   * Serializes the space data to JSON.
   *
   * @returns An object representing the space.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    type: TSpaceType;
    floor: string;
    center: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    };
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/poi.d.ts
/**
 * A class representing point of interest data within the map.
 *
 * Points of interest are used to represent specific points
 * on the map with additional information(e.g. ATMs, Water Fountains).
 */
declare class PointOfInterest extends DetailedMapData<FeatureCollection$1<Point$1, SpaceProperties>['features'][number]> implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "point-of-interest";
  /**
   * @internal
   */
  readonly __type = "point-of-interest";
  /**
   * Checks if the provided instance is of type PointOfInterest.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a PointOfInterest, false otherwise.
   */
  static is(instance: object): instance is PointOfInterest;
  /** @internal */
  get navigationTarget(): Coordinate;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: FeatureCollection$1<Point$1, SpaceProperties>['features'][number];
  });
  /**
   * Gets the {@link Floor} object associated with the POI.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Gets the {@link Coordinate} of the POI.
   *
   * @returns {Coordinate} The POI's coordinate.
   */
  get coordinate(): Coordinate;
  /**
   * Gets the underlying GeoJSON Feature representation of this PointOfInterest.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: Point$1;
  };
  /**
   * Gets the 3D images anchored to this point of interest.
   *
   * @returns {Image3DView[]} An array of Image3DView objects representing 3D images attached to this POI.
   */
  get images3D(): Image3DView[];
  /** @internal */
  get focusTarget(): Coordinate;
  /** @internal */
  get anchorTarget(): Coordinate;
  /**
   * Serializes the POI data to JSON.
   *
   * @returns An object representing the POI.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    floor: string;
    coordinate: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    };
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/annotation.d.ts
/**
 * A class representing annotation data within the map.
 *
 * Annotations are used to mark specific points or areas on the map with additional information.
 * It includes some details on a map that may be relevant to safety or accessibility (e.g. Fire Extinguishers).
 * Refer to the [Annotation Guide](https://developer.mappedin.com/web-sdk/annotations) for more information.
 */
declare class Annotation extends DetailedMapData<AnnotationCollection['features'][number]> implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "annotation";
  /**
   * @internal
   */
  readonly __type = "annotation";
  /**
   * Checks if the provided instance is of type Annotation.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is an Annotation, false otherwise.
   */
  static is(instance: object): instance is Annotation;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: AnnotationCollection['features'][number];
    symbol?: AnnotationSymbol;
  });
  /**
   * Gets the group of the annotation.
   *
   * @returns {string} The annotation group.
   */
  get group(): string;
  /**
   * Gets the type of the annotation.
   *
   * @returns {string} The annotation type.
   */
  get type(): string;
  /**
   * Gets the center {@link Coordinate} of the annotation.
   *
   * @returns {Coordinate} The annotation's coordinate.
   */
  get coordinate(): Coordinate;
  /**
   * Gets the {@link Floor} object associated with the annotation.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Gets the name of the annotation.
   *
   * @returns {string} The annotation's name.
   */
  get name(): string;
  /**
   * Gets the icon for the annotation.
   *
   * @returns {ImageMetaData | undefined} The icon of the annotation.
   */
  get icon(): ImageMetaData | undefined;
  /**
   * Gets the underlying GeoJSON Feature representation of this Annotation.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: _mappedin_mvf_v22.Point;
  };
  /** @internal */
  get focusTarget(): Coordinate;
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get navigationTarget(): Coordinate;
  /**
   * Converts the annotation information to a JSON object.
   *
   * @returns An object representing the annotation.
   */
  toJSON(): {
    __type: string;
    id: string;
    group: string;
    type: string;
    coordinate: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    };
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/connection.d.ts
/**
 * A class representing connection data within the map.
 *
 * Connections are used to represent pathways between different map nodes.
 */
declare class Connection extends DetailedMapData<Feature$1<Point$1, SpaceProperties> | Feature$1<Point$1, Connection$1>> implements IFocusable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "connection";
  /**
   * @internal
   */
  readonly __type = "connection";
  /**
   * Checks if the provided instance is of type Connection.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Connection, false otherwise.
   */
  static is(instance: object): instance is Connection;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    mvfData: Connection$1;
  });
  /**
   * Whether the connection is accessible. For example elevators are accessible while stairs are not.
   *
   * @returns {boolean} Whether the connection is accessible.
   */
  get accessible(): boolean;
  /**
   * Gets the type of the connection.
   *
   * @returns {TConnectionType} The type of the connection.
   */
  get type(): TConnectionType;
  /**
   * Extra properties of the connection.
   *
   * @returns {Record<string, unknown> | undefined} Extra properties of the connection.
   */
  get extra(): Record<string, unknown> | undefined;
  /**
   * Gets the coordinates ({@link Coordinate}) of the connection.
   *
   * @returns {Coordinate[]} An array of coordinates for the connection.
   */
  get coordinates(): Coordinate[];
  /**
   * Gets the nodes ({@link Node}) associated with the connection.
   */
  get nodes(): Node[];
  /**
   * Gets the floors ({@link Floor}) associated with the connection.
   *
   * @returns {Floor[]} An array of floors for the connection.
   */
  get floors(): Floor[];
  /** @internal */
  get focusTarget(): Coordinate[];
  /** @internal */
  get navigationTarget(): Coordinate[];
  /**
   * Serializes the connection data to JSON.
   *
   * @returns An object representing the connection.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    type: "door" | "elevator" | "escalator" | "stairs" | "ramp" | "ladder" | "slide" | "portal" | "security" | "shuttle";
    externalId: string;
    coordinates: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    }[];
    floors: string[];
    extra: Record<string, unknown> | undefined;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/object.d.ts
/**
 * A class representing generic map object data within the map.
 *
 * It could represent various objects on the map, such as desks, chairs, etc.
 *
 * MapObject appearance can be customized by changing the color or adding a texture to its top or sides.
 * Refer to the [Textures & Colors Guide](https://developer.mappedin.com/web-sdk/images-textures#textures--colors) for more information and interactive examples.
 */
declare class MapObject extends DetailedMapData<ObstructionFeature> implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "object";
  /**
   * @internal
   */
  readonly __type = "object";
  /**
   * Checks if the provided instance is of type MapObject.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a MapObject, false otherwise.
   */
  static is(instance: object): instance is MapObject;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: ObstructionFeature;
  });
  /**
   * Gets the type of the MapObject.
   *
   * @returns {string} The kind of the object.
   */
  get type(): string;
  /**
   * Gets the {@link EnterpriseLocation}s attached to this object.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials
   * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty array when
   * using Maker credentials. For Maker data, access locations via {@link LocationProfile.mapObjects}
   * instead.
   *
   * @returns {EnterpriseLocation[]} An array of enterprise locations.
   */
  get enterpriseLocations(): EnterpriseLocation[];
  /**
   * Gets the {@link EnterpriseLocation}s attached to this object.
   *
   * @deprecated Use {@link enterpriseLocations} instead. This property will be removed in a future release.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials.
   *
   * @returns {EnterpriseLocation[]} An array of enterprise locations.
   */
  get locations(): EnterpriseLocation[];
  /**
   * Gets the {@link Floor} associated with the MapObject.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Gets the center {@link Coordinate} of the MapObject.
   *
   * @returns {Coordinate} The object's center coordinate.
   */
  get center(): Coordinate;
  /**
   * Gets the 3D images anchored to this map object.
   *
   * @returns {Image3DView[]} An array of Image3DView objects representing 3D images attached to this object.
   */
  get images3D(): Image3DView[];
  /**
   * Gets the underlying GeoJSON Feature representation of this Object.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: _mappedin_mvf_v22.LineString | _mappedin_mvf_v22.Polygon;
  };
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get focusTarget(): this | Coordinate;
  /** @internal */
  get navigationTarget(): this;
  /**
   * Serializes the MapObject data to JSON.
   *
   * @returns An object representing the MapObject.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    type: string;
    floor: string;
    center: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    };
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/types.d.ts
/**
 * Places are the main objects that can be searched for.
 */
type Places = Space | Floor | Door | Connection | MapObject | PointOfInterest | Annotation | Area;
type LocationWithLocale = PartialExcept<EnterpriseLocation$1, 'id'>;
type CategoryWithLocale = PartialExcept<EnterpriseCategory$1, 'id'>;
type FloorStackWithLocale = PartialExcept<FloorStack$1, 'id'>;
type FloorWithLocale = PartialExcept<FloorProperties, 'id'>;
type LanguagePackRecords = {
  'enterprise-location': Record<string, LocationWithLocale> | undefined;
  'enterprise-category': Record<string, CategoryWithLocale> | undefined;
  'floor-stack': Record<string, FloorStackWithLocale> | undefined;
  floor: Record<string, FloorWithLocale> | undefined;
};
type LanguagePack = {
  type: 'downloaded';
  data: ParsedMVFLocalePack;
  optimized: LanguagePackRecords;
} | {
  type: 'initial';
  optimized: LanguagePackRecords;
};
type TMapDataInternalOptions = {
  env?: EnvControl;
  enterprise?: boolean;
  outdoorViewToken?: string;
  localePacksUrls?: LocalePackUrls;
  languagePacks?: LanguagePackHydrationItem[];
  binaryBundle?: Uint8Array;
  tokenManager?: TokenManager;
  getMapDataOptions?: TGetMapDataOptions;
  mvf3?: MVFv2_STANDARD_MVFv3;
};
type MVFNodeFeature = NodeCollection['features'][number];
type MVFFloorFeature = FloorCollection['features'][number];
//#endregion
//#region src/map-data-objects/floor.d.ts
/**
 * A class representing floor data within the map.
 *
 * Floors are used to represent different levels within a map, each containing various map elements.
 */
declare class Floor extends BaseMapData implements IFocusable, IGeoJSONData {
  #private;
  /**
   * @internal
   */
  static readonly __type = "floor";
  /**
   * @internal
   */
  readonly __type = "floor";
  /**
   * Checks if the provided instance is of type Floor.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Floor, false otherwise.
   */
  static is(instance: object): instance is Floor;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    mvfData: MVFFloorFeature;
  });
  /** @internal */
  get focusTarget(): this;
  /**
   * Gets the name of the floor.
   *
   * @returns {string} The name of the floor.
   */
  get name(): string;
  /**
   * Gets the short name of the floor (i.e. "F1", "L, "2", etc.).
   * Used in space constrained lists and Often aligns with what is displayed on an elevator.
   *
   * @returns {string} The short name of the floor.
   */
  get shortName(): string;
  /**
   * Gets the subtitle of the floor.
   *
   * @returns {string} The subtitle of the floor.
   */
  get subtitle(): string;
  /**
   * Gets the external ID of the floor.
   *
   * @returns {string} The external ID of the floor.
   */
  get externalId(): string;
  /**
   * Gets the elevation of the floor.
   *
   * @returns {number} The elevation of the floor.
   */
  get elevation(): number;
  /**
   * Gets the max height of the floor if there is one.
   *
   * @returns {number | undefined} The max height of the floor.
   */
  get maxHeight(): number | undefined;
  /**
   * Gets the spaces ({@link Space}) located on this floor.
   *
   * @returns {Space[]} An array of Space objects on this floor.
   */
  get spaces(): Space[];
  /**
   * Gets the spaces that are open to below on this floor.
   * These are spaces that create ceiling cutouts when viewed from floors above.
   *
   * @internal
   *
   * @returns {Space[]} An array of Space objects that are open to below.
   */
  get spacesOpenToBelow(): Space[];
  /**
   * Gets the underlying GeoJSON Feature representation of this Space.
   */
  get geoJSON(): Feature$1<Polygon$1 | MultiPolygon$1, null>;
  /**
   * Gets the objects ({@link MapObject}) located on this floor.
   *
   * @returns {MapObject[]} An array of MapObject objects on this floor.
   */
  get objects(): MapObject[];
  /**
   * Gets the connections ({@link Connection}) associated with this floor.
   *
   * @returns {Connection[]} An array of Connection objects linked to this floor.
   */
  get connections(): Connection[];
  /**
   * Gets the doors ({@link Door}) located on this floor.
   *
   * @returns {Door[]} An array of Door objects on this floor.
   */
  get doors(): Door[];
  /**
   * Gets the annotations ({@link Annotation}) associated with this floor.
   *
   * @returns {Annotation[]} An array of Annotation objects linked to this floor.
   */
  get annotations(): Annotation[];
  /**
   * Gets the points of interest ({@link PointOfInterest}) located on this floor.
   *
   * @returns {PointOfInterest[]} An array of PointOfInterest objects on this floor.
   */
  get pois(): PointOfInterest[];
  /**
   * Gets the FloorStack ({@link FloorStack}) that this floor belongs to.
   *
   * @returns {FloorStack} The FloorStack that this floor belongs to.
   */
  get floorStack(): FloorStack;
  get center(): Coordinate;
  /**
   * Serializes the floor data to JSON.
   *
   * @returns An object representing the floor.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    shortName: string;
    subtitle: string;
    elevation: number;
    maxHeight: number | undefined;
    spaces: string[];
    objects: string[];
    connections: string[];
    doors: string[];
    annotations: string[];
    pois: string[];
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/node.d.ts
/**
 * A class representing {@link Path} node data within the map.
 *
 * Nodes are used to define points in the map's pathfinding graph.
 *
 */
declare class Node extends BaseMetaData implements IGeoJSONData, IFocusable, IAnchorable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "node";
  /**
   * @internal
   */
  readonly __type = "node";
  /**
   * Checks if the provided instance is of type Node.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Node, false otherwise.
   */
  static is(instance: object): instance is Node;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    floorId: string;
    mvfData: MVFNodeFeature;
  });
  /**
   * Gets the {@link EnterpriseLocation}s attached to this node.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only populated when using CMS/Enterprise credentials
   * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty array when
   * using Maker credentials.
   *
   * @internal
   */
  get locations(): EnterpriseLocation[];
  /**
   * Gets the {@link Space} object associated with the node.
   */
  get space(): Space | undefined;
  /**
   * Gets the {@link MapObject} object associated with the node.
   */
  get object(): MapObject | undefined;
  /**
   * Gets the {@link Floor} associated with the node.
   *
   * @returns {Floor} The floor object.
   * @throws Will throw an error if the floor is not found.
   */
  get floor(): Floor;
  /**
   * Gets the {@link Coordinate} of the node.
   *
   * @returns {Coordinate} The node's coordinate.
   */
  get coordinate(): Coordinate;
  /**
   * Gets the external ID of the node.
   *
   * @returns {string} The external ID of the node.
   */
  get externalId(): string;
  /**
   * Gets the neighboring nodes of this node.
   *
   * @returns {Node[]} An array of neighboring Node objects.
   */
  get neighbors(): Node[];
  /**
   * Gets the navigation flags of the node.
   *
   * Navigation flags are string identifiers that describe properties of this node for navigation,
   * such as `accessible` for wheelchair accessibility or `outdoors` for outdoor routes.
   *
   * @returns {string[]} An array of navigation flags present on this node.
   */
  get navigationFlags(): readonly string[];
  /**
   * Gets the underlying GeoJSON Feature representation of this Node.
   */
  get geoJSON(): {
    properties: null;
    type: _mappedin_mvf_v22.FeatureType;
    geometry: _mappedin_mvf_v22.Point;
  };
  /** @internal */
  get focusTarget(): Coordinate;
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get navigationTarget(): this;
  /**
   * Serializes the node data to JSON.
   *
   * @returns An object representing the node.
   */
  toJSON(): {
    __type: string;
    id: string;
    floor: string;
    coordinate: {
      __type: string;
      latitude: number;
      longitude: number;
      floorId: string | undefined;
      verticalOffset: number;
    };
    neighbors: string[];
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/floor-stack.d.ts
/**
 * A class representing floor stack data within the map.
 *
 * FloorStacks are used to represent a group of floors that are part of a single entity.
 */
declare class FloorStack extends BaseMapData implements IGeoJSONData, IFocusable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "floor-stack";
  /**
   * @internal
   */
  readonly __type = "floor-stack";
  /**
   * Checks if the provided instance is of type FloorStack.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a FloorStack, false otherwise.
   */
  static is(instance: object): instance is FloorStack;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    mvfData: FloorStack$1;
    facadeId?: string;
  });
  /**
   * Gets the type of FloorStack.
   */
  get type(): FloorStack$1['type'];
  /**
   * Gets the name of the FloorStack.
   *
   * @returns {string} The name of the FloorStack.
   */
  get name(): string;
  /**
   * Gets the short name of the FloorStack.
   *
   * @returns {string} The short name of the FloorStack.
   */
  get shortName(): string;
  /**
   * Gets the externalId of FloorStack
   */
  get externalId(): string;
  /**
   * Gets the floors ({@link Floor}) included in this FloorStack.
   *
   * @returns {Floor[]} An array of Floor objects in this FloorStack.
   */
  get floors(): [Floor, ...Floor[]];
  /**
   * Get the default floor for this floor stack
   */
  get defaultFloor(): Floor;
  /**
   * Gets the facade ({@link Facade}) representing this floor stack, if it exists.
   */
  get facade(): Facade | undefined;
  /**
   * Returns this FloorStack as the focus target for the camera.
   */
  get focusTarget(): FloorStack;
  /**
   * Gets the underlying GeoJSON Feature representation of this FloorStack.
   *
   * Returns a union of all floor geometries in this stack.
   */
  get geoJSON(): Feature<Polygon | MultiPolygon, null>;
  /**
   * Serializes the FloorStack data to JSON.
   *
   * @returns An object representing the FloorStack.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
    shortName: string;
    type: "Building" | "Outdoor" | undefined;
    floors: string[];
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/facade.d.ts
/**
 * A Facade is a collection of spaces that make up the exterior representation of a Floor Stack ({@link FloorStack}).
 */
declare class Facade extends BaseMapData implements IFocusable, IAnchorable, INavigatable {
  #private;
  static readonly __type = "facade";
  readonly __type = "facade";
  /**
   * Checks if the provided instance is of type Floor.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a Floor, false otherwise.
   */
  static is(instance: object): instance is Facade;
  /** @internal */
  constructor(data: MapDataInternal, options: {
    mvfData: Facade$1;
    floorStackId: string;
  });
  /**
   * Gets the floor stack that this Facade represents.
   */
  get floorStack(): FloorStack;
  /**
   * Gets the collection of spaces that make up this Facade.
   */
  get spaces(): Space[];
  /**
   * Gets the center {@link Coordinate} of the Facade.
   */
  get center(): Coordinate;
  /** @internal */
  get focusTarget(): Space[];
  /** @internal */
  get anchorTarget(): Coordinate;
  /** @internal */
  get navigationTarget(): this;
  toJSON(): {
    id: string;
    __type: string;
    floorStackId: string;
    floorStack: FloorStack;
    spaces: Space[];
  };
}
//#endregion
//#region src/utils/data-creation.d.ts
type MapDataRecords = {
  spacesById: Record<string, Space>;
  nodesById: Record<string, Node>;
  objectsById: Record<string, MapObject>;
  floorsById: Record<string, Floor>;
  floorStacksById: Record<string, FloorStack>;
  facadesById: Record<string, Facade>;
  facadesBySpaceId: Record<string, Facade>;
  connectionsById: Record<string, Connection>;
  doorsById: Record<string, Door>;
  doorsByNodeId: Record<string, Door>;
  poisById: Record<string, PointOfInterest>;
  annotationsById: Record<string, Annotation>;
  areasById: Record<AreaId, Area>;
  spaceIdsByNodeId: Record<string, SpaceId[]>;
  objectIdsByNodeId: Record<string, ObstructionId[]>;
  destinationNodesIdsBySpaceId: Record<SpaceId, NodeId[]>;
  /**
   * Map of space id to door-linked node ids for fast routing.
   */
  entranceNodeIdsBySpaceId?: Record<string, string[]>;
  locationProfilesById: Record<string, LocationProfile>;
  locationCategoriesById: Record<string, LocationCategory>;
  locationProfilesByCategoryId: Record<string, LocationProfile[]>;
  locationCategoriesByParentId: Record<string, LocationCategory[]>;
  spacesByExternalId: Record<string, Space[]>;
  nodesByExternalId: Record<string, Node[]>;
  poisByExternalId: Record<string, PointOfInterest[]>;
  doorsByExternalId: Record<string, Door[]>;
  floorStacksByExternalId: Record<string, FloorStack[]>;
  floorsByExternalId: Record<string, Floor[]>;
  objectsByExternalId: Record<string, MapObject[]>;
  areasByExternalId: Record<string, Area[]>;
  locationProfilesByExternalId: Record<string, LocationProfile[]>;
  objectEntranceNodeIdsByObstructionId: Record<string, string[]>;
  obstructionIdByEntranceId: Record<string, string>;
  locationProfilesByAttachedFeatureId: Record<string, LocationProfile[]>;
  mvfSpacesById: Record<string, SpaceCollection['features'][number]>;
  mvfNodesById: Record<string, NodeCollection['features'][number]>;
  mvfObstructionById: Record<string, ObstructionCollection['features'][number]>;
  mvfFloorsById: Record<string, FloorProperties>;
  mvfFloorStacksById: Record<string, FloorStack$1>;
  mvfConnectionsById: Record<string, Connection$1>;
  mvfConnectionsByNodeId: Record<string, Connection$1>;
  mvfEntrancesById: Record<string, EntranceCollection['features'][number]>;
  mvfAnnotationsById: Record<string, AnnotationCollection['features'][number]>;
  mvfNodesByFloorId: {
    [floorId: string]: NodeCollection['features'][number][];
  };
  mvfSpacesByFloorId: {
    [floorId: string]: SpaceCollection['features'][number][];
  };
  mvfPoisByFloorId: {
    [floorId: string]: FeatureCollection$1<Point$1, SpaceProperties>['features'][number][];
  };
  mvfEntrancesByFloorId: {
    [floorId: string]: EntranceCollection['features'][number][];
  };
  mvfAnnotationsByFloorId: {
    [floorId: string]: AnnotationCollection['features'][number][];
  };
  mvfAreasById: Record<AreaId, AreaCollection['features'][number]>;
  mvf3LocationsById: Record<string, Required<MVFv2_STANDARD_MVFv3>['locations'][number]>;
};
type EnterpriseMapDataRecords = {
  connectionsByExternalId: Record<string, Connection[]>;
  locationsByExternalId: Record<string, EnterpriseLocation[]>;
  categoriesByExternalId: Record<string, EnterpriseCategory[]>;
  locationsById: Record<EnterpriseLocationId, EnterpriseLocation>;
  /** Instance locations by ID - separate from locationsById so they don't appear in getByType */
  locationInstancesById: Record<string, EnterpriseLocation>;
  /** Instance locations by polygon ID - for space.enterpriseLocations to check instances first */
  instanceLocationsByPolygonId: Record<string, EnterpriseLocation>;
  categoriesById: Record<EnterpriseCategoryId, EnterpriseCategory>;
  locationIdsByNodeId: Record<string, EnterpriseLocationId[]>;
  mvfLocationInstancesById: Record<string, EnterpriseLocationInstance>;
  venue: EnterpriseVenue$1;
  mvfCategoriesById: Record<string, EnterpriseCategory$1>;
  mvfLocationsById: Record<string, EnterpriseLocation$1>;
  mvfLocationsByGeometryId: Record<string, EnterpriseLocation$1[]>;
};
//#endregion
//#region src/map-data-objects/location.d.ts
/**
 * An EnterpriseLocation contains metadata about a location, such as its name, description, logo, phone number, social media links, hours of operation and more.
 * They can be accessed using the {@link MapData.getByType} method as shown below.
 *
 * ```typescript
 * const allLocations = mapData.getByType('enterprise-location');
 * ```
 *
 * Refer to the [EnterpriseLocation Guide](https://developer.mappedin.com/web-sdk/enterprise-data#enterprise-locations) for more information and interactive examples.
 *
 * @remarks
 * **Data Source: Enterprise** - This class is only available when using CMS/Enterprise credentials
 * (clientId/clientSecret or API keys that do NOT start with `mik_`). When using Maker
 * credentials (keys starting with `mik_`), use {@link LocationProfile} instead.
 *
 * @see {@link LocationProfile} for the Maker equivalent.
 */
declare class EnterpriseLocation extends BaseMetaData implements Omit<EnterpriseLocation$1, 'polygons' | 'nodes' | 'links' | 'spaces' | 'categories'>, IFocusable, INavigatable {
  #private;
  /**
   * @internal
   */
  static readonly __type = "enterprise-location";
  /**
   * @internal
   */
  readonly __type = "enterprise-location";
  /**
   * The description of the location.
   */
  description?: string | undefined;
  /**
   * The name of the location.
   */
  name: string;
  /**
   * The amenity of the location.
   */
  amenity?: string | undefined;
  /**
   * The external ID of the location.
   */
  externalId: string;
  /**
   * Extra properties of the location.
   */
  extra?: Record<string, unknown> | undefined;
  /**
   * The gallery of the location.
   */
  gallery?: {
    caption?: string | null;
    image: string;
    embeddedUrl?: string | null;
  }[] | undefined;
  /**
   * Specific instances of this location with different properties.
   * Typically, there will be at least one node or polygon defined,
   * plus one or more other properties that are different from the parent.
   * The remaining properties will be the same as the parent.
    * For example, suppose there is a location like this:
   *
   * ```json
   * {
   *   "id": "location-id-1",
   *   "name": "Location 1",
   *   "nodes": ["node-1", "node-2"],
   *   "polygons": ["polygon-1", "polygon-2"],
   *   "externalId": "externalId-1",
   *   "description": "Description 1",
   * }
   * ```
   *
   * (Note that for clarity, this example puts strings in for nodes and polygons, but in practice they would be objects.)
   *
   * Then suppose it had an `instances` array that contained an object that looked like this:
   *
   * ```json
   * {
   *   "id": "instance-id-1",
   *   "name": "Location 1 - A",
   *   "nodes": ["node-1"],
   *   "polygons": ["polygon-1"],
   *   "externalId": "externalId-1-A",
   *   "description": "Description 1",
   * }
   * ```
   * This says "Location 1" is the parent location, and "Location 1 - A" is an instance of it. The instance has a different name, and a different external ID, and it only applies to node `node-1` and polygon `polygon-1`.
   * The ID will always be different, but other properties (like the description) are the same as the parent.
   *
   * Example use cases:
   * - A Mall may have a location with two nodes and one polygon. It may then have an instance with one of the nodes, and operating hours
   * that are different from the parent. This indicates that this instance is an entrance for the location that is accessible at different times, perhaps for an interior mall entrance, when the main location (and other, exterior entrance) is open later than the rest of the mall.
   * - An airport may have a location with several polygons and nodes, and an instance for each node (and corresponding polygon, if any) with a different siblingGroup. The location in the sibling group may be the airport terminal, or airside vs landside.
   * This would allow an application to show the location once in a search result, but offer UX to select the instance that is in the right terminal.
   *
   * Note: Instances are actual EnterpriseLocations. This means they have all the properties of a normal EnterpriseLocation, including an `instances` property, that will always be undefined. They also do NOT have a parent property, or any other explicit reference to the parent location. These instances are
   * only referenced from their parent location, and will not show up in other places in the map data. However, they should otherwise behave like normal EnterpriseLocations, being targetable for things like navigation and focus.
   */
  instances?: EnterpriseLocation[] | undefined;
  /**
   * A URL to the logo of the location.
   */
  logo?: string | undefined;
  /**
   * The operation hours of the location.
   */
  operationHours?: OperationHours$1[] | undefined;
  /**
   * The phone number of the location.
   */
  phone?: {
    number: string;
    extension?: string;
  } | undefined;
  /**
   * A URL to the picture of the location.
   */
  picture?: string | undefined;
  /**
   * The short name of the location.
   */
  shortName?: string | undefined;
  /**
   * Whether to show the floating label when an image is present.
   */
  showFloatingLabelWhenImagePresent?: boolean | undefined;
  /**
   * Whether to show the logo.
   */
  showLogo?: boolean | undefined;
  /**
   * The sibling groups of the location.
   */
  siblingGroups?: SiblingGroup$1[] | undefined;
  /**
   * The social media links of the location.
   */
  social?: {
    facebook?: string;
    instagram?: string;
    twitter?: string;
    website?: string;
  } | undefined;
  /**
   * The sort order of the location.
   */
  sortOrder: number;
  /**
   * The {@link LocationState}s of the location.
   */
  states?: LocationState$1[] | undefined;
  /**
   * The tags of the location.
   */
  tags?: string[] | undefined;
  /**
   * The type of the location.
   */
  type: string;
  /**
   * Whether the location has been marked as hidden.
   */
  hidden: boolean;
  primaryCategory?: string | undefined;
  /**
   * Checks if the provided instance is of type EnterpriseLocation.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a EnterpriseLocation, false otherwise.
   */
  static is(instance: object): instance is EnterpriseLocation;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    mvfData: EnterpriseLocation$1;
    categoryIds: string[];
    locationInstances?: EnterpriseLocation[];
    parentId?: string;
  });
  /** @internal */
  get focusTarget(): Coordinate[] | Space[];
  /** @internal */
  get navigationTarget(): Space[];
  /**
   * Gets the {@link EnterpriseCategory}s associated with the location.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only available when using CMS/Enterprise credentials.
   *
   * @returns {EnterpriseCategory[]} The enterprise categories array.
   */
  get categories(): EnterpriseCategory[];
  get coordinates(): Coordinate[];
  get nodes(): Node[];
  get points(): PointOfInterest[];
  get spaces(): Space[];
  get objects(): MapObject[];
  /**
   * Serializes the EnterpriseLocation data to JSON.
   *
   * @returns An object representing the EnterpriseLocation.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/category.d.ts
/**
 * An EnterpriseCategory groups one or more EnterpriseLocation. These allow similar locations to be sorted in a logical fashion.
 * For example a mall may group locations into Food Court, Footwear and Women's Fashion. They can be accessed using the {@link MapData.getByType} method as shown below.
 *
 * ```typescript
 * const categories = mapData.getByType('enterprise-category');
 * ```
 *
 * Refer to the [EnterpriseCategory Guide](https://developer.mappedin.com/web-sdk/enterprise-data#enterprise-categories) for more information and interactive examples.
 *
 * @remarks
 * **Data Source: Enterprise** - This class is only available when using CMS/Enterprise credentials
 * (clientId/clientSecret or API keys that do NOT start with `mik_`). When using Maker
 * credentials (keys starting with `mik_`), use {@link LocationCategory} instead.
 *
 * @see {@link LocationCategory} for the Maker equivalent.
 */
declare class EnterpriseCategory extends BaseMetaData implements Omit<EnterpriseCategory$1, 'children' | 'locations'> {
  #private;
  /**
   * @internal
   */
  static readonly __type = "enterprise-category";
  /**
   * @internal
   */
  readonly __type = "enterprise-category";
  /**
   * The name of the category.
   */
  name: string;
  /**
   * The color of the category.
   */
  color?: string | undefined;
  /**
   * The external ID of the category.
   */
  externalId: string;
  /**
   * Extra properties of the category.
   */
  extra?: Record<string, unknown> | undefined;
  /**
   * A URL to the icon of the category.
   */
  icon?: string | undefined;
  /**
   * The icon from the default list of icons.
   */
  iconFromDefaultList?: string | null | undefined;
  /**
   * The sort order of the category.
   */
  sortOrder: number;
  /**
   * A URL to the picture of the category.
   */
  picture?: string | undefined;
  /**
   * Checks if the provided instance is of type EnterpriseCategory.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a EnterpriseCategory, false otherwise.
   */
  static is(instance: object): instance is EnterpriseCategory;
  /**
   * @internal
   */
  constructor(data: MapDataInternal, options: {
    mvfData: EnterpriseCategory$1;
  });
  /**
   * The child categories of the category.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only available when using CMS/Enterprise credentials.
   */
  get children(): EnterpriseCategory[];
  /**
   * The {@link EnterpriseLocation}s within this category.
   *
   * @remarks
   * **Data Source: Enterprise** - This property is only available when using CMS/Enterprise credentials.
   */
  get locations(): EnterpriseLocation[];
  /**
   * Serializes the EnterpriseCategory data to JSON.
   *
   * @returns An object representing the EnterpriseCategory.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/map-data-objects/venue.d.ts
/**
 * The EnterpriseVenue class holds metadata about the map, which includes the map name, supported languages, default language, top locations and more.
 * It can be accessed using the {@link MapData.getByType} method as shown below.
 *
 * ```typescript
 * const venue = mapData.getByType('enterprise-venue');
 * ```
 *
 * Refer to the [EnterpriseVenue Guide](https://developer.mappedin.com/web-sdk/enterprise-data#enterprise-venue) for more information.
 *
 * @remarks
 * **Data Source: Enterprise** - This class is only available when using CMS/Enterprise credentials
 * (clientId/clientSecret or API keys that do NOT start with `mik_`). This data is not available
 * when using Maker credentials (keys starting with `mik_`).
 */
declare class EnterpriseVenue extends BaseMetaData implements EnterpriseVenue$1 {
  #private;
  /**
   * @internal
   */
  static readonly __type = "enterprise-venue";
  /**
   * @internal
   */
  readonly __type = "enterprise-venue";
  /**
   * The country code of the venue.
   */
  countrycode?: string | undefined;
  /**
   * The venue's cover image.
   * @format uri
   */
  coverImage?: string | undefined;
  /**
   * The external ID of the venue.
   */
  externalId: string;
  /**
   * The default language of the venue.
   */
  defaultLanguage: Language;
  /**
   * The default floor of the venue.
   */
  defaultFloor?: string | undefined;
  /**
   * Extra properties of the venue.
   */
  extra?: Record<string, unknown> | undefined;
  /**
   * A URL to the icon of the venue.
   */
  icon?: string | undefined;
  /**
   * The languages supported by the venue.
   */
  languages: Language[];
  /**
   * The links of the venue.
   */
  links: Hyperlink[];
  /**
   * A URL to the logo of the venue.
   */
  logo?: string | undefined;
  /**
   * A URL to a web page with [Mappedin Web](https://developer.mappedin.com/docs/enterprise-apps/mappedin-web-v2) for this venue.
   */
  mappedinWebUrl?: string | undefined;
  /**
   * When this venue is open.
   */
  operationHours?: OperationHours$1[] | undefined;
  /**
   * The slug of the venue.
   */
  slug: string;
  /**
   * The top locations of the venue.
   */
  topLocations?: string[] | undefined;
  /**
   * The timezone ID of the venue.
   */
  tzid?: string | undefined;
  /**
   * Checks if the provided instance is of type EnterpriseVenue.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a EnterpriseVenue, false otherwise.
   */
  static is(instance: object): instance is EnterpriseVenue;
  /**
   * @internal
   */
  constructor(_data: MapDataInternal, options: {
    mvfData: EnterpriseVenue$1;
  });
  /**
   * Gets the name of the EnterpriseVenue.
   *
   * @returns {string} The name of the EnterpriseVenue.
   */
  get name(): string;
  /**
   * @deprecated Use `defaultFloor` instead
   * The default map of the venue.
   */
  get defaultMap(): string;
  /**
   * The enterprise venue type.
   */
  get enterpriseType(): EnterpriseVenueType | undefined;
  /**
   * Serializes the EnterpriseVenue data to JSON.
   *
   * @returns An object representing the EnterpriseVenue.
   */
  toJSON(): {
    __type: string;
    id: string;
    name: string;
  };
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/query/types.d.ts
/**
 * Types that can be queried for in the nearest search
 */
type TQueriables = PointOfInterest | Door | Annotation | Node | Space | EnterpriseLocation;
/**
 * Types that can be returned from Query.at() - geometry objects at a coordinate
 */
type TQueryAtResult = Space | MapObject | Area | Floor;
/**
 * Result of a nearest query
 */
type TFindNearestResult<T$1 extends TQueriables> = {
  distance: number;
  feature: T$1;
}[];
/**
 * Options for the nearest query
 */
type TFindNearestOptions = {
  /**
   * Limit query to a set of floors. Only applies if the origin has floor information. If it doesn't, it limits the query to all floor-stacks' default floors.
   *
   * @default 'same-floor'
   */
  limit?: 'same-floor'
  /**
   * Limit query to all floors at the same elevation as the origin
   */ | 'same-elevation'
  /**
   * Query all floors in the venue (no floor restriction)
   */ | 'all-floors';
  /**
   * Whether to use line of sight checks to filter results. This ensures that results aren't obstructed by walls, etc.
   * When 'auto', heuristics are used to determine whether to use line of sight checks. These are currently experimental, and are subject to change.
   * @experimental
   * @default 'auto'
   */
  lineOfSight?: boolean | 'auto';
  /**
   * The mode to use for the query
   */
  mode?: 'travel-distance' | 'absolute-distance';
  /**
   * The max distance to search for features within
   */
  maxDistance?: number;
  /**
   * The maximum number of results to return, the lower the number, the faster the query will be
   * @default 1
   */
  maxResults?: number;
};
//#endregion
//#region src/query/external.d.ts
/**
 * Query allows users to query for nodes, locations, categories, and other points of interest within the venue.
 */
declare class Query {
  #private;
  /**
   * @internal
   */
  constructor(mapDataInternal: MapDataInternal);
  /**
   * @internal
   */
  __LEGACY_NEAREST_SYNC: <T$1 extends TQueriables>(origin: Coordinate | PointOfInterest | Door | Annotation | Node, include: T$1[], options?: TFindNearestOptions) => TFindNearestResult<T$1> | undefined;
  /**
   * Find the nearest feature to the origin
   * @param origin - The origin object
   * @param include - The features to include in the query
   * @param options - The options for the query
   * @returns Objects with the distance and the feature, sorted by distance
   */
  nearest<T$1 extends TQueriables>(origin: Coordinate | PointOfInterest | Door | Annotation | Node, include: T$1[], options?: TFindNearestOptions): Promise<TFindNearestResult<T$1> | undefined>;
  /**
   * Find all geometry objects (Spaces, MapObjects, Areas, Floors) at the given coordinate.
   * If the coordinate has a floorId, only that floor is searched.
   * If no floorId is provided, all floors are searched.
   * @param coordinate - The coordinate to search at
   * @returns Array of Spaces, MapObjects, Areas, and Floors that contain the coordinate
   * @example
   * ```typescript
   * // Find all geometry at a coordinate with a floor
   * const coord = new Coordinate({ latitude: 43.861, longitude: -78.947, floorId: 'floor1' });
   * const results = await mapData.Query.at(coord);
   * // results may contain [Space, Floor, Area, ...]
   *
   * // Find all geometry at a coordinate across all floors
   * const coordNoFloor = new Coordinate({ latitude: 43.861, longitude: -78.947 });
   * const allResults = await mapData.Query.at(coordNoFloor);
   * ```
   */
  at(coordinate: Coordinate): Promise<TQueryAtResult[]>;
}
//#endregion
//#region src/map-data-objects/location-category.d.ts
/**
 * A LocationCategory groups one or more LocationProfile. These allow similar locations to be sorted in a logical fashion.
 * For example a mall may group locations into Food Court, Footwear and Women's Fashion. They can be accessed using the {@link MapData.getByType} method as shown below.
 *
 * ```typescript
 * const categories = mapData.getByType('location-category');
 * ```
 *
 * @remarks
 * **Data Source: Maker** - This class is only available when using Maker credentials
 * (API keys starting with `mik_`). When using CMS/Enterprise credentials (clientId/clientSecret
 * or keys that do NOT start with `mik_`), use {@link EnterpriseCategory} instead.
 *
 * @see {@link EnterpriseCategory} for the CMS/Enterprise equivalent.
 */
declare class LocationCategory extends BaseMetaData implements Omit<Category, 'parent'> {
  #private;
  /**
   * Checks if the provided instance is of type EnterpriseLocation.
   *
   * @param instance The instance to check.
   * @returns {boolean} True if the instance is a EnterpriseLocation, false otherwise.
   */
  static is(instance: object): instance is LocationCategory;
  /**
   * @internal
   */
  static readonly __type = "location-category";
  /**
   * @internal
   */
  readonly __type = "location-category";
  id: CategoryId;
  name: string;
  /**
   * The category's icon
   *
   * @format uri
   */
  icon: string;
  /** @internal */
  constructor(data: MapDataInternal, options: {
    mvfData: Category;
  });
  /**
   * Gets the parent {@link LocationCategory}.
   *
   * @remarks
   * **Data Source: Maker** - This property is only available when using Maker credentials.
   *
   * @returns {LocationCategory | undefined} The parent location category.
   */
  get parent(): LocationCategory | undefined;
  /**
   * Gets the children {@link LocationCategory}s.
   *
   * @remarks
   * **Data Source: Maker** - This property is only available when using Maker credentials.
   */
  get children(): LocationCategory[];
  /**
   * Gets the {@link LocationProfile}s that are associated with this category.
   *
   * @remarks
   * **Data Source: Maker** - This property is only available when using Maker credentials.
   */
  get locationProfiles(): LocationProfile[];
  toJSON(): {
    __type: string;
    id: string;
    name: string;
  };
}
//#endregion
//#region src/api-geojson/language.d.ts
type TFindPreferredLanguageInVenueOptions = {
  /**
   * Preferred language code to use.
   */
  languageCode?: string;
  /**
   * Whether to use browser's language settings as fallback if the supplied language code is not available.
   * @default true
   * */
  fallbackToNavigatorLanguage?: boolean;
};
/**
 * Finds the ideal language for the venue based on the following priority:
 * 1. User specified language (if it exists in venue languages)
 * 2. Browser navigator languages (if fallback is enabled)
 * 3. Venue's default language
 *
 * @param venue - The MappedinVenue object containing available languages
 * @param options - Configuration options
 * @returns An object containing the selected language code and name, or undefined if no language is found
 */
declare function findPreferredLanguageInVenue(venue: EnterpriseVenue, options?: TFindPreferredLanguageInVenueOptions): Language;
//#endregion
//#region src/map-data-objects/index.d.ts
/**
 * Represents the void data for a floor.
 * @internal
 */
interface FloorVoids {
  /** Void polygons extracted from holes in the footprint geometry */
  voids: FeatureCollection$1<Polygon$1, any>;
}
/**
 * Internal class representing detailed map data.
 *
 * @internal
 */
declare class MapDataInternal extends PubSub<{
  'language-change': {
    code: string;
    name: string;
  };
}> {
  #private;
  Analytics: AnalyticsInternal;
  Query: Query;
  /**
   * Represents the parsed Mappedin Venue Format (MVF) data.
   */
  readonly mvf: ParsedMVF;
  /**
   * The token is used to fetch outdoor tiles, which will then be rendered.
   */
  readonly outdoorViewToken?: string;
  /**
   * Represents a map of obstruction IDs to entrance node IDs.
   */
  readonly objectEntranceNodeIdsByObstructionId: Record<string, string[]>;
  /**
   * Represents a map of entrance IDs to obstruction IDs.
   */
  readonly obstructionIdByEntranceId: Record<string, string>;
  readonly venue?: EnterpriseVenue;
  readonly tokenManager?: TokenManager;
  directions: DirectionsInternal;
  enterpriseMode: boolean;
  nodesById: MapDataRecords['nodesById'];
  spacesById: MapDataRecords['spacesById'];
  floorsById: MapDataRecords['floorsById'];
  floorStacksById: MapDataRecords['floorStacksById'];
  facadesById: MapDataRecords['facadesById'];
  facadesBySpaceId: MapDataRecords['facadesBySpaceId'];
  connectionsById: MapDataRecords['connectionsById'];
  objectsById: MapDataRecords['objectsById'];
  doorsById: MapDataRecords['doorsById'];
  pointsOfInterestById: MapDataRecords['poisById'];
  annotationsById: MapDataRecords['annotationsById'];
  areasById: MapDataRecords['areasById'];
  locationProfilesById: MapDataRecords['locationProfilesById'];
  locationCategoriesById: MapDataRecords['locationCategoriesById'];
  locationProfilesByExternalId: MapDataRecords['locationProfilesByExternalId'];
  locationProfilesByCategoryId: MapDataRecords['locationProfilesByCategoryId'];
  locationCategoriesByParentId: MapDataRecords['locationCategoriesByParentId'];
  doorsByNodeId: MapDataRecords['doorsByNodeId'];
  mvfAnnotationsById: MapDataRecords['mvfAnnotationsById'];
  mvfConnectionsById: MapDataRecords['mvfConnectionsById'];
  mvfConnectionsByNodeId: MapDataRecords['mvfConnectionsByNodeId'];
  mvfEntrancesById: MapDataRecords['mvfEntrancesById'];
  mvfNodesById: MapDataRecords['mvfNodesById'];
  mvfObstructionById: MapDataRecords['mvfObstructionById'];
  mvfSpacesById: MapDataRecords['mvfSpacesById'];
  mvfFloorsById: MapDataRecords['mvfFloorsById'];
  mvfFloorStacksById: MapDataRecords['mvfFloorStacksById'];
  mvfAreasById: MapDataRecords['mvfAreasById'];
  spacesByExternalId: MapDataRecords['spacesByExternalId'];
  nodesByExternalId: MapDataRecords['nodesByExternalId'];
  objectsByExternalId: MapDataRecords['objectsByExternalId'];
  poisByExternalId: MapDataRecords['poisByExternalId'];
  floorsByExternalId: MapDataRecords['floorsByExternalId'];
  floorStacksByExternalId: MapDataRecords['floorStacksByExternalId'];
  doorsByExternalId: MapDataRecords['doorsByExternalId'];
  areasByExternalId: MapDataRecords['areasByExternalId'];
  locationProfilesByAttachedFeatureId: MapDataRecords['locationProfilesByAttachedFeatureId'];
  entranceNodeIdsBySpaceId?: MapDataRecords['entranceNodeIdsBySpaceId'];
  locationsById: EnterpriseMapDataRecords['locationsById'];
  locationInstancesById: EnterpriseMapDataRecords['locationInstancesById'];
  instanceLocationsByPolygonId: EnterpriseMapDataRecords['instanceLocationsByPolygonId'];
  categoriesById: EnterpriseMapDataRecords['categoriesById'];
  mvfLocationsByGeometryId: EnterpriseMapDataRecords['mvfLocationsByGeometryId'];
  locationIdsByNodeId: EnterpriseMapDataRecords['locationIdsByNodeId'];
  spaceIdsByNodeId: MapDataRecords['spaceIdsByNodeId'];
  objectIdsByNodeId: MapDataRecords['objectIdsByNodeId'];
  connectionsByExternalId: EnterpriseMapDataRecords['connectionsByExternalId'];
  locationsByExternalId: EnterpriseMapDataRecords['locationsByExternalId'];
  categoriesByExternalId: EnterpriseMapDataRecords['categoriesByExternalId'];
  destinationNodesIdsBySpaceId: MapDataRecords['destinationNodesIdsBySpaceId'];
  mvfNodesByFloorId: MapDataRecords['mvfNodesByFloorId'];
  mvfSpacesByFloorId: MapDataRecords['mvfSpacesByFloorId'];
  mvfPoisByFloorId: MapDataRecords['mvfPoisByFloorId'];
  mvfEntrancesByFloorId: MapDataRecords['mvfEntrancesByFloorId'];
  mvfAnnotationsByFloorId: MapDataRecords['mvfAnnotationsByFloorId'];
  /**
   * Map of floor ID to void data extracted from footprint holes.
   * @internal
   */
  voidsByFloorId: Record<string, FloorVoids>;
  /**
   * Map of anchor ID to floor images attached to that anchor.
   * @internal
   */
  floorImagesByAnchorId: Map<string, Image3DView[]>;
  localePacksUrls: LocalePackUrls;
  currentLanguage?: Language;
  /**
   * These represent maps of diffed objects that are used to store the translated values
   */
  languagePacks: {
    [languageCode: string]: LanguagePack;
  };
  tilesets: {
    [tilesetId: string]: TilesetStyle;
  };
  navigationFlags: NavigationFlagDeclarations;
  binaryBundle?: Uint8Array;
  envControl: EnvControl;
  getMapDataOptions?: TGetMapDataOptions;
  /**
   * @internal
   */
  constructor(mvf: ParsedMVF, options: TMapDataInternalOptions);
  getEnv(): {
    readonly baseUri: string;
    readonly baseAuthUri: string;
    readonly analyticsBaseUri: string;
    readonly tileServerUri: string;
  };
  /**
   * Retrieves the map name.
   *
   * @returns {string} The name of the map.
   */
  get mapName(): string;
  get organizationId(): string;
  get mapCenter(): Coordinate;
  get naturalBearing(): number;
  /**
   * Retrieves all spaces in the map.
   *
   * @returns {Space[]} An array of Space objects.
   */
  get spaces(): Space[];
  /**
   * Retrieves all objects in the map.
   *
   * @returns {MapObject[]} An array of MapObject objects.
   */
  get objects(): MapObject[];
  /**
   * Retrieves all connections in the map.
   *
   * @returns {Connection[]} An array of Connection objects.
   */
  get connections(): Connection[];
  /**
   * Retrieves all floors in the map.
   *
   * @returns {Floor[]} An array of Floor objects.
   */
  get floors(): Floor[];
  get floorStacks(): FloorStack[];
  get facades(): Facade[];
  /**
   * Retrieves all doors in the map.
   *
   * @internal
   * @hidden
   * @returns {Door[]} An array of Door objects.
   */
  get doors(): Door[];
  /**
   * Retrieves all points of interest in the map.
   *
   * @returns {PointOfInterest[]} An array of PointOfInterest objects.
   */
  get pointsOfInterest(): PointOfInterest[];
  /**
   * Retrieves all annotations in the map.
   *
   * @returns {Annotation[]} An array of Annotation objects.
   */
  get annotations(): Annotation[];
  get areas(): Area[];
  /**
   * Retrieves all nodes in the map.
   *
   * @returns {Annotation[]} An array of Annotation objects.
   */
  get nodes(): Node[];
  get locations(): EnterpriseLocation[];
  get categories(): EnterpriseCategory[];
  get locationProfiles(): LocationProfile[];
  get locationCategories(): LocationCategory[];
  get mvfFloors(): FloorProperties[];
  get mvfFloorStacks(): FloorStack$1[];
  getByType(type: string): object[];
  getByType(type: 'location-profile'): LocationProfile[];
  getByType(type: 'location-category'): LocationCategory[];
  getByType(type: 'space'): Space[];
  getByType(type: 'area'): Area[];
  getByType(type: 'door'): Door[];
  getByType(type: 'floor'): Floor[];
  getByType(type: 'floor-stack'): FloorStack[];
  getByType(type: 'connection'): Connection[];
  getByType(type: 'object'): MapObject[];
  getByType(type: 'point-of-interest'): PointOfInterest[];
  getByType(type: 'annotation'): Annotation[];
  getByType(type: 'node'): Node[];
  getByType(type: 'enterprise-location'): EnterpriseLocation[];
  getByType(type: 'enterprise-category'): EnterpriseCategory[];
  getByType(type: 'enterprise-venue'): EnterpriseVenue | undefined;
  getByType(type: 'facade'): Facade[];
  /**
   * Retrieves all map data objects that match any of the specified types.
   * If a list of elements is provided, it filters only those elements by type.
   * Otherwise, it retrieves all objects for the specified types from this dataset.
   *
   * @param types - A set of type names to filter/retrieve
   * @param elements - Optional. A list of elements to filter by the provided types
   * @returns An array of map data objects matching any of the specified types
   */
  getAllOfTypes<T$1 extends MapDataElements['__type']>(types: ReadonlySet<T$1> | readonly T$1[], elements?: readonly MapDataElements[]): Extract<MapDataElements, {
    __type: T$1;
  }>[];
  /**
   * Retrieves an object by its type and ID.
   *
   * @param type The type of the object (e.g., 'space', 'door').
   * @param id The ID of the object.
   * @returns The requested object, or undefined if not found.
   */
  getById<T$1 extends keyof Omit<TMapDataObjectTypes, 'enterprise-venue'> | 'unknown'>(type: T$1, id: string): (T$1 extends keyof TMapDataObjectTypes ? TMapDataObjectTypes[T$1] : TMapDataObjectTypes[keyof TMapDataObjectTypes]) | undefined;
  getById<T$1 extends keyof Omit<TMapDataObjectTypes, 'enterprise-venue'>>(type: T$1, id: string): TMapDataObjectTypes[T$1] | undefined;
  getById<T$1 extends keyof Omit<TMapDataObjectTypes, 'enterprise-venue'> | 'unknown'>(type: 'unknown', id: string): (T$1 extends keyof TMapDataObjectTypes ? TMapDataObjectTypes[T$1] : TMapDataObjectTypes[keyof TMapDataObjectTypes]) | undefined;
  getByExternalId<T$1 extends keyof Omit<TMapDataObjectTypes, 'annotation' | 'facade'>>(type: T$1, externalId: string): TMapDataObjectTypes[T$1][];
  getMapDataById(id: string): MapDataElements | undefined;
  /**
   * Retrieves a feature by its type and ID from the Mappedin Venue Format (MVF) data.
   *
   * @param type The type of the feature (e.g., 'space', 'node').
   * @param id The ID of the feature.
   * @returns The requested MVF feature or undefined if not found.
   */
  getMVFFeatureById(type: 'space', id: string): SpaceCollection['features'][number] | undefined;
  getMVFFeatureById(type: 'node', id: string): NodeCollection['features'][number] | undefined;
  getMVFFeatureById(type: 'obstruction', id: string): ObstructionCollection['features'][number] | undefined;
  getMVFFeatureById(type: 'floor', id: string): FloorProperties | undefined;
  getMVFFeatureById(type: 'floor-stack', id: string): FloorStack$1 | undefined;
  getMVFFeatureById(type: 'connection', id: string): Connection$1 | undefined;
  getMVFFeatureById(type: 'entrance', id: string): EntranceCollection['features'][number] | undefined;
  getMVFFeatureById(type: 'annotation', id: string): AnnotationCollection['features'][number] | undefined;
  getMVFFeatureById(type: 'area', id: string): AreaCollection['features'][number] | undefined;
  getMVFFeatureById(type: string, id: string): object | undefined;
  getMVFFeatureByNodeId(type: 'connection', id: string): Connection$1 | undefined;
  /**
   * Retrieves all MVF features of a given type. Safer than referencing the mvf's deprecated collections directly.
   */
  getMVFFeatureByType(type: 'floor-stack'): FloorStack$1[];
  getMVFFeatureByType(type: 'floor'): FloorProperties[];
  propTranslationCache: Map<number, Record<string, unknown>>;
  getPropTranslation<T$1 extends keyof LanguagePackRecords, P$1 extends keyof NonNullable<NonNullable<LanguagePackRecords[T$1]>[string]>>(type: T$1, prop: P$1, id: string, fallback: NonNullable<NonNullable<LanguagePackRecords[T$1]>[string]>[P$1]): unknown;
  findPreferredLanguage(options?: TFindPreferredLanguageInVenueOptions): Language | undefined;
  /**
   * Changes the language of the map data.
   *
   * @param languageCode The language code to change to.
   * @param preferred Whether to fallback to the preferred language in the venue.
   */
  changeLanguage(languageCode: string): Promise<void>;
  /**
   * @deprecated Use the async version instead. This method will be made truly async in the upcoming future.
   * @internal
   */
  __LEGACY_GET_DIRECTIONS_MULTI_DESTINATION_SYNC: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | (TNavigationTarget | TNavigationTarget[])[], opt?: TGetDirectionsOptions) => Directions | Directions[] | undefined;
  /**
   * @internal
   */
  __LEGACY_GET_DIRECTIONS_SYNC: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | (TNavigationTarget | TNavigationTarget[])[], opt?: TGetDirectionsOptions & {
    multiDestination?: boolean;
  }) => Directions | Directions[] | undefined;
  getDirections: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], opt?: TGetDirectionsOptions) => Promise<Directions | undefined>;
  getDirectionsMultiDestination: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | (TNavigationTarget | TNavigationTarget[])[], opt?: TGetDirectionsOptions) => Promise<Directions[] | undefined>;
  getDistance(from: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node | EnterpriseLocation | Area, to: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node | EnterpriseLocation | Area): number;
  /**
   * Gets the door associated with a node.
   *
   * @param nodeId The ID of the node to check
   * @returns The door object if the node is associated with a door, undefined otherwise
   */
  getDoorByNodeId: (nodeId: string) => Door | undefined;
  transformImageRequest: (url: string) => Promise<{
    url: string;
  }>;
  toJSONBundle({
    downloadLanguagePacks
  }?: {
    downloadLanguagePacks?: boolean;
  }): Promise<THydrateMapDataBundle>;
  toBinaryBundle({
    downloadLanguagePacks
  }?: {
    downloadLanguagePacks?: boolean;
  }): Promise<THydrateMapDataBundle | void>;
  /**
   * Cleans up resources used by the instance.
   *
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region src/search/internal.d.ts
declare class InternalSearch {
  #private;
  private mapData;
  private indexes;
  private ready;
  constructor(mapData: MapData);
  /**
   * Populates the search indexes with the map data.
   * @returns A promise that resolves when the indexes are populated.
   */
  populate(): Promise<any[]>;
  search(term: string, options?: SearchOptions): Promise<SearchResult>;
  suggest(term: string, options?: SuggestOptions): Promise<Suggestion[]>;
}
type SearchResultItem<T$1 extends Places | EnterpriseLocation | EnterpriseCategory> = {
  type: T$1['__type'];
  match: SearchResult$1['match'];
  score: number;
  item: T$1;
};
/**
 * @interface
 */
type SearchResultEnterpriseCategory = SearchResultItem<EnterpriseCategory>;
/**
 * @interface
 */
type SearchResultEnterpriseLocations = SearchResultItem<EnterpriseLocation>;
/**
 * @interface
 */
type SearchResultPlaces = SearchResultItem<Places>;
/**
 * Search results
 */
type SearchResult = {
  /**
   * Places search results
   */
  places: SearchResultPlaces[];
  /**
   * Enterprise Locations search results
   */
  enterpriseLocations?: SearchResultEnterpriseLocations[];
  /**
   * Enterprise Categories search results
   */
  enterpriseCategories?: SearchResultEnterpriseCategory[];
};
declare const searchOptionsSchema: ZodObject<{
  places: ZodOptional<ZodObject<{
    fields: ZodOptional<ZodObject<{
      name: ZodOptional<ZodBoolean>;
      description: ZodOptional<ZodBoolean>;
    }, $strip>>;
    limit: ZodOptional<ZodNumber>;
  }, $strip>>;
  enterpriseCategories: ZodOptional<ZodObject<{
    fields: ZodOptional<ZodObject<{
      name: ZodOptional<ZodBoolean>;
      description: ZodOptional<ZodBoolean>;
      'locations.name': ZodOptional<ZodBoolean>;
    }, $strip>>;
    limit: ZodOptional<ZodNumber>;
  }, $strip>>;
  enterpriseLocations: ZodOptional<ZodObject<{
    fields: ZodOptional<ZodObject<{
      name: ZodOptional<ZodBoolean>;
      tags: ZodOptional<ZodBoolean>;
      description: ZodOptional<ZodBoolean>;
    }, $strip>>;
    limit: ZodOptional<ZodNumber>;
  }, $strip>>;
}, $strip>;
declare const suggestOptionsSchema: ZodObject<{
  places: ZodOptional<ZodObject<{
    enabled: ZodOptional<ZodBoolean>;
  }, $strip>>;
  enterpriseLocations: ZodOptional<ZodObject<{
    enabled: ZodOptional<ZodBoolean>;
  }, $strip>>;
}, $strip>;
/**
 * @interface
 */
type SearchOptions = output<typeof searchOptionsSchema>;
/**
 * @interface
 */
type SuggestOptions = output<typeof suggestOptionsSchema>;
//#endregion
//#region src/search/external.d.ts
/**
 * Search allows users to search for locations, categories, and other points of interest within the venue.
 *
 * Refer to the [Search Guide](https://developer.mappedin.com/web-sdk/enterprise-data#enterprise-search) for more information and interactive examples.
 */
declare class Search {
  #private;
  private searchInstance?;
  /**
   * Whether the search is enabled.
   * @default false
   */
  enabled: boolean;
  /**
   * @internal
   */
  constructor(mapData: MapData, mapDataInternal: MapDataInternal, {
    enabled
  }?: {
    enabled?: boolean;
  });
  /**
   * Use query to search for locations based on a string input:
   *
   * - {@link EnterpriseLocation}: Specific places such as stores, restaurants, or washrooms.
   * - {@link EnterpriseCategory}: Groups of locations, such as "Food Court" or "Electronics."
   * - {@link Places}: Any main objects that can be searched for such as Space, Door, Point of Interest
   *
   * Search query returns a list of matching {@	link SearchResult} based on the input string.
   *
   * {@link SearchResult} include information about the type of match, the score (relevance), and detailed metadata about the matching items.
   *
   * @param term - The search term.
   * @param options - The search options.
   * @returns The search results.
   * @example
   * ```ts
   * const results = await search.query('Coffee Shop');
   * console.log(results.locations);
   * ```
   */
  query(term: string, options?: SearchOptions): ReturnType<typeof InternalSearch.prototype.search>;
  /**
   * Suggests the names of places, locations, and categories based on partial input. This is useful for creating an autocomplete feature for a search bar.
   * @param term - The search term.
   * @param options - The suggest options.
   * @returns The search suggestions.
   * @example
   * ```ts
   * const suggestions = await search.suggest('Coffee');
   * console.log(suggestions);
   * ```
   */
  suggest(term: string, options?: SuggestOptions): Promise<Suggestion$1[]>;
  /**
   * Enables the search.
   */
  enable(): Promise<void>;
}
//#endregion
//#region src/map-data.d.ts
/**
 * ## MapData in Mappedin JS
 *
 * MapData is the core data container for all map information, providing access to spaces, floors, points of interest, and navigation capabilities. It serves as the foundation for building interactive indoor mapping applications.
 *
 * ### Features
 * - Access to all map elements (spaces, floors, doors, etc.)
 * - Built-in search functionality with suggestions
 * - Navigation and wayfinding capabilities
 * - Multi-language support
 * - Analytics tracking
 * - Data export and serialization
 *
 * > **Best Practice:** Use `getByType()` to retrieve collections of map elements, and `getById()` for specific elements. Enable search functionality when you need location discovery features.
 *
 * ### Example Usage
 * ```ts
 * // Get all spaces on the map
 * const spaces = mapData.getByType('space');
 *
 * // Find a specific space by ID
 * const space = mapData.getById('space', 'space-123');
 *
 * // Get directions between two locations
 * const directions = mapData.getDirections(space1, space2);
 *
 * // Enable and use search
 * await mapData.Search.enable();
 * const results = await mapData.Search.query('Coffee Shop');
 *
 * // Change language
 * await mapData.changeLanguage('es');
 * ```
 *
 * ### Data Access Patterns
 * - **Collections**: Use `getByType()` for all elements of a type
 * - **Specific Elements**: Use `getById()` for individual elements
 * - **External IDs**: Use `getByExternalId()` for custom identifiers
 * - **GeoJSON**: Use `getGeoJSON()` for geometric data
 *
 * ### Navigation Features
 * - `getDirections()`: Route between two locations
 * - `getDirectionsMultiDestination()`: Route with multiple destinations
 * - `getDistance()`: Calculate distance between locations
 *
 * ### More Information
 * - [Getting Started Guide](https://developer.mappedin.com/web-sdk/getting-started)
 * - [Search Guide](https://developer.mappedin.com/web-sdk/enterprise-data#enterprise-search)
 * - [Wayfinding Guide](https://developer.mappedin.com/web-sdk/wayfinding)
 *
 * Represents the data for a map, providing access to map elements
 * like spaces, floors, and points of interest.
 */
declare class MapData {
  #private;
  Analytics: Analytics;
  /**
   * Search API for MapData
   *
   * Provides full-text search capabilities across all map locations, with support for suggestions, filtering, and result ranking.
   *
   * @example Enable search and perform a query
   * ```ts
   * // Enable search
   * const mapData = await getMapData({ search: { enabled: true } });
   * // or
   * await mapData.Search.enable();
   *
   * // Perform a search query
   * const results = await mapData.Search.query('Coffee Shop');
   * console.log(results.locations);
   * ```
   *
   * @example Get search suggestions
   * ```ts
   * // Get search suggestions
   * const suggestions = await mapData.Search.suggest('Coff');
   * console.log(suggestions);
   * ```
   *
   * @example Search with filters
   * ```ts
   * const results = await mapData.Search.query('Shop', {
   *   categories: ['retail'],
   *   floor: mapData.getByType('floor')[0]
   * });
   * ```
   *
   * @see [Search Guide](https://developer.mappedin.com/web-sdk/enterprise-data#enterprise-search)
   */
  Search: Search;
  /**
   * Query API for advanced data filtering and retrieval.
   *
   * Provides powerful querying capabilities to filter and find map elements based on various criteria.
   *
   * @example
   * ```ts
   * // Find all spaces with specific properties
   * const results = mapData.Query.spaces()
   *   .where('category', 'retail')
   *   .where('floor', floor)
   *   .execute();
   * ```
   */
  Query: Query;
  /**
   * @internal
   */
  internal: MapDataInternal;
  /**
   * Constructs a new instance of {@link MapData}.
   *
   * @internal
   */
  constructor(internal: MapDataInternal, {
    search
  }?: {
    search?: TSearchOptions;
  });
  /**
   * Subscribe to MapData events.
   *
   * Listen for events emitted by the MapData instance such as language changes.
   *
   * @param eventName The name of the event to listen for.
   * @param fn The callback function to execute when the event is emitted.
   *
   * @example Listen for language changes
   * ```ts
   * mapData.on('language-change', ({ code, name }) => {
   *   console.log(`Language changed to ${name} (${code})`);
   *
   *   // Update UI to reflect new language
   * 	updateInterfaceLanguage(code);
   * });
   * ```
   */
  on: <EventName extends keyof TMapDataEvents>(eventName: EventName, fn: (payload: TMapDataEvents[EventName] extends {
    data: null;
  } ? TMapDataEvents[EventName]["data"] : TMapDataEvents[EventName]) => void) => void;
  /**
   * Unsubscribe from MapData events.
   *
   * @param eventName The name of the event to unsubscribe from.
   * @param fn The callback function that was previously registered with `on()`.
   *
   * @example Remove language change listener
   * ```ts
   * const handleLanguageChange = ({ code, name }) => {
   *   console.log(`Language changed to ${name}`);
   * };
   *
   * // Add listener
   * mapData.on('language-change', handleLanguageChange);
   *
   * // Later, remove the listener
   * mapData.off('language-change', handleLanguageChange);
   * ```
   */
  off: <EventName extends keyof TMapDataEvents>(eventName: EventName, fn: (payload: TMapDataEvents[EventName] extends {
    data: null;
  } ? TMapDataEvents[EventName]["data"] : TMapDataEvents[EventName]) => void) => void;
  /**
   * Get the current environment configuration.
   *
   * Returns the environment settings including API endpoints and configuration.
   *
   * @returns Environment configuration object
   * @example
   * ```ts
   * const env = mapData.getEnv();
   * console.log(env.baseUri); // Get the API URL for the current environment
   * ```
   */
  getEnv(): {
    readonly baseUri: string;
    readonly baseAuthUri: string;
    readonly analyticsBaseUri: string;
    readonly tileServerUri: string;
  };
  /**
   * Get an access token for use with Mappedin's API.
   *
   * Returns the current access token that can be used for authenticated API requests.
   *
   * @returns {string} The current access token
   * @example
   * ```ts
   * const token = mapData.getAccessToken();
   * // Use token for API requests
   * ```
   */
  getAccessToken(): string | undefined;
  /**
   * The name of the map.
   *
   * @returns {string} The name of the map.
   * @example
   * ```ts
   * console.log(mapData.mapName); // "Downtown Mall"
   * ```
   */
  get mapName(): string;
  /**
   * The unique identifier for the map.
   *
   * @returns {string | undefined} The map ID.
   * @example
   * ```ts
   * console.log(mapData.mapId); // "map-12345"
   * ```
   */
  get mapId(): string | undefined;
  /**
   * Indicates whether the map data was loaded from a CMS/Enterprise data source.
   *
   * Use this property to determine which data types to access at runtime, especially
   * when loading map data from a zip file where the data source is unknown beforehand.
   *
   * @remarks
   * **Data Source Detection:**
   * - `true` - Map uses CMS/Enterprise data. Use `enterprise-location`, `enterprise-category`, `enterprise-venue`.
   * - `false` - Map uses Maker data. Use `location-profile`, `location-category`.
   *
   * **Important for AI/Code Generation:**
   * When loading from a zip file (using `hydrateMapData`), always check this property
   * and write code that handles both data sources dynamically. This ensures your code
   * works with any map regardless of its origin.
   *
   * @returns {boolean} `true` if using CMS/Enterprise data source, `false` if using Maker.
   *
   * @example Dynamic data source handling (recommended for zip files)
   * ```ts
   * import { hydrateMapData } from '@mappedin/mappedin-js';
   *
   * const mapData = await hydrateMapData(bundle);
   *
   * // Handle both data sources dynamically
   * const locations = mapData.isEnterpriseMode
   *   ? mapData.getByType('enterprise-location')
   *   : mapData.getByType('location-profile');
   *
   * const categories = mapData.isEnterpriseMode
   *   ? mapData.getByType('enterprise-category')
   *   : mapData.getByType('location-category');
   *
   * // Now use locations and categories regardless of data source
   * locations.forEach(loc => console.log(loc.name));
   * ```
   *
   * @example Conditional logic based on data source
   * ```ts
   * if (mapData.isEnterpriseMode) {
   *   const venue = mapData.getByType('enterprise-venue');
   *   console.log('Enterprise venue:', venue?.name);
   * } else {
   *   console.log('Maker map - no venue object available');
   * }
   * ```
   */
  get isEnterpriseMode(): boolean;
  /**
   * The approximate center coordinate ({@link Coordinate}) of the map.
   *
   * @returns {Coordinate} The center coordinate of the map.
   * @example
   * ```ts
   * const center = mapData.mapCenter;
   * console.log(`Map center: ${center.latitude}, ${center.longitude}`);
   * ```
   */
  get mapCenter(): Coordinate;
  /**
   * The organization ID of the map.
   *
   * @returns {string} The organization ID of the map.
   * @example
   * ```ts
   * console.log(mapData.organizationId); // "org-12345"
   * ```
   */
  get organizationId(): string;
  /**
   * The token used to fetch outdoor tiles for outdoor map integration.
   *
   * @returns {string | undefined} The outdoor view token.
   * @example
   * ```ts
   * const outdoorToken = mapData.outdoorViewToken;
   * if (outdoorToken) {
   *   // Configure outdoor map with token
   * }
   * ```
   */
  get outdoorViewToken(): string | undefined;
  /**
   * Retrieves all map elements of a specific type.
   *
   * This is the primary method for accessing collections of map elements. Use the typed overloads for better TypeScript support.
   *
   * @param type The type of elements to retrieve.
   * @returns An array of elements of the given type.
   *
   * @example Get all spaces
   * ```ts
   * const spaces = mapData.getByType('space');
   * console.log(`Found ${spaces.length} spaces`);
   * ```
   *
   * @example Get all floors
   * ```ts
   * const floors = mapData.getByType('floor');
   * floors.forEach(floor => console.log(floor.name));
   * ```
   *
   * @example Get all doors
   * ```ts
   * const doors = mapData.getByType('door');
   * const entranceDoors = doors.filter(door => door.type === 'entrance');
   * ```
   */
  getByType(type: string): MapDataElements[];
  /**
   * @returns The spaces ({@link Space}) on the map.
   * @example
   * ```ts
   * const spaces = mapData.getByType('space');
   * const retailSpaces = spaces.filter(space => space.category === 'retail');
   * ```
   */
  getByType(type: 'space'): Space[];
  /**
   * @returns The doors ({@link Door}) on the map.
   * @example
   * ```ts
   * const doors = mapData.getByType('door');
   * const entranceDoors = doors.filter(door => door.type === 'entrance');
   * ```
   */
  getByType(type: 'door'): Door[];
  /**
   * @returns The floors ({@link Floor}) on the map.
   * @example
   * ```ts
   * const floors = mapData.getByType('floor');
   * const groundFloor = floors.find(floor => floor.level === 0);
   * ```
   */
  getByType(type: 'floor'): Floor[];
  /**
   * @returns The stacks of floors ({@link FloorStack}) within the map.
   * @example
   * ```ts
   * const floorStacks = mapData.getByType('floor-stack');
   * const mainBuilding = floorStacks.find(stack => stack.name === 'Main Building');
   * ```
   */
  getByType(type: 'floor-stack'): FloorStack[];
  /**
   * @returns The facades ({@link Facade}) within the map.
   * @example
   * ```ts
   * const facades = mapData.getByType('facade');
   * const northFacade = facades.find(facade => facade.name === 'North');
   * ```
   */
  getByType(type: 'facade'): Facade[];
  /**
   * @returns The connections ({@link Connection}) on the map.
   * @example
   * ```ts
   * const connections = mapData.getByType('connection');
   * const elevators = connections.filter(conn => conn.type === 'elevator');
   * ```
   */
  getByType(type: 'connection'): Connection[];
  /**
   * @returns The objects ({@link MapObject}) on the map.
   * @example
   * ```ts
   * const objects = mapData.getByType('object');
   * const furniture = objects.filter(obj => obj.category === 'furniture');
   * ```
   */
  getByType(type: 'object'): MapObject[];
  /**
   * @returns The points of interest ({@link PointOfInterest}) on the map.
   * @example
   * ```ts
   * const pois = mapData.getByType('point-of-interest');
   * const restrooms = pois.filter(poi => poi.category === 'restroom');
   * ```
   */
  getByType(type: 'point-of-interest'): PointOfInterest[];
  /**
   * @returns The annotations ({@link Annotation}) on the map.
   * @example
   * ```ts
   * const annotations = mapData.getByType('annotation');
   * const infoAnnotations = annotations.filter(ann => ann.type === 'info');
   * ```
   */
  getByType(type: 'annotation'): Annotation[];
  /**
   * @returns The nodes ({@link Node}) on the map.
   * @example
   * ```ts
   * const nodes = mapData.getByType('node');
   * const navigationNodes = nodes.filter(node => node.type === 'navigation');
   * ```
   */
  getByType(type: 'node'): Node[];
  /**
   * @returns The areas ({@link Area}) on the map.
   * @example
   * ```ts
   * const areas = mapData.getByType('area');
   * const parkingAreas = areas.filter(area => area.category === 'parking');
   * ```
   */
  getByType(type: 'area'): Area[];
  /**
   * @returns The enterprise locations ({@link EnterpriseLocation}) on the map.
   *
   * @remarks
   * **Data Source: Enterprise** - Only populated when using CMS/Enterprise credentials
   * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty
   * array when using Maker credentials. Use `'location-profile'` instead for Maker data.
   *
   * @example
   * ```ts
   * const locations = mapData.getByType('enterprise-location');
   * const stores = locations.filter(loc => loc.category === 'store');
   * ```
   */
  getByType(type: 'enterprise-location'): EnterpriseLocation[];
  /**
   * @returns The enterprise categories ({@link EnterpriseCategory}) on the map.
   *
   * @remarks
   * **Data Source: Enterprise** - Only populated when using CMS/Enterprise credentials
   * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns an empty
   * array when using Maker credentials. Use `'location-category'` instead for Maker data.
   *
   * @example
   * ```ts
   * const categories = mapData.getByType('enterprise-category');
   * const retailCategories = categories.filter(cat => cat.type === 'retail');
   * ```
   */
  getByType(type: 'enterprise-category'): EnterpriseCategory[];
  /**
   * @returns The enterprise venue ({@link EnterpriseVenue}) for the map, or undefined if not available.
   *
   * @remarks
   * **Data Source: Enterprise** - Only available when using CMS/Enterprise credentials
   * (clientId/clientSecret or API keys that do NOT start with `mik_`). Returns undefined
   * when using Maker credentials.
   *
   * @example
   * ```ts
   * const venue = mapData.getByType('enterprise-venue');
   * if (venue) {
   *   console.log(venue.name, venue.languages);
   * }
   * ```
   */
  getByType(type: 'enterprise-venue'): EnterpriseVenue | undefined;
  /**
   * @returns The location profiles ({@link LocationProfile}) on the map.
   *
   * @remarks
   * **Data Source: Maker** - Only populated when using Maker credentials
   * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise
   * credentials. Use `'enterprise-location'` instead for Enterprise data.
   *
   * @example
   * ```ts
   * const profiles = mapData.getByType('location-profile');
   * const featuredProfiles = profiles.filter(profile => profile.featured);
   * ```
   */
  getByType(type: 'location-profile'): LocationProfile[];
  /**
   * @returns The location categories ({@link LocationCategory}) on the map.
   *
   * @remarks
   * **Data Source: Maker** - Only populated when using Maker credentials
   * (API keys starting with `mik_`). Returns an empty array when using CMS/Enterprise
   * credentials. Use `'enterprise-category'` instead for Enterprise data.
   *
   * @example
   * ```ts
   * const categories = mapData.getByType('location-category');
   * const mainCategories = categories.filter(cat => cat.parent === null);
   * ```
   */
  getByType(type: 'location-category'): LocationCategory[];
  /**
   * Retrieves a specific map feature by its type and ID.
   *
   * Use this method to find individual map elements when you know their exact ID. This is more efficient than filtering collections for specific elements.
   *
   * @remarks
   * **Data Source Availability:**
   * - `'enterprise-location'`, `'enterprise-category'`, `'enterprise-venue'` - Only available with CMS/Enterprise credentials
   * - `'location-profile'`, `'location-category'` - Only available with Maker credentials (keys starting with `mik_`)
   * - All other types (`'space'`, `'floor'`, `'door'`, etc.) - Available with both credential types
   *
   * @param type The type of element to retrieve.
   * @param id The unique identifier of the element.
   * @returns The map element if found, undefined otherwise.
   *
   * @example Find a specific space
   * ```ts
   * const space = mapData.getById('space', 'space-123');
   * if (space) {
   *   console.log(`Found space: ${space.name}`);
   * }
   * ```
   *
   * @example Find a specific floor
   * ```ts
   * const floor = mapData.getById('floor', 'floor-1');
   * if (floor) {
   *   console.log(`Floor level: ${floor.level}`);
   * }
   * ```
   *
   * @example Find a door
   * ```ts
   * const door = mapData.getById('door', 'door-main-entrance');
   * if (door) {
   *   console.log(`Door type: ${door.type}`);
   * }
   * ```
   *
   * @example Find an element by ID when you don't know the type.
   *
   * In general, it is better to specify the type if you know it, since you get better type safety.
   * ```ts
   * const element = mapData.getById('unknown', 'element-123');
   * if (!element) {
   *   console.log(`Element not found`);
   * } else if (Space.is(element)) {
   *   console.log(`Found space: ${element.name}`);
   * } else if (Door.is(element)) ...
   * ```
   */
  getById<T$1 extends keyof Omit<TMapDataObjectTypes, 'enterprise-venue'> | 'unknown'>(type: T$1, id: string): (T$1 extends keyof TMapDataObjectTypes ? TMapDataObjectTypes[T$1] : TMapDataObjectTypes[keyof TMapDataObjectTypes]) | undefined;
  getById<T$1 extends keyof TMapDataObjectTypes>(type: T$1, id: string): TMapDataObjectTypes[T$1] | undefined;
  getById<T$1 extends 'unknown'>(type: T$1, id: string): TMapDataObjectTypes[keyof TMapDataObjectTypes] | undefined;
  /**
   * Retrieves map elements by their external ID.
   *
   * External IDs are custom identifiers that can be assigned to map elements. This is useful for integrating with external systems or databases.
   *
   * @remarks
   * **Data Source Availability:**
   * - `'enterprise-location'`, `'enterprise-category'` - Only available with CMS/Enterprise credentials
   * - `'location-profile'` - Only available with Maker credentials (keys starting with `mik_`)
   * - All other types (`'space'`, `'floor'`, etc.) - Available with both credential types
   *
   * @param type The type of element to retrieve.
   * @param externalId The external identifier to search for.
   * @returns An array of elements with the matching external ID.
   *
   * @example Find spaces by external ID
   * ```ts
   * const spaces = mapData.getByExternalId('space', 'STORE-001');
   * spaces.forEach(space => console.log(`Found space: ${space.name}`));
   * ```
   *
   * @example Find locations by external ID (Enterprise)
   * ```ts
   * // With CMS/Enterprise credentials:
   * const locations = mapData.getByExternalId('enterprise-location', 'RESTAURANT-ABC');
   * locations.forEach(location => console.log(`Found location: ${location.name}`));
   * ```
   *
   * @example Find locations by external ID (Maker)
   * ```ts
   * // With Maker credentials (mik_ keys):
   * const locations = mapData.getByExternalId('location-profile', 'RESTAURANT-ABC');
   * locations.forEach(location => console.log(`Found location: ${location.name}`));
   * ```
   */
  getByExternalId<T$1 extends keyof Omit<TMapDataObjectTypes, 'annotation' | 'facade'>>(type: T$1, externalId: string): TMapDataObjectTypes[T$1][];
  /**
   * Retrieves the GeoJSON representation of a map element.
   *
   * Returns the geometric data for a map element in GeoJSON format, which can be used for custom rendering, analysis, or integration with mapping libraries.
   *
   * @param mapDataObject The map element to get GeoJSON for.
   * @returns The GeoJSON representation of the element.
   *
   * @example Get GeoJSON for a space
   * ```ts
   * const space = mapData.getById('space', 'space-123');
   * if (space) {
   *   const geoJSON = mapData.getGeoJSON(space);
   *   console.log('Space geometry:', geoJSON.geometry);
   *   console.log('Space properties:', geoJSON.properties);
   * }
   * ```
   *
   * @example Get GeoJSON for a floor
   * ```ts
   * const floor = mapData.getByType('floor')[0];
   * const geoJSON = mapData.getGeoJSON(floor);
   * console.log('Floor bounds:', geoJSON.geometry.coordinates);
   * ```
   */
  getGeoJSON<T$1 extends IGeoJSONData>(mapDataObject: T$1): T$1['geoJSON'];
  /**
   * Changes the language of the map data.
   *
   * Updates all text content (names, descriptions, etc.) to the specified language. The map will emit a 'language-change' event when the language is updated.
   *
   * @param localeCode The ISO 639-1 language code to change to (e.g., 'en' for English, 'fr' for French). Check ({@link EnterpriseVenue.languages}) for available
   languages
   * @returns A promise that resolves when the language change is complete.
   *
   * @example Change to Spanish
   * ```ts
   * await mapData.changeLanguage('es');
   * console.log('Map language changed to Spanish');
   * ```
   *
   * @example Change to French
   * ```ts
   * await mapData.changeLanguage('fr');
   * console.log('Map language changed to French');
   * ```
   *
   * @example Listen for language changes
   * ```ts
   * mapData.on('language-change', ({ code, name }) => {
   *   console.log(`Language changed to ${name} (${code})`);
   * });
   * ```
   */
  changeLanguage(localeCode: string): Promise<void>;
  /**
   * Gets the current language of the map data.
   *
   * @returns The current language code and name.
   * @example
   * ```ts
   * const language = mapData.currentLanguage;
   * console.log(`Current language: ${language.name} (${language.code})`);
   * ```
   */
  get currentLanguage(): _mappedin_mvf_v22.Language | undefined;
  /**
   * Gets the natural bearing of the map.
   *
   * The natural bearing represents the orientation of the map relative to true north. This is useful for aligning the map with compass directions or external mapping systems.
   *
   * @returns The natural bearing in degrees.
   * @example
   * ```ts
   * const bearing = mapData.naturalBearing;
   * console.log(`Map is oriented ${bearing} degrees from true north`);
   * ```
   */
  get naturalBearing(): number;
  /**
    * @deprecated Use the async version instead. This method will be made truly async in the upcoming future.
   * @internal
   */
  __LEGACY_GET_DIRECTIONS_SYNC: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], options?: TGetDirectionsOptions) => Directions | undefined;
  /**
   * Calculates directions between two or more locations.
   *
   * Provides turn-by-turn navigation instructions and a path between the specified locations. The path avoids obstacles and follows walkable routes.
   *
   * @param from The starting location(s).
   * @param to The destination location(s).
   * @param options Optional configuration for the directions calculation.
   * @returns A {@link Directions} object containing the route, or undefined if no route is found.
   *
   * @example Get directions between two spaces
   * ```ts
   * const space1 = mapData.getById('space', 'space-123');
   * const space2 = mapData.getById('space', 'space-456');
   *
   * if (space1 && space2) {
   *   const directions = await mapData.getDirections(space1, space2);
   *   if (directions) {
   *     console.log(`Distance: ${directions.distance}m`);
   *     console.log(`Duration: ${directions.duration}s`);
   *     directions.instructions.forEach(instruction => {
   *       console.log(instruction.action.type);
   *     });
   *   }
   * }
   * ```
   *
   * @example Get directions with options
   * ```ts
   * const directions = await mapData.getDirections(space1, space2, {
   *   accessible: true,
   *   smoothing: { radius: 3 }
   * });
   * ```
   *
   * @example Get directions from multiple starting points
   * ```ts
   * const directions = await mapData.getDirections([space1, space2], destination);
   * ```
   *
   * @see [Wayfinding Guide](https://developer.mappedin.com/web-sdk/wayfinding)
   */
  getDirections: (from: TNavigationTarget | TNavigationTarget[], to: TNavigationTarget | TNavigationTarget[], options?: TGetDirectionsOptions) => Promise<Directions | undefined>;
  /**
   * @deprecated Use the async version instead. This method will be made truly async in the upcoming future.
   * @internal
   */
  __LEGACY_GET_DIRECTIONS_MULTI_DESTINATION_SYNC: (from: TNavigationTarget, to: (TNavigationTarget | TNavigationTarget[])[], options?: TGetDirectionsOptions) => Directions[] | undefined;
  /**
   * Calculates directions to multiple destinations.
   *
   * Provides routes from a single starting point to multiple destinations. Useful for finding the best route when visiting multiple locations.
   *
   * @param from The starting location.
   * @param to An array of destination locations or arrays of destinations.
   * @param options Optional configuration for the directions calculation.
   * @returns An array of {@link Directions} objects, one for each destination.
   *
   * @example Get directions to multiple destinations
   * ```ts
   * const start = mapData.getById('space', 'entrance');
   * const destinations = [
   *   mapData.getById('space', 'store-1'),
   *   mapData.getById('space', 'store-2'),
   *   mapData.getById('space', 'restaurant')
   * ].filter(Boolean);
   *
   * const allDirections = await mapData.getDirectionsMultiDestination(start, destinations);
   * allDirections.forEach((directions, index) => {
   *   console.log(`Route ${index + 1}: ${directions.distance}m`);
   * });
   * ```
   *
   * @example Get directions with alternative routes
   * ```ts
   * const directions = await mapData.getDirectionsMultiDestination(start, [
   *   [destination1, destination2], // First route option
   *   [destination3, destination4]  // Second route option
   * ]);
   * ```
   */
  getDirectionsMultiDestination: (from: TNavigationTarget, to: (TNavigationTarget | TNavigationTarget[])[], options?: TGetDirectionsOptions) => Promise<Directions[] | undefined>;
  /**
   * Calculates the straight-line distance between two locations.
   *
   * Returns the direct distance between two points, not following walkable paths. For navigation distances, use {@link getDirections}.
   *
   * @param from The starting location.
   * @param to The destination location.
   * @returns The distance in meters.
   *
   * @example Calculate distance between spaces
   * ```ts
   * const space1 = mapData.getById('space', 'space-123');
   * const space2 = mapData.getById('space', 'space-456');
   *
   * if (space1 && space2) {
   *   const distance = mapData.getDistance(space1, space2);
   *   console.log(`Direct distance: ${distance}m`);
   * }
   * ```
   *
   * @example Calculate distance from coordinate
   * ```ts
   * const coordinate = mapData.mapCenter;
   * const space = mapData.getByType('space')[0];
   * const distance = mapData.getDistance(coordinate, space);
   * console.log(`Distance from center: ${distance}m`);
   * ```
   */
  getDistance(from: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node | EnterpriseLocation | Area, to: Space | Door | Coordinate | MapObject | PointOfInterest | Annotation | Node | EnterpriseLocation | Area): number;
  /**
   * Creates a backup of the map data including language packs.
   * @internal
   */
  toBinaryBundle({
    downloadLanguagePacks
  }?: {
    downloadLanguagePacks?: boolean;
  }): Promise<void | THydrateMapDataBundle>;
  /**
   * Exports the map data as a JSON bundle.
   *
   * Creates a JSON representation of the map data that can be easily parsed and manipulated. Useful for data analysis, debugging, or integration with other systems.
   *
   * @param options Configuration options for the export.
   * @param options.downloadLanguagePacks Whether to include language packs in the export.
   * @returns A JSON bundle containing the map data.
   *
   * @example Export map data as JSON
   * ```ts
   * const jsonBundle = mapData.toJSONBundle({ downloadLanguagePacks: true });
   * console.log('Map data exported:', jsonBundle);
   * ```
   *
   * @example Export for analysis
   * ```ts
   * const jsonBundle = mapData.toJSONBundle({ downloadLanguagePacks: false });
   * // Use JSON data for analysis or processing
   * ```
   */
  toJSONBundle({
    downloadLanguagePacks
  }?: {
    downloadLanguagePacks?: boolean;
  }): Promise<THydrateMapDataBundle>;
}
//#endregion
//#region ../renderer-three/src/request-idle-callback-polyfill.d.ts
/**
 * Type declarations for requestIdleCallback polyfill with interaction support
 */

interface __idleCallbackInteractionState {
  isInteracting: boolean;
  interactionCheckers: (() => boolean)[];
  pendingCallbacks: {
    callback: () => void;
    timeoutId: number;
  }[];
  checkTimeoutId?: number;

  /**
   * Registers a function that returns true when user is interacting
   * @param checker - Function that returns interaction state
   */
  registerInteractionChecker(checker: () => boolean): void;

  /**
   * Unregisters a previously registered interaction checker
   * @param checker - Function to remove from interaction checkers
   */
  unregisterInteractionChecker(checker: () => boolean): void;

  /**
   * Checks if any registered interaction checker reports active interaction
   * @returns True if user is currently interacting
   */
  checkInteraction(): boolean;

  /**
   * Schedules a callback to run when interactions stop
   * @param callback - Callback to execute
   * @param timeoutId - The timeout ID to track
   */
  addPendingCallback(callback: () => void, timeoutId: number): void;

  /**
   * Checks and executes pending callbacks when interaction stops
   */
  scheduleDeferredCheck(): void;

  /**
   * Removes a pending callback by its timeout ID
   * @param timeoutId - The timeout ID to cancel
   */
  removePendingCallback(timeoutId: number): void;
}
interface MappedinDebug {
  __idleCallbackInteractionState?: __idleCallbackInteractionState;
  mapViewCoreInstance?: any;
  TEST_IOS?: boolean;
  [key: string]: any;
}
declare global {
  var MappedinDebug: MappedinDebug;
}
//#endregion
//#region ../renderer-three/src/components/styles/style.d.ts
/**
 * Determines how a material is rendered, back face, front face or both (default)
 */
type MaterialSide = 'back' | 'front' | 'double' | 'auto';
type Style$1 = {
  color: string;
  width: number;
  opacity: number;
  visible: boolean;
  height: number;
  altitude: number;
  join: LineStyle$2['join'];
  cap: LineStyle$2['cap'];
  topColor?: string;
  showImage: boolean;
  flipImageToFaceCamera: boolean;
  enableImageCollisions: boolean;
  url?: string;
  side?: MaterialSide;
  renderOrder?: number;
  shading?: Shading$1;
  bevel?: BevelState;
  borderVisible: boolean;
  borderColor?: string;
  borderWidth?: number;
  effectStart?: number;
  effectDistance?: number;
  darkenAmount?: number;
  darkenUseDepth?: boolean;
  desaturateAmount?: number;
  desaturateUseDepth?: boolean;
  washOutAmount?: number;
  washOutUseDepth?: boolean;
  maxImageSize?: number;
};
declare class StyleComponent implements Style$1 {
  #private;
  readonly type: "style";
  initialColor: string;
  set color(color: string);
  get color(): string;
  initialTopColor?: string;
  set topColor(color: string | undefined);
  get topColor(): string | undefined;
  set hoverColor(color: string);
  get hoverColor(): string | undefined;
  dirty: boolean;
  visible: boolean;
  opacity: number;
  width: number;
  height: number;
  initialHeight: number;
  altitude: number;
  join: LineStyle$2['join'];
  cap: LineStyle$2['cap'];
  showImage: boolean;
  flipImageToFaceCamera: boolean;
  enableImageCollisions: boolean;
  url?: string;
  side: MaterialSide;
  renderOrder: number;
  shading?: Shading$1;
  bevel?: BevelState;
  borderVisible: boolean;
  borderColor: string;
  borderWidth: number;
  effectStart: number;
  effectDistance: number;
  darkenAmount: number;
  darkenUseDepth: boolean;
  desaturateAmount: number;
  desaturateUseDepth: boolean;
  washOutAmount: number;
  washOutUseDepth: boolean;
  maxImageSize?: number;
  constructor(style?: Partial<Style$1>);
}
//#endregion
//#region ../renderer-three/src/components/styles/text-style.d.ts
/**
 * avoid storying default values on the text style to save space
 */
declare class Text3DStyleComponent implements Partial<Text3DStyle> {
  readonly type: "text3dStyle";
  visible?: boolean;
  altitude?: number;
  color?: string;
  dirty: boolean;
  maxWidth?: number;
  maxHeight?: number;
  hoverByPolygon?: boolean;
  flipToFaceCamera?: boolean | undefined;
  font?: string;
  fillOpacity?: number;
  fontSize?: number;
  margin?: number;
  outlineWidth?: number;
  outlineBlur?: number | string;
  outlineOffsetX?: number;
  strokeColor?: string;
  strokeOpacity?: number;
  strokeWidth?: number;
  hoverColor?: string | undefined;
  outlineOffsetY?: number;
  outlineColor?: string;
  outlineOpacity?: number;
  constructor(initialState?: Partial<Text3DStyle>);
  /**
   * Put together a json ignore all the undefined fields.
   * This is helpful when we Object.assign(instance, json) to update the instance.
   */
  getState(includeDirty?: boolean): Partial<Text3DStyle>;
}
/**
 * Style options for 3D text rendering.
 *
 * Note: Some properties behave differently depending on how the text is created:
 * - **Geometry labels** (created via `label()` or `labelAll()`): Text is associated with a geometry.
 *   The text responds to geometry hover events and is automatically sized to fit within the geometry's text area.
 * - **Point-based text** (created via `add()`): Standalone text at a coordinate.
 *   The text does not respond to hover events and is not constrained by text areas.
 */
type Text3DStyle = {
  /**
   * Controls the visibility of the text element.
   * @default true
   */
  visible: boolean;
  /**
   * The color of the text.
   *
   * For geometry labels: Will change to `hoverColor` when the associated geometry is hovered.
   *
   * Accepts any CSS color string.
   * @default 'black'
   */
  color: string;
  /**
   * When true, the text will flip to face the camera while maintaining its position.
   * @default true
   */
  flipToFaceCamera: boolean;
  /**
   * URL to a custom font file (.ttf, .otf, .woff).
   * Falls back to Roboto if undefined.
   */
  font: string | undefined;
  /**
   * The size of the text in meters.
   *
   * This represents the height of a line of text (similar to CSS font-size).
   * The width of individual characters and the overall text block will scale
   * proportionally based on the font's aspect ratio and the text content.
   *
   * For geometry labels: Will be automatically adjusted if the text exceeds the text area bounds.
   */
  fontSize: number;
  /**
   * Padding between the text and its bounding box, in meters.
   * Can be specified as either:
   * - A single number for uniform padding on all sides
   * - An array of 4 numbers [top, right, bottom, left] for individual side padding
   *
   * Only applies to geometry labels. Ignored for point-based text.
   * @default [0.2, 1, 0.2, 1.5]
   */
  margin: number | [number, number, number, number];
  /**
   * Color of the text outline.
   * Accepts any CSS color string.
   * @default 'black'
   */
  outlineColor: string;
  /**
   * Opacity of the text outline.
   * Accepts values between 0 and 1.
   * @default 1
   */
  outlineOpacity: number;
  /**
   * Blur radius for the text outline.
   * Can be a number in pixels or a string with units.
   */
  outlineBlur: number | string;
  /**
   * Width of the text outline effect in pixels.
   */
  outlineWidth: number;
  /**
   * Horizontal offset of the outline effect from the text, in pixels.
   */
  outlineOffsetX: number;
  /**
   * Vertical offset of the outline effect from the text, in pixels.
   */
  outlineOffsetY: number;
  /**
   * Width of the inner stroke of each text glyph.
   * @default 0
   */
  strokeWidth: number;
  /**
   * Maximum width constraint for the text area in meters.
   *
   * Only applies to geometry labels. Overrides default text field constraints when set.
   * Ignored for point-based text.
   */
  maxWidth: number | undefined;
  /**
   * Maximum height constraint for the text area in meters.
   *
   * Only applies to geometry labels. Overrides default text field constraints when set.
   * Ignored for point-based text.
   */
  maxHeight: number | undefined;
  /**
   * Opacity of the text stroke when strokeWidth > 0.
   * @default 1
   */
  strokeOpacity: number;
  /**
   * Color of the text stroke when strokeWidth > 0.
   * Accepts any CSS color string.
   * @default 'black'
   */
  strokeColor: string;
  /**
   * Opacity of the text fill, independent of stroke and outline opacity.
   * Set to 0 to show only stroke/outline.
   * Accepts values between 0 and 1.
   */
  fillOpacity: number;
  /**
   * Color to display when the associated geometry is hovered.
   *
   * Only applies to geometry labels. When a geometry with a label is hovered,
   * the text color changes from `color` to `hoverColor`.
   *
   * For point-based text: This property is ignored (text does not respond to hover events).
   *
   * Falls back to global hover color if undefined.
   */
  hoverColor: string | undefined;
};
//#endregion
//#region ../renderer-three/src/components/styles/model-style.d.ts
type MaterialStyle = {
  color: string;
};
type ModelStyle = {
  /**
   * Model's URL. Can be based64 inlined url.
   */
  url: string;
  /**
   * Visiiblity of the model group
   */
  visible: boolean;
  /**
   * Opacity of the model group.
   */
  opacity: number;
  /**
   * Change material state by name
   * @example
   * ```ts
   * mapView.Models.add(
   *   { target: new Coordinate(45, -75) },
   *   {
   *     url: 'bed.glb',
   *     materials: {
   *       Default: {
   *         color: MAPPEDIN_COLOR.orange,
   *       },
   *     },
   *   },
   * );
   * ```
   */
  material: {
    [name: string]: MaterialStyle;
  };
  /**
   * Vertical offset of the model in meters off the floor.
   * @deprecated Use `position.verticalOffset` instead by passing a Coordinate with the desired
   * verticalOffset to `updateState(model, { position: coordinate })`. This property will be
   * removed in a future version.
   */
  verticalOffset: number;
  /**
   * Color property designed for use with @mappedin/3d-assets.
   * Updates the accent color of 3d assets by applying the color to materials named
   * ['Default', 'Fabric', 'Mpdn_Logo', 'Fabric_Logo'].
   * For custom colors on non-Mappedin models, use the `material` property.
   * If both the `material` and `color` properties are provided, `material` property updates will take higher precedence than `color` property updates.
   */
  color: string;
  /**
   * The rotation of the model in degrees [x, y, z].
   * - x: Rotation around x-axis (pitch)
   * - y: Rotation around y-axis (yaw)
   * - z: Rotation around z-axis (roll), where z points up
   *
   * Rotations are applied in order: x, then y, then z.
   * 0 degrees means the model faces north (or the parent group's forward direction).
   * Positive rotations follow the right-hand rule.
   */
  rotation: [number, number, number];
  /**
   * The scale of the model in [x, y, z]
   */
  scale: [number, number, number];
  /**
   * Whether the model should be visible through geometry.
   *
   * Note: When set to true at creation time, this will de-optimize the model by disabling instancing.
   */
  visibleThroughGeometry: boolean;
  /**
   * When true, enables clipping plane functionality for this model.
   * This cannot be changed at runtime.
   *
   * Note: This will de-optimize the model by disabling instancing.
   * @default false
   */
  EXPERIMENTAL_clippingEnabled: boolean;
  /**
   * The clipping plane z offset of the model.
   * @default Infinity
   */
  clippingPlaneZOffset: number;
  /**
   * The color of the top of the clipping plane.
   */
  clippingPlaneTopColor: string;
  /**
   * Whether the clipping plane is visible.
   * @experimental
   * @default true
   */
  clippingPlaneTopVisible: boolean;
};
declare class ModelStyleComponnet implements Partial<ModelStyle> {
  #private;
  readonly type: "modelStyle";
  dirty: boolean;
  /** Flag to indicate render order needs to be recalculated (e.g., visibleThroughGeometry changed) */
  renderOrderDirty: boolean;
  visible: boolean;
  opacity: number;
  verticalOffset: number;
  interactive: boolean;
  color?: string;
  material?: ModelStyle['material'];
  rotation?: [number, number, number];
  scale?: [number, number, number];
  EXPERIMENTAL_clippingEnabled: boolean;
  clippingPlaneZOffset: number;
  clippingPlaneTopColor?: string;
  clippingPlaneTopVisible: boolean;
  get visibleThroughGeometry(): boolean;
  set visibleThroughGeometry(value: boolean);
  constructor(init?: Partial<ModelStyle>);
}
//#endregion
//#region ../renderer-three/src/components/mask.d.ts
declare class Mask {
  type: "mask";
  /**
   * The ID of the mask, undefined means no mask
   * min value is 0, max value is 255
   */
  maskId: number;
  enabled: boolean;
  /**
   * Whether the mask is a mask or a masked object
   */
  mode: 'mask' | 'masked-object';
  /**
   * Whether the masked object should be hidden or revealed when the mask is applied
   */
  effect: 'hide' | 'reveal';
  dirty: boolean;
}
//#endregion
//#region ../renderer-three/src/entities/feature-collection.d.ts
/**
 * State representing a Feature Collection, which is a conceptual container for
 * GeoJSON features rendered via one or more THREE.js BatchedMeshes.
 *
 * Collection-level `visible` and `altitude` map directly to the wrapping
 * `FeatureCollectionObject3D` (`.visible` and `.position.z`) and do not
 * cascade into per-feature styles.
 */
type FeatureCollectionState = {
  readonly id: string | number;
  readonly type: 'feature-collection';
  /**
   * The ids of the children of the feature collection
   */
  readonly children: (string | number)[];
  /**
   * @deprecated The feature collection no longer dictates opacity. Opacity is
   * per-feature or controlled via the wrapping `GroupContainer`. Read-through
   * to the first child is preserved for now.
   */
  opacity?: number;
  /**
   * @deprecated The feature collection no longer dictates color. Set color
   * per-feature via the style callback. Read-through to the first child is
   * preserved for now.
   */
  color?: string;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  height?: number;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  texture?: string;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  topColor?: string;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  topTexture?: string;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  outline?: boolean;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  shading?: Shading$1;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  side?: MaterialSide;
  /**
   * @deprecated Per-feature property; read-through to the first child is
   * preserved for now.
   */
  interactive?: boolean;
  /**
   * Collection-level visibility. Maps directly to `Object3D.visible` on the
   * wrapping `FeatureCollectionObject3D`; toggling cascades to children via
   * three.js's normal scene-graph traversal. Per-feature `StyleComponent.visible`
   * is a separate axis controlled via `setState` on individual feature entities.
   */
  visible?: boolean;
  /**
   * Collection-level altitude. Maps directly to `position.z` on the wrapping
   * `FeatureCollectionObject3D`. Per-feature altitude is a separate axis set
   * via the style callback or on each child.
   */
  altitude?: number;
  /**
   * Bevel configuration for extruded shapes.
   */
  bevel?: BevelState;
  maskId?: number;
  maskEnabled?: boolean;
  maskEffect?: 'hide' | 'reveal';
  maskMode?: 'mask' | 'masked-object';
  effectStart?: number;
  effectDistance?: number;
  darkenAmount?: number;
  darkenUseDepth?: boolean;
  desaturateAmount?: number;
  desaturateUseDepth?: boolean;
  washOutAmount?: number;
  washOutUseDepth?: boolean;
  /**
   * The position of the feature collection as a GeoJSON Position `[lon, lat]`,
   * computed from the centroid of its child features. Vertical offset is a
   * per-feature concern and is not tracked at the collection level.
   */
  position: Position$2;
};
declare class FeatureCollectionObject3D extends Object3D {
  readonly type: "feature-collection";
  components: [Mask?];
  getComponent(type: 'mask'): Mask | undefined;
  userData: {
    entityId: string | number;
    entities3D: Set<string | number>;
    modelURL?: string;
    dirty: boolean;
    shadingDirty: boolean;
    centroid?: Position$2;
    positionDirty: boolean;
    /** Cached world-space bounding-box center, updated after each position move */
    localCenter?: Vector3;
    isMerged?: boolean;
  };
  removeEntity(): void;
  constructor(id: string);
  /**
   * Get first child entity of a collection if it's a batched mesh.
   * We use this logic for reading representative per-child state (e.g. color,
   * texture) in getState() because the collection does not directly own a
   * material; the batched mesh does.
   */
  getfirstChildEntityId(): string | number | undefined;
}
//#endregion
//#region ../renderer-three/src/components/interaction.d.ts
declare class InteractionComponent {
  type: "interaction";
  hover: boolean | 'user-interaction';
  dirty: boolean;
}
//#endregion
//#region ../renderer-three/src/systems/batched-mesh/batched-material.d.ts
declare class BatchedStandardMaterial extends MeshLambertMaterial {
  private propertiesTexture;
  texturesVisible: boolean;
  /**
   * Number of PCF shadow samples (compile-time constant for GPU optimization)
   * Valid values: 4, 8, or 16
   */
  private pcfSampleCount;
  private uniforms;
  private colorSpace;
  constructor(params: MeshLambertMaterialParameters, geometryCount: number, scaleFactor?: number);
  /**
   * These control the repeat factor of the texture in the Y direction.
   * So when we scale a geometry, it needs to scale the texture as well.
   * For now this only applies to detached geometries.
   */
  get repeatYFactor(): number;
  set repeatYFactor(value: number);
  get texture(): Texture | null;
  set texture(texture: Texture | null);
  get topTexture(): Texture | null;
  set topTexture(texture: Texture | null);
  get blendTexture(): boolean;
  set blendTexture(value: boolean);
  setGradientShading(start: number, end: number, intensity: number): void;
  getGradientShading(): {
    start: number;
    end: number;
    intensity: number;
  };
  /**
   * Sets the distance-based effect parameters.
   * @param start - World-space Z altitude where effects begin
   * @param distance - Distance in meters below start at which effects reach full strength. 0 = disabled.
   */
  setEffectRange(start: number, distance: number): void;
  /**
   * Gets the current effect range settings
   */
  getEffectRange(): {
    start: number;
    distance: number;
  };
  /**
   * Sets the depth-based visual effect parameters for geometry de-emphasis.
   * @param darkenAmount - Darkening strength towards #333 (0-1)
   * @param darkenUseDepth - Whether darkening varies by depth
   * @param desaturateAmount - Desaturation strength (0-1)
   * @param desaturateUseDepth - Whether desaturation varies by depth
   * @param washOutAmount - Wash out strength towards white (0-1)
   * @param washOutUseDepth - Whether wash out varies by depth
   */
  setVisualEffect(darkenAmount: number, darkenUseDepth: boolean, desaturateAmount: number, desaturateUseDepth: boolean, washOutAmount: number, washOutUseDepth: boolean): void;
  /**
   * Gets the current visual effect settings
   */
  getVisualEffect(): {
    darkenAmount: number;
    darkenUseDepth: number;
    desaturateAmount: number;
    desaturateUseDepth: number;
    washOutAmount: number;
    washOutUseDepth: number;
  };
  setColor(batchId: number, color: Color, topColor: Color): void;
  getColor(batchId: number): {
    color: Color;
    topColor: Color;
  };
  showTextures: (batchId: number) => void;
  hideTextures(batchId: number): void;
  removeSideTexture(batchId: number): void;
  removeTopTexture(batchId: number): void;
  dispose(): void;
  setShadowUniforms(shadowMap: Texture, lightMatrix: Matrix4, cameraNear: number, cameraFar: number, shadowBias: number, shadowOpacity: number, baseColor: Color, shadowMapSize: number, pcfSpread: number, pcfSamples: number, sunDir: Vector3, normalBias: number, depthRangeMax: number, shadowEnabled: boolean): void;
  clone(params?: MeshLambertMaterialParameters): this;
}
//#endregion
//#region ../renderer-three/src/systems/batched-mesh/simple-material.d.ts
/**
 * Single-geometry variant of BatchedStandardMaterial.
 * Uses `uColor`/`uTopColor` uniforms instead of a per-instance data texture,
 * so no DataTexture is allocated. All gradient, shadow, and visual-effect
 * uniforms are identical to BatchedStandardMaterial.
 */
declare class SimpleGeometryMaterial extends MeshLambertMaterial {
  texturesVisible: boolean;
  private pcfSampleCount;
  private uniforms;
  private colorSpace;
  constructor(params?: MeshLambertMaterialParameters);
  /**
   * Sets `color` and `topColor` as uniforms directly (no batchId / data texture).
   */
  setColor(color: Color, topColor: Color): void;
  getColor(): {
    color: Color;
    topColor: Color;
  };
  get texture(): Texture | null;
  set texture(texture: Texture | null);
  get topTexture(): Texture | null;
  set topTexture(texture: Texture | null);
  get blendTexture(): boolean;
  set blendTexture(value: boolean);
  setGradientShading(start: number, end: number, intensity: number): void;
  getGradientShading(): {
    start: number;
    end: number;
    intensity: number;
  };
  setEffectRange(start: number, distance: number): void;
  getEffectRange(): {
    start: number;
    distance: number;
  };
  setVisualEffect(darkenAmount: number, darkenUseDepth: boolean, desaturateAmount: number, desaturateUseDepth: boolean, washOutAmount: number, washOutUseDepth: boolean): void;
  getVisualEffect(): {
    darkenAmount: number;
    darkenUseDepth: number;
    desaturateAmount: number;
    desaturateUseDepth: number;
    washOutAmount: number;
    washOutUseDepth: number;
  };
  get repeatYFactor(): number;
  set repeatYFactor(value: number);
  showTextures: (_batchId: number) => void;
  hideTextures(_batchId: number): void;
  removeSideTexture(_batchId: number): void;
  removeTopTexture(_batchId: number): void;
  setShadowUniforms(shadowMap: Texture, lightMatrix: Matrix4, cameraNear: number, cameraFar: number, shadowBias: number, shadowOpacity: number, baseColor: Color, shadowMapSize: number, pcfSpread: number, pcfSamples: number, sunDir: Vector3, normalBias: number, depthRangeMax: number, shadowEnabled: boolean): void;
}
//#endregion
//#region ../renderer-three/src/components/image.d.ts
declare class EntityMesh$1 extends Mesh {
  userData: {
    entityId: string | number;
  };
}
type ImageStyle = {
  /**
   * Attempt to keep the image facing the camera as much as possible
   */
  flipImageToFaceCamera?: boolean;
  /**
   * url of the image
   */
  url: string;
  /**
   * Maximum image width or height in pixels. If the image's largest dimension
   * exceeds this value, it will be scaled down proportionally.
   * @default 1024
   */
  maxImageSize?: number;
  /**
   * Whether the image is interactive (receives click/hover events).
   * @default false
   */
  interactive?: boolean;
};
type ImageProperties = {
  width: number;
  height: number;
  rotation?: number;
  verticalOffset?: number;
};
/**
 * State representing an Image
 */
type ImageState = {
  readonly id: string | number;
  readonly type: 'image';
  /**
   * The position of the image in [lon, lat]
   */
  readonly position: Position$2;
  /**
   * The offset of the image in the z direction
   */
  readonly verticalOffset: number;
  /**
   * Whether the image is visible
   */
  visible: boolean;
  width: number;
  height: number;
  rotation: number;
  /**
   * Attempt to keep the image facing the camera as much as possible
   */
  flipImageToFaceCamera: boolean;
  /**
   * The opacity of the image
   */
  opacity: number;
  /**
   * Whether the image is interactive (receives click/hover events).
   */
  interactive: boolean;
};
declare class ImageComponent {
  mesh: Geometry3DObject3D;
  imageMesh?: EntityMesh$1;
  outline?: LineSegments;
  readonly type = "image";
  instanceIndex: number;
  geometry?: PlaneGeometry;
  material?: MeshLambertMaterial;
  feature: Feature<Point, ImageProperties>;
  constructor(feature: Feature<Point, ImageProperties>);
  get visible(): boolean;
  set visible(visible: boolean);
  position: Vector3;
}
//#endregion
//#region ../renderer-three/src/components/mesh.d.ts
declare class EntityBatchedMesh extends BatchedMesh {
  type: "entityBatchedMesh";
  userData: {
    entities: {
      [key: number]: string | number;
    };
    detached?: boolean;
  };
}
declare class EntityMergedMesh extends Mesh {
  type: "entityMergedMesh";
}
type MeshComponentProperties = {
  id: string;
  image?: ImageProperties & {
    position: Position;
    path: string;
  };
  textArea?: BaseTextAreaProperties & {
    position: Position;
  };
  textures?: EnterpriseTexture[];
  bevel?: BevelState;
};
/**
 * State representing a Geometry
 */
type GeometryState = {
  readonly id: string | number;
  readonly type: 'geometry';
  /**
   * The position of the geometry in [lon, lat]
   */
  readonly position: Position$2;
  /**
   * The parent group of the geometry
   */
  readonly parent: EntityId$1<FeatureCollectionState>;
  /**
   * Whether the geometry is visible. This is independent of the visibility of the children, but will affect the visibility of the children if set to false.
   */
  visible: boolean;
  /**
   * The initial color of the geometry. This is used to reset the color of the geometry to its initial value.
   */
  initialColor: string;
  /**
   * The color of the geometry
   */
  color: string;
  /**
   * The initial top color of the geometry. This is used to reset the top color of the geometry to its initial value.
   */
  initialTopColor?: string;
  /**
   * The color of geometry faces that are facing up
   */
  topColor?: string;
  /**
   * The color of the geometry when hovered over with a mouse
   */
  hoverColor?: string;
  /**
   * Whether the geometry is interactive, which means it can be hovered over and clicked on.
   *
   * @example
   * ```javascript
   * 	renderer.on('click', ({ geometry }) => {});
   * ```
   */
  interactive: boolean;
  /**
   * Whether the geometry is outlined with a 30% darkened color. This effect adds lines around the geometry to make it stand out.
   */
  outline: boolean;
  /**
   * Show geometry image if present
   */
  showImage: boolean;
  /**
   * Attempt to keep the image facing the camera as much as possible
   */
  flipImageToFaceCamera: boolean;
  /**
   * Whether the anchored image should collide with other images.
   */
  enableImageCollisions: boolean;
  /**
   * Whether the geometry should emit an event when focused on by the center of the camera
   */
  focusable: boolean;
  /**
   * The opacity of the geometry
   */
  opacity: number;
  /**
   * The height of the geometry
   */
  height: number;
  /**
   * The texture URL of the geometry
   */
  texture?: string;
  /**
   * The top texture URL of the geometry
   */
  topTexture?: string;
  /**
   * Whether the geometry is currently in hover state or not
   */
  hovered: boolean;
  /**
   * The render order of the geometry
   */
  renderOrder?: number;
  /**
   * The altitude of the geometry element in meters.
   */
  altitude: number;
  /**
   * The shading of the geometry
   */
  shading?: Shading$1;
  /**
   * The side of the geometry
   */
  side?: MaterialSide;
  /**
   * Bevel configuration for extruded shapes.
   */
  bevel?: BevelState;
  /**
   * TODO: it's annoying that we have to store these here just so that they can be applied from mappedin-js. Let's think about a better way to do this.
   */
  /**
   * Whether the geometry has a border
   */
  borderVisible: boolean;
  /**
   * The color of the border
   */
  borderColor?: string;
  /**
   * The width of the border
   */
  borderWidth?: number;
};
declare class MeshComponent {
  #private;
  mesh?: EntityBatchedMesh | EntityMergedMesh;
  imageMesh?: Mesh;
  /**
   * holds a pointer to space label text if the polygon has label active.
   */
  textMesh?: Text;
  textEntityId?: string;
  readonly type = "geometry";
  dirty: boolean;
  shouldDetach: boolean;
  detached: boolean;
  instanceIndex: number;
  geometry?: BufferGeometry;
  batchedProps?: {
    range: BatchedMeshGeometryRange;
    positionCount: number;
    geometryId: number;
  };
  material?: BatchedStandardMaterial | SimpleGeometryMaterial;
  feature: Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties> | Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties>[];
  currentHeight: number;
  constructor(feature: Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties> | Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties>[]);
  get visible(): boolean;
  set visible(visible: boolean);
  get renderOrder(): number;
  set renderOrder(value: number);
  color: Color;
  topColor: Color;
  setColor(color: string, topColor: string): void;
  getColor(): {
    color: Color;
    topColor: Color;
  } | undefined;
  position: Vector3;
  altitude: number;
  get opacity(): number;
  set opacity(value: number);
  get featureBbox(): BBox;
}
//#endregion
//#region ../renderer-three/src/components/model.d.ts
/**
 * State representing a Model, typically loaded via a URL
 */
type ModelState = {
  readonly id: string;
  readonly type: 'model';
  /**
   * The parent container of the marker
   */
  readonly parent?: EntityId$1<FeatureCollectionState> | string | number;
  /**
   * The position of the model in [lon, lat]
   */
  readonly position: Position$2;
  /**
   * Whether the model is interactive, which means it can be hovered over and clicked on.
   *
   * @example
   * ```javascript
   * 	renderer.on('click', ({ geometry }) => {});
   * ```
   */
  interactive: boolean;
} & Partial<Omit<ModelStyle, 'rotation' | 'scale'>> & Pick<ModelStyle, 'rotation' | 'scale'>;
/**
 * initialize model state
 * @interface
 * Note: EXPERIMENTAL_clippingEnabled and visibleThroughGeometry are now part of ModelStyle
 */
type InitializeModelState$2 = Omit<Partial<ModelState>, 'id' | 'type' | 'parent' | 'position'>;
/**
 * updatable model state
 * @interface
 */
type UpdateModelState = Omit<InitializeModelState$2, 'url'> & {
  position?: Position$2;
};
declare class ModelComponent {
  #private;
  mesh?: Geometry3DObject3D | Group$1;
  readonly type = "model";
  positionDirty: boolean;
  outline?: LineSegments;
  geometry?: Object3D;
  material?: BatchedStandardMaterial;
  feature: Feature<Point, ModelProperties>;
  instanceIndex?: number;
  /**
   * If true, this model uses a regular mesh instead of instancing.
   * Set at creation time based on visibleThroughGeometry or EXPERIMENTAL_clippingEnabled.
   * Cannot be changed at runtime.
   */
  instancingDisabled: boolean;
  constructor(feature: Feature<Point, ModelProperties>);
  get visible(): boolean;
  set visible(value: boolean);
  color: Color;
  clippingPlane?: Plane;
  /**
   * The model scene that was loaded from GLB, minus the hole-fill-mesh business.
   */
  get modelScene(): Object3D<three0.Object3DEventMap> | Geometry3DObject3D | undefined;
  position: Vector3;
  get altitude(): number;
  set altitude(value: number);
  get opacity(): number;
  set opacity(value: number);
  get renderOrder(): number;
  set renderOrder(value: number);
  get visibleThroughGeometry(): boolean;
  set visibleThroughGeometry(value: boolean);
}
//#endregion
//#region ../renderer-three/src/components/path.d.ts
/**
 * @experimental
 * Border configuration for ribbon path geometry.
 */
type BorderConfig = {
  /** Whether the border is enabled */
  enabled: boolean;
  /** Border color - 'darken' to auto-darken main color, or explicit hex color string */
  color: 'darken' | string;
  /** Border width as fraction of total ribbon width (0-0.5). @default 0.1 */
  width?: number;
};
/**
 * @experimental
 * Configuration for the x-ray appearance of paths behind geometry.
 */
type XrayStyleConfig = {
  /** Explicit color override for the x-ray base color. When omitted, uses the path color. Tint is always applied on top. */
  color?: string;
  /** Tint strength (0-1) controlling how much the color is desaturated.
   *  0 = no muting (same as base color), 1 = fully gray. @default 0.2 */
  tint?: number;
  /** Dithering cell size in screen pixels. 0 or undefined = off. */
  dithering?: number;
};
type PathProperties = {
  /**
   * The parentId of the point. The point will be anchored to the altitude of this parent group container.
   */
  parentId?: EntityId$1<GroupContainerState$1> | string | null;
};
/**
 * Updatable path state
 * @interface
 */
type PathUpdateState = Omit<Partial<PathState$1>, 'id' | 'type'>;
/**
 * State representing a Path
 */
type PathState$1 = {
  readonly id: string | number;
  readonly type: 'path';
  /**
   * The position of the path in [lon, lat]
   */
  readonly position: Position$2;
  /**
   * How much the path hovers above the floor plane in meters.
   */
  verticalOffset?: number;
  /**
   * Whether the path is visible.
   */
  visible: boolean;
  /**
   * Whether the path is interactive, which means it can be hovered over and clicked on.
   *
   * @example
   * ```javascript
   * 	renderer.on('click', ({ geometry }) => {});
   * ```
   */
  interactive?: boolean;
  /**
   * The fraction of the path that has been drawn. This can be used to animate the drawing of the path.
   * Note: use values between 0 and 1.
   */
  completeFraction: number;
  /**
   * The color of the path.
   */
  color: string;
  /**
   * The accent color of the path. When arrows are visible, it is applied to them
   */
  accentColor: string;
  /**
   * Display Arrows on Path to indicate direction
   */
  displayArrowsOnPath: boolean;
  /**
   * Arrows on path should animate to indicate direction
   */
  animateArrowsOnPath: boolean;
  /**
   * The width of the path. Can be a number (meters), a pixel string like '20px',
   * or an {@link Interpolation} (meters or pixels).
   */
  width: PathWidth$3;
  /**
   * The fraction of the path that should be highlighted. This can be used to animate the highlight.
   * @default 0
   */
  highlightStartFraction: number;
  highlightEndFraction: number;
  highlightColor: string;
  highlightWidthMultiplier: number;
  highlightCompleteFraction: number;
  /**
   * The opacity of the path when it's behind geometry (x-ray effect). Value from 0 to 1.
   * @default 0.25
   */
  xrayOpacity: number;
  /**
   * @experimental
   * Configuration for x-ray appearance when path is behind geometry.
   */
  xrayStyle?: XrayStyleConfig;
  /**
   * The fraction of the path that has been travelled. This is used to indicate how far the user has walked along the path.
   * Note: use values between 0 and 1.
   * @default 0
   */
  travelledEndFraction: number;
  /**
   * The color of the travelled portion of the path.
   * @default '#999'
   */
  travelledColor: string;
  /**
   * Controls the smoothness of path corners using CatmullRom curve tension. Higher values create smoother curves.
   * Values between 0.1-0.3 provide subtle smoothing suitable for most use cases.
   */
  smoothingTension: number;
  /**
   * Distance in meters from corners where control points are inserted for smoothing. Higher values create smoother curves around corners.
   * Only applies when smoothingTension > 0.
   */
  smoothingCornerRadius: number;
  /**
   * Whether the path should be rendered as a dashed line.
   */
  dashed: boolean;
  /**
   * Length of each dash segment as fraction of path (0-1).
   */
  dashLength: number;
  /**
   * Length of each gap between dashes as fraction of path (0-1).
   */
  dashGap: number;
  /**
   * When true, dashSize and gapSize are interpreted as multiples of path width.
   * When false, dashLength and dashGap are used as fractions of path length.
   */
  dashRelativeToWidth: boolean;
  /**
   * Length of each dash as a multiple of path width. Only used when dashRelativeToWidth is true.
   */
  dashSize: number;
  /**
   * Length of each gap as a multiple of path width. Only used when dashRelativeToWidth is true.
   */
  gapSize: number;
  /**
   * When true, dashMeters and gapMeters are used as absolute sizes in meters.
   * Takes precedence over dashRelativeToWidth.
   */
  dashAbsolute: boolean;
  /**
   * Length of each dash in meters. Only used when dashAbsolute is true.
   */
  dashMeters: number;
  /**
   * Length of each gap in meters. Only used when dashAbsolute is true.
   */
  gapMeters: number;
  /**
   * @experimental
   * Geometry type for path rendering.
   * @default 'tube'
   */
  __EXPERIMENTAL_GEOMETRY: 'tube' | 'ribbon';
  /**
   * @experimental
   * Endcap extension for ribbon geometry as [start, end] tuple in meters.
   * - Value > 0: extends path and renders rounded cap
   * - Value = 0: square/flat end (no extension, no rounded cap)
   * @default [0.5, 0.5]
   */
  __EXPERIMENTAL_ENDCAP_EXTENSION: [number, number];
  /**
   * @experimental
   * When true and using ribbon geometry, the path will always face the camera (billboard effect).
   * Most useful for vertical paths between floors.
   * @default false
   */
  __EXPERIMENTAL_BILLBOARDING: boolean | number;
  /**
   * @experimental
   * Border configuration for ribbon path geometry.
   * Renders darkened edges along both sides of the ribbon.
   */
  __EXPERIMENTAL_BORDER?: BorderConfig;
  /**
   * @experimental
   * When true, prevents the xray path from rendering multiple overlapping pixels
   * when the path crosses over itself. Uses stencil buffer to ensure single-pixel rendering.
   * @default false
   */
  __EXPERIMENTAL_PREVENT_SELF_OVERLAP?: boolean;
};
type AddPathOptions = {
  /**
   * Whether the Path should be clickable.
   * @default false
   */
  interactive?: boolean;
  /**
   * @internal
   */
  id?: string | number;
  /**
   * The width of the path.
   * - `number` — meters (e.g. `1.5`)
   * - `'Npx'` — screen-space pixels (e.g. `'20px'`)
   * - `Interpolation` — zoom-interpolated meters
   * - `Interpolation<'zoom-level', PixelWidth[]>` — zoom-interpolated pixels (e.g. `output: ['10px', '20px']`)
   *
   * @default Interpolation { on: 'zoom-level', input: [17, 22], output: [0.8, 0.4] }
   */
  width?: PathWidth$3;
  /**
   * The color of the path.
   */
  color?: string;
  /**
   * The accent color of the path. When arrows are visible, it is applied to them
   */
  accentColor?: string;
  /**
   * Display Arrows on Path to indicate direction
   */
  displayArrowsOnPath?: boolean;
  /**
   * Arrows on path should animate to indicate direction
   */
  animateArrowsOnPath?: boolean;
  /**
   * Whether the path should be visible through geometry.
   */
  visibleThroughGeometry?: boolean;
  /**
   * Whether the path should be dashed.
   */
  dashed?: boolean;
  /**
   * How much the path hovers above the floor plane in meters.
   */
  verticalOffset?: number;
  /**
   * The fraction of the path that should be highlighted. This can be used to animate the highlight.
   * @default 0
   */
  highlightStartFraction?: number;
  highlightEndFraction?: number;
  highlightColor?: string;
  highlightWidthMultiplier?: number;
  highlightCompleteFraction?: number;
  /**
   * The opacity of the path when it's behind geometry (x-ray effect). Value from 0 to 1.
   * @default 0.25
   */
  xrayOpacity?: number;
  /**
   * @experimental
   * Configuration for x-ray appearance when path is behind geometry.
   */
  xrayStyle?: XrayStyleConfig;
  /**
   * The fraction of the path that has been travelled. This is used to indicate how far the user has walked along the path.
   * Note: use values between 0 and 1.
   * @default 0
   */
  travelledEndFraction?: number;
  /**
   * The color of the travelled portion of the path.
   * @default '#999'
   */
  travelledColor?: string;
  /**
   * Controls the smoothness of path corners using CatmullRom curve tension. Higher values create smoother curves.
   * Values between 0.1-0.3 provide subtle smoothing suitable for most use cases.
   * @default 0.0
   */
  smoothingTension?: number;
  /**
   * Distance in meters from corners where control points are inserted for smoothing. Higher values create smoother curves around corners.
   * Only applies when smoothingTension > 0. Typical values are 0.5-2.0 meters for subtle smoothing.
   * @default 0.0
   */
  smoothingCornerRadius?: number;
  /**
   * Length of each dash segment as fraction of path (0-1).
   * @default 0.1
   */
  dashLength?: number;
  /**
   * Length of each gap between dashes as fraction of path (0-1).
   * @default 0.1
   */
  dashGap?: number;
  /**
   * When true, dashSize and gapSize are interpreted as multiples of path width (deck.gl style).
   * When false (default), dashLength and dashGap are used as fractions of path length.
   * @default false
   */
  dashRelativeToWidth?: boolean;
  /**
   * Length of each dash as a multiple of path width. Only used when dashRelativeToWidth is true.
   * @default 3.0
   */
  dashSize?: number;
  /**
   * Length of each gap as a multiple of path width. Only used when dashRelativeToWidth is true.
   * @default 2.0
   */
  gapSize?: number;
  /**
   * When true, dashMeters and gapMeters are used as absolute sizes in meters.
   * Takes precedence over dashRelativeToWidth.
   * @default false
   */
  dashAbsolute?: boolean;
  /**
   * Length of each dash in meters. Only used when dashAbsolute is true.
   * @default 1.0
   */
  dashMeters?: number;
  /**
   * Length of each gap in meters. Only used when dashAbsolute is true.
   * @default 0.5
   */
  gapMeters?: number;
  /**
   * @experimental
   * Geometry type for path rendering.
   * @default 'tube'
   */
  __EXPERIMENTAL_GEOMETRY?: 'tube' | 'ribbon';
  /**
   * @experimental
   * Endcap extension for ribbon geometry as [start, end] tuple in meters.
   * - Value > 0: extends path and renders rounded cap
   * - Value = 0: square/flat end (no extension, no rounded cap)
   * @default [0.5, 0.5]
   */
  __EXPERIMENTAL_ENDCAP_EXTENSION?: [number, number];
  /**
   * @experimental
   * When true and using ribbon geometry, the path will always face the camera (billboard effect).
   * Most useful for vertical paths between floors.
   * @default false
   */
  __EXPERIMENTAL_BILLBOARDING?: boolean | number;
  /**
   * @experimental
   * Border configuration for ribbon path geometry.
   * Renders darkened edges along both sides of the ribbon.
   */
  __EXPERIMENTAL_BORDER?: BorderConfig;
  /**
   * @experimental
   * When true, prevents the xray path from rendering multiple overlapping pixels
   * when the path crosses over itself. Uses stencil buffer to ensure single-pixel rendering.
   * @default false
   */
  __EXPERIMENTAL_PREVENT_SELF_OVERLAP?: boolean;
};
declare class PathComponent {
  #private;
  readonly type = "path";
  mesh: PatMeshContainer;
  material?: PathMaterial;
  geometry?: BufferGeometry;
  outline?: LineSegments;
  feature: FeatureCollection<Point, PathProperties>;
  options: AddPathOptions;
  width: PathWidth$3;
  breakpoint: number;
  /** Whether width is in screen-space pixels (derived from width value). */
  screenSpace: boolean;
  /** Pre-parsed numeric output values for interpolated widths. Avoids parseFloat on every frame. */
  parsedOutputValues: number[];
  altitudeBreakpoints?: number[];
  accentColor: string;
  completeFraction: number;
  altitudeAdjustment: number;
  displayArrowsOnPath: boolean;
  animateArrowsOnPath: boolean;
  visibleThroughGeometry: boolean;
  highlightStartFraction: number;
  highlightEndFraction: number;
  highlightCompleteFraction: number;
  highlightWidthMultiplier: number;
  highlightColor: string;
  xrayOpacity: number;
  xrayStyle?: XrayStyleConfig;
  travelledEndFraction: number;
  travelledColor: string;
  dashed: boolean;
  smoothingTension: number;
  smoothingCornerRadius: number;
  dashLength: number;
  dashGap: number;
  dashRelativeToWidth: boolean;
  dashSize: number;
  gapSize: number;
  dashAbsolute: boolean;
  dashMeters: number;
  gapMeters: number;
  __EXPERIMENTAL_GEOMETRY: 'tube' | 'ribbon';
  __EXPERIMENTAL_ENDCAP_EXTENSION: [number, number];
  __EXPERIMENTAL_BILLBOARDING: boolean | number;
  __EXPERIMENTAL_BORDER?: BorderConfig;
  __EXPERIMENTAL_PREVENT_SELF_OVERLAP: boolean;
  /**
   * If the path is vertical it will be rebuilt whenever altitudeDirty = true. This will be set during the first render of the path.
   */
  isVertical: boolean;
  dirty: boolean;
  materialDirty: boolean;
  constructor(feature: FeatureCollection<Point, PathProperties>, options?: AddPathOptions);
  updateScreenSpaceState(): void;
  setColor(): void;
  setOpacity(): void;
  set visible(visible: boolean);
  get visible(): boolean;
  position: Vector3;
  get altitude(): number;
  set altitude(value: number);
  set complete(value: number);
}
//#endregion
//#region ../renderer-three/src/components/custom.d.ts
/**
 * Represents the state of a custom shape.
 */
type ShapeState = {
  /**
   * The unique identifier of the shape.
   */
  readonly id: string;
  /**
   * The type of the shape, which is always 'custom-geometry'.
   */
  readonly type: 'custom-geometry';
  /**
   * The position of the geometry in [longitude, latitude].
   */
  readonly position: Position$2;
  /**
   * Whether the geometry is visible.
   */
  visible?: boolean;
  /**
   * The altitude of the geometry, in meters.
   */
  altitude?: number;
  /**
   * The color of the shape.
   */
  color: string;
  /**
   * The opacity of the shape.
   */
  opacity: number;
  /**
   * The parent container of the geometry.
   */
  readonly parent: EntityId$1<GroupContainerState$1> | string | number;
  /**
   * Whether the geometry is interactive.
   */
  interactive?: boolean;
};
type CustomGeometryBuilder = {
  /**
   * A setup function that is called once when the geometry is created
   */
  setup: (object: Object3D) => void;
  /**
   *  An update function that is called every render frame.
   *
   *  Note: do not create new objects in this function, and only update the object's children
   *  Note 2: calling `render` or `setState` in this method will result in a render loop, so avoid if possible
   */
  update: (object: Object3D) => void;
};
declare class CustomGeometryComponent {
  #private;
  mesh: Geometry3DObject3D;
  readonly type = "custom-geometry";
  dirty: boolean;
  feature: Feature<Point>;
  builder: CustomGeometryBuilder;
  outline?: LineSegments;
  constructor(feature: Feature<Point>, builder: CustomGeometryBuilder);
  get visible(): boolean;
  set visible(value: boolean);
  set opacity(value: number);
  get opacity(): number;
  color: Color;
  setColor(color: string): void;
  get position(): three0.Vector3;
  get altitude(): number;
  set altitude(value: number);
  get renderOrder(): number;
  set renderOrder(value: number);
}
//#endregion
//#region ../renderer-three/src/components/text3d.d.ts
/**
 * State representing an Text3D
 */
type Text3DState$1 = {
  readonly id: string | number;
  readonly type: 'text3d';
  /**
   * The position of the Text3D in [lon, lat, altitude]
   */
  readonly position: Position$2;
  /**
   * Whether the Text3D is visible
   */
  visible: boolean;
  /**
   * Attempt to keep the Text3D facing the camera as much as possible
   */
  flipToFaceCamera: boolean;
  /**
   * Content of the text3d
   */
  content: string;
  /**
   * Rotation of the text in degrees clockwise from North.
   */
  readonly rotation: number;
} & Text3DStyle;
/**
 * @interface
 */
type InitializeText3DState$1 = Partial<Omit<Text3DState$1, 'id' | 'type'>>;
/**
 * At this moment updating text margin, rotation, and content are not supported.
 * @interface
 */
type UpdatableText3DState = Omit<InitializeText3DState$1, 'margin' | 'position' | 'content' | 'rotation'>;
type Text3DProperties = {
  id: string;
  content: string;
  textArea?: MeshComponentProperties['textArea'];
};
/**
 * Options for labeling a geometry with 3D text.
 */
type AddText3DOptions$2 = {
  appearance?: Partial<InitializeText3DState$1>;
};
declare class Text3DComponent {
  mesh: Geometry3DObject3D;
  textMesh?: Text$1;
  readonly type = "text3d";
  feature: Feature<Point, Text3DProperties | (FloorTextCommonProperties & {
    verticalOffset: number;
  })>;
  constructor(feature: Feature<Point, Text3DProperties | (FloorTextCommonProperties & {
    verticalOffset: number;
  })>);
  get visible(): boolean;
  set visible(visible: boolean);
  parent?: GroupContainerObject3D;
  batchedText?: BatchedText$1;
  /**
   * if this Text3DComponent is a polygon label, populate this id with the polygon entity id
   * This id is used to prevent drawing text for the same polygon.
   */
  polygonEntityId?: string;
}
//#endregion
//#region ../renderer-three/src/components/outline.d.ts
type Outline = {
  color: string;
  dirty: boolean;
  enabled: boolean;
  edgeColors?: BufferAttribute;
  ranges?: {
    start: number;
    count: number;
  };
  geometry?: BufferGeometry;
  currentOpacity: number;
  currentColor: [number, number, number];
  topFaceVerticesIndices?: number[];
  visible: boolean;
};
declare class OutlineComponent implements Outline {
  #private;
  readonly type: "outline";
  color: string;
  dirty: boolean;
  /** Controls whether the outline should be updated in the renderer */
  enabled: boolean;
  edgeColors?: BufferAttribute;
  edgeVisibility?: BufferAttribute;
  geometry?: BufferGeometry;
  ranges?: {
    start: number;
    count: number;
  };
  topFaceVerticesIndices?: number[];
  get currentOpacity(): number;
  /**
   * Sets the visibility of the outline.
   */
  set visible(visible: boolean);
  /**
   * Gets the visibility of the outline.
   */
  get visible(): boolean;
  get currentColor(): [number, number, number];
  constructor(color: string);
}
//#endregion
//#region ../renderer-three/src/components/focusable.d.ts
declare class FocusableComponent {
  readonly type: "focusable";
  dirty: boolean;
  /**
   * Vertices of the geometry in world space
   */
  vertices?: Vector3[];
  /**
   * Bounding box computed from object for frustum culling
   */
  boundingBox: Box3;
}
//#endregion
//#region ../renderer-three/src/components/texture.d.ts
type TextureStyle = {
  texture?: SingleTexture;
  topTexture?: SingleTexture;
  showTexture: boolean;
  showTopTexture: boolean;
  textureInstance?: Texture;
  topTextureInstance?: Texture;
  dirty: boolean;
};
type SingleTexture = {
  repeat?: {
    u: number;
    v: number;
  };
  offset?: {
    u: number;
    v: number;
  };
  rotation?: number;
  path: string;
  surface?: 'inside' | 'outside' | 'both';
  bounds?: [number, number, number, number];
};
declare class TextureComponent implements TextureStyle {
  readonly type: "texture";
  texture?: SingleTexture;
  topTexture?: SingleTexture;
  showTexture: boolean;
  showTopTexture: boolean;
  textureInstance?: Texture;
  topTextureInstance?: Texture;
  dirty: boolean;
  constructor(texture?: SingleTexture | string, topTexture?: SingleTexture | string);
}
//#endregion
//#region ../renderer-three/src/components/border.d.ts
type Border = {
  dirty: boolean;
  visible: boolean;
  mesh?: Object3D;
  needsRebuild: boolean;
};
declare class BorderComponent implements Border {
  readonly type: "border";
  dirty: boolean;
  needsRebuild: boolean;
  set visible(visible: boolean);
  get visible(): boolean;
  mesh?: Object3D;
}
//#endregion
//#region ../renderer-three/src/components/clipping-plane.d.ts
type ClippingPlane = {
  dirty: boolean;
  verticalOffset: number;
  plane?: Plane;
  holeFillMesh?: Mesh;
  topColor?: string;
  needsRebuild: boolean;
  topVisible?: boolean;
};
declare class ClippingPlaneComponent implements ClippingPlane {
  readonly type: "clippingPlane";
  dirty: boolean;
  needsRebuild: boolean;
  verticalOffset: number;
  plane?: Plane;
  holeFillMesh?: Mesh;
  topColor?: string;
  topVisible: boolean;
}
//#endregion
//#region ../renderer-three/src/entities/geometry3d.d.ts
type Geometry3DObjectTypes = 'geometry' | 'path' | 'model' | 'custom-geometry' | 'image' | 'text3d';
declare class Geometry3DObject3D extends Object3D {
  type: Geometry3DObjectTypes;
  userData: {
    entityId: string;
    type: Geometry3DObjectTypes;
    /** Whether this is a detached instance (separate mesh for opacity support) */
    detached?: boolean;
    /** Whether this is a non-instanced model (regular mesh) */
    nonInstanced?: boolean;
    /** Opacity for shared model batches */
    sharedOpacity?: number;
  };
  components: never[];
  /**
   * Custom raycast implementation for model objects only.
   * This selectively enables recursive raycasting just for models, which have complex hierarchies,
   * while avoiding the performance cost of recursive raycasting for other object types.
   */
  raycast(raycaster: Raycaster, intersects: any[]): void;
}
type PathMaterial = ShaderMaterial & {
  uniforms: PathUniforms;
};
type PathMesh = Mesh<TubeGeometry | BufferGeometry, PathMaterial, Object3DEventMap>;
declare class PatMeshContainer extends Geometry3DObject3D {
  children: [PathMesh, PathMesh];
}
type MeshComponentTypes = MeshComponent | PathComponent | ModelComponent | CustomGeometryComponent | Text3DComponent | ImageComponent;
type MappedComponentType<M$1> = M$1 extends MeshComponent ? 'geometry' : M$1 extends PathComponent ? 'path' : M$1 extends ModelComponent ? 'model' : M$1 extends CustomGeometryComponent ? 'custom-geometry' : M$1 extends ImageComponent ? 'image' : M$1 extends Text3DComponent ? 'text3d' : never;
type ComponentTypeMap$1 = {
  interaction: InteractionComponent;
  geometry: MeshComponent;
  path: PathComponent;
  model: ModelComponent;
  'custom-geometry': CustomGeometryComponent;
  image: ImageComponent;
  text3d: Text3DComponent;
  style: StyleComponent;
  text3dStyle: Text3DStyleComponent;
  modelStyle: ModelStyleComponnet;
  outline: OutlineComponent;
  focusable: FocusableComponent;
  texture: TextureComponent;
  border: BorderComponent;
  clippingPlane: ClippingPlaneComponent;
};
declare class Geometry3D<M$1 extends MeshComponentTypes = MeshComponent, S extends StyleComponent | Text3DStyleComponent | ModelStyleComponnet = StyleComponent, I extends InteractionComponent = InteractionComponent, T$1 extends MappedComponentType<M$1> = MappedComponentType<M$1>, O extends OutlineComponent | undefined = OutlineComponent | undefined, F$1 extends FocusableComponent | undefined = FocusableComponent | undefined, TX extends TextureComponent | undefined = TextureComponent | undefined, B extends BorderComponent | undefined = BorderComponent | undefined, C extends ClippingPlaneComponent | undefined = ClippingPlaneComponent | undefined> {
  id: string | number;
  components: [M$1, S, I?, O?, F$1?, B?, TX?, C?];
  getComponent<K$1 extends keyof ComponentTypeMap$1>(type: K$1): ComponentTypeMap$1[K$1] | undefined;
  /**
   * Parent geometry group ID
   */
  parentId?: string | number;
  get object3d(): M$1["mesh"];
  get parentObject3D(): GroupContainerObject3D | FeatureCollectionObject3D | null;
  type: T$1;
  entities2D: Map<string | number, Geometry2D>;
  constructor(meshComponent: M$1, styleComponent: S);
  /** Attaching a 2D entity to the 3D entity so it will follow the style changes */
  attach(entity: Geometry2D): void;
  detach(entity: Geometry2D): void;
  removeAllEntities(): void;
}
type TextGeometry3D = Geometry3D<Text3DComponent, Text3DStyleComponent, InteractionComponent, 'text3d'>;
type CustomGeometry3D = Geometry3D<CustomGeometryComponent, StyleComponent, InteractionComponent, 'custom-geometry'>;
type ModelGeometry3D = Geometry3D<ModelComponent, ModelStyleComponnet, InteractionComponent, 'model'>;
type PathGeometry3D = Geometry3D<PathComponent, StyleComponent, InteractionComponent, 'path'>;
type ImageGeometry3D = Geometry3D<ImageComponent, StyleComponent, InteractionComponent, 'image'>;
type MeshGeometry3D = Geometry3D<MeshComponent, StyleComponent, InteractionComponent, 'geometry'>;
type Geometry3DTypes = TextGeometry3D | CustomGeometry3D | PathGeometry3D | ImageGeometry3D | MeshGeometry3D | ModelGeometry3D;
interface PathUniforms {
  vertexes: {
    type: 'f';
    value: number;
  };
  resolution: {
    type: 'v2';
    value: Vector2;
  };
  cameraParameters: {
    type: 'v2';
    value: Vector2;
  };
  complete: {
    type: 'f';
    value: number;
  };
  color: {
    type: 'c';
    value: Color;
  };
  pathLength: {
    type: 'f';
    value: number;
  };
  nearRadius: {
    type: 'f';
    value: number;
  };
  farRadius: {
    type: 'f';
    value: number;
  };
  nearZoom: {
    type: 'f';
    value: number;
  };
  farZoom: {
    type: 'f';
    value: number;
  };
  pulseColor: {
    type: 'c';
    value: Color;
  };
  pulse: {
    type: 'f';
    value: number;
  };
  pulseLength: {
    type: 'f';
    value: number;
  };
  pathIsVertical: {
    type: 'b';
    value: boolean;
  };
  arrowAnimationTimer: {
    type: 'f';
    value: number;
  };
  arrowTexture: {
    type: 't';
    value: Texture;
  };
  displayArrowsOnPath: {
    type: 'b';
    value: boolean;
  };
  showPulse: {
    type: 'b';
    value: boolean;
  };
  opacityMultiplier: {
    type: 'f';
    value: number;
  };
  dashed: {
    type: 'b';
    value: boolean;
  };
  xrayDithering: {
    type: 'f';
    value: number;
  };
  highlightStartFraction: {
    type: 'f';
    value: number;
  };
  highlightEndFraction: {
    type: 'f';
    value: number;
  };
  highlightCompleteFraction: {
    type: 'f';
    value: number;
  };
  highlightColor: {
    type: 'c';
    value: Color;
  };
  highlightWidthMultiplier: {
    type: 'f';
    value: number;
  };
  travelledEndFraction: {
    type: 'f';
    value: number;
  };
  travelledColor: {
    type: 'c';
    value: Color;
  };
  dashLength: {
    type: 'f';
    value: number;
  };
  dashGap: {
    type: 'f';
    value: number;
  };
  dashRelativeToWidth: {
    type: 'b';
    value: boolean;
  };
  dashSize: {
    type: 'f';
    value: number;
  };
  gapSize: {
    type: 'f';
    value: number;
  };
  dashAbsolute: {
    type: 'b';
    value: boolean;
  };
  dashMeters: {
    type: 'f';
    value: number;
  };
  gapMeters: {
    type: 'f';
    value: number;
  };
  isRibbon: {
    type: 'b';
    value: boolean;
  };
  billboardThreshold: {
    type: 'f';
    value: number;
  };
  borderEnabled: {
    type: 'b';
    value: boolean;
  };
  borderColor: {
    type: 'c';
    value: Color;
  };
  borderWidth: {
    type: 'f';
    value: number;
  };
  borderUseDarken: {
    type: 'b';
    value: boolean;
  };
  endcapEnabled: {
    type: 'v2';
    value: Vector2;
  };
  cameraViewMatrix: {
    type: 'm4';
    value: Matrix4;
  };
  screenSpace: {
    type: 'b';
    value: boolean;
  };
  metersPerPixel: {
    type: 'f';
    value: number;
  };
}
//#endregion
//#region ../renderer-three/src/services/renderer.d.ts
type TRendererOptions = Partial<{
  canvas: HTMLCanvasElement | OffscreenCanvas;
  antialias: boolean;
  backgroundColor: string;
  backgroundAlpha: number;
  alpha: boolean;
  onWebGLRendererError: (e: Error) => void;
  xRayPath: boolean;
  onWebGLContextCreationError: (e: Event) => void;
  onWebGLContextLost: (e: Event) => void;
  onWebGLContextRestored: (e: Event) => void;
}>;
declare class Renderer {
  backgroundAlpha: number;
  backgroundColor: Color;
  width: number;
  height: number;
  options: TRendererOptions;
  renderer?: WebGLRenderer;
  constructor(renderOptions: TRendererOptions);
  /**
   * Dispose of the renderer and its buffers.
   */
  destroy(): void;
  enabledLayers: Set<number>;
  private matricesUpdatedThisFrame;
  /**
   * Indicate that a new frame is starting, so we can reset the matrices updated flag
   */
  startFrame(): void;
  /**
   * Per frame, we can call this function many times, but it should only fire once
   */
  private updateMatricesIfNeeded;
  /**
   * Render a custom scene
   */
  renderScene(scene: Scene, sceneCamera: Camera$1): void;
  /**
   * Re-render the scene, depending on which parts of the scene have been
   * invalidated.
   *
   * @method render
   * @param renderTarget {null or WebGLRenderTarget}
   * @param scene {Scene}
   * @param sceneCamera {Camera}
   */
  renderFullScene(scene: Scene, sceneCamera: Camera$1): void;
  clear(): void;
  /**
   * Set the size of the renderer, composer, and all its internal buffers.
   *
   * @method setBufferSize
   * @param width {number}
   * @param height {number}
   */
  setBufferSize(width: number, height: number): void;
  /**
   * Set the color and opacity that will be drawn behind the scene.
   *
   * @method setBackgroundColor
   * @param color {Color}
   * @param alpha {number}
   */
  setBackgroundColor(color: any, alpha: any): void;
  domElement(): HTMLCanvasElement | undefined;
  handleWebGLContextCreationError: (event: Event) => void;
  /**
   * The browser only fires the subsequent `webglcontextrestored` event if
   * the page calls `preventDefault()` on the `webglcontextlost` event.
   * Without this, after the GPU drops the context (e.g. iOS backgrounding,
   * thermal pressure, or another canvas exhausting the per-process WebGL
   * context budget), the canvas stays in a permanently lost state and any
   * subsequent draws produce garbage geometry.
   *
   * See: https://registry.khronos.org/webgl/specs/latest/1.0/#5.15.2
   */
  handleWebGLContextLost: (event: Event) => void;
  handleWebGLContextRestored: (event: Event) => void;
}
//#endregion
//#region ../renderer-three/src/systems/interactions/tap-controller.d.ts
declare enum TapType {
  onefinger = 0,
  twofinger = 1,
}
declare class Tap {
  type: TapType;
  event: PointerEvent;
  constructor(event: PointerEvent);
  get timestamp(): number;
}
declare class TapsController {
  private taps;
  add(tap: Tap): void;
  get lastPointerDown(): Tap | undefined;
  get isSingleTapWithTwoFingers(): boolean;
  get isSingleTapWithOneFinger(): boolean;
  get isDoubleTapWithOneFinger(): boolean;
  get isSingleTap(): boolean;
  get isDoubleTap(): boolean;
  discardOutsideOfWaitWindow(timestamp: number): void;
  flush(): void;
  get _taps(): Tap[];
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/interactions/system.d.ts
type InteractionPayload = {
  entity2D: Geometry2D[];
  entity3D?: Geometry3D;
  position?: Vector3;
  groupContainers?: GroupContainerObject3D[];
  pointerEvent: Pick<PointerEvent, 'button'>;
};
type InteractionEvents = {
  click: InteractionPayload;
  hover: Omit<InteractionPayload, 'pointerEvent'>;
  'singletap-with-twofinger': PointerEvent;
  'doubletap-with-onefinger': PointerEvent;
};
type CursorTypes = 'grabbing' | 'grab' | 'pointer';
type InteractionState = {
  distanceFromMouseDown: number | undefined;
  isPanning: boolean;
  mouseDownStart: {
    time: number;
    timestamp: number;
    offsetX: number;
    offsetY: number;
  } | undefined;
};
/**
 * TODO: touch support
 */
declare class InteractionSystem extends PubSub<InteractionEvents> {
  raycaster: Raycaster;
  private state;
  private coreState;
  private camera;
  private worldPlane;
  _quadtree: QuadTree<{
    entityId: Geometry2D['id'];
  }>;
  _container: HTMLCanvasElement;
  private lastPointerEvent?;
  private cursor;
  private touchesCount;
  private isUserMovingCamera;
  constructor(container: HTMLCanvasElement, coreState: RendererState, camera: PerspectiveCamera, worldPlane: Mesh, isUserMovingCamera: () => boolean);
  updateQuadtree(takeIT: QuadTree<{
    entityId: Geometry2D['id'];
  }>): void;
  setHovered3DEntityInteractionComponentDirty(): void;
  hasTouched: boolean;
  private onPointerMove;
  tapsControl: TapsController;
  getThreeDIntersectsFromXY(point: Vector2): Intersection<Object3D<Object3DEventMap>>[];
  getGroupContainerIntersectsFromXY(point: Vector2): any;
  private onPointerDown;
  private clickTimeout;
  private onPointerUp;
  private flush;
  handleHover(e?: PointerEvent): void;
  private handleCursor;
  private detect2DEntityHover;
  private handleClick;
  dirty3D: boolean;
  private cachedHitBoxes;
  get _hitBoxes(): {
    entities: (Object3D | EntityMesh<Geometry3D> | EntityBatchedMesh)[];
  };
  private ndcPoint;
  private intersect;
  private detect3DEntityHover;
  private detect3DContainerHover;
  private updateInteractionStateIfPanning;
  getMouseRayIntersects(): Intersection<Object3D<Object3DEventMap>>[];
  destroy(): void;
  debugPanel: HTMLDivElement | undefined;
  enableDebug(): void;
  get _state(): {
    hovered3DEntity: Geometry3D | undefined;
    hovered2DEntities: Set<string | number>;
    hovered3DContainers: GroupContainerObject3D[] | undefined;
    lastHover: Geometry3D | undefined;
    interaction: InteractionState;
  };
  private queueDebugMessage;
  /**
   * Get the current cursor type determined by the interaction.
   */
  getCursor(): CursorTypes;
}
//#endregion
//#region ../renderer-three/src/systems/exporter/exporter.d.ts
type GLTFExportOptions = {
  onlyVisible?: boolean;
  binary?: boolean;
  scale?: number;
  light?: boolean;
};
/**
 * Class for exporting a three.js scene as a GLTF file.
 */
declare class ExporterSystem {
  #private;
  /**
   * @hidden
   */
  constructor(state: RendererState);
  /**
   * Exports the current scene as a GLTF file.
   * @param {GLTFExportOptions} userOptions - User-defined options for exporting.
   * @returns {Promise<Blob>} - A promise that resolves to a Blob containing the GLTF data.
   */
  getCurrentSceneGLTF: (userOptions: GLTFExportOptions) => Promise<Blob>;
  /**
   * Cleans up resources used by the ExporterSystem.
   */
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/batched-mesh/system.d.ts
declare class BatchedMeshSystem extends PubSub<{
  'geometry-2d-added': void;
  'geometry-group-added': void;
}> {
  #private;
  state: RendererState;
  convertTo3DMapPosition: any;
  constructor(state: RendererState, convertTo3DMapPosition: any);
  createEntityFromFeature(id: string | number, featureOrFeatures: Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties> | Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties>[], style?: (LineStyle$2 | PaintStyle$2) & {
    focusable?: boolean;
  }): Geometry3D<MeshComponent, StyleComponent, InteractionComponent, "geometry", OutlineComponent | undefined, FocusableComponent | undefined, TextureComponent | undefined, BorderComponent | undefined, ClippingPlaneComponent | undefined>;
  populateEntityMesh(entity: Geometry3D, geometry: BufferGeometry, isMerged?: boolean): void;
  populateEntityGroup(entities: Set<string | number>): Set<string | number>;
  update(): Promise<void>;
}
//#endregion
//#region ../renderer-three/src/systems/draw/system.d.ts
declare class DrawSystem {
  state: RendererState;
  /**
   * Flag to indicate that any geometry has gone from zero to non zero opacity
   */
  transparencyChanged: boolean;
  convertTo3DMapPosition: (position: Position$2) => Vector3;
  convert3DMapPositionToCoordinate: (v: Vector3) => Position$2;
  constructor(state: RendererState, convertTo3DMapPosition: (position: Position$2) => Vector3, convert3DMapPositionToCoordinate: (v: Vector3) => Position$2);
  determineTextureVisiblity(meshComponent: MeshComponent, textureComponent: TextureComponent, interactionComponent?: InteractionComponent): void;
  update(): void;
  endFrame: () => void;
}
//#endregion
//#region ../renderer-three/src/systems/render/system.d.ts
declare class RenderSystem extends PubSub<{
  'measure-canvas': undefined;
  'pre-render': undefined;
  'post-render': undefined;
  'camera-state-change': undefined;
}> {
  private state;
  private renderer;
  private mode;
  private scene;
  private cameraObject;
  private viewCamera;
  private systems;
  constructor(renderer: Renderer, state: RendererState, mode: Core['mode'], scene: Scene, cameraObject: PerspectiveCamera, viewCamera: Camera$1, systems: Systems);
  twoDdirty: boolean;
  threeDdirty: boolean;
  private frameId;
  update: (sync?: boolean) => Promise<any>;
  /** Paint to screen */
  private paint;
  private commitRenderState;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/camera/constants.d.ts
declare const EVENTS: readonly ["change", "pan-start", "pan-end", "rotate-start", "rotate-end", "zoom-start", "zoom-end", "multi-start", "multi-end", "multi-cancel", "pedestal-start", "pedestal-change", "pedestal-end", "user-pan-start", "user-pedestal-start", "user-rotate-start", "user-dolly-start", "user-zoom-start", "user-tilt-start", "user-pan-end", "user-pedestal-end", "user-rotate-end", "user-dolly-end", "user-zoom-end", "user-tilt-end", "position-updated", "zoom-updated", "tilt-updated", "rotation-updated"];
//#endregion
//#region ../renderer-three/src/systems/camera/types.d.ts
type AnimateCameraTarget = {
  position?: {
    x?: number;
    y?: number;
    z?: number;
  };
  zoom?: number;
  tilt?: number;
  rotation?: number;
  doNotAutoStart?: boolean;
};
type CameraControlsOptions = {
  mode: Core['mode'];
  canvasHeight: number;
  canvasWidth: number;
};
type CameraFocusOnOptions = {
  /**
   * The duration (in ms) the focus animation should last for.
   * @defaultValue `100`
   */
  duration?: number;
  /**
   * The animation curve to use for zooming in. Uses the animateCamera one by default.
   */
  curve?: (n: number) => number;
  /**
   * Camera tilt between 0 (top-down) to 1 (from the side)
   */
  tilt?: number;
  /**
   * Rotation in degrees
   */
  rotation?: number;
  /**
   * You can overide the {{#crossLink "MapView/focusZoomFactor:property"}}{{/crossLink}} for a specific {{#crossLink "MapView/focusOn:method"}}{{/crossLink}} call, rather than globally, if you like.
   */
  focusZoomFactor?: number;
  /**
   * Sets a floor for how close you can zoom in on the scene. If it's lower than mapView.controls.minZoom, it's ignored.
   * @defaultValue: 0
   */
  minZoom?: number;
  maxZoom?: number;
  padding?: InsetPadding$2;
  points?: any[];
  boundingBox?: any;
  callback?: () => void;
  cancelledCallback?: () => void;
  interruptible?: boolean;
  verticalPadding?: number;
};
type PanBounds = {
  min: Vector3;
  max: Vector3;
  center: Vector3;
  radius: number;
};
//#endregion
//#region ../renderer-three/src/systems/camera/system.d.ts
declare enum CameraControlsState {
  NONE = -1,
  ROTATE = 0,
  DOLLY = 1,
  PAN = 2,
  WHEEL_ZOOM = 3,
  TOUCH_TILT = 4,
  TOUCH_DOLLY = 5,
  TOUCH_PAN = 6,
  MULTI = 7,
  PEDESTAL = 8,
  TOUCH_PEDESTAL = 9,
}
type CameraEventName = (typeof EVENTS)[number];
type SpecificCameraEvents = {
  'multi-start': {
    zooming: boolean;
    rotating: boolean;
    tilting: boolean;
  };
  'multi-end': {
    zooming: boolean;
    rotating: boolean;
    tilting: boolean;
  };
  'multi-cancel': {
    zooming: boolean;
    rotating: boolean;
    tilting: boolean;
  };
  'pedestal-change': {
    pedestal: number;
    scrolledToTop?: boolean;
    scrolledToBottom?: boolean;
    scrollPercent?: number;
  };
};
type CameraEvents = { [Event in CameraEventName]: Event extends keyof SpecificCameraEvents ? SpecificCameraEvents[Event] : undefined };
/**
 * The advanced, manual camera controls.
 * This class will let you do things like change the min/max zoom, tilt, and pan, attach to camera events, and move/animate the camera to specifc points.
 *
 * The camera works by setting an anchor point on the scene at ground level and pointing the camera at it.
 * The camera will always be pointed directly at the anchor point.
 */
declare class CameraSystem extends PubSub<CameraEvents> {
  #private;
  dirty: boolean;
  zoomDirty: boolean;
  rotationDirty: boolean;
  panDirty: boolean;
  stateDirty: boolean;
  /**
   * Factor that controls how fast zooming in and out happens in response to mouse wheel events
   *
   * @property zoomSpeed {Float}
   * @default 5.0
   */
  zoomSpeed: number;
  /**
   * Factor to multiple mouse movement by to get tilt/rotation.
   *
   * @property rotateSpeed {Float}
   * @default 100
   */
  rotateSpeed: number;
  /**
   * Disable or re-enable user input.
   *
   * @property enabled {Boolean}
   * @default true
   */
  enabled: boolean;
  /**
   * Disable or re-enable user zoom.
   *
   * @property enableZoom {Boolean}
   * @default true
   */
  enableZoom: boolean;
  /**
   * Disable or re-enable user pan.
   *
   * @property enablePan {Boolean}
   * @default true
   */
  enablePan: boolean;
  /**
   * Disable or re-enable user pedestal.
   *
   * @property enablePedestal {Boolean}
   * @default false
   */
  enablePedestal: boolean;
  /**
   * Max amount to allow scrolling maps down
   * (In Z-axis units, at the origin, down is positive)
   *
   * @property maxPedestal {Number}
   * @default Infinity
   */
  maxPedestal: number;
  /**
   * Max amount to allow scrolling maps up
   * (In Z-axis units, at the origin, up is negative)
   *
   * @property minPedestal {Number}
   * @default 0
   */
  minPedestal: number;
  /**
   * Disable or re-enable user tilt/rotation.
   *
   * @property enableRotate {Boolean}
   * @default true
   */
  enableRotate: boolean;
  /**
   * This is actually the minium distance the camera can get from it's anchor on the ground. May be worth changing if your map has very tall buildings to avoid the camera clipping through them.
   *
   * @property minZoomAltitude {Number}
   * @default 0
   */
  minZoomAltitude: number;
  /**
   * Maximum distance the camera can get from it's anchor on the ground. Setting this too high will result in parts of the map falling out of the camera's clipping plane and disappearing.
   *
   * @property maxZoomAltitude {Number}
   * @default Infinity
   */
  maxZoomAltitude: number;
  /**
   * How far the camera can zoom in towards the ground.
   *
   * This is equivalent to the minZoomAltitude property in mercator zoom level units.
   * @default 0
   */
  get maxZoomLevel(): number;
  /**
   * Sets distance the camera can zoom in towards the ground.
   * @default Infinity
   */
  setMaxZoomLevel(zoomLevel: number): void;
  /**
   * The default minimum zoom level of the camera in mercator zoom levels.
   */
  get defaultMinZoomLevel(): number;
  /**
   * How far the camera can zoom out away from the ground.
   *
   * This is equivalent to the maxZoomAltitude property in mercator zoom level units.
   */
  get minZoomLevel(): number;
  /**
   * Sets distance the camera can zoom away from the ground.
   */
  setMinZoomLevel(zoomLevel: number): void;
  /**
   * ignoreZoomLimits; use with caution for special effects
   * @default false
   */
  ignoreZoomLimits: boolean;
  /**
   * Multiplier for min and max zoom, for convenience.
   *
   * @hidden
   * @property zoomFactor {Number}
   * @default 1
   */
  zoomFactor: number;
  /**
   * Constrains the camera from panning to far away from the scene. It's set automatically based on the size of the map.
   * If you want to change anything, you probably want to change the margin property, which is the factor the min and max in
   * each dimension are multiplied by to give the true bounds. For example, on a truely huge venue a 1.25 margin could get you
   * way out into space when zoomed in.
   *
   * @property panBounds {Object}
   @property panBounds.min {Object} An x, y pair representing the bounds of one corner of the map.
   @property panBounds.max {Object} An x, y pair representing the bounds of the other corner of the map.
   */
  panBounds: PanBounds;
  /**
   * Minium camera tilt, in radians. If it's anything other than 0, you won't be able to look at the venue from the top down perspective.
   *
   * @property minTilt {Number}
   * @default 0.0
   */
  minTilt: number;
  /**
   * Minium camera tilt, in radians. If you set it too high, the camera will be able to tilt down through the geometery of the scene, which will produce clipping issues.
   *
   * @property maxTilt {Number}
   * @default 1.2
   */
  maxTilt: number;
  /**
   * If you would really prefer to pan with the right mouse button and tilt/rotate with the left, you can swap the values here to achieve that.
   *
   * @property MOUSE_BUTTONS {Object}
   * @hidden
   @property mouseButtons.ORBIT=MOUSE.RIGHT {MOUSE} The button to use for tilt/rotation. Defaults to `MOUSE.RIGHT`.
   @property mouseButtons.ZOOM=MOUSE.MIDDLE {MOUSE} The button to use for zoom behaviour. Don't change
   @property mouseButtons.PAN=MOUSE.LEFT {MOUSE} The button to use for panning the camera. Defaults to `MOUSE.LEFT`.
   */
  private readonly MOUSE_BUTTONS;
  readonly camera: PerspectiveCamera;
  private readonly scene;
  private readonly renderer;
  private readonly elevation;
  readonly orbit: Object3D;
  private readonly cameraPlane;
  private readonly raycaster;
  private readonly rendererState;
  private readonly options;
  state: CameraControlsState;
  private intersection?;
  private viewState;
  private tweens;
  private clock;
  private coords;
  private touch;
  private scrollTimer;
  private lastWheelTime;
  private resetZoom;
  private zoomStart;
  private pedestalScaleFactor;
  private isUserZooming;
  private stayInsideBounds;
  private userInteracting;
  private cameraMoving;
  private lastCameraMoveTime;
  constructor(camera: PerspectiveCamera, scene: Scene, renderer: WebGLRenderer, rendererState: RendererState, options: CameraControlsOptions);
  private addMovingStateListeners;
  /**
   * The amount the camera is shifted up/down
   * (corresponds to scroll amount in multifloor mode)
   * 100% == camera is as far up as it will go
   * 0% == camera is as far down as it will go
   */
  get scrollPercent(): number;
  /**
   * Returns current field of view(FOV) in degrees
   */
  get fov(): number;
  /**
   * Returns whether the maps are scrolled to bottom
   */
  get scrolledToBottom(): boolean;
  /**
   * Returns whether the maps are scrolled to top
   */
  get scrolledToTop(): boolean;
  /**
   * The camera's current center in [longitude, latitude] degrees.
   */
  get center(): [number, number];
  /**
   * @param center The center in [longitude, latitude] degrees.
   */
  setCenter(longitude: number, latitude: number): void;
  /**
   * @hidden
   */
  raycastToFloor: (pos: Vector2) => Vector3;
  /**
   * Returns true if the the user is currently manipulating the camera.
   *
   * @return {Boolean} True if the user is currently manipulating the camera, false otherwise.
   */
  isUserInteracting: () => boolean;
  /**
   * Returns the current camera position.
   *
   * @return {Object} An {x, y} object of the current camera postion.
   */
  getPosition: () => Vector3;
  /**
   * Returns the current camera pedestal zoom level.
   */
  getPedestal: () => number;
  /**
   * Pans the camera right and down from the current position
   *
   * @param right {Number} The units to move right. Negative will pan left. This is in relation to the global coordinate system, not the current camera rotation.
   * @param down {Number} The units to move down. Negative will pan up. This is in relation to the global coordinate system, not the current camera rotation.
   */
  pan: (right: number, down: number) => void;
  /**
   * Anything we need to do after we render the camera, like update anchors for the mouse/touch controls.
   *
   * @hidden
   */
  postRender: () => void;
  /**
   * Returns true if the camera is currently animating.
   * @return {Boolean} True if the camera is animating, false otherwise.
   */
  get isAnimating(): boolean;
  /**
   * Returns true if the camera is currently moving (it's animating, the user is manipulating it).
   *
   * @return {Boolean} True if the camera is moving, false otherwise.
   */
  isCameraMoving: () => boolean;
  /**
   * Returns the most recent time the camera stopped moving.
   *
   * @returns {Number} The time in ms the camera stopped moving.
   */
  lastCameraStoppedMovingTime: () => number;
  /**
   * Marks the camera as under active external manipulation (e.g. a Mapbox/MapLibre
   * overlay gesture) and publishes `pan-start`. While in this state, the per-tick
   * `*-start`/`*-end` publishes inside setters are gated off, so a burst of
   * setCenter/setZoom/setRotation/setTilt calls does not flicker
   * `cameraMoving` between true and false.
   *
   * @hidden
   */
  beginGesture: () => void;
  /**
   * Ends a gesture started by {@link beginGesture} and publishes `pan-end`.
   * No-op if state is not PAN — guards against stomping a concurrent
   * user-initiated drag, and against `moveend` firing without a matching
   * `movestart`.
   *
   * @hidden
   */
  endGesture: () => void;
  /**
   * Sets the camera anchor to a specifc x/y positon, in the global reference frame. 0,0 will be roughly the middle of the map, and panBounds holds the min/max points.
   *
   * @param x {Number} The x position to move the camera to. +x will take you right, from the default camera rotation of 0.
   * @param y {Number} The y position to move the camera to. +y will take you down (towards the viewer) in the default camera rotation of 0.
   */
  setPosition: (x: number, y: number) => void;
  private updateCameraPosition;
  /**
   * Tilts the camera up or down by some number of radians. Bounded by minTilt and maxTilt.
   *
   * @param radians {Number} Number of radians to increase or decrease the current tilt by.
   */
  tilt: (radians: number) => void;
  /**
   * Zooms the camera in on the center of the current view.
   *
   * @param duration {Number} The duration of the zoom animation, in ms.
   * @param curve {Function} The easing function to use for the zoom animation.
   * @param callback {Function} A callback that will be executed when the zoom animation is done.
   */
  zoomIn: (duration: number, curve: (n: number) => number, callback: (...args: any) => void) => void;
  /**
   * Zooms the camera out from the center of the current view.
   *
   * @param duration
   * @param curve
   * @param callback
   */
  zoomOut: (duration: number, curve: (n: number) => number, callback: (...args: any) => void) => void;
  /**
   * Returns the current camera rotation.
   *
   * @return {Number} The current rotation of the camera, in radians.
   */
  getRotation: () => number;
  /**
   * Cancel animation- for the new API
   */
  cancelAnimation: () => void;
  /**
   * Animates the camera from it's current position to the state specified in target. You only
   * need to specify the properties you actually want to change.
   *
   * You can also specify a duration, animation curve, and a callback for when it's done.
   *
   * @param target {Object} A list of optional parameters you can set that represent the camera state.
   @param [target.position] {Object} An {x, y, z} object representing the position to move to.
   @param [target.zoom] {Number} The zoom level to end at.
   @param [target.tilt] {Number} The tilt to end at, in radians.
   @param [target.rotation] {Number} The rotation to end at, in radians.
   @param [target.doNotAutoStart=false] {Boolean} Set this to true if you want to start the tween yourself.
   * @param [duration] {Number} The duration to animate the camera for, in ms.
   * @param [curve] {Mappedin.Easing} The animation curve to use for the animation.
   * @param [callback] {Function} A callback that will be executed when the animation is done.
   * @param [options] {Object} An Options object
   * @param [options.interruptible=true] {Boolean} Determines if this animation must complete before any new animations start
   it will cancel and omit any previous animations. Set to "chain" to chain instead
   *
   * @return {Mappedin.Tween} The tween being used, if you want to do anything to control it manually. Do not overide it's events.
   */
  animateCamera: (target: AnimateCameraTarget, duration: number, curve?: (n: number) => number, callback?: (...args: any) => void, cancelledCallback?: (...args: any) => void, options?: {
    interruptible?: boolean;
  }) => Promise<void>;
  /**
   * Allows you to set any of the Camera's position, zoom, rotation and tilt at once, with one function.
   *
   * @param [position] {Object} an {x, y, z} object representing the new position.
   * @param [zoom] {Number} The new zoom distance.
   * @param [rotation] {Number} The new rotation, in radians.
   * @param [tilt] {Number} The new tilt, in radians.
   */
  setMulti: (position?: {
    x?: number;
    y?: number;
    z?: number;
  }, zoom?: number, rotation?: number, tilt?: number, publishChangeEvent?: boolean) => void;
  /**
   * Returns the actual zoom minimum based on real-world distance.
   *
   * @return {Number} The actual zoom minimum in map units.
   */
  getZoomScaledMin: () => number;
  /**
   * Returns the actual zoom maximum based on visible map size.
   *
   * @return {Number} The actual zoom maximum in map units.
   */
  getZoomScaledMax: () => number;
  /**
   * Sets the rotation to a specific orientation, clockwise in radians. Mostly useful to orient the map a certain way for a physical directory.
   *
   * @param radians {Number} Absolute rotation to set the camera to, in radians. 0 in the starting point.
   * @param silent {Boolean} Whether to avoid emitting events
   */
  setRotation: (radians: number, silent?: boolean) => void;
  /**
   * Sets the camera to be a certain distance from the anchor point, along it's tilt and rotation.
   * Keeps it inside minZoom and maxZoom.
   *
   * @param zoom {Number} The distance to set the camera to.
   */
  setZoomAltitude: (zoom: number) => void;
  /**
   * Set the camera's zoom level in mercator zoom level units.
   */
  setZoomLevel: (zoomLevel: number) => void;
  /**
   * Returns the current camera zoom
   *
   * @return {Number} The distance of the camera from the anchor.
   */
  getZoomAltitude: () => number;
  /**
   * Current camera zoom in mercator zoom level units.
   */
  getZoomLevel: () => number;
  /**
   * Sets the tilt to a specific level, in radians. 0 is top down. Bounded by minTilt and maxTilt.
   *
   * @param radians {Number} Tilt to set the camera to, in radians.
   * @param silent {Boolean} Whether to avoid emitting events.
   */
  setTilt: (radians: number, silent?: boolean) => void;
  /**
   * Returns the current camera tilt
   *
   * @return {Number} The current tilt of the camera, in radians.
   */
  getTilt: () => number;
  /**
   * @param elevation {number}
   * @hidden
   */
  setCameraPlaneElevation: (elevation: number) => void;
  /**
   * Moves the camera towards or away from the camera by a set amount. Positive will zoom in (bringing the distance closer to 0).
   *
   * @param zoom {Number} The distance to increase or decrease the zoom.
   */
  zoom: (zoomDelta: number) => void;
  /**
   * Returns the current projection scale factor.
   * @param FOV {number} Field of view
   * @param canvasHeight {number} Height of the canvas
   * @param zoom{number} Zoom level
   */
  getProjectionScaleFactor: (FOV: number, canvasHeight: number, zoom: number) => number;
  /**
   * Should probably be "pre-render". Anything we need to do before rendering the scene.
   *
   * @hidden
   */
  update: () => void;
  setPedestal: (z: number, emitEvent?: boolean, emitCameraStateChanged?: boolean) => void;
  /**
   * Disposes of the camera and all of it's events.
   *
   * @hidden
   */
  dispose: () => void;
  private createCameraPlane;
  private addEventListeners;
  private addMouseEventListeners;
  private addMouseMoveEventListeners;
  private removeMouseMoveEventListeners;
  private removeMouseUpEventListeners;
  private onContextMenu;
  private onMouseUp;
  private onMouseMove;
  private onTouchStart;
  private onTouchMove;
  private onTouchEnd;
  private handleTouchMovePan;
  private handleTouchStartDolly;
  private handleMouseMovePan;
  private handleTouchStartTilt;
  private handleTouchMovePedestal;
  private handleTouchMoveTilt;
  private handleTouchMoveDolly;
  private handleTouchEnd;
  private handleTouchStartPan;
  private handleTouchStartPedestal;
  private onMouseDown;
  private onMouseWheel;
  private handleMouseWheel;
  private setCameraFromTransformMatrix;
  private makeTransformFromTouchAnchors;
  private updateTouchOrigin;
  private touchToScene;
  private canScrollZoom;
  private mouseToScene;
  private getMousePos;
  private handleMouseDownRotate;
  private handleMouseDownPan;
  private handleMouseDownPedestal;
  private handleMouseMovePedestal;
  private handleMouseMoveRotate;
  private publishUserZoomDebounced;
  private publishUserZoomEvent;
  private setCameraMoving;
  private unsetCameraMoving;
  private setUserInteracting;
  private unsetUserInteracting;
  private publishPedestalChangeEvent;
  /**
   * Converts the altitude to the mercator zoom level.
   * @param altitude {number} The altitude in meters.
   */
  convertAltitudeToZoomLevel: (altitude: number) => number;
  /**
   * Converts a mercator zoom level to an altitude in meters.
   * @param zoomLevel{number} The mercator zoom level
   */
  convertZoomLevelToAltitude: (zoomLevel: number) => number;
  private completeTween;
  static CAMERA_FRAME_PADDING_SIDES: readonly ["top", "bottom", "left", "right"];
  debugContainer: Object3D<three0.Object3DEventMap>;
  getCameraFrameForCoordinates(pointCloud: Vector3[], options: CameraFocusOnOptions & {
    padding: InsetPadding$2;
  }): {
    center: Vector3;
    zoomLevel: number;
  };
  focusOn(pointCloud: Vector3[], options: CameraFocusOnOptions & {
    padding: InsetPadding$2;
  }): void;
  resize(canvasWidth: number, canvasHeight: number): void;
  computeMetersPerPixelFromZoomLevel(zoomLevel: number): number;
  computeMetersPerPixelFromAltitude(altitude: number): number;
  getCurrentMetersPerPixel(): number;
}
//#endregion
//#region ../renderer-three/src/camera-debug.d.ts
type FocusOnDebugConfig = {
  pointCloud?: {
    size?: number;
    color?: string;
  } | false;
  boundingBox?: {
    color?: string;
  } | false;
} | false;
//#endregion
//#region ../renderer-three/src/camera.d.ts
type AnimationOptions = {
  duration?: number;
  easing?: EasingCurve;
};
type AnimateElevationOptions = AnimationOptions & {
  interruptible?: boolean;
};
type FocusOnOptions = AnimationOptions & {
  bearing?: number;
  pitch?: number;
  padding?: InsetPaddingOption$2;
  minZoomLevel?: number;
  maxZoomLevel?: number;
  interruptible?: boolean;
  verticalPadding?: number;
  /** Debug key — the target object used as a Map key so multiple debug visualizations coexist. */
  debugKey?: object;
  /** Debug color override (CSS color string) for this point cloud. */
  debugColor?: string;
};
type AnimateToOptions = AnimationOptions & {
  center?: Position$2;
  zoomLevel?: number;
  bearing?: number;
  pitch?: number;
  elevation?: number;
  interruptible?: boolean;
};
declare class Camera$2 extends PubSub<{
  'padding-change': {
    padding: InsetPadding$2;
  };
}> {
  #private;
  /**
   * @internal
   */
  constructor(core: Core, systems: Systems, state: RendererState);
  /**
   * The camera's current center in [longitude, latitude] degrees.
   */
  get center(): [number, number] | [lon: number, lat: number, alt: number];
  /**
   * @param center The center in [longitude, latitude] degrees.
   */
  setCenter(center: Position$2): void;
  /**
   * Current camera zoom in mercator zoom level units.
   */
  get zoomLevel(): number;
  /**
   * Set the camera's zoom level in mercator zoom level units.
   */
  setZoomLevel(zoomLevel: number): void;
  getState(): {
    zoomLevel: number;
    minZoomLevel: number;
    maxZoomLevel: number;
    minPitch: number;
    maxPitch: number;
    autoMinZoomLevel: boolean;
    panMode: "default" | "elevation";
    screenOffsets: InsetPadding$2;
    center: [number, number];
    bearing: number;
    pitch: number;
    elevation: number;
  };
  /**
   * Whether the camera is animating.
   */
  get isAnimating(): boolean;
  /**
   * Cancel the last animation.
   */
  cancelAnimation(): void;
  /**
   * How far the camera can zoom in towards the ground
   */
  get maxZoomLevel(): number;
  /**
   * How far the camera can zoom out away from the ground
   */
  get minZoomLevel(): number;
  /**
   * Toggle the mode of the camera to automatically set the minimum zoom level based on the size of the scene.
   * It will be automatically disabled when the minimum zoom level is set manually.
   * @param value The new value for the auto min zoom level mode.
   */
  setAutoMinZoomLevel(value: boolean): void;
  /**
   * The mode of the camera to automatically set the minimum zoom level based on the size of the scene.
   */
  get autoMinZoomLevel(): boolean;
  /**
   * How far out the camera can zoom
   *
   * @param zoomLevel  The minimum zoom level in mercator zoom level units.
   * @default 0
   */
  setMinZoomLevel(zoomLevel: number, disableAutoMinZoomLevel?: boolean): void;
  /**
   * How far in the camera can zoom
   *
   * @param zoomLevel The maximum zoom level in mercator zoom level units.
   * @default Infinity
   */
  setMaxZoomLevel(zoomLevel: number): void;
  /**
   * The maximum pitch in degrees.
   */
  get maxPitch(): number;
  /**
   * The minimum pitch in degrees.
   */
  get minPitch(): number;
  /**
   * @param pitch The minimum pitch in degrees.
   */
  setMinPitch(pitch: number): void;
  /**
   * @param pitch The maximum pitch in degrees.
   */
  setMaxPitch(pitch: number): void;
  /**
   * The camera's current clockwise rotation in degrees from north.
   */
  get bearing(): number;
  /**
   * @param bearing The bearing in degrees from north.
   */
  setBearing(bearing: number): void;
  /**
   * The camera's current pitch in degrees.
   */
  get pitch(): number;
  /**
   *
   * @param pitch The pitch in degrees.
   */
  setPitch(pitch: number): void;
  /**
   * The camera's current elevation in meters from the ground.
   */
  get elevation(): number;
  /**
   * @param elevation The elevation in meters.
   */
  setElevation(elevation: number): void;
  /**
   * Animate the camera's elevation to a new value.
   * @param elevation The new elevation in meters.
   * @param options The animation options.
   */
  animateElevation(elevation: number, options?: AnimateElevationOptions): Promise<void>;
  /**
   * The padding around the edges of the map when focusing on a set of coordinates.
   */
  get insetsPadding(): InsetPadding$2;
  /**
   * The camera's current pan mode.
   */
  get panMode(): "default" | "elevation";
  /**
   * Set the camera's pan mode. 'elevation' moves the camera up and down, while 'default' allows the camera to pan along the ground.
   */
  setPanMode(panMode: 'default' | 'elevation'): void;
  /**
   *
   * @param padding The padding around the edges of the map when focusing on a set of coordinates (in screen pixels).
   */
  setInsetPadding(padding: Partial<InsetPadding$2>): void;
  animateTo(options: AnimateToOptions): Promise<void>;
  getCameraFrameForCoordinates(coordinates: (Position | Position$2 | string)[], options?: FocusOnOptions): {
    center: [number, number] | [lon: number, lat: number, alt: number];
    zoomLevel: number;
  };
  /**
   *  Focuses the camera on a set of coordinates, with optional animation
   *
   * @param target list of [longitude, latitude, altitude?] points
   * @param options {FocusOnOptions}
   * @returns Promise<void>
   */
  focusOn(target: (Position | Position$2 | string)[], options?: FocusOnOptions): Promise<void>;
  /**
   * Enable debug visualization of camera targets.
   * Shows green dot for animateTo targets, orange box for focusOn bounds, cyan box for getFocusOnTransform bounds.
   * @internal
   */
  showCameraTargetsDebug(): void;
  /**
   * Disable debug visualization of camera targets.
   * @internal
   */
  hideCameraTargetsDebug(): void;
  /**
   * Enable 3D debug visualization of the focusOn point cloud and bounding boxes.
   * @internal
   */
  showFocusOnDebug(cfg: FocusOnDebugConfig): void;
  /**
   * Disable 3D debug visualization of the focusOn point cloud and bounding boxes.
   * @internal
   */
  hideFocusOnDebug(): void;
  /**
   * Enable debug visualization of screen offsets.
   * Shows colored overlays for each padding area.
   * @internal
   */
  showScreenOffsetsDebug(): void;
  /**
   * Disable debug visualization of screen offsets.
   * @internal
   */
  hideScreenOffsetsDebug(): void;
  /**
   * Cleans up camera resources including debug visualizations.
   * Called automatically when the renderer is destroyed.
   * @internal
   */
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/pan-bounds/system.d.ts
declare class PanBoundsSystem extends PubSub<{
  update: void;
}> {
  private currentTotalBoundingBox?;
  private state;
  private cameraSystem;
  private debugMesh;
  dirty: boolean;
  autoMinZoomLevel: boolean;
  constructor(state: RendererState, cameraSystem: CameraSystem);
  /**
   * Checks if the given 3D position is outside current bounds.
   * If outside, sets dirty flag to trigger bounds expansion.
   * Call this when adding entities to conditionally trigger pan bounds update.
   * @param point - The 3D position to check
   */
  expandBoundsIfOutside(point: Vector3): void;
  /**
   * Recomputes the pan bounds based on the current 2D and 3D entities in the scene
   * This is only additive, meaning removing entities will not shrink the pan bounds
   */
  update(): void;
}
//#endregion
//#region ../renderer-three/src/systems/watermark/system.d.ts
type WatermarkPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center' | 'top' | 'bottom' | 'left' | 'right';
type WatermarkOptions = {
  /**
   * Padding in pixels. Can be a number or an object with top, right, bottom, and left properties.
   * @default 16
   */
  padding?: number | {
    top?: number;
    right?: number;
    bottom?: number;
    left?: number;
  };
  /**
   * Position of the watermark on the screen.
   * @default 'bottom-left'
   */
  position?: WatermarkPosition;
  /**
   * Show only the Mappedin icon without text.
   * @default false
   */
  iconOnly?: boolean;
  /**
   * Color of the watermark.
   * @default 'dark'
   */
  color?: 'light' | 'dark';
  /**
   * Scale of the watermark between 0.5 and 1.5.
   * @default 1
   */
  scale?: number;
  /**
   * Callback when the watermark is clicked.
   * @hidden
   */
  onClick?: () => void;
  /**
   * Whether the watermark is interactive.
   * @default true
   */
  interactive?: boolean;
  /**
   * Whether the watermark should be visible.
   * @hidden
   * @default true
   */
  visible?: boolean;
};
type WatermarkUpdateOptions$1 = Omit<WatermarkOptions, 'onClick' | 'visible'> & {
  /** Show the Mappedin watermark. */
  visible?: boolean;
  /** Set the interactivity of the watermark. */
  interactive?: boolean;
};
declare class WatermarkSystem extends PubSub<{
  'texture-loaded': void;
}> {
  #private;
  dirty: boolean;
  private get color();
  private get iconName();
  private get minWidth();
  private get defaultWidth();
  private get aspectRatio();
  get options(): Required<WatermarkOptions>;
  set options(options: WatermarkUpdateOptions$1);
  get icon(): string;
  constructor(cameraObject: PerspectiveCamera, rendererState: RendererState, options?: Partial<WatermarkOptions>);
  private setSize;
  private setXY;
  get width(): number;
  get height(): number;
  getPositionAlignedOffset(width: number, height: number): {
    x: number;
    y: number;
  };
  getPositionAlignedCanvasCoordinates: (canvasWidth: number, canvasHeight: number) => {
    x: number;
    y: number;
  };
  getPositionAlignedPadding: () => {
    x: number;
    y: number;
  };
  insertIntoQuadTree(quadTree: QuadTree<{
    entityId: Geometry2D['id'];
  }>): void;
  resize(canvasWidth: number, canvasHeight: number): void;
  update(): void;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/html-controls/system.d.ts
/**
 * All possible control anchor positions.
 */
declare const ATTRIBUTION_POSITIONS: readonly ["top-left", "top-right", "bottom-left", "bottom-right"];
type AttributionPosition = (typeof ATTRIBUTION_POSITIONS)[number];
type AttributionControlOptions = {
  custom?: string[];
  position?: AttributionPosition;
  feedback?: boolean;
};
type HTMLControlsSystemOptions = {
  outdoorEnabled?: boolean;
};
declare class HTMLControlsSystem {
  #private;
  controlContainerEl: HTMLDivElement;
  controlPositions: Record<AttributionPosition, HTMLDivElement>;
  compact: boolean | undefined;
  attribContainerEl?: HTMLDetailsElement;
  attribInnerEl?: HTMLDivElement;
  attribButtonEl?: HTMLElement;
  feedbackLinkEl?: HTMLAnchorElement;
  attribHTML: string;
  customAttributions: string[];
  constructor(container: HTMLElement, options?: HTMLControlsSystemOptions);
  addAttributionControl(options?: AttributionControlOptions): void;
  toggleAttribution: (e: MouseEvent) => void;
  /**
   * Updates the attribution based on sources in the map style.
   */
  private updateAttribution;
  /**
   * Combines custom and map attributions and updates the display.
   */
  private updateAttributionDisplay;
  private resizeAttribution;
  destroyAttributionControl(): void;
  resize(canvasWidth: number): void;
  /**
   * This should fire when Maplibre data changes.
   */
  updateData(map: Map$1): void;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/custom-geometry/system.d.ts
/**
 * System that renders and updates custom geometry entities. For every custom geometry entity, this calls the builder's
 * setup method once (when it is visible) and then the update method every frame.
 */
declare class CustomGeometrySystem {
  private state;
  private convertTo3DMapPosition;
  constructor(state: RendererState, convertTo3DMapPosition: Core['convertTo3DMapPosition']);
  update(): void;
}
//#endregion
//#region ../renderer-three/src/utils/idle-queue.d.ts
/**
 * A queue that processes callbacks during browser idle time.
 * Supports tracking queue size and running callbacks when all jobs complete.
 */
declare class IdleQueue {
  #private;
  /**
   * Returns the current number of pending jobs in the queue
   */
  get size(): number;
  /**
   * Adds a callback to the queue.
   * The queue will process callbacks during idle time to avoid blocking the main thread.
   * @param callback - The callback to execute during idle time
   */
  add(callback: () => void): void;
  /**
   * Sets a callback to run when all jobs in the queue have completed.
   * This callback will be invoked after the last job finishes processing.
   * @param callback - The callback to execute when queue is empty
   */
  onComplete(callback: () => void): void;
  /**
   * Clears the completion callback
   */
  clearOnComplete(): void;
  /**
   * Clears all pending jobs and the completion callback.
   * Cancels any in-progress idle callback.
   * Useful when resetting the queue completely.
   */
  clearAll(): void;
}
//#endregion
//#region ../renderer-three/src/systems/outline-interpolation/system.d.ts
declare class OutlineInterpolationSystem extends PubSub<{
  'needs-render': void;
}> {
  #private;
  private rendererState;
  /**
   * Maximum opacity for outlines at full zoom
   */
  private readonly maxOpacity;
  /**
   * Set to true when we need to update the outline opacity of all entities, regardless of zoom level.
   */
  outlineOpacitiesDirty: boolean;
  /**
   * Use IdleQueue to ensure the thread isn't blocked by building outlines
   * @internal for unit tests only
   */
  useIdleFramesOnly: boolean;
  get geometries3DDirty(): boolean;
  set geometries3DDirty(value: boolean);
  /**
   * Allow the building of outlines to occur when we have idle frames, so it doesn't impact initial load times
   */
  idleBuildQueue: IdleQueue;
  /**
   * Based on perf testing computing bounding sphere can take a very long time,
   * and we only need it for frustum checking, which can wait a little, so putting it into its own idle frame queue
   */
  idleComputeBoundingSphereQueue: IdleQueue;
  /**
   * Creates a new OutlineInterpolationSystem
   * @param rendererState - The renderer state
   * @param options - Optional configuration for outline rendering
   */
  constructor(rendererState: RendererState, options?: OutlinesOptions$1);
  buildOutlines(geometryGroupEntity: FeatureCollectionObject3D): void;
  /**
   * Update the outline color of all entities with an outline component.
   * @param zoomLevel - The current zoom level.
   * @param isCameraZoomDirty - Whether the zoom level has changed since the last update. If this is true, the system will update if zoomLevel falls between range.
   */
  update(zoomLevel: number, isCameraZoomDirty?: boolean): void;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/image/system.d.ts
declare class ImageSystem extends PubSub<{
  'image-loaded': void;
}> {
  private rendererState;
  private convertTo3DMapPosition;
  private projectToScreen;
  private initialBearing;
  private naturalBearing;
  private imagePlacementOptions;
  private cameraFrustum;
  private transformImageRequest?;
  private cameraWorldPosition;
  private debug;
  get debugLOD(): boolean;
  set debugLOD(value: boolean);
  /**
   * Cache for tracking image LOD state. Stores the original image element
   * and textures at each LOD level for memory-efficient switching.
   */
  private cache;
  constructor(rendererState: RendererState, convertTo3DMapPosition: Core['convertTo3DMapPosition'], projectToScreen: Core['project'], initialBearing?: number, naturalBearing?: number, imagePlacementOptions?: ImagePlacementOptions$1, transformImageRequest?: TransformImageRequest);
  private createImageMesh;
  /**
   * Gets or downloads an image texture. Cache entry must exist before calling.
   * For resizable URLs (Mappedin CDN): uses server-side resizing with LOD levels.
   * For non-resizable URLs: caps to the specified size once at load.
   * @param cacheKey - Cache key (URL or URL|size for non-resizable images)
   * @param url - The image URL for loading
   * @param targetSize - Texture dimension in pixels
   * @returns Promise that resolves to the texture
   */
  private getOrDownloadImage;
  /**
   * Returns the texture capped to maxSize. Only scales if the image exceeds maxSize.
   * Used for external images to prevent VRAM exhaustion on mobile.
   * @param sourceTexture - The loaded texture from TextureLoader
   * @param maxSize - Maximum dimension in pixels
   * @returns The original texture if within limits, or a new CanvasTexture if scaled
   */
  private createCappedTexture;
  /**
   * Updates the LOD for an image mesh based on camera distance.
   * Only applies to resizable URLs (Mappedin CDN) - server handles the scaling.
   * Non-resizable URLs use a fixed image size set at load time.
   * @param url - The image URL
   * @param imageMesh - The mesh to update
   * @param position - The world position of the image
   * @param maxImageSize - Maximum image size for non-resizable images (used for cache key)
   */
  private updateLODIfNeeded;
  /**
   * Applies debug LOD colors to all image materials when debug mode is enabled.
   * Calculates LOD based on current camera position and applies appropriate color tinting.
   */
  private applyDebugLODColors;
  /**
   * Resets emissive colors on all image materials when debug mode is disabled.
   */
  private resetDebugLODColors;
  private flipIfNeeded;
  currentImageScreenBBoxes: Rectangle[];
  private viewProjectionMatrix;
  private lastLODUpdateTime;
  update(cameraRotationRadians: number, isCameraMoving: boolean, cameraStoppedTime: number): void;
  /**
   * Disposes all cached textures and clears the cache.
   * Called when the renderer is destroyed to prevent GPU memory leaks.
   */
  destroy(): void;
  updateImageScreenBBoxes(meshComponent: MeshComponent | ImageComponent): void;
}
//#endregion
//#region ../renderer-three/src/systems/geometry-in-focus/system.d.ts
declare class GeometryInFocusSystem extends PubSub<{
  /**
   * Returns the list of entities that are likely in focus, sorted by the weight of the raycast.
   */
  'geometry-in-focus': string[];
}> {
  #private;
  cameraDirty: boolean;
  focusablesDirty: boolean;
  private state;
  private camera;
  private cameraFrustum;
  private viewProjectionMatrix;
  private tempScreenPos;
  private debugEl;
  private collisions;
  private focusableEntities;
  private debug;
  private debugBBoxElements;
  private viewfinder;
  private screenBoundsMap;
  private screenDiagonal;
  constructor(state: RendererState, camera: Camera$1);
  resize(): void;
  /**
   * Everything within this square is considered "in focus" and ranked based on proximity to center.
   */
  private createViewfinder;
  /**
   * Filters vertices to keep only those on the perimeter (convex hull)
   * @param vertices - Array of all vertices in world space
   * @returns Array of perimeter vertices in world space
   */
  private simplifyVertices;
  /**
   * Computes screen-space bounding box and depth info from world-space vertices
   * Projects all vertices to clip space and finds the bounding box
   * Culls if the bounding box doesn't intersect the camera frustum
   *
   * @param focusableComponent - Component containing vertices and/or bounding box
   * @returns Screen-space bounding box and closest depth, or undefined if not visible
   */
  private computeScreenSpaceBounds;
  private updateFocusableEntities;
  update: (cameraIsMoving?: boolean, cameraStoppedMovingTime?: number) => void;
  updateRaf(): void;
  /**
   * Updates debug visualization for screen-space bounding boxes
   */
  private updateDebugBBoxes;
  compute(): void;
  showDebug(): void;
  hideDebug(): void;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/outdoor-layers/system.d.ts
declare class OutdoorLayers extends PubSub<{}> {
  #private;
  idleQueue: IdleQueue;
  hideLayersIntersectingPolygons(polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[], layers: string[]): void;
  constructor(map?: Map$1);
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/path/system.d.ts
/**
 * A system for drawing and controlling the visual state of paths
 */
declare class PathSystem extends PubSub<{
  'animate:path': undefined;
}> {
  private rendererState;
  verticalDistanceDirty: boolean;
  convertTo3DMapPosition: Core['convertTo3DMapPosition'];
  getParentContainer: Core['getParentContainer'];
  convertZoomLevelToAltitude: CameraSystem['convertZoomLevelToAltitude'];
  constructor(rendererState: RendererState, convertTo3DMapPosition: Core['convertTo3DMapPosition'], getParentContainer: Core['getParentContainer'], convertZoomLevelToAltitude: CameraSystem['convertZoomLevelToAltitude']);
  update(minZoomAltitude: number, maxZoomAltitude: number, currentZoomAltitude: number, metersPerPixel: number): void;
}
//#endregion
//#region ../renderer-three/src/systems/mesh-detachment/system.d.ts
/**
 * This system is responsible for updating the opacity of the mesh, which results in the mesh
 * being detached from the parent's optimized geometry group and rendered as a separate mesh.
 */
declare class MeshDetachmentSystem {
  #private;
  rendererState: RendererState;
  dirty: boolean;
  constructor(rendererState: RendererState);
  updateOne(geometry: All3DTypes | undefined): void;
  update(): void;
  private cleanup;
}
//#endregion
//#region ../renderer-three/src/systems/mesh-modification/system.d.ts
/**
 * Any physical changes to geometry should go in here. This includes height changes, etc.
 * This is to ensure that physical changes apply before any other systems need to do their work,
 * such as the outline system.
 *
 * TODO: For now, this piggybacks of style.dirty, but we may want to create a flag indicating geometry dirty.
 */
declare class MeshModificationSystem {
  #private;
  rendererState: RendererState;
  dirty: boolean;
  constructor(rendererState: RendererState);
  updateOne(entity?: EntityTypes): void;
  update(): void;
  cleanup(): void;
}
//#endregion
//#region ../renderer-three/src/systems/text3d/system.d.ts
declare class Text3DSystem extends PubSub<{
  render: undefined;
}> {
  private rendererState;
  private convertTo3DMapPosition;
  textSet: Set<string>;
  batchedTextMap: Map<GroupContainerObject3D, Promise<BatchedText>>;
  private resolvedBatchedTextMap;
  useWorker: boolean;
  remove(id: string): void;
  getBatchedText(group: GroupContainerObject3D): BatchedText | undefined;
  constructor(rendererState: RendererState, convertTo3DMapPosition: Core['convertTo3DMapPosition'], useWorker?: boolean);
  update(cameraRotationRadians: number): Promise<void[] | undefined>;
  /**
   * flip text based on camera rotation
   * - flipping when text and camera angle is larger than 90 degrees or less than 270 degrees, see: https://mappedin.atlassian.net/wiki/spaces/SDK/pages/522715164/V6+Implementation#Handling-Flipping
   * - could do this in GPU, updating camera position uniform can save running through the loops. Although, since we are running the loops anyway, it's not much more work to do it here for now.
   * @returns true if the flipped
   */
  private flipIfNeeded;
  private debugTextAreaMesh;
  showTextAreaMesh(): void;
  hideTextAreaMesh(): void;
}
/**
 *  Preload fonts and optionally pre-generate the SDF textures for particular glyphs up front.
 *  This is to avoid ondemand font generation can take long.
 *
 *  If working in CSP-restricted environment, call `disableText3DWorker` before to avoid errors
 *
 *  @param fontUrl - url of the font file served.
 *  @returns  A promise that resolves when the font is loaded
 *
 */
declare function preloadFont(fontUrl?: string): Promise<string>;
//#endregion
//#region ../renderer-three/src/utils/debug.d.ts
/**
 * Default debug state configuration with all debug features disabled by default.
 */
declare const DEFAULT_DEBUG_STATE: {
  /** Shows the text area mesh used for polygon label rendering */
  showPolygonLabelTextAreaMesh: boolean;
  /** Enables the basic environment map for lighting and reflections */
  showEnvMap: boolean;
  /** Shows collision detection boxes for debugging spatial interactions */
  showCollisionBoxes: boolean;
  /** Shows the debug for the geometry in focus system */
  showGeometryInFocus: boolean;
  /**
   * Shows LOD level indicators on images via color tinting.
   */
  showImageLOD: boolean;
  /** Shows model instancing statistics (batch counts, instance counts, draw calls) */
  showModelInstancingStats: boolean;
  /**
   * Shows screen offset areas as transparent colored overlays.
   * - Red: top offset
   * - Green: bottom offset
   * - Blue: left offset
   * - Yellow: right offset
   */
  showScreenOffsets: boolean;
  /**
   * Shows camera target debug visualization.
   * - Green dot: animateTo target position
   * - Orange box: focusOn bounding area
   * - Cyan box: getFocusOnTransform bounding area
   */
  showCameraTargets: boolean;
  /**
   * Shows focusOn 3D debug visualization (point cloud spheres and/or wireframe bounding boxes).
   * Pass `{ pointCloud?: { size?, color? } | false, boundingBox?: { color? } | false }` to configure.
   */
  focusOn: FocusOnDebugConfig;
};
/**
 * Type definition for the debug state configuration.
 * Represents all available debug options that can be toggled.
 */
type DebugState$2 = typeof DEFAULT_DEBUG_STATE;
/**
 * Debug utility class for toggling various debug visualization features.
 *
 * This class provides a centralized way to control debug features like:
 * - Text area mesh visualization for polygon labels
 * - Environment map rendering
 * - Collision box visualization
 *
 * @example
 * ```typescript
 * const debug = new Debug(core);
 *
 * // Enable collision boxes and environment map
 * debug.update({
 *   showCollisionBoxes: true,
 *   showEnvMap: true
 * });
 *
 * // Disable all debug features
 * debug.update({
 *   showCollisionBoxes: false,
 *   showEnvMap: false,
 *   showPolygonLabelTextAreaMesh: false
 * });
 * ```
 */
declare class Debug$1 {
  /** Current debug state configuration */
  state: {
    /** Shows the text area mesh used for polygon label rendering */
    showPolygonLabelTextAreaMesh: boolean;
    /** Enables the basic environment map for lighting and reflections */
    showEnvMap: boolean;
    /** Shows collision detection boxes for debugging spatial interactions */
    showCollisionBoxes: boolean;
    /** Shows the debug for the geometry in focus system */
    showGeometryInFocus: boolean;
    /**
     * Shows LOD level indicators on images via color tinting.
     */
    showImageLOD: boolean;
    /** Shows model instancing statistics (batch counts, instance counts, draw calls) */
    showModelInstancingStats: boolean;
    /**
     * Shows screen offset areas as transparent colored overlays.
     * - Red: top offset
     * - Green: bottom offset
     * - Blue: left offset
     * - Yellow: right offset
     */
    showScreenOffsets: boolean;
    /**
     * Shows camera target debug visualization.
     * - Green dot: animateTo target position
     * - Orange box: focusOn bounding area
     * - Cyan box: getFocusOnTransform bounding area
     */
    showCameraTargets: boolean;
    /**
     * Shows focusOn 3D debug visualization (point cloud spheres and/or wireframe bounding boxes).
     * Pass `{ pointCloud?: { size?, color? } | false, boundingBox?: { color? } | false }` to configure.
     */
    focusOn: FocusOnDebugConfig;
  };
  /** Reference to the core renderer instance */
  core: Core;
  /**
   * Creates a new Debug instance.
   *
   * @param core - The core renderer instance to control debug features for
   */
  constructor(core: Core);
  /**
   * Updates the debug state with new configuration options.
   * Only changed values will trigger updates to the corresponding systems.
   *
   * @param updateState - Partial debug state with the options to update
   *
   * @example
   * ```typescript
   * // Enable only collision boxes
   * debug.update({ showCollisionBoxes: true });
   *
   * // Enable multiple features at once
   * debug.update({
   *   showEnvMap: true,
   *   showPolygonLabelTextAreaMesh: true
   * });
   * ```
   */
  update(updateState: Partial<DebugState$2>): void;
  /**
   * Handles the actual system updates based on changed debug state values.
   * This method applies the debug state changes to the appropriate renderer systems.
   *
   * @param diff - Object containing only the debug state properties that changed
   * @private
   */
  private handleUpdate;
}
//#endregion
//#region ../renderer-three/src/systems/2d-occlusion/system.d.ts
/**
 * Set to `true` by the visual regression harness (see `e2e/visual/fixtures.ts`)
 * before page load. When set we bypass the throttle so screenshots are
 * deterministic. Anything else leaves the throttle in effect.
 */
declare global {
  interface Window {
    __MAPPEDIN_E2E__?: boolean;
  }
}
declare class Occlusion2DSystem {
  private state;
  private renderer;
  private renderService;
  private pickingTexture?;
  private pickingMaterial;
  private pixelBuffer?;
  private width;
  private height;
  private scale;
  private color;
  private convertTo3DMapPosition;
  private destroyed;
  private enabled;
  backgroundId: number;
  /**
   * Applies the id to the geometry which is encoded as a color
   */
  private applyId;
  private createOccluderMesh;
  constructor(state: RendererState, convertTo3DMapPosition: (position: Position) => Vector3, renderer?: Renderer);
  reserveOccluderId(): number;
  enable(): void;
  disable(): void;
  resize: () => void;
  private shouldShowByXY;
  activeOccluders: Set<unknown>;
  private framesSinceLastUpdate;
  /**
   * Throttled per-frame entry point called by the render loop. Delegates to
   * {@link updateImmediately} once every {@link OCCLUSION_SKIP_FRAMES} calls.
   * Callers that need a guaranteed synchronous pass should use
   * {@link updateImmediately} directly. When running under the visual
   * regression harness (`?e2e=true`) the throttle is bypassed so every
   * render produces a deterministic occlusion state.
   */
  update: () => void;
  updateImmediately: () => void;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/geometry-disposal/system.d.ts
/**
 * This system is responsible for disposing of geometries that are no longer needed.
 * It runs at the end of the render loop, so that we can create outlines and whatever is needed in the frame.
 */
declare class GeometryDisposalSystem {
  private readonly state;
  dirty: boolean;
  constructor(state: RendererState);
  update(): void;
}
//#endregion
//#region ../renderer-three/src/systems/texture/system.d.ts
declare class TextureSystem extends PubSub<{
  'texture-added': void;
}> {
  dirty: boolean;
  state: RendererState;
  constructor(state: RendererState);
  texturePromiseCache: Map<string, Promise<Texture>>;
  loadTexture(path: string): Promise<Texture | undefined>;
  update(): void;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/border/system.d.ts
declare class BorderSystem {
  rendererState: RendererState;
  dirty: boolean;
  convertTo3DMapPosition: Core['convertTo3DMapPosition'];
  constructor(rendererState: RendererState, convertTo3DMapPosition: Core['convertTo3DMapPosition']);
  update(): void;
  private buildBordersForFeatures;
  private colorToMaterialCache;
  private getOrCreateMaterials;
  private buildBorder;
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/render-order/system.d.ts
/**
 * System for managing dynamic render order assignment for always-on-top elements.
 */
declare class RenderOrderSystem {
  private currentOrder;
  private assignedOrders;
  private state;
  constructor(state: RendererState);
  /**
   * Assigns a unique render order for an overlay object
   * @param object - The object to assign render order to
   * @returns The assigned render order
   */
  assignOrder(object: object): number;
  /**
   * Releases the render order for an object
   * @param object - The object to release render order from
   * @returns The default render order
   */
  releaseOrder(object: object): number;
  /**
   * Gets the current highest render order
   * @returns The current highest render order
   */
  getHighestOrder(): number;
  /**
   * Gets the assigned render order for an object
   * @param object - The object to get render order for
   * @returns The render order or undefined if not assigned
   */
  getOrder(object: object): number | undefined;
  update(): void;
  /**
   * Applies render order to a model component's mesh
   * @param modelComponent - The model component to apply render order to
   */
  private applyRenderOrder;
}
//#endregion
//#region ../renderer-three/src/systems/masking/system.d.ts
/**
 * Masking is a way to hide or show parts of a geometry based on a mask of another geometry.
 * There are two types of masks:
 * - Mask: a mask is a geometry that is used to hide or show parts of another geometry.
 * - Masked object: a masked object is a geometry that is hidden or revealed when the mask is applied.
 *
 * There are two types of effects:
 * - Hide: the masked object is hidden when the mask is rendered in front of it.
 * - Reveal: the masked object is revealed when the mask is rendered in front of it.
 *
 * Due to the fact that we merge outlines, for now this only works for geometry groups.
 *
 */
declare class MaskingSystem {
  private state;
  constructor(state: RendererState);
  private applyMask;
  update(): void;
  /** Render order for mask producers - renders before all other geometry */
  private static MASK_RENDER_ORDER;
  private enableMaskProducer;
  private enableMaskReciever;
  private disableMask;
}
//#endregion
//#region ../renderer-three/src/systems/clipping-plane/system.d.ts
declare class ClippingPlaneSystem {
  rendererState: RendererState;
  dirty: boolean;
  constructor(rendererState: RendererState);
  update(): void;
  private process;
  /**
   * Creates the stencil geometry for hole fill detection
   * @param modelGeometry - The merged model geometry for counting passes
   * @param planeGeometry - The plane geometry for bias pass (covers entire hole fill area)
   * @param plane - The clipping plane
   * @param renderOrder - Base render order for the meshes
   */
  private createHoleFillGeometry;
}
//#endregion
//#region ../renderer-three/src/systems/system-plugins/system.d.ts
/**
 * **Super experimental — this API may change or be removed in any release without notice.
 * Do not depend on it in production.**
 *
 * Interface for plugins that hook into the Mappedin render loop.
 *
 * Plugins receive the full renderer state every frame, providing direct access
 * to the Three.js scene, camera, renderer, lighting, and all ECS geometry entities.
 * Use this to inject custom Three.js objects, apply per-frame effects, or read scene state.
 *
 * ## Lifecycle
 *
 * - `update()` is called **every frame** during the finalization phase of the render loop
 *   (after camera, path, and 2D systems have run, but before `DrawSystem` applies
 *   style changes and before `paint()` draws the frame).
 * - Plugins are called in registration order.
 *
 * ## Standalone vs. Overlay Mode
 *
 * | Concern | Standalone | MapLibre Overlay |
 * |---|---|---|
 * | Add meshes to | `state.threeJSScene` | `state.geometryScene` |
 * | Camera position | Reflects actual viewer position | **Not reliable** — MapLibre overwrites the projection matrix each frame |
 * | Coordinate space | Scene units (meters from map center) | Scene units (meters from map center) |
 *
 * ## Performance
 *
 * `update()` runs on the main thread every frame. Avoid heavy computation, allocations,
 * or GPU-blocking operations. Gate one-time work behind an initialization flag.
 *
 * @example
 * ### Adding a custom Three.js mesh
 * ```ts
 * import { type ISystemPlugin, type TRendererState } from '@mappedin/mappedin-js';
 * import { Mesh, MeshStandardMaterial, SphereGeometry } from 'three';
 *
 * class SpherePlugin implements ISystemPlugin {
 *   private sphere: Mesh | null = null;
 *
 *   update(state: TRendererState): void {
 *     // One-time setup — add a sphere to the scene
 *     if (!this.sphere) {
 *       const geo = new SphereGeometry(3, 32, 32);
 *       const mat = new MeshStandardMaterial({ color: 0xff4444 });
 *       this.sphere = new Mesh(geo, mat);
 *       // Use geometryScene for overlay mode, threeJSScene for standalone
 *       state.geometryScene.add(this.sphere);
 *     }
 *     this.sphere.rotation.y += 0.01;
 *   }
 * }
 *
 * mapView.registerPlugin(new SpherePlugin());
 * ```
 *
 * @example
 * ### Reading ECS component data
 * ```ts
 * class InspectorPlugin implements ISystemPlugin {
 *   update(state: TRendererState): void {
 *     for (const geometry of state.geometry3DsInScene) {
 *       const style = geometry.getComponent('style');
 *       if (style) {
 *         console.log(geometry.id, style.color, style.opacity);
 *       }
 *     }
 *   }
 * }
 * ```
 *
 * @example
 * ### Mutating ECS styles (mark dirty to apply)
 * ```ts
 * class HighlightPlugin implements ISystemPlugin {
 *   update(state: TRendererState): void {
 *     for (const geometry of state.geometry3DMap.values()) {
 *       const style = geometry.getComponent('style');
 *       if (style) {
 *         style.color = 'red';
 *         style.dirty = true; // Required — triggers DrawSystem to apply the change
 *       }
 *     }
 *   }
 * }
 * ```
 *
 * @experimental
 */
interface ISystemPlugin$2 {
  /**
   * Called every frame with the current renderer state.
   *
   * @param state - The renderer state snapshot for this frame. Contains Three.js objects
   *   (`threeJSScene`, `renderer`, `cameraObject`, `directionalLight`, `ambientLight`),
   *   the geometry scene graph (`geometryScene`), and all ECS entity maps
   *   (`geometry3DMap`, `geometry3DsInScene`, `geometry2DMap`, `geometry2DsInScene`).
   */
  update(state: RendererState): void;
}
/**
 * Manages registered {@link ISystemPlugin} instances and invokes them each frame.
 *
 * @internal — Not part of the public API. Use {@link MapView.registerPlugin} and
 * {@link MapView.unregisterPlugin} instead.
 */
declare class PluginSystem {
  private plugins;
  /** @internal */
  registerPlugin(plugin: ISystemPlugin$2): void;
  /** @internal */
  unregisterPlugin(plugin: ISystemPlugin$2): void;
  /** @internal */
  update(state: RendererState): void;
}
//#endregion
//#region ../renderer-three/src/systems/shadows/system.d.ts
declare class ShadowsSystem {
  private state;
  private rendererService;
  private depthMaterial;
  private cameraOrbit;
  private lightCamera;
  private shadowRenderTarget;
  private lightMatrix;
  private currentSnapX;
  private currentSnapY;
  private shadowCenter;
  private shadowPlane;
  private shadowPlaneMaterial;
  private shadowPlaneEnabled;
  private visibleAtCurrentZoom;
  private zoomOpacityFactor;
  private lightCameraHelper;
  private debugEnabled;
  private debugGrid;
  private debugCurrentCell;
  private debugCurrentCellMaterial;
  private debugCanvas;
  private debugCanvasCtx;
  private debugRenderTarget;
  private debugDepthMaterial;
  private debugDepthQuad;
  private debugDepthScene;
  private debugDepthCamera;
  /** Immutable user-provided configuration (external API) */
  private readonly options;
  /** Mutable internal state that changes during runtime */
  private readonly internal;
  private readonly shadowResolutionSizes;
  private readonly shadowResolutionZoomThresholds;
  constructor(state: RendererState, rendererService: Renderer, cameraOrbit: Object3D, options?: ShadowsOptions);
  /**
   * Creates a WebGLRenderTarget for shadow mapping with the specified size
   * @param size - The width and height of the render target in pixels
   * @returns A configured WebGLRenderTarget with depth texture
   */
  private createShadowRenderTarget;
  /**
   * Resizes the shadow render target to the specified size
   * Reuses the existing render target to avoid memory allocation overhead
   * @param size - The new width and height of the render target in pixels
   */
  private resizeShadowRenderTarget;
  /**
   * Creates a shadow-receiving plane at ground level (z=0)
   * The plane only renders shadow pixels and is transparent elsewhere
   */
  private createShadowPlane;
  /**
   * Enable or disable the shadow plane
   */
  setShadowPlaneEnabled(enabled: boolean): void;
  /**
   * Get shadow plane enabled state
   */
  isShadowPlaneEnabled(): boolean;
  /**
   * Update shadow plane position to follow camera (for large scenes)
   */
  private updateShadowPlanePosition;
  /**
   * Enable or disable debug visualization for the shadow system
   * @param enabled - Whether to show debug helpers
   */
  setDebugEnabled(enabled: boolean): void;
  /**
   * Get debug visualization enabled state
   * @returns Whether debug visualization is enabled
   */
  isDebugEnabled(): boolean;
  /**
   * Creates debug visualization helpers for the shadow system
   */
  private createDebugHelpers;
  /**
   * Creates a grid visualization showing the shadow snap grid
   */
  private createDebugGrid;
  /**
   * Creates a colored mesh highlighting the current grid cell
   */
  private createDebugCurrentCell;
  /**
   * Creates a debug canvas to display the shadow map (what the light camera sees)
   */
  private createDebugCanvas;
  private debugPixelBuffer;
  /**
   * Updates the debug canvas with a color render from the light camera's perspective
   * When DEBUG_DEPTH_MAP is true, shows the captured depth texture instead
   */
  private updateDebugCanvas;
  /**
   * Disposes debug visualization helpers
   */
  private disposeDebugHelpers;
  /**
   * Updates the debug helpers to reflect current light camera state
   */
  private updateDebugHelpers;
  /**
   * Calculate sun direction vector from azimuth and elevation angles
   */
  private updateSunDirection;
  private updateLightCamera;
  private bias;
  private matrix;
  private updateLightMatrix;
  /**
   * Update sun distance based on camera zoom level
   */
  private updateAutoSunDistance;
  /**
   * Update shadow resolution based on camera zoom level
   * Only applies when shadowMapSize is set to 'auto'
   * Switches between high (4K) and low (2K) resolution with hysteresis
   */
  private updateAutoShadowResolution;
  private updateAutoLightSize;
  /**
   * Updates shadow visibility and opacity based on zoom level threshold.
   * Shadows smoothly fade in/out over a zoom range for a smoother transition.
   * When zoom >= visibleAtZoomLevel: fully visible (opacity factor = 1)
   * When zoom < visibleAtZoomLevel - OPACITY_FADE_ZOOM_RANGE: invisible (opacity factor = 0)
   * Between these: opacity interpolates linearly
   * @param zoomLevel - Current mercator zoom level
   */
  private updateZoomVisibility;
  /**
   * Returns whether shadows are currently enabled and visible at the current zoom level
   * @returns True if shadows should be rendered
   */
  isVisibleAtCurrentZoom(): boolean;
  /**
   * Update snap grid size based on camera zoom level
   * Larger grid when zoomed out = fewer shadow map re-renders
   */
  private updateAutoSnapGridSize;
  /**
   * Recreates the debug grid visualization when grid size changes
   */
  private recreateDebugGrid;
  private transparentGeometryVisibilityStateMap;
  private renderShadowMap;
  private updateShadowUniforms;
  private lastZoomLevel;
  private lastCameraElevation;
  /**
   * Checks if zoom level or camera elevation has changed significantly since the last update
   * @param zoomLevel - Current zoom level
   * @param cameraElevation - Current camera elevation
   * @returns True if zoom or elevation changed significantly, false otherwise
   */
  private zoomOrElevationChanged;
  private updateSnap;
  needsRender: boolean;
  needsCompute: boolean;
  update(zoomLevel: number, cameraElevation: number): void;
  /**
   * Dispose shadow plane resources
   */
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/systems/model/system.d.ts
/**
 * System responsible for loading and managing 3D models (GLB/GLTF)
 */
declare class ModelSystem extends PubSub<{
  'model-loaded': void;
  'batch-changed': void;
}> {
  /**
   * Flag to indicate that any model has gone from zero to non zero opacity
   */
  transparencyChanged: boolean;
  private state;
  private convertTo3DMapPosition;
  private loader?;
  private loadPromises;
  /** Cache of loaded GLTF data, keyed by cyrb53 hash of URL */
  private gltfCache;
  /** Pending GLTF load promises to prevent duplicate loads */
  private gltfLoadPromises;
  /** Instance map per GroupContainer, keyed by container entityId -> URL hash -> InstancedMesh container */
  private instanceMap;
  /** Debug UI instance */
  private debugUI;
  /** Map of URL hash to friendly model name */
  private modelNames;
  /** Counter for generating batch IDs */
  private batchCounter;
  /** All batches tracked by mesh reference for fast lookup during removal */
  private batchByMesh;
  /** Batches grouped by URL hash for debug UI */
  private batchesByUrlHash;
  /** Set of non-instanced model entity IDs for debug UI */
  private nonInstancedModels;
  /** Pending opacity changes to be processed in bulk at end of update cycle */
  /**
   * Tracks entities that need opacity batch changes, processed in bulk.
   * Note: visibleThroughGeometry is always false for instanced models since models
   * with visibleThroughGeometry=true at creation are handled as non-instanced.
   */
  private pendingOpacityChanges;
  /** Tracks entity IDs in detached batches for efficient rebatch checks */
  private detachedEntityIds;
  /** Reusable Matrix4 instance for transform calculations */
  private readonly tempMatrix;
  /** Reusable Quaternion instance for rotation calculations */
  private readonly tempQuaternion;
  /** Reusable Euler instance for rotation calculations */
  private readonly tempEuler;
  /** Reusable Vector3 instance for scale calculations */
  private readonly tempScale;
  /** Reusable Color instance for color operations */
  private readonly tempColor;
  constructor(state: RendererState, convertTo3DMapPosition: any);
  /**
   * Creates a new batch entry and registers it
   * @param mesh - The Object3D containing InstancedMeshes
   * @param urlHash - The URL hash for this model
   * @param containerId - The container this batch belongs to
   * @param opacity - The opacity for this batch (1 = default)
   * @param maxCount - Maximum instance capacity
   * @returns The created batch entry
   */
  private createBatch;
  /**
   * Computes bounding spheres for all InstancedMeshes in a mesh container.
   * This is required for proper raycasting/intersection detection.
   * @param mesh - The container Object3D with InstancedMesh children
   */
  /**
   * Removes a batch and cleans up tracking
   * @param batch - The batch to remove
   */
  private removeBatch;
  /**
   * Gets the batch for a mesh
   * @param mesh - The mesh to look up
   * @returns The batch entry or undefined
   */
  private getBatchForMesh;
  /**
   * Updates the debug UI with current batch information
   */
  private updateDebugUI;
  /**
   * Shows the model instancing debug UI
   */
  showDebug(): void;
  /**
   * Hides the model instancing debug UI
   */
  hideDebug(): void;
  /**
   * Lazily loads and returns the GLTFLoader instance
   * @returns The GLTFLoader instance
   */
  getGLTFLoader(): Promise<GLTFLoader>;
  /**
   * Gets a cached GLTF or loads it if not cached
   * @param url - The URL or data URI of the model
   * @param urlHash - The cyrb53 hash of the URL
   * @returns The loaded GLTF data
   */
  private getOrLoadGLTF;
  /**
   * Creates a non-instanced model (regular mesh) for entities with visibleThroughGeometry or clippingEnabled
   * @param entity - The model entity
   * @param gltf - The loaded GLTF data
   * @param tree - The geometry group container to add the mesh to
   * @param urlHash - The URL hash for tracking
   */
  private createNonInstancedModel;
  /**
   * Resizes instance containers when capacity is exceeded
   * @param entry - The current instance cache entry
   * @param gltf - The GLTF data for creating new meshes
   * @returns The updated instance cache entry
   */
  private resizeInstanceContainer;
  /**
   * Gets or creates an instance container for a GroupContainer and URL
   * @param containerId - The GroupContainer entity ID
   * @param urlHash - The cyrb53 hash of the URL
   * @param gltf - The loaded GLTF data
   * @returns The instance cache entry
   */
  private getOrCreateInstanceContainer;
  /**
   * Creates a model entity from a GeoJSON feature
   * @param id - The unique identifier for the model
   * @param feature - The GeoJSON Point feature with model properties
   * @param style - Optional model style overrides (includes EXPERIMENTAL_clippingEnabled)
   * @returns The created model geometry entity
   */
  createModelFromFeature(id: string | number, feature: Feature<Point, ModelProperties>, style?: Partial<InitializeModelState$2>): ModelGeometry3D;
  /**
   * Populates a geometry group with loaded model instances using cached GLTF and shared InstancedMeshes
   * @param entities - Set of entity IDs to populate with the model
   * @param url - The URL or data URI of the model to load
   * @param tree - The geometry group container
   * @returns The created Object3D containing the model instances
   */
  populateModelGroup(entities: Set<string | number>, url: string, tree: FeatureCollectionObject3D): Promise<Geometry3DObject3D>;
  /**
   * Updates the model system, processing any pending model loads and style updates
   * @returns A promise that resolves when all model loading is complete
   */
  update(): Promise<void[]>;
  /**
   * Re-batches detached instances that share the same opacity into shared InstancedMeshes
   * This optimizes draw calls when multiple instances animate to the same opacity
   */
  private rebatchDetachedInstances;
  /**
   * Creates a shared InstancedMesh batch for multiple detached entities with the same opacity
   */
  private createSharedBatchForDetached;
  /**
   * Removes an instance from a batch using swap-and-decrement pattern
   * This properly cleans up the old batch without destroying the entity
   */
  private removeInstanceFromBatch;
  /**
   * Updates styles for all dirty model entities in the scene
   */
  private updateModelStyles;
  /**
   * Processes all pending opacity changes in bulk, grouping entities by target opacity
   * to minimize the number of batches created.
   *
   * Optimization: If all entities in a batch are moving to the same new opacity,
   * update the batch's opacity in-place instead of creating a new batch.
   */
  private flushPendingOpacityChanges;
  /**
   * Updates an instance's transform (position, rotation, scale, visibility)
   * @param entity - The model entity to update
   */
  updateInstanceTransform(entity: ModelGeometry3D): void;
  /**
   * Updates styles for a non-instanced model (regular mesh)
   * @param entity - The model entity to update
   */
  private updateNonInstancedModelStyle;
  /**
   * Updates an instance's color
   * @param entity - The model entity to update
   * @param color - The color to set (CSS color string), or undefined to use original
   * @param materialOverrides - Optional per-material color overrides
   */
  updateInstanceColor(entity: ModelGeometry3D, color?: string, materialOverrides?: ModelStyle['material']): void;
  /**
   * Removes a model instance from its batch
   * Swaps the removed instance with the last one and decrements the count
   * @param entity - The model entity to remove
   * @returns true if the mesh should be destroyed (detached mesh or last instance), false otherwise
   */
  removeInstance(entity: ModelGeometry3D): boolean;
  /**
   * Cleans up all resources used by the model system
   * Called automatically when the renderer is destroyed via onAbort
   */
  destroy(): void;
  endFrame: () => void;
}
//#endregion
//#region ../renderer-three/src/systems/two-d-entity/system.d.ts
/**
 * Facade bridging the 3D scene graph and the 2D labels/markers pipeline.
 *
 * Owns the TwoDPipeline internally and exposes only the methods needed by
 * the renderer and render system. External code should not access pipeline
 * internals directly.
 */
declare class TwoDEntitySystem {
  #private;
  /**
   * Creates a new TwoDEntitySystem with an internal TwoDPipeline.
   * @param container - DOM element to host the 2D overlay
   * @param state - Renderer state
   * @param pipelineState - 2D pipeline state
   * @param projectFn - Function to project world coords to screen coords
   * @param options - Pipeline options (worker URL, collision settings, etc.)
   */
  constructor(container: HTMLElement, state: RendererState, pipelineState: TwoDPipelineState, projectFn: (out: Vector2, v3: Vector3) => void, options?: TwoDPipelineOptions);
  /** Returns the internal pipeline for direct access (test use only). */
  get pipeline(): TwoDPipeline;
  /** @internal Canvas used for rendering 2D labels. */
  get labelCanvas(): HTMLCanvasElement;
  /** Quad tree of interactive colliders for hit testing. */
  get interactiveCollidersQTree(): QuadTree<{
    entityId: string | number;
  }>;
  /** Quad tree of visible colliders for spatial queries. */
  get visibleCollidersQTree(): QuadTree<{
    entityId: string | number;
  }>;
  /**
   * Resizes the pipeline canvas to match the container.
   * Called from the renderer's resize handler.
   */
  resize(): void;
  /**
   * Rebuilds the pipeline's flat entity set from the Geometry2D scene graph.
   *
   * The 3D renderer maintains a scene graph where floor containers control
   * which 2D entities are "in the scene" (visible floor = entities included).
   * This method clears the pipeline and re-adds only the entities that are
   * currently in the scene, syncing their world positions from the Three.js
   * Object3D into the lightweight Entity2D used by the pipeline.
   *
   * Called by the render system only when twoDdirty is true (scene graph
   * membership changed, e.g. floor change or container visibility toggle).
   */
  syncTwoDEntities(): void;
  /**
   * Per-frame update. Syncs attached entity state from 3D parents, then
   * runs the 2D pipeline (projection, collision, draw).
   *
   * @param zoomLevel - Current mercator zoom level
   * @param isUserInteracting - Whether user is panning/zooming
   * @param isCameraMoving - Whether the camera is animating
   * @param imageScreenBBoxes - Bounding boxes of images on screen for collision avoidance
   */
  update(zoomLevel: number, isUserInteracting: boolean, isCameraMoving: boolean, imageScreenBBoxes?: Rectangle[]): void;
  /**
   * Marks the 2D state as dirty, triggering re-population of the entity set
   * and collision recalculation.
   */
  markDirty(): void;
  /**
   * Controls whether the next collision update performs a full strategy recompute.
   * Set to false on camera-start events (locks strategies during movement).
   * Set to true on camera-end events (triggers fresh recompute).
   */
  get collidersNeedRecomputing(): boolean;
  set collidersNeedRecomputing(v: boolean);
  /**
   * Updates the watermark configuration for collision avoidance.
   * @param watermark - Watermark dimensions and position
   */
  updateWatermark(watermark: {
    width: number;
    height: number;
    position: WatermarkPosition$1;
  }): void;
  /**
   * Cancels all pending requestAnimationFrame callbacks.
   * Call before a synchronous render to avoid double-drawing.
   */
  cancelPendingFrames(): void;
  /**
   * Marks the collision system's colliders as dirty, triggering recalculation.
   */
  setCollidersDirty(): void;
  /**
   * Deletes a text cache entry by entity ID.
   * Used when removing a label to clean up cached text rendering.
   * @param id - The entity ID
   */
  deleteTextCacheEntry(id: string | number): void;
  /** Enables the debug overlay that draws visible collision boxes. */
  showCollisionBoxes(): void;
  /** Disables the debug overlay and clears the canvas. */
  hideCollisionBoxes(): void;
  /**
   * Destroys the internal pipeline, removing DOM elements and freeing resources.
   * Called automatically via #registerSystem when the renderer is destroyed.
   */
  destroy(): void;
}
//#endregion
//#region ../renderer-three/src/renderer.d.ts
type Systems = {
  cameraSystem: CameraSystem;
  panBoundsSystem: PanBoundsSystem;
  twoDEntitySystem: TwoDEntitySystem;
  interactionSystem: InteractionSystem;
  batchedMeshSystem: BatchedMeshSystem;
  modelSystem: ModelSystem;
  drawSystem: DrawSystem;
  renderSystem: RenderSystem;
  watermarkSystem: WatermarkSystem;
  htmlControlsSystem: HTMLControlsSystem;
  exporterSystem: ExporterSystem;
  customGeometrySystem: CustomGeometrySystem;
  outlineInterpolationSystem: OutlineInterpolationSystem;
  outdoorLayersSystem: OutdoorLayers;
  pathSystem: PathSystem;
  imageSystem: ImageSystem;
  geometryInFocusSystem: GeometryInFocusSystem;
  meshDetachmentSystem: MeshDetachmentSystem;
  meshModificationSystem: MeshModificationSystem;
  text3DSystem: Text3DSystem;
  occlusion2DSystem: Occlusion2DSystem;
  geometryDisposalSystem: GeometryDisposalSystem;
  textureSystem: TextureSystem;
  borderSystem: BorderSystem;
  renderOrderSystem: RenderOrderSystem;
  maskingSystem: MaskingSystem;
  clippingPlaneSystem: ClippingPlaneSystem;
  pluginSystem: PluginSystem;
  shadowsSystem?: ShadowsSystem;
};
type MapViewState$1 = {
  readonly type: 'map-view';
  hoverColor: string;
  text3dHoverColor: string;
};
declare class Core extends PubSub<MapEvent> {
  #private;
  options: Omit<RendererCoreOptions$2, 'outdoorView'>;
  container: HTMLElement;
  Debug: Debug$1;
  /**
   * The view camera is used for projecting both the outdoor map and our scene
   */
  get viewCamera(): Camera$1;
  /**
   * The perspective camera used for 3D scene calculations and view-dependent lighting
   */
  get cameraObject(): PerspectiveCamera;
  get canvasWidth(): number;
  get canvasHeight(): number;
  rendererDomElement: HTMLCanvasElement;
  /**
   * Returns pixel ratio of the renderer
   */
  get resolutionScale(): number;
  get aspect(): number;
  /**
   * @internal
   * Returns the canvas used for rendering 2D labels.
   */
  get labelsCanvas(): HTMLCanvasElement | null;
  camera: Camera$2;
  map: Map$1 | undefined;
  /**
   * Returns the mode the Renderer is in.
   */
  get mode(): "standalone" | "outdoors-interleaved" | "outdoors-overlay" | undefined;
  /**
   * @internal
   */
  constructor(container: HTMLElement, options?: RendererCoreOptions$2);
  /**
   * Projects a position into screen space. If a Vector3 is provided, the z-coordinate will include the depth from the camera.
   * @param projectVector - The vector to project the position into
   * @param position - The position to project
   */
  /**
   * Projects a 3D position into screen space.
   * @param projectVector - The vector to store the projected screen coordinates (x, y). If Vector3, z will contain depth from camera.
   * @param position - The 3D world position to project
   */
  project: (projectVector: Vector2 | Vector3, position: Vector3) => void;
  /**
   * Add a container that can hold other containers, geometry groups, markers, labels and paths. Use this to group entities together.
   */
  addGroupContainer(id: string, options?: {
    visible?: boolean;
    altitude?: number;
    interactive?: boolean;
    focusable?: boolean;
    preloadGeometry?: boolean;
  }, parent?: EntityId$1<GroupContainerState$1> | string | number | null): EntityId$1<GroupContainerState$1>;
  getParentContainer: (parent?: EntityId$1<GroupContainerState$1> | EntityId$1<GeometryState> | string | number | null, defaultToScene?: boolean) => GroupContainerObject3D | undefined;
  /**
   * Add a custom THREE.js entity to the map. The geometry is placed at the GeoJSON coordinate and includes a `setup` and `update` methods.
   * Setup is called when the first time the geometry visible, and update is called every render frame.
   */
  addCustomGeometry(id: string, feature: Feature<Point>, builder: CustomGeometryBuilder, style?: {
    visible?: boolean;
    altitude?: number;
    interactive?: boolean;
  }, parent?: EntityId$1<GroupContainerState$1> | string | number | null): EntityId$1<ShapeState>;
  registerPlugin(plugin: ISystemPlugin$2): void;
  unregisterPlugin(plugin: ISystemPlugin$2): void;
  /**
   * Add a conceptual feature collection from GeoJSON data.
   *
   * Each feature is converted into a batched entity, which may be split across
   * multiple BatchedMeshes internally based on material. The collection itself
   * is a lightweight container; visual properties such as color, opacity,
   * altitude, height, etc. are driven per-feature via the `style` callback.
   *
   * To toggle visibility of the whole collection, wrap it in a
   * `GroupContainer` via the `parent` argument and set visibility on the
   * container.
   *
   * The only collection-level concern honored at creation time is the optional
   * mask — read from `style(features[0])`.
   */
  addFeatureCollection<T$1 extends FeatureCollection<Polygon | MultiPolygon | LineString, any>>(id: string, geometry: T$1, style?: ((feature: Feature<Polygon | MultiPolygon | LineString, any>) => T$1 extends FeatureCollection<LineString, any> ? LineStyle$2 : PaintStyle$2) | (T$1 extends FeatureCollection<LineString, any> ? LineStyle$2 : PaintStyle$2), fcState?: {
    altitude?: number;
    visible?: boolean;
  }, parent?: EntityId$1<GroupContainerState$1> | string | number | null): EntityId$1<FeatureCollectionState>;
  addOccluder<T$1 extends Feature<Polygon | MultiPolygon, any>>(feature: T$1, parent?: EntityId$1<GroupContainerState$1> | string | number | null): number;
  addImage(id: string, geometry: Feature<Point, ImageProperties>, style: ImageStyle, parent?: EntityId$1<GroupContainerState$1> | string | null): EntityId$1<ImageState> | undefined;
  /**
   * Add a group of models from GeoJSON data. These will be instanced automatically for better performance.
   */
  addModelGroup(id: string, geometry: FeatureCollection<Point, ModelProperties>, style: Partial<InitializeModelState$2>, {
    parent,
    onComplete: onAdd
  }?: {
    parent?: EntityId$1<GroupContainerState$1> | string | null;
    onComplete?: () => void;
  }): EntityId$1<FeatureCollectionState> | undefined;
  /**
   * Add an HTML Marker at a GeoJSON coordinate.
   */
  addMarker2D(coordinate: Position$2, contentHTML: string, options?: AddMarkerOptions$1, parent?: EntityId$1<GroupContainerState$1> | string | number | null): EntityId$1<MarkerState$1> | undefined;
  addText3D(id: string, geometry: Feature<Point, FloatingFloorTextProperties>, options: AddText3DOptions$2, parent?: EntityId$1<GroupContainerState$1> | string | null): EntityId$1<Text3DState$1>;
  /**
   * Labels an existing 3D geometry with a text area.
   *
   * @param meshGeometryId - The ID of the target 3D geometry to label.
   * @param content - The text content to display.
   * @param options - Additional options for adding the text label, including:
   *   - parentId: Optional ID of the parent container.
   *   - appearance: Optional appearance settings for the text label.
   *
   * @returns An object containing the ID and type of the created or existing text label, or undefined if labeling failed. If geometry is already labeld, the same text id will be returned
   *
   * @example
   * ```typescript
   * const label = renderer.labelText3D('geometry123', 'Hello World', { parentId: 'parent456', appearance: { color: 'red' } });
   * if (label) {
   *   console.log(`Label created with ID: ${label.id}`);
   * }
   *
   */
  labelText3D(meshGeometryId: string, content: string, options?: AddText3DOptions$2 & {
    parentId?: string;
  }): EntityId$1<Text3DState$1> | undefined;
  /**
   * Add a 2D label at a GeoJSON coordinate.
   */
  addLabel2D(coordinate: Position$2, text: string, options?: AddLabelOptionsInternal$2, parent?: EntityId$1<GroupContainerState$1> | string | null): EntityId$1<LabelState> | undefined;
  /**
   * Add a Path along a set of GeoJSON coordinates that can be animated.
   */
  addPath(geometry: FeatureCollection<Point, PathProperties>, options?: AddPathOptions, parent?: EntityId$1<GroupContainerState$1> | string | null): EntityId$1<PathState$1> | undefined;
  /**
   * Updates the watermark on the map.
   *
   * @param options {WatermarkUpdateOptions}
   */
  updateWatermark(options: WatermarkUpdateOptions$1): void;
  /**
   * Remove an entity from the renderer and release associated resources.
   */
  remove(object: string | number): void;
  remove(object: EntityTypes): void;
  /**
   * Show collision boxes for 2D entities for debugging.
   * Draws visible bounding rectangles on a transparent overlay canvas.
   */
  showCollisionBoxes: () => void;
  /**
   * Hide collision boxes for 2D entities for debugging.
   */
  hideCollisionBoxes: () => void;
  /**
   * Recursively get the state for the whole scene. Can be an expensive operation.
   */
  getScene(): GroupContainerState$1;
  getThreeScene(): Scene | undefined;
  getThreeCamera(): PerspectiveCamera;
  setEnvironment(update: EnvMapOptions$2): Promise<void>;
  getEnvironment(): EnvMapOptions$2;
  /**
   * Get the current scene as a GLB file
   */
  getCurrentSceneGLTF(options: GLTFExportOptions): Promise<Blob>;
  /**
   * Gets the bounding area (4 corners) in lon,lat of a geometry, geomrtry group, or group container. This can be used with Camera to focus on an entity
   */
  getBoundingArea(geometryOrGeometryId?: string | number | EntityId$1<EntityState>): Position$2[] | undefined;
  /**
   * Check if the state for a given geometry or geometry id exists
   * @param geometryOrGeometryId - The geometry or geometry id to check
   * @returns True if the state exists, false otherwise
   */
  hasState(geometryOrGeometryId: string | number | EntityId$1<EntityState>): boolean;
  /**
   * Get the current state of the map view, or any entity that was added, regardless of whether it is visible in the scene
   */
  getState(): MapViewState$1;
  getState<T$1 extends EntityId$1<EntityState>>(geometryOrGeometryId: T$1): T$1 extends EntityId$1<LabelState> ? LabelState : T$1 extends EntityId$1<GeometryState> ? GeometryState : T$1 extends EntityId$1<MarkerState$1> ? MarkerState$1 : T$1 extends EntityId$1<FeatureCollectionState> ? FeatureCollectionState : T$1 extends EntityId$1<GroupContainerState$1> ? GroupContainerState$1 : T$1 extends EntityId$1<ModelState> ? ModelState : T$1 extends EntityId$1<PathState$1> ? PathState$1 : T$1 extends EntityId$1<ShapeState> ? ShapeState : T$1 extends EntityId$1<ImageState> ? ImageState : T$1 extends EntityId$1<Text3DState$1> ? Text3DState$1 : EntityState;
  getState(geometryOrGeometryId?: Record<string | number, any> | string | number): EntityState;
  getState<T$1 extends EntityState>(geometryOrGeometryId: T$1['id']): T$1 extends LabelState ? LabelState : T$1 extends GeometryState ? GeometryState : T$1 extends MarkerState$1 ? MarkerState$1 : T$1 extends FeatureCollectionState ? FeatureCollectionState : T$1 extends GroupContainerState$1 ? GroupContainerState$1 : T$1 extends ModelState ? ModelState : T$1 extends PathState$1 ? PathState$1 : T$1 extends ShapeState ? ShapeState : T$1 extends ImageState ? ImageState : EntityState;
  /**
   * Get rendered state for an entity (e.g., runtime rendering state that changes frequently)
   * @param entity The entity to get rendered state for
   * @returns Object with all available rendered state properties, or undefined if not found
   */
  getRenderedState(entity: EntityId$1<LabelState> | string | number): LabelRenderedState$1 | undefined;
  /**
   * Set the state of the map view or any entity that was added, regardless of whether it is visible in the scene.
   */
  setState(object: Partial<Omit<MapViewState$1, 'type'>>): void;
  setState<T$1 extends EntityId$1<LabelState>>(object: T$1 | T$1['id'], state: Partial<LabelState>): void;
  setState<T$1 extends EntityId$1<MarkerState$1>>(object: T$1 | T$1['id'], state: Partial<MarkerStateUpdate>): void;
  setState<T$1 extends EntityId$1<FeatureCollectionState>>(object: T$1 | T$1['id'], state: Partial<FeatureCollectionState>): void;
  setState<T$1 extends EntityId$1<GroupContainerState$1>>(object: T$1 | T$1['id'], state: Partial<GroupContainerState$1>): void;
  setState<T$1 extends EntityId$1<GeometryState>>(object: T$1 | T$1['id'], state: Partial<GeometryState>): void;
  setState<T$1 extends EntityId$1<ShapeState>>(object: T$1 | T$1['id'], state: Partial<ShapeState>): void;
  setState<T$1 extends EntityId$1<PathState$1>>(object: T$1 | T$1['id'], state: PathUpdateState): void;
  setState<T$1 extends EntityId$1<ModelState>>(object: T$1 | T$1['id'], state: Partial<UpdateModelState>): void;
  setState<T$1 extends EntityId$1<ImageState>>(object: T$1 | T$1['id'], state: Partial<ImageState>): void;
  setState<T$1 extends EntityId$1<Text3DState$1>>(object: T$1 | T$1['id'], state: Partial<UpdatableText3DState>): void;
  setState<T$1 extends EntityId$1<PathState$1>>(object: T$1 | T$1['id'], state: Partial<PathState$1>): void;
  setState<T$1 extends EntityState>(object: T$1 | T$1['id'], state: Partial<T$1>): void;
  /**
   * Project a clientX/clientY screen coordinate to a geographic coordinate
   */
  projectScreenXYToCoordinate: (clientX: MouseEvent["clientX"], clientY: MouseEvent["clientY"], useWorldPlane?: boolean) => {
    coordinate: Position$2;
    groupContainers: GroupContainerObject3D[] | undefined;
  } | undefined;
  /**
   * Project a geographic coordinate to a screen coordinate
   */
  projectCoordinateToScreenXY: (coordinate: Position$2) => {
    x: number;
    y: number;
  };
  /**
   * Convert a GeoJSON position to a 3D map position.
   *
   * @param position - The GeoJSON position to convert.
   * @param vector - Optional vector to copy the result into instead of creating a new vector.
   * @returns The converted 3D map position.
   */
  convertTo3DMapPosition(position: Position, vector?: Vector3): Vector3;
  /**
   * Convert latitude and longitude to a 3D map position.
   *
   * @param latitude - The latitude to convert.
   * @param longitude - The longitude to convert.
   * @param altitude - Optional altitude to include in the conversion. Defaults to 0.
   * @param vector - Optional vector to copy the result into instead of creating a new vector.
   * @returns The converted 3D map position.
   */
  convertTo3DMapPosition(latitude: number, longitude: number, altitude?: number, vector?: Vector3): Vector3;
  /**
   * @internal
   */
  convert3DMapPositionToCoordinate: (v: Vector3) => Position$2;
  /**
   * Sets the background color of the renderer. Only applies to "standalone mode"
   */
  setBackgroundColor: (color: string, alpha: number) => void;
  /**
   * Returns  the background color of the renderer. Only applies to "standalone mode"
   */
  get backgroundColor(): string;
  /**
   * Returns  the background alpha of the renderer. Only applies to "standalone mode"
   */
  get backgroundAlpha(): number;
  /**
   * internal
   */
  getThreeRenderer(): Renderer;
  /**
   * Returns the current scale of the map in meters per pixel.
   */
  getMetersPerPixel: () => number;
  /**
   * Filters out layers at a certain point on the outdoor map. This can be used to hide the outdoor building footprint underneath the 3D geometry.
   * @param polygons The polygons to filter layers under.
   * @param layers The layers to filter out.
   */
  hideOutdoorLayersIntersectingPolygons: (polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[], layers: string[]) => void;
  /**
   * Get the center of a geometry or bounding box.
   * @param geometryOrBoundingBox Geometry, geometry id, or bounding box to get the center of.
   */
  getCenter(geometryOrBoundingBox: string | number | EntityId$1<EntityState> | Position$2[]): [number, number] | undefined;
  /**
   * Checks if the given entity is within the current camera's view frustum.
   * This method is useful for determining if an entity is visible on the screen.
   *
   * @param target - The entity to check. This can be an object with `id` and `type` properties,
   *                 a string representing the entity's ID, or an entity state object.
   * @returns - Returns `true` if the entity is within the camera's view, otherwise `false`.
   */
  isInView(target: {
    id: EntityState['id'];
    type: EntityState['type'];
  } | string | EntityState): boolean;
  /**
   * Return a list of Geometry2D IDs currently rendered on screen.
   *
   * @param options - The options to query.
   * @param options.screenOffsets - Optional offsets to account for on the edges of the screen.
   * @param options.fullyContains - Whether to exclude entities that intersect with the screen edges after accounting for offsets.
   * @returns A list of IDs.
   */
  queryGeometry2DInView(options?: {
    screenOffsets?: Partial<InsetPadding$2>;
    fullyContains?: boolean;
  }): string[];
  /**
   * Perform a render of the scene. This is called internally when something changes, but can be called when adding external models
   * The render happens in an animation frame, not matter how frequently it is called
   * @method render
   */
  render: () => Promise<any> | undefined;
  /**
   * Perform a synchronous render of the scene. This bypasses the animation frame and renders immediately.
   *
   * Note: Only use this if you have an animation frame setup elsewhere
   */
  renderSync: () => Promise<any>;
  /**
   * Register a MapLibre event listener
   */
  onMapLibreEvent(event: LiteralUnion<keyof MapEventType, string>, handler: (...args: any[]) => void): void;
  /**
   * Remove a MapLibre event listener
   */
  offMapLibreEvent(event: LiteralUnion<keyof MapEventType, string>, handler: (...args: any[]) => void): void;
  /**
   * @internal for testing
   */
  getSystems(): Systems;
  /**
   * @internal for testing
   */
  getInternalState(): RendererState;
  /** @internal */
  getInternalTweenGroup(): Group;
  getExternalTweenGroup(): Group;
  computeMinZOffsetBetweenContainers(lowerContainer: GroupContainerObject3D, upperContainer: GroupContainerObject3D, debug?: boolean): number;
  /**
   * Subscribe a function to an event.
   *
   * @param eventName An event name which, when fired, will call the provided
   * function.
   * @param fn A callback that gets called when the corresponding event is fired. The
   * callback will get passed an argument with a type that's one of event payloads.
   * @example
   * // Subscribe to the 'click' event
   * const handler = (event) => {
   *  const { coordinate } = event;
   *  const { latitude, longitude } = coordinate;
   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
   * };
   * map.on('click', handler);
   */
  on: PubSub<MapEvent>['on'];
  /**
   * Unsubscribe a function previously subscribed with {@link on}
   *
   * @param eventName An event name to which the provided function was previously
   * subscribed.
   * @param fn A function that was previously passed to {@link on}. The function must
   * have the same reference as the function that was subscribed.
   * @example
   * // Unsubscribe from the 'click' event
   * const handler = (event) => {
   * 	console.log('Map was clicked', event);
   * };
   * map.off('click', handler);
   */
  off: PubSub<MapEvent>['off'];
  /**
   * @hidden
   * Returns the current cursor decided by Mappedin. This is useful when integrating with other overlays to show the correct user interaction.
   */
  getCursor: () => "grabbing" | "grab" | "pointer";
  /**
   * Destroys instance and frees resources
   */
  destroy: () => void;
}
//#endregion
//#region ../renderer-three/src/entities/group-container.d.ts
/**
 * State representing a Group Container, which is a container for other Group Containers, Geometry Groups, Labels, Markers and Paths.
 */
type GroupContainerState$1 = {
  readonly id: string | number;
  readonly type: 'group-container';
  /**
   * The states of the children of the group container
   */
  readonly children: (PathState$1 | MarkerState$1 | LabelState | GroupContainerState$1 | FeatureCollectionState)[];
  /**
   * Whether the group container is visible
   */
  visible: boolean;
  /**
   * The altitude of the group container above the ground in meters
   */
  altitude: number;
  interactive: boolean;
  /**
   * The opacity of the group container, which sets the opacity of all its children
   */
  opacity: number;
  /**
   * If true, the group container will preload geometry for its children even when invisible.
   */
  readonly preloadGeometry: boolean;
  focusable: boolean;
};
declare class GroupContainerObject3D extends Object3D {
  childrenIds: Set<string | number>;
  children: (GroupContainerObject3D | FeatureCollectionObject3D | BatchedText$1 | Geometry2D['object3d'] | NonNullable<Geometry3D['object3d']>)[];
  getComponent(): void;
  readonly type: "group-container";
  userData: {
    entityId: string | number;
    entities2D: Set<string | number>;
    dirty: boolean;
    occluderDirty: boolean;
    occluderId?: number;
    occluderFeature?: Feature<Polygon | MultiPolygon, any>;
    opacity: number;
    /** The effective opacity of the entity after all parent containers have been considered. */
    computedOpacity: number;
    /**
     * If true, the group container will preload geometry for its children even when invisible.
     */
    preloadGeometry: boolean;
  };
  components: [InteractionComponent?, FocusableComponent?];
  constructor(id: string);
  addOccluderFeature(feature: Feature<Polygon | MultiPolygon, any>, occluderId: number): void;
  addEntity(entityGroupOrContainer: GroupContainerObject3D | FeatureCollectionObject3D | Geometry2D | Geometry3DTypes): void;
  removeEntity(entityGroupOrContainer: EntityTypes): void;
  setVisible(visible: boolean): void;
  setAltitude(altitude: number): void;
  set2DGeometryChildrenPositionDirty(): void;
  get altitude(): number;
  setOpacity(opacity: number): void;
  get opacity(): number;
}
//#endregion
//#region ../renderer-three/src/components/occlusion.d.ts
type Occlusion2D = {
  enabled: boolean;
  id: number;
};
/**
 * Component for occlusion of 2D entities
 */
declare class Occlusion2DComponent implements Occlusion2D {
  readonly type: "occlusion2d";
  enabled: boolean;
  /**
   * Id of the occluder
   */
  id: number;
  constructor(id: number);
}
//#endregion
//#region ../renderer-three/src/entities/geometry2d.d.ts
declare class Geometry2DObject3D extends Object3D {}
type ComponentTypeMap = {
  interaction: InteractionComponent;
  marker: MarkerComponent;
  label: LabelComponent;
  occlusion2d: Occlusion2DComponent;
};
declare class Geometry2D {
  id: string | number;
  type: 'label' | 'marker';
  /** Lightweight entity for the 2D pipeline */
  entity2D: Entity2D;
  get parentObject3D(): GroupContainerObject3D | FeatureCollectionObject3D | null;
  /** The geometry3D that this 2D entity is attached to */
  get attachedTo(): string | number | undefined;
  verticalOffset: number;
  object3d: Geometry2DObject3D;
  components: [MarkerComponent | LabelComponent, InteractionComponent?, Occlusion2DComponent?];
  getComponent<T$1 extends keyof ComponentTypeMap>(type: T$1): ComponentTypeMap[T$1] | undefined;
  disposed: boolean;
  constructor(ui: MarkerComponent | LabelComponent, position: Vector3, verticalOffset?: number);
  private worldPosition;
  /**
   * Recomputes the cached world position from the Object3D scene graph.
   * matrixAutoUpdate must be temporarily enabled so updateWorldMatrix
   * (called internally by getWorldPosition) incorporates parent transforms.
   */
  private computeWorldPosition;
  get position(): Vector3;
  /**
   * When the position of the entity changes, this should be set to true, so that systems like pan bounds can update
   */
  get positionDirty(): boolean;
  set positionDirty(value: boolean);
  updatePosition(position: Vector3): void;
  setAltitude(z: number): void;
  /**
   * Copies the ThreeJS world position to the lightweight Entity2D.
   * Uses the position getter which clears positionDirty.
   */
  syncPosition(): void;
  /**
   * Syncs the Entity2D world position without clearing positionDirty,
   * so that downstream systems (e.g. pan bounds) still see the dirty flag.
   */
  private syncEntity2DWorldPosition;
}
//#endregion
//#region ../renderer-three/src/types/geometry.d.ts
type Position$2 = [lon: number, lat: number] | [lon: number, lat: number, alt: number];
//#endregion
//#region ../renderer-three/src/types/options.d.ts
type EnvMapOptions$2 = 'basic' | false;
type RendererCoreOptions$2 = Partial<{
  center?: Position$2;
  zoomLevel?: number;
  pitch?: number;
  bearing?: number;
  naturalBearing?: number;
  outdoorView: {
    headers?: {
      'x-mappedin-tiles-key': string;
    };
    style?: string;
    enabled: boolean;
    lowDpi?: boolean;
  };
  gl?: WebGLRenderingContext;
  map?: Map$1;
  mode?: 'standalone' | 'outdoors-interleaved' | 'outdoors-overlay';
  antialias?: boolean;
  /**
   * @deprecated DO NOT USE — breaks depth buffer sync with MapLibre, causing
   * incorrect ordering between MapLibre layers (e.g. extruded buildings, DeckGL)
   * and SDK geometry. View-dependent lighting now works correctly with the
   * default viewCamera.
   */
  useStandaloneCamera?: boolean;
  onWebGLRendererError?: (error: Error) => void;
  onWebGLContextCreationError?: (event: Event) => void;
  onWebGLContextLost?: (event: Event) => void;
  onWebGLContextRestored?: (event: Event) => void;
  backgroundColor?: string;
  backgroundAlpha?: number;
  watermark?: WatermarkOptions;
  attribution?: AttributionControlOptions;
  imagePlacementOptions?: ImagePlacementOptions$1;
  /**
   * environment map for reflections.
   * @default 'basic'
   */
  environment?: EnvMapOptions$2;
  occlusionEnabled?: boolean;
  /** Callback to intercept and modify requests for images. */
  transformImageRequest?: TransformImageRequest;
  useWorkers?: boolean;
  useCollisionWorker?: boolean;
  /**
   * Shadow rendering configuration
   * @experimental
   * @default { enabled: false }
   */
  __EXPERIMENTAL_shadows?: ShadowsOptions;
  /**
   * Outline rendering configuration.
   * - `true` enables outlines with default settings
   * - `false` disables outlines (note: this only affects the darken/opacity options, not the outline enable/disable which is per-geometry)
   * - An object with `maxOpacity` and/or `darkenFactor` allows fine-grained control
   */
  outlines?: boolean | OutlinesOptions$1;
}>;
/**
 * Outline rendering configuration options
 */
type OutlinesOptions$1 = {
  /**
   * Maximum opacity for outlines. The outline opacity interpolates from 0 to this value
   * based on zoom level (fully transparent when zoomed out, max opacity when zoomed in).
   * @default 1
   */
  maxOpacity?: number;
  /**
   * Percentage to darken the outline color from the polygon's original color.
   * Higher values create darker, more prominent outlines.
   * @default 30
   */
  darkenFactor?: number;
};
/**
 * Shadow rendering configuration options
 * @experimental
 */
type ShadowsOptions = {
  /**
   * Master toggle for the entire shadow system
   * @default false
   */
  enabled: boolean;
  /**
   * Enable debug visualization (light camera frustum, snap grid, current cell highlight, shadow map preview)
   * @default false
   */
  debug?: boolean;
  /**
   * Base color tint applied to shadows. Lighter colors make shadows softer and less harsh.
   * @default '#a0a0a0'
   */
  baseColor?: string;
  /**
   * Opacity/darkness of shadows (0.0 = invisible, 1.0 = completely black).
   * Lower values create softer, more subtle shadows that blend with ambient lighting.
   * @default 0.35
   */
  shadowOpacity?: number;
  /**
   * Number of Poisson disk samples for Percentage Closer Filtering (PCF).
   * Higher values create softer shadow edges but impact performance.
   * Valid range: 1-16 samples (uses rotated Poisson disk pattern).
   * @default 4
   */
  pcfSamples?: number;
  /**
   * Sampling spread/radius for PCF soft shadows in shadow map texels.
   * Larger values create softer, more blurred shadow edges and reduce banding.
   * Smaller values create sharper, more defined shadows.
   * @default 2.5
   */
  pcfSpread?: number;
  /**
   * Depth bias to prevent shadow acne and self-shadowing artifacts.
   * Increase if you see moiré patterns, noise, or overall darkening.
   * Too high causes "peter panning" (detached shadows).
   * @default 0.001
   */
  shadowBias?: number;
  /**
   * Offset shadows along surface normals to prevent self-shadowing artifacts (shadow acne).
   * Increase if you see noise/banding on surfaces. Too high causes shadows to detach from objects.
   * @default 0.12
   */
  normalBias?: number;
  /**
   * Resolution of the shadow map texture in pixels (width/height).
   * - `'auto'` (default): Automatically switches between high (4096) and low (2048) resolution based on zoom level
   * - A number value (e.g., 1024, 2048, 4096): Uses a fixed resolution
   * Higher values create sharper shadows but use more memory and bandwidth.
   * Lower values are faster but may show pixelation.
   * @default 'auto'
   */
  shadowMapSize?: 'auto' | number;
  /**
   * Sun azimuth angle in degrees: 0=North, 90=East, 180=South, 270=West
   * @default 225
   */
  sunAzimuth?: number;
  /**
   * Sun elevation angle in degrees: 0=horizon, 90=directly overhead
   * @default 45
   */
  sunElevation?: number;
  /**
   * Mercator zoom level at which shadows become visible.
   * Shadows are hidden when zoomed out beyond this level for performance.
   * Higher values mean you need to zoom in more to see shadows.
   * @default 18
   */
  visibleAtZoomLevel?: number;
};
//#endregion
//#region ../renderer-three/src/types/index.d.ts
/**
 * The state of an entity, which can be a geometry, geometry group, group container, path, model, label, or marker.
 */
type EntityState = GeometryState | FeatureCollectionState | GroupContainerState$1 | PathState$1 | ModelState | LabelState | MarkerState$1 | ImageState | Text3DState$1 | ShapeState;
/**
 * A wrapper object that contains the ID and type of an entity. This is returned when adding entities to the scene, and can be used
 * to `getState` and `setState` of the entity.
 */
type EntityId$1<T$1 extends EntityState> = {
  id: T$1['id'];
  type: T$1['type'];
};
declare class EntityMesh<T$1> extends Mesh<any> {
  userData: {
    entity: T$1;
  };
}
/**
 * Options for configuring bevel effects on extruded geometry.
 */
type BevelState = {
  /**
   * Whether beveling is enabled.
   */
  enabled: boolean;
  /**
   * The thickness of the bevel.
   * @default 0
   */
  thickness: number;
  /**
   * How far from the shape outline the bevel extends inward.
   * @default Same as thickness
   */
  size?: number;
  /**
   * How far from the shape outline the bevel starts.
   * @default 0
   */
  offset?: number;
  /**
   * The number of bevel layers for smoother bevels.
   * @default 3
   */
  segments?: number;
};
type PaintStyle$2 = {
  color: string;
  topColor?: string;
  height?: number;
  altitude?: number;
  opacity?: number;
  visible?: boolean;
  topTexture?: string;
  texture?: string;
  shading?: Shading$1;
  outline?: boolean;
  showImage?: boolean;
  flipImageToFaceCamera?: boolean;
  side?: MaterialSide;
  renderOrder?: number;
  /**
   * Bevel configuration for extruded shapes.
   */
  bevel?: BevelState;
  /**
   * @experimental
   * The ID of the mask
   * min value is 0, max value is 255
   */
  __EXPERIMENTAL_maskId?: number;
  /**
   * Whether the masked object should be hidden or revealed when the mask is applied
   * @experimental
   */
  __EXPERIMENTAL_maskEffect?: 'hide' | 'reveal';
  /**
   * Whether the mask is a mask or a masked object
   * @experimental
   */
  __EXPERIMENTAL_maskMode?: 'mask' | 'masked-object';
  /**
   * Whether the mask is enabled
   * @experimental
   */
  __EXPERIMENTAL_maskEnabled?: boolean;
};
type Shading$1 = {
  start?: number;
  end?: number;
  intensity?: number;
};
type LineStyle$2 = {
  color: string;
  topColor?: string;
  width: number;
  opacity?: number;
  height?: number;
  altitude?: number;
  visible?: boolean;
  cap?: 'round' | 'square' | 'butt';
  join?: 'round' | 'bevel' | 'miter';
  shading?: Shading$1;
  outline?: boolean;
  side?: MaterialSide;
  renderOrder?: number;
  __EXPERIMENTAL_maskId?: number;
  __EXPERIMENTAL_maskEnabled?: boolean;
  __EXPERIMENTAL_maskEffect?: 'hide' | 'reveal';
  __EXPERIMENTAL_maskMode?: 'mask' | 'masked-object';
};
type ModelProperties = {
  rotation?: [number, number, number];
  scale?: [number, number, number];
  interactive?: boolean;
  id?: string | number;
  verticalOffset?: number;
  /**
   * When true, enables clipping plane functionality for this model.
   * This cannot be changed at runtime.
   *
   * Note: This will de-optimize the model by disabling instancing.
   * @default false
   */
  EXPERIMENTAL_clippingEnabled?: boolean;
  /**
   * When true at creation time, the model will be visible through other geometry.
   * This value at creation time determines instancing behavior and cannot be changed.
   *
   * Note: This will de-optimize the model by disabling instancing.
   */
  visibleThroughGeometry?: boolean;
};
type InsetPadding$2 = {
  top: number;
  left: number;
  bottom: number;
  right: number;
  /**
   * The type of padding to use. If 'portion', the padding will be a portion of the canvas size. If 'pixel', the padding will be in pixels.
   * @defaultValue 'pixel'
   */
  type: 'pixel' | 'portion';
};
/**
 * An option for setting the inset padding of the camera.
 * @interface
 */
type InsetPaddingOption$2 = Omit<InsetPadding$2, 'type'> & {
  /**
   * The type of padding to use. If 'portion', the padding will be a portion of the canvas size. If 'pixel', the padding will be in pixels.
   * @defaultValue 'pixel'
   */
  type?: InsetPadding$2['type'];
};
/**
 * Result of a user click event.
 */
type ClickPayload = {
  /**
   * The coordinate of the interaction.
   */
  coordinate: Position$2;
  /**
   * An array of path IDs which the user interaction passed through. Will be empty if no paths were interacted with.
   */
  paths: (string | number)[] | [];
  /**
   * An array of marker IDs which the user interaction passed through. Will be empty if no markers were interacted with.
   */
  markers: (string | number)[] | [];
  /**
   * An array of 3D models IDs which the user interaction passed through. Will be empty if no models were interacted with.
   */
  models: [string | number] | [];
  /**
   * An array of 3D image IDs which the user interaction passed through. Will be empty if no images were interacted with.
   * Only images added with `interactive: true` are included.
   */
  images: [string | number] | [];
  /**
   * An array of label IDs which the user interaction passed through. Will be empty if no labels were interacted with.
   */
  labels: (string | number)[] | [];
  /**
   * An array of geometry IDs which the user interaction passed through. Will be empty if no geometry was interacted with.
   */
  geometry: (string | number)[] | [];
  /**
   * Details about the pointer event which triggered the interaction.
   */
  pointerEvent: Pick<PointerEvent, 'button'>;
  /**
   * An array of group container IDs which the user interaction passed through. Will be empty if no group containers were interacted with.
   */
  containers: (string | number)[] | [];
};
/**
 * Result of a user hover event.
 */
type HoverPayload = Omit<ClickPayload, 'pointerEvent'>;
/**
 * The result of a camera change event.
 */
type CameraPayload = {
  /**
   * The camera's current center in [longitude, latitude].
   */
  center: Position$2;
  /**
   * The camera's current bearing in degrees from north.
   */
  bearing: number;
  /**
   * The camera's current pitch in degrees.
   */
  pitch: number;
  /**
   * The camera's current zoom level in mercator zoom level units
   */
  zoomLevel: number;
  /**
   * The camera's current elevation in meters from the ground.
   */
  elevation: number;
};
/**
 * The events which can be subscribed to on the renderer.
 */
type MapEvent = {
  /**
   * Fired when the user hovers over an interactive entity on the map.
   */
  hover: HoverPayload;
  /**
   * Fired when the user clicks on an interactive entity on the map.
   */
  click: ClickPayload;
  /**
   * Fired when the camera moves, either by user interaction or programmatic change.
   */
  'camera-change': CameraPayload;
  /**
   * If outdoor view is enabled, this is fired when the renderer has loaded the outdoor view.
   */
  'outdoor-view-loaded': undefined;
  /**
   * If outdoor view is enabled, this is fired when the style first loads or changes.
   */
  'outdoor-style-loaded': undefined;
  /**
   * Fired when outdoor style loading fails. The map will fall back to indoor-only rendering.
   */
  'outdoor-style-error': {
    error: unknown;
  };
  /**
   * Fired when the user starts interacting with the map.
   */
  'user-interaction-start': undefined;
  /**
   * Fired when the user stops interacting with the map.
   */
  'user-interaction-end': undefined;
  /**
   * Fired when a geometry is in focus, meaning it occupies the area closest to the center of the screen. Is an array of geometry IDs sorted by most likely to be in focus.
   * Geometries can be added to the focus listener via `mapView.setState(.., { focusable: true })`.
   */
  'geometry-in-focus': string[];
  /**
   * Fired before the scene is rendered. Use this to modify the scene before it is rendered.
   */
  'pre-render': undefined;
  /**
   * Fired when the synchronous tasks of the scene render are complete.
   */
  'post-render': undefined;
  /**
   * Fired when a render error occurs.
   */
  'render-error': {
    error: Error;
  };
  resize: undefined;
  'pan-bounds-change': PanBounds;
};
/**
 * All entities in 3D
 */
type All3DTypes = Geometry3DTypes | FeatureCollectionObject3D | GroupContainerObject3D;
type RendererState = {
  /**
   * A map of all 3D geometries in the world.
   */
  readonly geometry3DMap: Map<string | number, All3DTypes>;
  /**
   * A map of all 2D geometries in the world.
   */
  readonly geometry2DMap: Map<string | number, Geometry2D>;
  /**
   * A set of all 2D geometry IDs in the scene. This is updated when objects' visiblity changes.
   * @deprecated Use geometry2DsInScene instead.
   */
  readonly geometry2DIdsInScene: Set<Geometry2D['id']>;
  /**
   * A set of all 3D geometry IDs in the scene. This is updated when objects' visiblity changes.
   * @deprecated Use geometry3DsInScene instead.
   */
  readonly geometry3DIdsInScene: Set<All3DTypes['id']>;
  /**
   * A set of all 3D geometries in the scene. This is updated when objects' visiblity changes.
   */
  readonly geometry3DsInScene: Set<All3DTypes>;
  /**
   * A set of all 2D geometries in the scene. This is updated when objects' visiblity changes.
   */
  readonly geometry2DsInScene: Set<Geometry2D>;
  /**
   * IDs of geometry groups that need to be loaded, including preloaded geometry groups that are not in the scene yet
   */
  readonly geometryGroupIdsToLoad: Set<FeatureCollectionObject3D['userData']['entityId']>;
  readonly geometryScene: GroupContainerObject3D;
  hoverColor: string;
  text3dHoverColor: string;
  center?: Position$2;
  insetsPadding: InsetPadding$2;
  shouldMeasureCanvas: boolean;
  /**
   * Current clamped pixel ratio of the renderer, based on maplibre's clamping logic (when in interleaved mode)
   */
  pixelRatio: number;
  canvasWidth: number;
  canvasHeight: number;
  /** Group for all tweens that are created internally by the SDK */
  internalTweenGroup: Group;
  /** Group for all tweens that are created externally, such as from animateState */
  externalTweenGroup: Group;
  cameraObject: Camera$1;
  naturalBearing: number;
  containerOffset: [number, number];
  useStandaloneCamera: boolean;
  directionalLight: DirectionalLight;
  ambientLight: AmbientLight;
  renderer: WebGLRenderer;
  threeJSScene: Scene;
  /**
   * The depth range for 3D rendering. This is used to ensure that depth comparisons are accurate, since Maplibre changes the depth range during rendering.
   * @defaultValue [0, 1]
   */
  depthRangeFor3D: [number, number];
  /**
   * Options for configuring outline rendering
   */
  outlinesOptions?: OutlinesOptions$1;
  /** State shared with the 2D labels/markers pipeline */
  geometry2DState: TwoDPipelineState;
};
/**
 * All of the entities in the scene
 */
type EntityTypes = Geometry3DTypes | Geometry2D | FeatureCollectionObject3D | GroupContainerObject3D;
/** @internal */
type TransformImageRequest = (url: string) => Promise<{
  url: string;
}>;
/**
 * The mode to use for auto image placement.
 * - `default` will currently not rotate the image, but in the future it may be settable per-image, in which case this mode will use that setting.
 * - `none` will not rotate the image.
 * - `nearest 90` may rotate the image 90 degrees to fit the polygon better.
 * - `initial bearing` will rotate the images to face the initial bearing of the map view, then try to fit them to their polygon.
 *
 * @internal
 */
type ImagePlacementMode = 'default' | 'none' | 'fit-nearest-90' | 'fit-initial-bearing';
/**
 * Options for configuring how images are automatically placed on polygons.
 *
 * @internal
 */
type ImagePlacementOptions$1 = {
  /**
   * The mode to use for auto image placement. See {@link ImagePlacementMode} for more information.
   * @defaultValue 'default'
   */
  mode?: ImagePlacementMode;
  /**
   * Scale factor applied to the resulting rectangle dimensions.
   * Values less than 1 create a safety margin inside the polygon.
   * @defaultValue 0.9
   */
  scaleFactor?: number;
  /**
   * Controls the balance between optimizing for rectangle area vs. proximity to center.
   * Higher values prioritize center alignment over size.
   * @defaultValue 0.5
   */
  centerPriority?: number;
  /**
   * Resolution of the grid used for finding the rectangle.
   * Higher values provide more precise results but require more computation.
   * @defaultValue 100
   */
  resolution?: number;
  /**
   * Threshold ratio for determining when to fall back to the original rectangle.
   * If the calculated rectangle is smaller than this ratio of the original,
   * the original rectangle will be returned instead.
   * @defaultValue 0.5
   */
  minimumSizeRatio?: number;
};
type LabelRenderedState$1 = {
  /**
   * whether the text is visible
   */
  textVisible: boolean;
};
//#endregion
//#region ../renderer-three/src/components/validation.d.ts
/**
 * Geojson-specific extension of the base `AddLabelOptionsInternal` that allows
 * `attachTo` to reference a 3D geometry entity via `EntityId<GeometryState>`.
 */
type AddLabelOptionsInternal$2 = Omit<AddLabelOptionsInternal$1, 'attachTo'> & {
  attachTo?: EntityId$1<GeometryState> | string | null;
};
/**
 * Geojson-specific extension of the base `AddMarkerOptions` that allows
 * `attachTo` to reference a 3D geometry entity via `EntityId<GeometryState>`.
 */
type AddMarkerOptions$1 = AddMarkerOptions & {
  attachTo?: EntityId$1<GeometryState> | string | number | null;
};
/**
 * State representing a Label
 */
type LabelState = {
  readonly id: string | number;
  readonly type: 'label';
  /** The position of the label in [lon, lat] */
  readonly position: Position$2;
  /** The parent container of the label */
  readonly parent: EntityId$1<GroupContainerState$1>;
  /** Whether the label is enabled */
  enabled: boolean;
  /** Whether the label is visible IF it is enabled */
  visible: boolean;
  /** Text content of the label */
  text: string;
  /** The initial rank of the label */
  initialRank: CollisionRankingTier;
  /** Options for the label */
  options: Omit<AddLabelOptionsInternal$2, 'id'>;
  /** Vertical offset of the model in meters off the floor */
  verticalOffset: number;
};
/**
 * State representing a Marker
 */
type MarkerState$1 = {
  readonly id: string | number;
  readonly type: 'marker';
  /** The parent container of the marker */
  readonly parent: EntityId$1<GroupContainerState$1> | string | number;
  /** The position of the marker in [lon, lat] */
  readonly position: Position$2;
  /** Whether the marker is enabled */
  enabled: boolean;
  /** Whether the marker is visible IF it is enabled */
  visible: boolean;
  /** HTML content of the marker as text */
  contentHTML?: string;
  /** Pointer to the HTML element of the marker in the DOM tree */
  element: HTMLElement;
  /** The initial rank of the marker */
  initialRank: CollisionRankingTier | number;
  options: Omit<AddMarkerOptions$1, 'id'> & {
    lowPriorityPin: LowPriorityPinConfig;
  };
  /** Placement for the marker */
  placement: MarkerPlacement | MarkerPlacement[];
  /** Dynamic resize of the marker */
  dynamicResize: boolean;
};
type MarkerStateUpdate = Omit<MarkerState$1, 'type' | 'parent' | 'id' | 'options'> & {
  options?: Partial<Omit<AddMarkerOptions$1, 'id' | 'lowPriorityPin'>>;
};
//#endregion
//#region ../renderer-three/src/maplibre-overlay.d.ts
declare class MapLibreOverlay<T$1> extends PubSub<T$1> implements IControl {
  private gl;
  private options?;
  el: HTMLDivElement;
  core: Core;
  origin?: Position$2;
  map?: Map$1;
  layer?: CustomLayerInterface;
  private cameraSystem;
  constructor(origin: Position$2 | undefined, options?: RendererCoreOptions$2);
  private handleStyleChange;
  private handleMoveStart;
  private handleMove;
  private handleMoveEnd;
  private handleError;
  onAdd(map: Map$1): HTMLDivElement;
  onRemove(): void;
}
//#endregion
//#region ../renderer-three/src/utils/constants.d.ts
declare const MAPPEDIN_LAYER_ID = "mappedin";
//#endregion
//#region src/constants.d.ts
declare const MAPPEDIN_COLORS: {
  orange: string;
  teal: string;
  lightTeal: string;
};
//#endregion
//#region ../packages/common/Mappedin.Logger.d.ts
declare enum E_SDK_LOG_LEVEL {
  LOG = 0,
  WARN = 1,
  ERROR = 2,
  SILENT = 3,
}
declare function setLoggerLevel(level: E_SDK_LOG_LEVEL): void;
//#endregion
//#region src/utils/convert-renderer-core-options.d.ts
/**
 * Converts TShow3DMapOptions to RendererCoreOptions format.
 * Transforms outdoorView.token to outdoorView.headers['x-mappedin-tiles-key'].
 * @internal
 */
declare function convertToRendererCoreOptions(options: TShow3DMapOptions | undefined): Partial<RendererCoreOptions$1> | undefined;
//#endregion
//#region src/api-geojson/multi-floor.d.ts
type VisibilityState = {
  outdoorOpacity: number | 'initial';
  floorStates: {
    floor?: Floor;
    state: TFloorState;
  }[];
};
type FootprintConfig = {
  /**
   * The color of the footprint.
   * Can be a single color string applied to all floors, or an object mapping floor IDs to colors.
   * Floors without a specified color will use the default ('#ffffff').
   */
  color: string | Partial<Record<Floor['id'], string>>;
  /** Optional opacity override. If provided, overrides internal elevation-based opacity calculation. */
  opacity?: number;
  /** Whether to show outlines on footprint walls and ceilings. */
  outline: boolean;
  /** Whether spaces open to below (ceiling cutouts) are enabled. */
  spacesOpenToBelowEnabled: boolean;
  spacesOpenToBelowVisualEffectEnabled?: boolean;
  spacesOpenToBelowVisualEffectDarkenAmount?: number;
  spacesOpenToBelowVisualEffectDarkenUseDepth?: boolean;
  spacesOpenToBelowVisualEffectDesaturateAmount?: number;
  spacesOpenToBelowVisualEffectDesaturateUseDepth?: boolean;
  spacesOpenToBelowVisualEffectWashOutAmount?: number;
  spacesOpenToBelowVisualEffectWashOutUseDepth?: boolean;
};
/**
 * Calculates the multi-floor visibility state for rendering stacked floors
 * @param floors - Array of floors to process
 * @param currentFloor - The currently active floor
 * @param floorIdsInNavigation - Array of floor IDs that are part of the current navigation
 * @param floorsVisualHeightMap - Map of floor elevations to their visual height data (altitude map from FloorStackObject)
 * @param footprintConfig - Configuration for footprint color and voids behavior
 * @returns The visibility state for all floors
 */
declare function getMultiFloorState(floors: Floor[], currentFloor: Floor, floorIdsInNavigation: Floor['id'][], floorsVisualHeightMap: Map<number, TFloorAltitudeData>, footprintConfig: FootprintConfig): VisibilityState;
//#endregion
//#region src/index.d.ts
/**
 * @internal
 * @hidden
 * Must be called before {@link show3dMap}
 */
declare function __setWatermarkOnClickFn(fn: () => void): void;
/**
 * Represents all the available antialiasing options.
 */
type TAntialiasingOptions = {
  /**
   * Enable antialiasing. Only works when device supports WebGL2.
   *
   * @default true
   */
  enabled?: boolean;
  /**
   * Change the quality of antialiasing in the scene. Greater quality means less noise, but worse performance.
   *
   * @default 'medium'
   */
  quality?: 'low' | 'medium' | 'high' | 'ultra';
};
/**
 * @interface
 * Options for the watermark.
 */
type TWatermarkOptions = WatermarkUpdateOptions;
/**
 * Options for showing a 3D map.
 *
 * @experimental
 */
type TShow3DMapOptions = {
  /**
   * The outdoor view options.
   */
  outdoorView?: {
    /**
     * The token is used to fetch outdoor tiles, which will then be rendered.
     */
    token?: string;
    /**
     * A url to a style specification conforming to the [Maplibre Style Spec](https://maplibre.org/maplibre-style-spec/).
     * Use the {@link Environment | `environment`} setting to switch environments.
     */
    style?: string;
    /**
     * Enable or disable the outdoor view.
     * @default true
     */
    enabled?: boolean;
    /**
     * Layers that should be hidden by geometry. This is useful when you want to hide certain layers when they are below the geometry.
     * @default ['building', 'building-top']
     */
    layersHiddenByGeometry?: string[];
    /**
     * Reduces the pixel ratio for MapLibre rendering to improve framerate performance.
     * When enabled, the rendering quality will be lower but performance will be better,
     * which can be useful on devices with high-DPI displays or limited GPU capabilities.
     *
     * @default false
     */
    lowDpi?: boolean;
  };
  /**
   * The initial bearing of the map, in degrees.
   *
   * @default 0
   */
  bearing?: number;
  /**
   * The initial pitch of the map, in degrees.
   *
   * @default 45
   */
  pitch?: number;
  /**
   * The initial zoom level of the map, in mercator zoom levels.
   * If it is not specified, it will default to the level that fits the map bounds.
   */
  zoomLevel?: number;
  /**
   * The screen offsets of the map, in screen pixels.
   */
  screenOffsets?: InsetPadding;
  /**
   * Antialiasing settings.
   *
   * @hidden
   * @default true
   */
  antialiasing?: boolean | TAntialiasingOptions;
  /**
   * @experimental
   *
   * Enable debug mode to check the visual representation of performance stats.
   * @default false
   */
  debug?: boolean;
  /**
   * Options when showing the watermark.
   *
   * @hidden
   */
  watermark?: TWatermarkOptions;
  /**
   * Options for the attribution control.
   *
   * @hidden
   */
  attribution?: {
    /**
     * Custom attribution content.
     */
    custom?: string[];
    /**
     * Attribution position.
     * @default 'bottom-right'
     */
    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
    /**
     * Whether to show a feedback link next to the attributions.
     * @default true
     */
    feedback?: boolean;
  };
  /**
   * First floor to be rendered.
   * By default, floor with the elevation that's closest to 0 is rendered. All floors will be sorted by elevation in ascending order.
   */
  initialFloor?: Floor | string;
  /**
   * Enable shading of bottoms of geometry along with outlines to make geometry stand out.
   * @default true
   * @deprecated Use `style.shading`.
   */
  shadingAndOutlines?: boolean;
  /**
   * Specify a color for the top of wall geometry.
   * @deprecated Use `style.wallTopColor`.
   */
  wallTopColor?: string;
  /**
   * Style options for the map.
   * @experimental
   */
  style?: {
    /**
     * Background color. Only relevant if outdoor map is disabled.
     */
    backgroundColor?: string;
    /**
     * Background alpha value. Only relevant if outdoor map is disabled.
     */
    backgroundAlpha?: number;
    /**
     * Set the global shading for all elements. True will use default values, false will disable shading.
     * @default true
     */
    shading?: boolean | Shading;
    /**
     * Set the global outlines for all elements.
     * - `true` will enable outlines with default settings
     * - `false` will disable outlines
     * - An object with `maxOpacity` and/or `darkenFactor` allows fine-grained control
     * @default true
     */
    outlines?: boolean | OutlinesOptions;
    /**
     * Specify a color for the top of wall geometry.
     */
    wallTopColor?: string;
  };
  /**
   * Options for controlling multi-floor view.
   */
  multiFloorView?: TMultiFloorViewOptions;
  /**
   * @experimental
   * @internal
   */
  imagePlacementOptions?: TImagePlacementOptions;
  /**
   * Enable or disable the flip of images to face the camera.
   * @default true
   */
  flipImagesToFaceCamera?: boolean;
  /**
   * Automatically inject necessary styles into the document head. If `false`, the `index.css` file needs to be manually imported.
   *
   * ```ts
   * import '@mappedin/mappedin-js/lib/index.css';
   * ...
   * await show3dMap(...);
   * ```
   *
   * @default true
   */
  injectStyles?: boolean;
  /**
   * @hidden
   * @internal
   */
  onWebGLContextCreationError?: (event: Event) => void;
  /**
   * @hidden
   * @internal
   */
  onWebGLContextLost?: (event: Event) => void;
  /**
   * @hidden
   * @internal
   */
  onWebGLContextRestored?: (event: Event) => void;
  /**
   * @hidden
   * @internal
   */
  onWebGLRendererError?: (error: Error) => void;
  /**
   * @experimental
   * @internal
   *
   * @deprecated DO NOT USE — breaks depth buffer sync with MapLibre, causing
   * incorrect ordering between MapLibre layers (e.g. extruded buildings, DeckGL)
   * and SDK geometry. View-dependent lighting now works correctly with the
   * default viewCamera.
   *
   * @default false
   */
  useStandaloneCamera?: boolean;
  /**
   *
   * Preload floors for the map. Allows floors to appear faster but requires more time and memory up front.
   */
  preloadFloors?: Floor[];
  /**
   * If true, the map will not use web workers. This will turn off outdoor context, and may negatively impact performance of labels and markers.
   * @internal
   *
   * ⚠️ **WARNING**: Setting this to true is not recommended and should only be used for environments where the CSP does not allow web workers.
   * Disabling web workers may significantly degrade performance and disable outdoor map functionality.
   * @default false
   */
  disableWorkers?: boolean;
  /**
   * Shadow rendering configuration.
   * @experimental
   * @default { enabled: false }
   */
  __EXPERIMENTAL_shadows?: {
    /**
     * Master toggle for the entire shadow system
     * @default false
     */
    enabled: boolean;
    /**
     * Enable debug visualization (light camera frustum, snap grid, current cell highlight, shadow map preview)
     * @default false
     */
    debug?: boolean;
    /**
     * Base color tint applied to shadows. Lighter colors make shadows softer and less harsh.
     * @default '#a0a0a0'
     */
    baseColor?: string;
    /**
     * Opacity/darkness of shadows (0.0 = invisible, 1.0 = completely black).
     * Lower values create softer, more subtle shadows that blend with ambient lighting.
     * @default 0.35
     */
    shadowOpacity?: number;
    /**
     * Number of Poisson disk samples for Percentage Closer Filtering (PCF).
     * Higher values create softer shadow edges but impact performance.
     * Valid range: 1-16 samples (uses rotated Poisson disk pattern).
     * @default 4
     */
    pcfSamples?: number;
    /**
     * Sampling spread/radius for PCF soft shadows in shadow map texels.
     * Larger values create softer, more blurred shadow edges and reduce banding.
     * Smaller values create sharper, more defined shadows.
     * @default 2.5
     */
    pcfSpread?: number;
    /**
     * Depth bias to prevent shadow acne and self-shadowing artifacts.
     * Increase if you see moiré patterns, noise, or overall darkening.
     * Too high causes "peter panning" (detached shadows).
     * @default 0.001
     */
    shadowBias?: number;
    /**
     * Offset shadows along surface normals to prevent self-shadowing artifacts (shadow acne).
     * Increase if you see noise/banding on surfaces. Too high causes shadows to detach from objects.
     * @default 0.12
     */
    normalBias?: number;
    /**
     * Resolution of the shadow map texture in pixels (width/height).
     * - `'auto'` (default): Automatically switches between high (4096) and low (2048) resolution based on zoom level
     * - A number value (e.g., 1024, 2048, 4096): Uses a fixed resolution
     * Higher values create sharper shadows but use more memory and bandwidth.
     * Lower values are faster but may show pixelation.
     * @default 'auto'
     */
    shadowMapSize?: 'auto' | number;
    /**
     * Sun azimuth angle in degrees: 0=North, 90=East, 180=South, 270=West
     * @default 225
     */
    sunAzimuth?: number;
    /**
     * Sun elevation angle in degrees: 0=horizon, 90=directly overhead
     * @default 45
     */
    sunElevation?: number;
  };
  /**
   * @experimental
   * @internal
   *
   * If true, updateState calls will not be validated. This allows for faster updates and should likely only be used for production environment where the input
   * is predictable and has been validated by the developer.
   * @default false
   */
  disableUpdateStateValidation?: boolean;
};
/**
 * @internal
 * @deprecated Use {@link hydrateMapData} instead.
 *
 * Returns a {@link MapData} instance from a parsed MVF object.
 */
declare const hydrateMapDataFromMVF: (mvf: TMVF, options?: TGetMapDataWithCredentialsOptions & {
  languagePacks?: LanguagePackHydrationItem[];
}) => Promise<MapData>;
/**
 * @internal
 * @deprecated Use {@link getMapData} and enterprise will be inferred from key/secret.
 */
declare function setUseEnterpriseAPI(value: boolean): void;
/**
 * @internal
 * @hidden
 *
 * If true, the SDK will create enterprise locations in addition to location profiles. Use this to allow
 * legacy applications to load platform maps.
 */
declare function forceEnterpriseLocations(value: boolean): void;
/**
 * @hidden
 * @internal
 *
 * See {@link forceEnterpriseLocations}
 */
declare function shouldForceEnterpriseLocations(): boolean;
/**
 * Asynchronously retrieves map data ({@link MapData}) based on user-provided options.
 *
 * The SDK automatically detects whether you're using Maker or CMS/Enterprise
 * credentials and populates the appropriate data types.
 *
 * @remarks
 * **Understanding Data Sources**
 *
 * This SDK supports two data sources with different location types:
 *
 * **Maker** (API keys starting with `mik_`):
 * - Use `mapData.getByType('location-profile')` for {@link LocationProfile}
 * - Use `mapData.getByType('location-category')` for {@link LocationCategory}
 * - Enterprise types will return empty arrays
 *
 * **CMS/Enterprise** (clientId/clientSecret, or keys NOT starting with `mik_`):
 * - Use `mapData.getByType('enterprise-location')` for {@link EnterpriseLocation}
 * - Use `mapData.getByType('enterprise-category')` for {@link EnterpriseCategory}
 * - Use `mapData.getByType('enterprise-venue')` for {@link EnterpriseVenue}
 * - Maker types will return empty arrays
 *
 * **Detection Logic:**
 * - If `accessToken` is provided: Enterprise if token audience matches CMS endpoints
 * - If `key`/`secret` is provided: Maker if key starts with `mik_`, otherwise Enterprise
 *
 * @param userOptions Options provided by the user to retrieve map data.
 * @returns Promise resolving to the MapData.
 *
 * @example
 * // Maker usage (key starts with 'mik_')
 * const makerData = await getMapData({
 *   key: 'mik_xxx',
 *   secret: 'mis_xxx',
 *   mapId: '65c0ff7430b94e3fabd5bb8c'
 * });
 * const locations = makerData.getByType('location-profile'); // Use this for Maker
 *
 * @example
 * // CMS/Enterprise usage (clientId/clientSecret)
 * const enterpriseData = await getMapData({
 *   key: 'clientId',
 *   secret: 'clientSecret',
 *   mapId: 'mappedin-demo-mall'
 * });
 * const locations = enterpriseData.getByType('enterprise-location'); // Use this for Enterprise
 */
declare const getMapData: (userOptions: TGetMapDataOptions) => Promise<MapData>;
/**
 * @internal
 * @deprecated Use {@link getMapData} and enterprise will be inferred from key/secret.
 */
declare const getMapDataEnterprise: (userOptions: TGetMapDataOptions) => Promise<MapData>;
/**
 * @internal
 *
 * Note: had to add this here to avoid a circular reference when I put it in options
 * TODO: investigate
 *
 * Check if the worker urls are valid
 * @returns false if workers have not been set, and an object with the worker urls if they are set
 */
declare const checkWorkerUrls: () => Promise<false | {
  collision: boolean;
  maplibre: boolean;
}>;
declare const show3dMap: (el: HTMLElement, mapData: MapData, options?: TShow3DMapOptions) => Promise<MapView>;
/**
 * Returns the package version of the SDK.
 */
declare const getVersion: () => string | undefined;
/**
 * @internal
 * @deprecated Use {@link show3dMap} instead.
 */
declare const show3dMapGeojson: (el: HTMLElement, mapData: MapData, options?: TShow3DMapOptions) => Promise<MapView>;
//#endregion
export { ACTION_TYPE, ANIMATION_TWEENS, type AddText3DOptions, type Analytics, Annotation, Area, type AutoElements, BBox, BEARING_TYPE, CONNECTION_TYPE, type Camera, type CameraBounds, type CameraTransform, type CaptureEventsPayloadMap, type ColorString, Connection, Coordinate, DOORS, type Debug, type DebugState, DetailedMapData, Directions, Door, E_SDK_LOG_LEVEL, EnterpriseCategory, EnterpriseLocation, EnterpriseVenue, type EnvMapOptions, type Environment, type Exporter, Facade, Feature, FeatureCollection, Floor, FloorStack, type FootprintConfig, GeoJSON$1 as GeoJSON, GeoJsonGeometryTypes, GeoJsonObject, GeoJsonProperties, GeoJsonTypes, Geometry, GeometryCollection, GeometryObject, type GlobalState, Hyperlink, type IAnchorable, type IFocusable, type IGeoJSONData, type INavigatable, type ISystemPlugin, type Image3D, type Image3DView, ImageMetaData, type InitializeModelState, type InitializeText3DState, type InsetPadding, type InsetPaddingOption, type InterpolateOn, type Interpolation, type Label, type LabelAppearance, type LabelTextPlacement, type Labels, LineString, type LineStyle, LocationCategory, LocationProfile, type LocationSocial, type LocationState, MAPPEDIN_COLORS, type MapData, type MapDataElements, type MapElementToGetRenderedState, type MapElementToGetState, type MapElementToUpdateState, type MapElementsWithState, type MapFeatureOfType, MapObject, MapView, type MapViewElements, type MapViewState, type MappedinError, type MappedinRenderError, type Marker, type Markers, type MatchInfo, type Model, type Models, type MultiFloorViewEffectState, MultiLineString, MultiPoint, MultiPolygon, type Navigation, type NavigationState, Node, type OpeningHours, type OperationHours, type Outdoor, type OutlinesOptions, type PaintStyle, type Path, type PathSegment$1 as PathSegment, type PathWidth, type Paths, type PixelWidth, type Places, Point, PointOfInterest, Polygon, type Position, type PubSub, type Query, type RendererCoreOptions, type Search, type SearchOptions, type SearchResult, type SearchResultEnterpriseCategory, type SearchResultEnterpriseLocations, type SearchResultItem, type SearchResultPlaces, type Shading, type Shape, type Shapes, type SiblingGroup, Space, type Style, type Suggestion, type TActionType, type TAddImageOptions, type TAddLabelOptions, type TAddMarkerOptions, type TAddModel, type TAddModelOptions, type TAddPathOptions, type TAddText3DAnchorableOptions, type TAddText3DOptions, type TAnalyticsUpdateState, type TAnimateStateResult, type TAnimationOptions, type TAntialiasingOptions, type TBearingType, type TCameraAnimationOptions, type TCameraInteractionsSetOptions, type TCameraTarget, type TCancellablePromise, type TClickPayload, type TCollisionRankingTier, type TConnectionPathOptions, type TConnectionType, type TCoordinateParams, type TCreateMarker, type TDirectionInstruction, type TDirectionInstructionAction, type TDirectionZone, type TDoorsState, type TDoorsUpdateState, type TEasingFunction, type TEventPayload, type TEvents, type TExperimentalDashOptions, type TFacadeState, type TFacadeUpdateState, type TFindNearestOptions, type TFindNearestResult, type TFindPreferredLanguageInVenueOptions, type TFloorAltitudeData, type TFloorChangePayload, type TFloorChangeReason, type TFloorState, type TFloorUpdateState, type TFocusOnOptions, type TFocusTarget, type TGeometryState, type TGeometryUpdateState, type TGetDirectionsOptions, type TGetMapDataOptions, type TGetMapDataSharedOptions, type TGetMapDataWithAccessTokenOptions, type TGetMapDataWithCredentialsOptions, type TGetState, type THoverPayload, type THydrateMapDataBundle, type TImage3DState as TImageState, type TImage3DUpdateState as TImageUpdateState, type TLabelState, type TLabelUpdateState, type TMVF, type TMVFLineStringStyle, type TMVFPointStyle, type TMVFPolygonStyle, type TMVFStyle, type TMVFStyleCollection, type TMapDataEvents, type TMapDataObjectTypes, type TMapFeatureTypes, type TMapViewObjectTypes, type TMarkerPlacement, type TMarkerState, type TMarkerUpdateState, type TModelState, type TModelUpdateState, type TMultiFloorViewOptions, type TNavigationOptions, type TNavigationPathOptions, type TNavigationTarget, type TOutsideThresholdPathStyle, type TPathSectionHighlightOptions, type TPathState, type TPathUpdateState, type TQueriables, type TQueryAtResult, type RendererState as TRendererState, type TSearchOptions, type TSetFloorOptions, type TShapeState, type TShapeUpdateState, type TShow3DMapOptions, type TSpaceType, type TStateChangedInternalPayload, type TTakeScreenshotOptions, type TTetheredOptions as TTetherOptions, type TText3DState, type TText3DUpdateState, type TTrackCoordinateOptions, type TTravelledOptions, type TUpdateState, type TWallsState, type TWallsUpdateState, TWatermarkOptions, type Text3D, type Text3DView, type UpdateGlobalState, type VisibilityState, WALLS, type WithState, MAPPEDIN_LAYER_ID as __INTERNAL__MAPPEDIN_LAYER_ID, MapLibreOverlay as __INTERNAL__MapLibreOverlay, Core as __INTERNAL__RendererCore, convertToRendererCoreOptions as __INTERNAL__convertToRendererCoreOptions, __setWatermarkOnClickFn, checkWorkerUrls, disableText3DWorker, enableTestMode, findPreferredLanguageInVenue, forceEnterpriseLocations, getMapData, getMapDataEnterprise, getMultiFloorState, getVersion, hydrateMapData, hydrateMapDataFromMVF, parseMVFv2 as parseMVF, preloadFont, setLoggerLevel, setUseEnterpriseAPI, setWorkersUrl, shouldForceEnterpriseLocations, show3dMap, show3dMapGeojson, unzipAndParseMVFv2, unzipMVFv2 as unzipMVF };