@micrio/client 5.2.1 → 5.3.0

package/micrio.min.d.ts

@@ -1,57 +1,101 @@
 declare module '@micrio/client' {
 	import type { Readable, Writable } from 'svelte/store';
-	export const VERSION = "5.2.1";
+	/**
+	 * Defines the current version of the Micrio library.
+	 * This constant is used internally and exposed statically via `HTMLMicrioElement.VERSION`.
+	 */
+	export const VERSION = "5.3.0";
 	export type PREDEFINED = [string, Models.ImageInfo.ImageInfo, Models.ImageData.ImageData | undefined];
-	export const isFetching: (uri: string) => boolean;
-	export const getLocalData: (id: string) => PREDEFINED | undefined;
-	/** Get a character numeric value from a Micrio ID
+	/** Enum for identifying media type. */
+	export enum MediaType {
+		None = 0,
+		IFrame = 1,
+		Video = 2,
+		Audio = 3,
+		VideoTour = 4,
+		Micrio = 5
+	}
+	/** Enum for identifying iframe player type. */
+	export enum FrameType {
+		YouTube = 1,
+		Vimeo = 2
+	}
+	/**
+	 * Converts seconds into a human-readable time string (hh?:mm:ss).
+	 * @param s Time in seconds. Can be negative for remaining time display.
+	 * @returns Formatted time string (e.g., "1:23", "1:05:09", "-0:15").
+	 */
+	export function parseTime(s: number): string;
+	/**
+	 * Decodes a character from a Micrio ID into its numeric value (used for V4 short IDs).
 	 * @private
-	*/
+	 */
 	export const getIdVal: (a: string) => number;
+	/** Checks if an ID likely belongs to the V5 format (6 or 7 characters). */
 	export const idIsV5: (id: string) => boolean;
-	/** Hard-limit a view to full image bounds */
+	/** Clamps a view rectangle [x0, y0, x1, y1] to the image bounds [0, 0, 1, 1]. */
 	export const limitView: (v: Models.Camera.View) => Models.Camera.View;
-	/** Calculating the movement vector between two 360 images
+	/**
+	 * Calculates the 3D vector and navigation parameters between two images in a 360 space.
+	 * Used for smooth transitions between waypoints.
 	 * @private
-	*/
+	 * @param micrio The main HTMLMicrioElement instance.
+	 * @param targetId The ID of the target image.
+	 * @returns An object containing the vector, normalized vector, direction, and transition parameters, or undefined if calculation fails.
+	 */
 	export function getSpaceVector(micrio: HTMLMicrioElement, targetId: string): {
 		vector: Models.Camera.Vector;
 		directionX: number;
 		v: Models.Spaces.DirectionVector;
 		vN: Models.Spaces.DirectionVector;
 	} | undefined;
-	/** Feature detection for native HLS video support
+	/**
+	 * Checks if the browser natively supports HLS video playback via the `<video>` element.
 	 * @private
+	 * @param video Optional HTMLVideoElement to check (defaults to creating a temporary one).
+	 * @returns True if native HLS support is detected.
 	 */
 	export const hasNativeHLS: (video?: HTMLMediaElement) => boolean;
+	/**
+	 * Defines various enums used throughout the Micrio application,
+	 * primarily for standardizing action types and option values.
+	 */
 	export namespace Enums {
+		/** Enums related to the Grid functionality. */
 		namespace Grid {
-			/** External grid action types */
+			/**
+			 * Defines the types of actions that can be performed on a Grid instance,
+			 * often triggered by marker data (`gridAction`) or tour events.
+			 */
 			enum GridActionType {
-				/** Filter the grid display by these IDs, comma separated */
+				/** Focus on specific images within the grid, hiding others. Data: comma-separated image IDs. */
 				focus = 0,
-				/** Fly the camera to the bounding box of these in-grid image IDs */
+				/** Animate the main grid view to fit the bounding box of specified images. Data: comma-separated image IDs. */
 				flyTo = 1,
-				/** Filter the grid to the images containing markers that have this custom class name */
+				/** Focus on images containing markers with a specific tag. Data: tag name. */
 				focusWithTagged = 2,
-				/** Filter the grid to the images containing markers that have this custom class name, and fly to their views */
+				/** Focus on images containing markers with a specific tag and fly to the marker views. Data: tag name. */
 				focusTagged = 3,
-				/** Reset the grid to its inception state */
+				/** Reset the grid to its initial layout and view. */
 				reset = 4,
-				/** Go back one grid history step */
+				/** Navigate back one step in the grid layout history. */
 				back = 5,
-				/** When a grid image is in full-focus, immediately switch to the view as if it were in the initial grid */
+				/** Instantly switch a focused image back to its position within the grid layout (used internally?). */
 				switchToGrid = 6,
-				/** If there is a current MarkerTour going on, filter the grid to all grid images that are part of the tour */
+				/** Filter the grid to show only images that are part of the currently active marker tour. */
 				filterTourImages = 7,
-				/** Single time fade duration for next image that will be navigated to */
+				/** Set a one-time crossfade duration for the *next* grid transition. Data: duration in seconds. */
 				nextFadeDuration = 8
 			}
 		}
+		/** Enums related to the Camera functionality. */
 		namespace Camera {
-			/** Camera animation timing function */
+			/**
+			 * Defines the available timing functions for camera animations (flyToView, flyToCoo).
+			 * These correspond to standard CSS easing functions.
+			 */
 			enum TimingFunction {
-				'ease' = 0,
+				'ease' = 0,// Default ease-in-out
 				'ease-in' = 1,
 				'ease-out' = 2,
 				'linear' = 3
@@ -62,122 +106,98 @@ declare module '@micrio/client' {
 	 * Micrio grid display controller
 	 * @author Marcel Duin <marcel@micr.io>
 	 */
-	/** The Grid controller class */
+	/**
+	 * Controls the display and interaction logic for grid layouts.
+	 * Instantiated on the primary {@link MicrioImage} if grid data is present.
+	 * Accessed via `micrioImage.grid`.
+	 */
 	export class Grid {
 		micrio: HTMLMicrioElement;
 		image: MicrioImage;
-		/** The instanced grid images */
+		/** Array of {@link MicrioImage} instances currently part of the grid definition (loaded). */
 		readonly images: MicrioImage[];
-		/** The currently shown images */
+		/** Array of {@link MicrioImage} instances currently visible in the grid layout. */
 		current: MicrioImage[];
-		/** The grid HTML element */
-		_grid: HTMLDivElement;
-		/** The image HTML `<button>` grid elements */
-		_buttons: Map<string, HTMLButtonElement>;
-		/** The HTML grid will stay visible and clickable */
+		/** If true, the HTML grid overlay remains visible and interactive even when an image is focused. */
 		clickable: boolean;
-		/** The current full-view focussed image */
+		/** Writable Svelte store holding the currently focused {@link MicrioImage} instance, or undefined if in grid view. */
 		readonly focussed: Writable<MicrioImage | undefined>;
-		/** Get the current focussed store value */
+		/** Getter for the current value of the {@link focussed} store. */
 		get $focussed(): MicrioImage | undefined;
-		/** Show the markers of these elements */
+		/** Writable Svelte store holding an array of {@link MicrioImage} instances whose markers should be displayed in the grid view. */
 		readonly markersShown: Writable<MicrioImage[]>;
-		/** The grid state history */
+		/** Array storing the history of grid layouts for back navigation. */
 		history: Models.Grid.GridHistory[];
-		/** The current history length */
+		/** Writable Svelte store indicating the current depth in the grid history stack. */
 		depth: Writable<number>;
-		/** The animation duration when opening a new layout, in s */
+		/** Default animation duration (seconds) when transitioning *into* a new layout or focused view. */
 		aniDurationIn: number;
-		/** The animation duration when going back, in s */
+		/** Default animation duration (seconds) when transitioning *out* of a focused view or going back in history. */
 		aniDurationOut: number;
-		/** For delayed transitions, individual delay in s */
+		/** Delay (seconds) between individual image transitions for 'delayed' effects. */
 		transitionDelay: number;
-		/** Duration for the next crossfade */
-		private nextCrossFadeDuration;
-		/** The current grid layout is a single horizontal row */
-		private isHorizontal;
-		/** Current individual cell sizes w,h */
-		readonly cellSizes: Map<string, [number, number?]>;
-		/** Temporary size map for next .set() */
-		private readonly nextSize;
-		/** The Grid constructor
-		 * @param micrio The Micrio instance
-		 * @param image The MicrioImage which is the virtual grid container
+		/**
+		 * The Grid constructor. Initializes the grid based on image settings.
+		 * @param micrio The main HTMLMicrioElement instance.
+		 * @param image The MicrioImage instance acting as the virtual container for the grid.
 		*/
 		constructor(micrio: HTMLMicrioElement, image: MicrioImage);
-		/** Hook all events */
-		private hook;
-		private clearTimeouts;
-		/** Set the grid to this input
-		 * @param input The grid string
-		 * @param opts Optional settings
-		 * @returns Promise when the animation is done with the currently shown images
+		/**
+		 * Sets the grid layout based on an input string or array of image definitions.
+		 * This is the main method for changing the grid's content and appearance.
+		 *
+		 * @param input The grid definition. Can be:
+		 *   - A semicolon-separated string following the format defined in `Grid.getString`.
+		 *   - An array of {@link MicrioImage} instances.
+		 *   - An array of objects `{image: MicrioImage, ...GridImageOptions}`.
+		 * @param opts Options controlling the transition and layout.
+		 * @returns A Promise that resolves with the array of currently displayed {@link MicrioImage} instances when the transition completes.
 		*/
 		set(input?: string | MicrioImage[] | ({
 			image: MicrioImage;
 		} & Models.Grid.GridImageOptions)[], opts?: {
-			/** Don't add the layout to the history stack */
+			/** If true, does not add the previous layout to the history stack. */
 			noHistory?: boolean;
-			/** Don't remove the grid HTML element */
+			/** If true, keeps the HTML grid element in the DOM (used internally). */
 			keepGrid?: boolean;
-			/** The layout is horizontal */
+			/** If true, arranges images in a single horizontal row. */
 			horizontal?: boolean;
-			/** Any main camera animation duration in seconds */
+			/** Overrides the default animation duration for the main grid view transition. */
 			duration?: number;
-			/** Fly the main grid view to this viewport */
+			/** If provided, animates the main grid view to this viewport rectangle. */
 			view?: Models.Camera.View;
-			/** Don't draw any frame or do any camera stuff */
+			/** If true, skips the main grid camera animation. */
 			noCamAni?: boolean;
-			/** Force area animating for images currently not visible */
+			/** If true, forces area animation even for images not currently visible. */
 			forceAreaAni?: boolean;
-			/** Don't unfocus the current focussed image */
+			/** If true, does not unfocus the currently focused image when setting a new layout. */
 			noBlur?: boolean;
-			/** Don't do any fading in */
+			/** If true, skips the fade-in animation for new images. */
 			noFade?: boolean;
-			/** Transition animation, defaults to crossfade */
+			/** Specifies the transition animation type (e.g., 'crossfade', 'slide-left', 'behind-delayed'). */
 			transition?: Models.Grid.GridSetTransition;
-			/** Force an animation for all images */
+			/** If true, forces animation even if duration is 0. */
 			forceAni?: boolean;
-			/** Limit the images to cover view */
+			/** If true, limits individual image views to cover their grid cell. */
 			coverLimit?: boolean;
-			/** Open the images on cover view, but don't limit */
+			/** If true, sets the initial view of images to cover their grid cell (but doesn't enforce limit). */
 			cover?: boolean;
-			/** Scale individual grid images (0-100%) */
+			/** Scale factor (0-1) applied to each grid cell (creates margins). */
 			scale?: number;
-			/** Grid columns */
+			/** Overrides the automatic calculation of grid columns. */
 			columns?: number;
 		}): Promise<MicrioImage[]>;
-		/** See if grid has changed configuration from original state */
-		private hasChanged;
-		/** Convert a grid string to GridImage object
-		 * @param s The image individual encoded grid string
-		 * @returns the GridImage
+		/**
+		 * Parses an individual image grid string into a GridImage object.
+		 * @param s The grid string for a single image.
+		 * @returns The parsed {@link Models.Grid.GridImage} object.
 		*/
 		getImage(s: string): Models.Grid.GridImage;
-		/** Convert an ImageInfo object to an individual image grid string
-		 * @returns The grid encoded string of this image
+		/**
+		 * Converts an ImageInfo object and options back into the grid string format.
+		 * @returns The grid encoded string for this image.
 		*/
 		getString: (i: Models.ImageInfo.ImageInfo, opts?: Models.Grid.GridImageOptions) => string;
-		private getCols;
-		/** Print the image grid based on a generated HTML layout
-		 * @param images Print these images
-		 * @param horizontal Print the images as a single row
-		*/
-		private printGrid;
-		/** Place and watch the grid */
-		private placeGrid;
-		/** Remove the grid */
-		private removeGrid;
-		/** Update grid placement */
-		private updateGrid;
-		/** Place an image in the grid
-		 * @param entry The GridImage:MicrioInfo info object
-		 * @param duration The duration of flying to an optional view
-		 * @param noCamAni Just set internal values, don't animate camera
-		 * @param delay Delay the animation, s
-		 * @returns The instanced MicrioImage
-		*/
-		private placeImage;
 		/** Fade out unused images in the grid
 		 * @param images The images to hide
 		*/
@@ -203,17 +223,14 @@ declare module '@micrio/client' {
 		 * @returns Promise when the transition is complete
 		*/
 		back(duration?: number): Promise<void>;
-		private setTimingFunction;
 		/** Open a grid image full size and set it as the main active image
 		 * @param img The image
 		 * @param opts Focus options
 		 * @returns Promise for when the transition completes
 		*/
 		focus(img: MicrioImage | undefined, opts?: Models.Grid.FocusOptions): Promise<void>;
-		private transition;
 		/** Unfocusses any currently focussed image */
 		blur(): void;
-		private tourEvent;
 		/** Do an (external) action
 		 * @param action The action type enum or string
 		 * @param data Optional action data
@@ -231,656 +248,616 @@ declare module '@micrio/client' {
 		getRelativeView(image: MicrioImage, view: Models.Camera.View): Models.Camera.View;
 	}
 	/**
-	 * The virtual Micrio camera
+	 * Loads an image texture asynchronously. Adds the request to the queue
+	 * and returns a Promise that resolves with the TextureBitmap or rejects on error.
+	 * @param src The URL of the image to load.
+	 * @returns A Promise resolving to the loaded TextureBitmap.
+	 */
+	export const loadTexture: (src: string) => Promise<TextureBitmap>;
+	/**
+	 * Represents the virtual camera used to view a {@link MicrioImage}.
+	 * Provides methods for controlling the viewport (position, zoom, rotation),
+	 * converting between screen and image coordinates, and managing animations.
+	 *
+	 * Instances are typically accessed via `micrioImage.camera`.
 	 * @author Marcel Duin <marcel@micr.io>
 	*/
 	export class Camera {
-		/** Current center screen coordinates and scale */
+		/** Current center screen coordinates [x, y] and scale [z]. For 360, also includes [yaw, pitch]. For Omni, also includes [frameIndex]. */
 		readonly center: Models.Camera.Coords;
-		/** Get the current image view rectangle
-		 * @returns The current screen viewport
+		/**
+		 * Gets the current image view rectangle [x0, y0, x1, y1] relative to the image (0-1).
+		 * @returns A copy of the current screen viewport array, or undefined if not initialized.
 		 */
 		getView: () => Models.Camera.View | undefined;
-		/** Set the screen viewport
-		 * @param v The viewport
-		 * @param opts Options
+		/**
+		 * Sets the camera view instantly to the specified rectangle.
+		 * @param v The target viewport rectangle [x0, y0, x1, y1].
+		 * @param opts Options for setting the view.
 		 */
 		setView(v: Models.Camera.View, opts?: {
-			/** Don't restrict the boundaries */
+			/** If true, allows setting a view outside the normal image boundaries. */
 			noLimit?: boolean;
-			/** [360] Correct the view to trueNorth */
+			/** If true (for 360), corrects the view based on the `trueNorth` setting. */
 			correctNorth?: boolean;
-			/** Don't render */
+			/** If true, prevents triggering a Wasm render after setting the view. */
 			noRender?: boolean;
-			/** Custom sub-area */
+			/** If provided, interprets `v` relative to this sub-area instead of the full image. */
 			area?: Models.Camera.View;
 		}): void;
-		/** Gets the static image XY coordinates of a screen coordinate
-		 * @param x The screen X coordinate in pixels
-		 * @param y The screen Y coordinate in pixels
-		 * @param absolute Use absolute browser window coordinates
-		 * @param noLimit Allow to go out of image bounds
-		 * @returns The relative image XY coordinates
+		/**
+		 * Gets the relative image coordinates [x, y, scale, depth, yaw?, pitch?] corresponding to a screen coordinate.
+		 * Rounds the result for cleaner output.
+		 * @param x The screen X coordinate in pixels.
+		 * @param y The screen Y coordinate in pixels.
+		 * @param absolute If true, treats x/y as absolute browser window coordinates.
+		 * @param noLimit If true, allows returning coordinates outside the image bounds (0-1).
+		 * @returns A Float64Array containing the relative image coordinates [x, y, scale, depth, yaw?, pitch?].
 		 */
 		getCoo: (x: number, y: number, absolute?: boolean, noLimit?: boolean) => Float64Array;
-		/** Sets current coordinates as the center of the screen
-		 * @param x The X Coordinate
-		 * @param y The Y Coordinate
-		 * @param scale The scale to set
+		/**
+		 * Sets the center of the screen to the specified image coordinates and scale instantly.
+		 * @param x The target image X coordinate (0-1).
+		 * @param y The target image Y coordinate (0-1).
+		 * @param scale The target scale (optional, defaults to current scale).
 		 */
 		setCoo(x: number, y: number, scale?: number): void;
-		/** Gets the static screen XY coordinates of an image coordinate
-		 * @param x The image X coordinate
-		 * @param y The image Y coordinate
-		 * @param abs Use absolute browser window coordinates
-		 * @returns The screen XY coordinates in pixels
+		/**
+		 * Gets the screen coordinates [x, y, scale, depth] corresponding to relative image coordinates.
+		 * @param x The image X coordinate (0-1).
+		 * @param y The image Y coordinate (0-1).
+		 * @param abs If true, returns absolute browser window coordinates instead of element-relative.
+		 * @param radius Optional offset radius for 360 calculations.
+		 * @param rotation Optional offset rotation (radians) for 360 calculations.
+		 * @param noTrueNorth If true (for 360), ignores the `trueNorth` correction.
+		 * @returns A Float64Array containing the screen coordinates [x, y, scale, depth].
 		 */
 		getXY: (x: number, y: number, abs?: boolean, radius?: number, rotation?: number, noTrueNorth?: boolean) => Float64Array;
-		/** Get the current image scale */
+		/** Gets the current camera zoom scale. */
 		getScale: () => number;
-		/** Get a rectangle in 360 space
-		 * @param cX The quad center X coordinate
-		 * @param cY The quad center Y coordinate
-		 * @param w The quad width
-		 * @param h The quad height
-		 * @param rotX Rotation over X axis
-		 * @param rotY Rotation over Y axis
-		 * @param rotZ Rotation over Z axis
-		 * @param scaleX Horizontal scale
-		 * @param scaleY Vertical scale
+		/**
+		 * Calculates the screen coordinates of the four corners of a transformed quad in 360 space.
+		 * Used for positioning HTML embeds accurately on the 360 sphere.
+		 * @param cX The quad center X coordinate (0-1).
+		 * @param cY The quad center Y coordinate (0-1).
+		 * @param w The quad relative width (0-1).
+		 * @param h The quad relative height (0-1).
+		 * @param rotX Rotation over X axis (radians).
+		 * @param rotY Rotation over Y axis (radians).
+		 * @param rotZ Rotation over Z axis (radians).
+		 * @param scaleX Horizontal scale multiplier.
+		 * @param scaleY Vertical scale multiplier.
+		 * @returns A Float32Array containing the screen coordinates [x0,y0, x1,y1, x2,y2, x3,y3].
 		*/
 		getQuad(cX: number, cY: number, w: number, h: number, rotX?: number, rotY?: number, rotZ?: number, scaleX?: number, scaleY?: number): Float32Array;
-		/** Get a custom matrix for 360 placed embeds
-		 * @param x The X coordinate
-		 * @param y The Y coordinate
-		 * @param scale  The object scale
-		 * @param radius The object radius (default 10)
-		 * @param rotX The object X rotation in radians
-		 * @param rotY The object Y rotation in radians
-		 * @param rotZ The object Z rotation in radians
-		 * @param transY Optional Y translation in 3d space
-		 * @param scaleX Optional X scaling
-		 * @param scaleY Optional Y scaling
-		 * @returns The resulting 4x4 matrix
+		/**
+		 * Calculates a 4x4 transformation matrix for placing an object at specific coordinates
+		 * with scale and rotation in 360 space. Used for CSS `matrix3d`.
+		 * @param x The image X coordinate (0-1).
+		 * @param y The image Y coordinate (0-1).
+		 * @param scale The object scale multiplier.
+		 * @param radius The object radius (distance from center, default 10).
+		 * @param rotX The object X rotation in radians.
+		 * @param rotY The object Y rotation in radians.
+		 * @param rotZ The object Z rotation in radians.
+		 * @param transY Optional Y translation in 3D space.
+		 * @param scaleX Optional non-uniform X scaling.
+		 * @param scaleY Optional non-uniform Y scaling.
+		 * @returns The resulting 4x4 matrix as a Float32Array.
 		 */
 		getMatrix(x: number, y: number, scale?: number, radius?: number, rotX?: number, rotY?: number, rotZ?: number, transY?: number, scaleX?: number, scaleY?: number): Float32Array;
-		/** Set the current image scale
-		 * @param s The scale
+		/**
+		 * Sets the camera zoom scale instantly.
+		 * @param s The target scale.
 		*/
 		setScale: (s: number) => void;
-		/** Get the scale when the image would cover the screen*/
+		/** Gets the scale at which the image fully covers the viewport. */
 		getCoverScale: () => number;
-		/** Get the minimum scale
-		 * @returns The minimum scale
+		/**
+		 * Gets the minimum allowed zoom scale for the image.
+		 * @returns The minimum scale.
 		*/
 		getMinScale: () => number;
-		/** Sets the minimum scale
-		 * @param s The minimum scale to set
+		/**
+		 * Sets the minimum allowed zoom scale.
+		 * @param s The minimum scale to set.
 		*/
 		setMinScale(s: number): void;
-		/** Sets the minimum screen size you can zoom out to -- this makes you able to zoom out with margins
-		 * Note: This does not work with albums!
-		 * @param s The minimum screen size [0-1]
+		/**
+		 * Sets the minimum screen size the image should occupy when zooming out (0-1).
+		 * Allows zooming out further than the image boundaries, creating margins.
+		 * Note: Does not work with albums.
+		 * @param s The minimum screen size fraction (0-1).
 		*/
 		setMinScreenSize(s: number): void;
-		/** Returns true when the camera is zoomed in to the max */
+		/** Returns true if the camera is currently zoomed in to its maximum limit. */
 		isZoomedIn: () => boolean;
-		/** Returns true when the camera is fully zoomed out
-		 * @param full When using a custom .minSize, use this in the calculation
+		/**
+		 * Returns true if the camera is currently zoomed out to its minimum limit.
+		 * @param full If true, checks against the absolute minimum scale (ignoring `setMinScreenSize`).
 		*/
 		isZoomedOut: (full?: boolean) => boolean;
-		/** Limit camera navigation boundaries
-		 * @param l The viewport limit
+		/**
+		 * Sets a rectangular limit for camera navigation within the image.
+		 * @param l The viewport limit rectangle [x0, y0, x1, y1].
 		*/
 		setLimit(l: Models.Camera.View): void;
-		/** Set the coverLimit of the image to always fill the screen
-		 * @param b Limit the image to cover view
+		/**
+		 * Sets whether the camera view should be limited to always cover the viewport.
+		 * @param b If true, limits the view to cover the screen.
 		*/
 		setCoverLimit(b: boolean): void;
-		/** Get whether the image always fills the screen or not */
+		/** Gets whether the cover limit is currently enabled. */
 		getCoverLimit: () => boolean;
-		/** Limit camera navigation boundaries
-		 * @param xPerc The horizontal arc to limit to, percentage (1 = 360°)
-		 * @param yPerc The vertical arc to limit to, percentage (1 = 180°)
+		/**
+		 * Limits the horizontal and vertical viewing range for 360 images.
+		 * @param xPerc The horizontal arc limit as a percentage (0-1, where 1 = 360°). 0 disables horizontal limit.
+		 * @param yPerc The vertical arc limit as a percentage (0-1, where 1 = 180°). 0 disables vertical limit.
 		*/
 		set360RangeLimit(xPerc?: number, yPerc?: number): void;
-		/** Fly to a specific view
-		 * @returns Promise when the animation is done
-		 * @param view The viewport to fly to
-		 * @param opts Optional animation settings
+		/**
+		 * Animates the camera smoothly to a target view rectangle.
+		 * @param view The target viewport rectangle [x0, y0, x1, y1].
+		 * @param opts Optional animation settings.
+		 * @returns A Promise that resolves when the animation completes, or rejects if aborted.
 		 */
 		flyToView: (view: Models.Camera.View, opts?: Models.Camera.AnimationOptions & {
-			/** Set the starting animation progress percentage */
+			/** Set the starting animation progress percentage (0-1). */
 			progress?: number;
-			/** Base the progress override on this starting view */
+			/** Base the progress override on this starting view. */
 			prevView?: Models.Camera.View;
-			/** Zoom out and in during the animation */
+			/** If true, performs a "jump" animation (zooms out then in). */
 			isJump?: boolean;
-			/** For omni objects: image index to animate to */
+			/** For Omni objects: the target image frame index to animate to. */
 			omniIndex?: number;
-			/** Don't do trueNorth correction */
+			/** If true (for 360), ignores the `trueNorth` correction. */
 			noTrueNorth?: boolean;
-			/** Custom sub-area */
+			/** If provided, interprets `view` relative to this sub-area. */
 			area?: Models.Camera.View;
-			/** Respect the image's maximum zoom limit */
+			/** If true, respects the image's maximum zoom limit during animation. */
 			limitZoom?: boolean;
 		}) => Promise<void>;
-		/** Fly to a full view of the image
-		 * @param opts Animation options
-		 * @returns Promise when the animation is done
+		/**
+		 * Animates the camera to a view showing the entire image (minimum zoom).
+		 * @param opts Optional animation settings.
+		 * @returns A Promise that resolves when the animation completes.
 		 */
 		flyToFullView: (opts?: Models.Camera.AnimationOptions) => Promise<void>;
-		/** Fly to a screen-covering view of the image
-		 * @param opts Animation options
-		 * @returns Promise when the animation is done
+		/**
+		 * Animates the camera to a view where the image covers the viewport.
+		 * @param opts Optional animation settings.
+		 * @returns A Promise that resolves when the animation completes.
 		 */
 		flyToCoverView: (opts?: Models.Camera.AnimationOptions) => Promise<void>;
-		/** Fly to the specific coordinates
-		 * @param coords The X, Y and scale coordinates to fly to
-		 * @param opts Animation options
-		 * @returns Promise when the animation is done
+		/**
+		 * Animates the camera to center on specific image coordinates and scale.
+		 * @param coords The target coordinates [x, y, scale]. Scale is optional.
+		 * @param opts Optional animation settings.
+		 * @returns A Promise that resolves when the animation completes.
 		 */
 		flyToCoo: (coords: Models.Camera.Coords, opts?: Models.Camera.AnimationOptions) => Promise<void>;
-		/** Do a zooming animation
-		 * @param delta The amount to zoom
-		 * @param duration A forced duration in ms of the animation
-		 * @param x Screen pixel X-coordinate as zoom focus
-		 * @param y Screen pixel Y-coordinate as zoom focus
-		 * @param speed A non-default camera speed
-		 * @param noLimit Can zoom outside of the image boundaries
-		 * @returns Promise when the zoom animation is done
+		/**
+		 * Performs an animated zoom centered on a specific screen point (or the current center).
+		 * @param delta The amount to zoom (positive zooms out, negative zooms in).
+		 * @param duration Forced duration in ms (0 for instant).
+		 * @param x Screen pixel X-coordinate for zoom focus (optional, defaults to center).
+		 * @param y Screen pixel Y-coordinate for zoom focus (optional, defaults to center).
+		 * @param speed Animation speed multiplier (optional).
+		 * @param noLimit If true, allows zooming beyond image boundaries.
+		 * @returns A Promise that resolves when the zoom animation completes.
 		 */
 		zoom: (delta: number, duration?: number, x?: number | undefined, y?: number | undefined, speed?: number, noLimit?: boolean) => Promise<void>;
-		/** Zoom out a factor
-		 * @param factor The amount to zoom in
-		 * @param duration A forced duration in ms of the animation
-		 * @param speed A non-default camera speed
-		 * @returns Promise when the zoom animation is done
+		/**
+		 * Zooms in by a specified factor.
+		 * @param factor Zoom factor (e.g., 1 = standard zoom step).
+		 * @param duration Animation duration in ms.
+		 * @param speed Animation speed multiplier.
+		 * @returns A Promise that resolves when the animation completes.
 		 */
 		zoomIn: (factor?: number, duration?: number, speed?: number) => Promise<void>;
-		/** Zoom out a factor
-		 * @param factor The amount to zoom out
-		 * @param duration A forced duration in ms of the animation
-		 * @param speed A non-default camera speed
-		 * @returns Promise when the zoom animation is done
+		/**
+		 * Zooms out by a specified factor.
+		 * @param factor Zoom factor (e.g., 1 = standard zoom step).
+		 * @param duration Animation duration in ms.
+		 * @param speed Animation speed multiplier.
+		 * @returns A Promise that resolves when the animation completes.
 		 */
 		zoomOut: (factor?: number, duration?: number, speed?: number) => Promise<void>;
-		/** Pan relative pixels
-		 * @param x The horizontal number of pixels to pan
-		 * @param y The vertical number of pixels to pan
-		 * @param duration An optional duration
+		/**
+		 * Pans the camera view by a relative pixel amount.
+		 * @param x The horizontal pixel distance to pan.
+		 * @param y The vertical pixel distance to pan.
+		 * @param duration Animation duration in ms (0 for instant).
+		 * @param opts Options: render (force render), noLimit (allow panning outside bounds).
 		*/
 		pan(x: number, y: number, duration?: number, opts?: {
 			render?: boolean;
 			noLimit?: boolean;
 		}): void;
-		/** Stop any animation */
+		/** Stops any currently running camera animation immediately. */
 		stop(): void;
-		/** Pause any animation */
+		/** Pauses the current camera animation. */
 		pause(): void;
-		/** Pause any animation */
+		/** Resumes a paused camera animation. */
 		resume(): void;
-		/** Returns whether the current camera movement is kinetic / rubber banding */
+		/** Returns true if the camera is currently performing a kinetic pan/zoom (coasting). */
 		aniIsKinetic(): boolean;
-		/** Get the current direction facing in 360 mode in radians */
+		/** Gets the current viewing direction (yaw) in 360 mode.
+		 * @returns The current yaw in radians.
+		 */
 		getDirection: () => number;
-		/** Sets the 360 viewing direction in radians
-		 * @param yaw The direction in radians
-		 * @param pitch Optional pitch in radians
+		/**
+		 * Sets the viewing direction (yaw and optionally pitch) instantly in 360 mode.
+		 * @param yaw The target yaw in radians.
+		 * @param pitch Optional target pitch in radians.
 		*/
 		setDirection(yaw: number, pitch?: number): void;
-		/** Get the current direction pitch
-		 * @returns The current pitch in radians
+		/**
+		 * Gets the current viewing pitch in 360 mode.
+		 * @returns The current pitch in radians.
 		*/
 		getPitch: () => number;
-		/** Set the relative {@link Models.Camera.View} to render to, animates by default */
+		/**
+		 * Sets the rendering area for this image within the main canvas.
+		 * Used for split-screen and potentially other layout effects. Animates by default.
+		 * @param v The target area rectangle [x0, y0, x1, y1] relative to the main canvas (0-1).
+		 * @param opts Options for setting the area.
+		 */
 		setArea(v: Models.Camera.View, opts?: {
-			/** Directly set the area without animation */
+			/** If true, sets the area instantly without animation. */
 			direct?: boolean;
-			/** Don't emit the updates back to JS */
+			/** If true, prevents dispatching view updates during the animation. */
 			noDispatch?: boolean;
-			/** Don't trigger a frame draw */
+			/** If true, prevents triggering a Wasm render after setting the area. */
 			noRender?: boolean;
 		}): void;
-		/** For in-image 360 embeds */
+		/** Sets the 3D rotation for an embedded image (used for placing embeds in 360 space). */
 		setRotation(rotX?: number, rotY?: number, rotZ?: number): void;
-		/** [Omni] Get the current rotation in degrees */
+		/** [Omni] Gets the current rotation angle in degrees based on the active frame index. */
 		getOmniRotation(): number;
-		/** [Omni] Get the corresponding frame number to current rotation */
+		/** [Omni] Gets the frame index corresponding to a given rotation angle (radians). */
 		getOmniFrame(rot?: number): number | undefined;
-		/** [Omni] Get the corresponding screen coordinates based on xyz coords */
+		/** [Omni] Gets the screen coordinates [x, y, scale, depth] for given 3D object coordinates. */
 		getOmniXY(x: number, y: number, z: number): Float64Array;
+		/** [Omni] Applies Omni-specific camera settings (distance, FoV, angle) to Wasm. */
 		setOmniSettings(): void;
 	}
-	export const BASEPATH_V5: string;
-	export const BASEPATH_V5_EU: string;
-	/** External wasm binary */
-	export const WASM: {
-		'b64': string;
-		'ugz'?: (b: string, t: boolean) => Promise<ArrayBuffer | Uint8Array>;
-	};
-	/** The WebAssembly class */
+	/**
+	 * The main WebAssembly controller class. Handles interaction between JavaScript
+	 * and the compiled C++ core of Micrio. Accessed via `micrio.wasm`.
+	 */
 	export class Wasm {
 		micrio: HTMLMicrioElement;
-		/** Wasm inited */
+		/** Flag indicating if the Wasm module has been loaded and initialized. */
 		ready: boolean;
-		/** Shared WebAssembly memory -- 1 page is 64KB */
+		/** Shared WebAssembly memory instance. */
 		private memory;
-		/** The actual WebAssembly memory buffer -- only call here since memory won't grow */
-		private b;
-		/** The WebAssembly main instance memory pointer */
-		private i;
-		/** The WebAssembly current canvas instance memory pointer */
-		private c;
-		/** The current frame's timestamp */
-		private now;
-		/** RequestAnimationFrame pointer */
-		private raf;
-		/** Is currently drawing */
-		private drawing;
-		/** Barebone mode, minimal tile downloading */
-		private bareBone;
-		/** Number of tiles per image */
-		private baseTiles;
-		/** Array of tile indices drawn this frame */
-		private drawn;
-		/** Array of tile indices drawn last frame */
-		private prevDrawn;
-		/** Tile indices to be deleted */
-		private toDelete;
-		/** Tile textures */
-		private textures;
-		/** Running texture download threads */
-		private requests;
-		/** Timeout after texture loads */
-		private timeouts;
-		/** Tile loaded timestamp */
-		private tileLoaded;
-		/** Tile opacity */
-		private tileOpacity;
-		/** Tile load states */
-		private loadStates;
-		/** Svelte watch subscriptions */
-		private unsubscribe;
-		private cameras;
-		/** The tile vertex buffer */
-		_vertexBuffer: Float32Array;
-		/** The tile texture buffer */
-		static readonly _textureBuffer: Float32Array;
-		/** Number of X geometry segments per tile */
-		static segsX: number;
-		/** Number of Y geometry segments per tile */
-		static segsY: number;
-		/** The tile vertex buffer for 360 */
-		_vertexBuffer360: Float32Array;
-		/** The tile texture buffer for 360 */
-		static _textureBuffer360: Float32Array;
-		/** Camera perspective matrix from WebAssembly */
-		private _pMatrices;
-		/** Is paged */
-		private isGallery;
-		/** Wasm imports */
-		private imports;
-		/** Build the static tile texture coord buffer */
-		private static getTextureBuffer;
-		/** Create the WebAssembly instance
-		 * @param micrio The main <micr-io> instance
+		/**
+		 * Creates the Wasm controller instance.
+		 * @param micrio The main HTMLMicrioElement instance.
 		*/
 		constructor(micrio: HTMLMicrioElement);
-		/** Load the WebAssembly module
-		 * @returns The promise when loading is complete
+		/**
+		 * Loads and instantiates the WebAssembly module.
+		 * @returns A Promise that resolves when the Wasm module is ready.
 		*/
 		load(): Promise<void>;
-		/** Unbind this module */
+		/** Unbinds event listeners, stops rendering, and cleans up resources. */
 		unbind(): void;
-		/** Add a new rendering canvas */
-		private addCanvas;
-		/** Set the specified canvas as active
-		 * @param canvas The Image to add
+		/**
+		 * Sets the currently active canvas/image instance in the Wasm module.
+		 * Handles adding the canvas to Wasm if it's not already initialized.
+		 * @param canvas The MicrioImage instance to set as active.
 		*/
 		setCanvas(canvas?: MicrioImage): void;
-		/** Remove a canvas */
+		/** Removes a canvas instance from the Wasm module. */
 		removeCanvas(c: MicrioImage): void;
-		/** Request a next frame to draw */
+		/** Requests the next animation frame to trigger the `draw` method. */
 		render(): void;
-		/** Draw an actual frame */
-		private draw;
-		/** Cancel the current requestAnimationFrame request */
-		private stop;
-		/** Tile drawing function called from inside Wasm
-		 * @returns True when the tile is downloaded and ready to drawn
-		 */
-		private drawTile;
-		/** Clear the canvas for drawing */
-		private drawStart;
-		/** Received the texture data */
-		private gotTexture;
-		/** Delete an ended or cancelled request */
-		private deleteRequest;
-		/** Delete a tile */
-		private deleteTile;
-		/** Do a general cleanup */
-		private cleanup;
-		/** Resize the internal canvas
-		 * @param c The viewport rect
-		*/
-		resize(c: Models.Canvas.ViewRect): void;
 		/** Add a child image to the current canvas, either embed or independent canvas */
 		private addImage;
-		/** Add a child image to the current canvas
-		 * @param image The image
-		 * @param parent The parent image
-		 * @param opts Embedding options
-		 * @returns Promise when the image is added
-		 */
-		addEmbed: (image: MicrioImage | Models.Omni.Frame, parent: MicrioImage, opts?: Models.Embeds.EmbedOptions) => Promise<void>;
 		/** Add a child independent canvas to the current canvas, used for grid images
 		 * @param image The image
 		 * @param parent The parent image
 		 * @returns Promise when the image is added
 		 */
 		addChild: (image: MicrioImage, parent: MicrioImage) => Promise<void>;
-		/** Simple image fader
-		 * @param ptr The child image mem pointer
-		 * @param opacity The target opacity
-		 * @param direct Set immediately
-		 */
-		fadeImage(ptr: number, opacity: number, direct?: boolean): void;
 	}
 	/**
-	 * Swipeable switching image sequence
+	 * Handles swipe gestures for navigating image sequences, particularly for
+	 * swipe galleries and Omni object rotation.
 	 * @author Marcel Duin <marcel@micr.io>
-	 *
-	*/
+	 */
 	export class GallerySwiper {
 		private micrio;
 		private length;
 		goto: (i: number) => void;
 		private opts;
-		private startIndex;
-		private startX;
-		private hitTresh;
-		private snapTo;
-		private raf;
-		private pointers;
-		private isFullWidth;
-		private startedWithShift;
-		private firstTouchId;
-		private image;
+		/** Getter for the current active image/frame index from the Wasm module. */
 		get currentIndex(): number;
-		constructor(micrio: HTMLMicrioElement, length: number, goto: (i: number) => void, opts?: {
+		/**
+		 * Creates a GallerySwiper instance.
+		 * @param micrio The main HTMLMicrioElement instance.
+		 * @param length The total number of images/frames in the sequence.
+		 * @param goto Callback function to navigate to a specific index.
+		 * @param opts Swiper options: sensitivity, continuous looping, coverLimit.
+		 */
+		constructor(micrio: HTMLMicrioElement, length: number, goto: (i: number) => void, // Callback to change the active index
+		opts?: {
 			sensitivity?: number;
 			continuous?: boolean;
 			coverLimit?: boolean;
 		});
+		/** Cleans up event listeners when the swiper is destroyed. */
 		destroy(): void;
-		private isDragging;
-		/** Drag start */
-		private dStart;
-		/** Drag move */
-		private dMove;
-		/** Drag stop */
-		private dStop;
-		private mouseleave;
-		private swipeEnd;
-		/** Same as .goto(), but animate the rotation */
+		/**
+		 * Animates smoothly to a target index using requestAnimationFrame.
+		 * @param idx The target index.
+		 */
 		animateTo(idx: number): void;
 	}
 	/**
 	 * # Micrio State management
 	 *
-	 * Newly introduced in Micrio 4.0 is the replacement of the way you can interact with markers and tours from a classic imperative JavaScript API to a Svelte-inspired, store-based **state** management using SvelteStore.
-	 *
-	 * This has greatly simplified the internal workings and has made the HTML interface fully reactive based on the image state instead of being interwoven in the previous JS API itself.
-	 *
-	 * There are 2 `State` controllers:
-	 *
-	 * 1. {@link State.Main}: the main {@link HTMLMicrioElement} state controller, used for:
-	 * 	* Getting and setting the active tour and marker
-	 * 	* Loading and saving the entire current state as a minimal independent JSON object
-	 * 2. {@link State.Image}: individual image {@link MicrioImage.state} controller, used for:
-	 * 	* Setting the current opened marker in this image
-	 * 	* Getting the image's last known viewport, even if it is not active at the moment
-	 *
-	 * ## Upgrading from Micrio 3.x to 4.x
+	 * Manages the application state using Svelte stores, allowing reactive updates
+	 * throughout the UI and providing methods to get/set the overall state.
+	 * Replaces the imperative API of Micrio 3.x.
 	 *
-	 * Please refer to [this Micrio knowledge base article](https://doc.micr.io/client/v4/migrating.html)
-	 * for if you want to upgrade an existing 3.x implementation to 4.x.
+	 * Consists of two main state controllers:
+	 * 1. {@link State.Main}: Global state for the `<micr-io>` element (active tour, marker, UI state).
+	 * 2. {@link State.Image}: State specific to individual {@link MicrioImage} instances (view, active marker within that image).
 	 *
+	 * @see {@link https://doc.micr.io/client/v4/migrating.html | Migrating from Micrio 3.x}
 	 * @author Marcel Duin <marcel@micr.io>
-	*/
+	 */
 	export namespace State {
-		/** A main Micrio state JSON object */
+		/** Represents the entire serializable state of a Micrio instance. */
 		type MicrioStateJSON = {
-			/** The current image id */
+			/** The ID of the currently active main image. */
 			id: string;
-			/** Array of individual image states */
+			/** Array containing the state of each individual image canvas. */
 			c: ImageState[];
-			/** Any running tour */
+			/** Optional information about the currently active tour [tourId, currentTime?, pausedState?]. */
 			t?: [string, number?, string?];
-			/** Any running media */
+			/** Reference to the currently active HTMLMediaElement (unused?). */
 			m?: HTMLMediaElement;
 		};
-		/** An individual image state */
+		/** Represents the serializable state of a single MicrioImage instance. */
 		type ImageState = [
+			/** The image ID. */
 			string,
+			/** The current viewport x0. */
 			number,
+			/** The current viewport y0. */
 			number,
+			/** The current viewport x1. */
 			number,
+			/** The current viewport y1. */
 			number,
+			/** The ID of the currently opened marker within this image (optional). */
 			string?,
+			/** The UUID of the media element associated with the opened marker (optional). */
 			string?,
+			/** The currentTime of the marker's media element (optional). */
 			number?,
+			/** The paused state ('p') of the marker's media element (optional). */
 			string?
 		];
 		/**
-		* # HTMLMicrioElement state controller
-		*
-		* The {@link State.Main} constructor is used as {@link HTMLMicrioElement.state}, and offers:
-		*
-		* * Reading and setting the active tour and marker
-		* * Loading and saving the entire current state as a minimal independent JSON object
+		* # HTMLMicrioElement state controller (`micrio.state`)
 		*
+		* Manages the global application state associated with the main `<micr-io>` element.
+		* Provides Svelte stores for reactive UI updates and methods for state serialization.
 		*/
 		class Main {
 			private micrio;
-			/** The current {@link Models.ImageData.MarkerTour} or {@link Models.ImageData.VideoTour} store Writable */
+			/** Writable Svelte store holding the currently active tour object (VideoTour or MarkerTour), or undefined if no tour is active. */
 			readonly tour: Writable<Models.ImageData.VideoTour | Models.ImageData.MarkerTour | undefined>;
-			/** The current active {@link Models.ImageData.MarkerTour} or {@link Models.ImageData.VideoTour} */
+			/** Getter for the current value of the {@link tour} store. */
 			get $tour(): Models.ImageData.VideoTour | Models.ImageData.MarkerTour | undefined;
-			/** The current shown image's opened {@link Models.ImageData.Marker} store Writable */
+			/** Writable Svelte store holding the marker object currently opened in the *main* active image, or undefined if none is open. */
 			readonly marker: Writable<Models.ImageData.Marker | undefined>;
-			/** The current hovered marker */
+			/** Writable Svelte store holding the ID of the marker currently being hovered over. */
 			readonly markerHoverId: Writable<string | undefined>;
-			/** The current opened {@link Models.ImageData.Marker} of the current shown {@link MicrioImage} */
+			/** Getter for the current value of the {@link marker} store. */
 			get $marker(): Models.ImageData.Marker | undefined;
-			/** The current opened popup */
+			/** Writable Svelte store holding the marker object whose popup is currently displayed. */
 			readonly popup: Writable<Models.ImageData.Marker | undefined>;
-			/** The current opened custom content page */
+			/** Writable Svelte store holding the data for the currently displayed popover (custom page or gallery). See {@link Models.State.PopoverType}. */
 			readonly popover: Writable<Models.State.PopoverType | undefined>;
-			/** UI controls settings */
+			/** UI state stores. */
 			ui: {
-				/** Show/hide main controls */
+				/** Writable store controlling the visibility of the main UI controls (bottom right). */
 				controls: Writable<boolean>;
-				/** Show zoom buttons if applicable */
+				/** Writable store controlling the visibility of zoom buttons. */
 				zoom: Writable<boolean>;
-				/** Hide all UI elements */
+				/** Writable store controlling the visibility of all UI elements (e.g., for fullscreen or specific modes). */
 				hidden: Writable<boolean>;
 			};
 			/**
-			 * Gets the current state as an independent, minimal JSON object.
-			 * This includes the currently open image(s), marker(s), and actively playing media (video, audio, tour) and its state.
-			 * You can use this object in any other environment to immediately replicate this state (neat!).
-			 *
-			 * Example:
+			 * Gets the current state of the Micrio viewer as a serializable JSON object.
+			 * This object captures the active image(s), viewports, open markers, active tour,
+			 * and media playback states, allowing the exact state to be restored later or elsewhere.
 			 *
-			 * ```js
-			 * // Save the current state in Browser 1
-			 * const state = micrio.state.get();
-			 *
-			 * // Save or sync this object to Browser 2 and load it there..
-			 *
-			 * // This makes the <micr-io> session state identical to Browser 1.
-			 * micrio.state.set(state);
+			 * @example
+			 * ```javascript
+			 * const currentState = micrio.state.get();
+			 * // Store or transmit `currentState`
 			 * ```
+			 * @returns The current state as a {@link MicrioStateJSON} object, or undefined if no image is loaded.
 			 */
 			get(): MicrioStateJSON | undefined;
 			/**
-			 * Sets the state from a `MicrioStateJSON` object, output by the function above here.
-			 * This works on any Micrio instance!
-			*/
+			 * Sets the Micrio viewer state from a previously saved {@link MicrioStateJSON} object.
+			 * This will attempt to restore the active image, viewports, open markers, active tour,
+			 * and media playback states.
+			 *
+			 * @example
+			 * ```javascript
+			 * const savedState = // ... load state object ...
+			 * micrio.state.set(savedState);
+			 * ```
+			 * @param s The state object to load.
+			 */
 			set(s: MicrioStateJSON): Promise<void>;
-			private setTour;
 		}
 		/**
-		* # MicrioImage state controller
-		*
-		* The {@link State.Image} constructor is used as {@link MicrioImage.state}, and offers:
+		* # MicrioImage state controller (`micrioImage.state`)
 		*
-		* * Setting the current opened marker in this image
-		* * Getting the image's last known viewport, even if it is not active at the moment
+		* Manages the state specific to a single {@link MicrioImage} instance,
+		* primarily its viewport and currently opened marker.
 		*/
 		class Image {
 			private image;
-			/** The current image viewport store Writable */
+			/** Writable Svelte store holding the current viewport [x0, y0, x1, y1] of this image. */
 			readonly view: Writable<Models.Camera.View | undefined>;
-			/** The current or last known viewport of this image */
+			/** Getter for the current value of the {@link view} store. */
 			get $view(): Models.Camera.View | undefined;
 			/**
-			 * The current active marker store Writable.
-			 * You can either set this to be a {@link Models.ImageData.Marker} JSON object, or `string`, which is the ID
-			 * of the marker you wish to open.
+			 * Writable Svelte store holding the currently active marker within *this specific image*.
+			 * Can be set with a marker ID string or a full marker object. Setting to undefined closes the marker.
 			 */
 			readonly marker: Writable<Models.ImageData.Marker | string | undefined>;
-			/** The current active Marker instance */
+			/** Getter for the current value of the {@link marker} store. */
 			get $marker(): Models.ImageData.Marker | undefined;
-			/** The current layer to display (omni objects) */
+			/** Writable Svelte store holding the currently displayed layer index (for Omni objects). */
 			readonly layer: Writable<number>;
-			/** Hook omni layer */
-			hookOmni(): void;
 		}
 	}
 	/**
-	 * An individual Micrio image
+	 * Represents and controls a single Micrio image instance within the viewer.
+	 * This class manages the image's metadata (info), cultural data (data),
+	 * settings, camera, state, and interactions with the WebAssembly module
+	 * for rendering and processing. It handles loading image tiles, embeds,
+	 * markers, tours, and galleries associated with the image.
+	 *
+	 * Instances are typically created and managed by the main {@link HTMLMicrioElement}.
 	 * @author Marcel Duin <marcel@micr.io>
 	*/
 	export class MicrioImage {
 		wasm: Wasm;
 		private attr;
 		opts: {
-			/** Optional sub area for partial / embedded images */
+			/** Optional sub area [x0, y0, x1, y1] defining placement within a parent canvas (for embeds/galleries). */
 			area?: Models.Camera.View;
-			/** For split screen, the image this is secondary to */
+			/** For split screen, the primary image this one is secondary to. */
 			secondaryTo?: MicrioImage;
-			/** Follow the movements of the main image */
+			/** If true, passively follows the view changes of the primary split-screen image. */
 			isPassive?: boolean;
-			/** This is an in-image embed */
+			/** If true, this image is embedded within another image (affects rendering/camera). */
 			isEmbed?: boolean;
-			/** For non-independent embeds, use the parent's .camera */
+			/** If true, uses the parent image's camera instead of creating its own (for switch/omni galleries). */
 			useParentCamera?: boolean;
 		};
-		/** The image id */
+		/** The unique identifier (Micrio ID) for this image. */
 		readonly id: string;
-		/** Unique instance id */
+		/** A unique instance identifier (UUID) generated for this specific instance. */
 		readonly uuid: string;
-		/** The Micrio info data Readable store */
+		/** Svelte Readable store holding the image's core information (dimensions, format, settings, etc.). See {@link Models.ImageInfo.ImageInfo}. */
 		readonly info: Readable<Models.ImageInfo.ImageInfo | undefined>;
-		/** The image info data
+		/** Getter for the current value of the {@link info} store.
 		 * @readonly
 		*/
 		get $info(): Models.ImageInfo.ImageInfo | undefined;
-		/** The image settings Writable */
+		/** Svelte Writable store holding the image's specific settings, often merged from attributes and info data. See {@link Models.ImageInfo.Settings}. */
 		readonly settings: Writable<Models.ImageInfo.Settings>;
-		/** The current CultureData */
+		/** Getter for the current value of the {@link settings} store. */
 		get $settings(): Models.ImageInfo.Settings;
-		/** The Micrio culture data Writable */
+		/** Svelte Writable store holding the image's cultural data (markers, tours, text content for the current language). See {@link Models.ImageData.ImageData}. */
 		readonly data: Writable<Models.ImageData.ImageData | undefined>;
-		/** The current CultureData */
+		/** Getter for the current value of the {@link data} store. */
 		get $data(): Models.ImageData.ImageData | undefined;
-		/** State manager */
+		/** State manager specific to this image instance (view, active marker, etc.). See {@link State.Image}. */
 		readonly state: State.Image;
-		/** The virtual camera instance to control the current main image views */
+		/** The virtual camera instance controlling the view for this image. */
 		camera: Camera;
-		/** The 2D or 360 video MediaElement */
+		/** Svelte Writable store holding the HTMLVideoElement if this image represents a video. */
 		readonly video: Writable<HTMLVideoElement | undefined>;
-		/** The canvas is currently visible
+		/** Svelte Writable store indicating if this image's canvas is currently visible and being rendered.
 		 * @readonly
 		*/
 		readonly visible: Writable<boolean>;
-		/** Album info if image is part of an album (V5+) */
+		/** Album information if this image is part of a V5 album. */
 		album?: Models.Album | undefined;
-		/** Gallery swiper instance */
+		/** Gallery swiper instance, if this image is part of a swipe gallery. */
 		swiper: GallerySwiper | undefined;
-		/** The last opened view */
+		/** Stores the camera view state when a marker is opened, used to return to the previous view. */
 		openedView: Models.Camera.View | undefined;
-		/** Error, if any */
+		/** Base path URI for fetching `data.[lang].json` files. */
+		dataPath: string;
+		/** Stores an error message if loading failed. */
 		error: string | undefined;
-		/** Rendered pixel rectangle [left, top, width, height] */
+		/** Svelte Writable store holding the calculated pixel viewport [left, top, width, height] of this image within the main canvas. */
 		readonly viewport: Writable<Models.Camera.View>;
-		/** Embedded in-image children */
+		/** Array of child {@link MicrioImage} instances embedded within this image. */
 		readonly embeds: MicrioImage[];
-		/** Grid controller */
+		/** Grid controller instance, if this image is a grid container. */
 		grid: Grid | undefined;
-		/** The tile basePath */
+		/** Base path for fetching image tiles. */
 		tileBase: string | undefined;
-		private setError;
-		private loadScript;
-		private loadStyle;
-		/** Enrich marker tour data with external tour step info and durations
-		 * This method is called BEFORE Image.data is set. So that's pretty neat.
-		*/
-		private enrichData;
-		private parseIIIFSequence;
-		/** Add an in-image micrio embed */
+		/**
+		 * Adds an embedded MicrioImage (representing another Micrio image or video) within this image.
+		 * @param info Partial info data for the embed.
+		 * @param area The placement area `[x0, y0, x1, y1]` within the parent image.
+		 * @param opts Embedding options (opacity, fit, etc.).
+		 * @returns The newly created embedded {@link MicrioImage} instance.
+		 */
 		addEmbed(info: Partial<Models.ImageInfo.ImageInfo>, area: Models.Camera.View, opts?: Models.Embeds.EmbedOptions): MicrioImage;
-		/** Get the accompanying HTMLMediaElement for any in-image video embeds */
+		/** Gets the HTMLMediaElement associated with a video embed ID. */
 		getEmbedMediaElement(id: string): HTMLMediaElement | undefined;
-		/** Fade in the individual image */
+		/** Fades in the image smoothly or instantly. */
 		fadeIn(direct?: boolean): void;
+		/** Fades out the image smoothly or instantly. */
 		fadeOut(direct?: boolean): void;
 	}
 	/**
-	 * Video tour controller
+	 * Video tour controller. Manages playback and camera animation for video tours
+	 * defined by a timeline of view rectangles and durations.
 	 * @author Marcel Duin <marcel@micr.io>
-	*/
-	/** The Video Tour class */
+	 */
+	/**
+	 * Controls the playback of a video tour, animating the camera according
+	 * to a predefined timeline and synchronizing with associated audio/video media.
+	 * Instances are typically created and managed by the `Tour.svelte` component.
+	 */
 	export class VideoTourInstance {
 		private image;
 		private data;
-		/** The tour timeline */
-		private timeline;
-		private content;
-		/** Micrio instance */
-		private micrio;
-		/** Set the data */
+		/**
+		 * Creates a VideoTourInstance.
+		 * @param image The parent {@link MicrioImage} instance.
+		 * @param data The {@link Models.ImageData.VideoTour} data object.
+		 */
 		constructor(image: MicrioImage, data: Models.ImageData.VideoTour);
+		/** Cleans up the tour instance, stops animations, and re-hooks events if necessary. */
 		destroy(): void;
-		/** Parse the timeline data */
+		/** Parses the raw timeline data from the tour content into the internal `timeline` array. */
 		read(): void;
+		/** Getter for the total duration of the tour in seconds. */
 		get duration(): number;
+		/** Setter for the total duration (updates internal content). */
 		set duration(v: number);
+		/** Getter for the current paused state. */
 		get paused(): boolean;
+		/** Getter indicating if the tour has ended. */
 		get ended(): boolean;
+		/** Getter for the current playback time in seconds. */
 		get currentTime(): number;
+		/** Setter for the current playback time (seeks to the corresponding progress). */
 		set currentTime(v: number);
+		/** Getter for the current progress percentage (0-1). */
 		get progress(): number;
+		/** Setter for the current progress percentage (seeks to that point). */
 		set progress(v: number);
-		/** Play/resume the tour */
+		/** Starts or resumes tour playback. */
 		play(): void;
-		/** Pause the tour */
+		/** Pauses the tour playback. */
 		pause(): void;
-		/** Go to time segment index */
-		private gotoStep;
-		/** Go to the next tour segment */
-		private nextStep;
-		/** Get a viewport for a step index */
-		private getView;
-		/** Start a segment animation */
-		private startAni;
-		/** Set the tour to this progress percentage */
+		/**
+		 * Seeks the tour to a specific progress percentage.
+		 * @param perc The target progress (0-1).
+		 */
 		private setProgress;
-		/** Go to a timestamp in milliseconds */
-		private gotoTime;
 	}
 	/**
 	 * # Micrio JSON data model
@@ -1740,6 +1717,7 @@ declare module '@micrio/client' {
 				currentTime?: number;
 				/** Media has ended */
 				ended?: boolean;
+				hasSubtitle?: boolean;
 			};
 			interface MenuPageButton {
 				/** Localized button title */
@@ -2079,91 +2057,143 @@ declare module '@micrio/client' {
 			}
 		}
 	}
+	/**
+	 * Handles WebGL postprocessing effects.
+	 * Sets up a framebuffer to render the main scene to a texture,
+	 * then renders a fullscreen quad using that texture and a custom fragment shader
+	 * to apply effects like bloom, vignette, etc.
+	 */
 	export class PostProcessor {
 		private gl;
-		/** Framebuffer render target for postprocessing */
+		/** Framebuffer object used as the render target for the main scene. */
 		frameBuffer: WebGLFramebuffer;
-		/** Frame buffer render-to-texture */
-		private texture;
-		/** Quad buffer for frameBuffer */
-		private quad;
-		/** Post processing shader */
-		private program;
-		private ppPositionLoc;
-		private ppTexCoordLoc;
-		private ppTimeLoc;
+		/**
+		 * Creates a PostProcessor instance.
+		 * Compiles the shaders, creates the framebuffer and texture, and sets up attributes/uniforms.
+		 * @param gl The WebGL rendering context.
+		 * @param micrio The main HTMLMicrioElement instance (used for WebGL utilities).
+		 * @param fragmentShader The source code for the custom fragment shader implementing the effect.
+		 */
 		constructor(gl: WebGL2RenderingContext | WebGLRenderingContext, micrio: HTMLMicrioElement, fragmentShader: string);
+		/**
+		 * Renders the postprocessing effect.
+		 * Binds the postprocessing shader, sets up attributes, binds the scene texture,
+		 * passes uniforms (like time), and draws the fullscreen quad.
+		 * Assumes the main scene has already been rendered to this instance's framebuffer.
+		 */
 		render(): void;
+		/**
+		 * Resizes the framebuffer texture when the canvas size changes.
+		 */
 		resize(): void;
 	}
 	/**
-	 * Micrio user input event handler
+	 * Handles user input events (mouse, touch, keyboard, wheel, gestures) for the Micrio viewer.
+	 * Translates browser events into camera movements (pan, zoom), dispatches custom Micrio events,
+	 * and manages interaction states like panning, pinching, and enabled/disabled states.
+	 * Accessed via `micrio.events`.
 	 * @author Marcel Duin <marcel@micr.io>
 	 */
 	export class Events {
-		/** Enable/disable events */
+		/** Writable Svelte store indicating if event handling is currently enabled. Set to false during tours or animations. */
 		enabled: Writable<boolean>;
-		/** Enabled state getter */
+		/** Getter for the current value of the {@link enabled} store. */
 		get $enabled(): boolean;
-		/** User is pinching above certain treshold */
+		/** Current pinch zoom factor relative to the start of the pinch. Undefined when not pinching. */
 		pinchFactor: number | undefined;
-		/** User is currently manually navigating or not
-		 * @returns Whether the user is using mouse/gestures to navigate right now
+		/**
+		 * Checks if the user is currently interacting with the map via panning, pinching, or wheeling.
+		 * @returns True if the user is actively navigating.
 		*/
 		get isNavigating(): boolean;
-		/** Hook all event listeners */
+		/** Hooks all necessary event listeners based on current settings. */
 		hook(): void;
-		/** Unhook all event listeners */
+		/** Unhooks all attached event listeners. */
 		unhook(): void;
-		/** Hook keyboard event listeners */
+		/** Hooks keyboard event listeners. */
 		hookKeys(): void;
-		/** Unhook keyboard event listeners */
+		/** Unhooks keyboard event listeners. */
 		unhookKeys(): void;
-		/** Hook all zoom event listeners */
+		/** Hooks zoom-related event listeners (pinch, scroll, double-tap/click). */
 		hookZoom(): void;
-		/** Remove all zoom event listeners */
+		/** Unhooks zoom-related event listeners. */
 		unhookZoom(): void;
-		scrollHooked: boolean;
-		/** Hook mousewheel / scroll event listeners */
+		/** Hooks mouse wheel/scroll event listeners. */
 		hookScroll(): void;
-		/** Unhook mousewheel / scroll event listeners */
+		/** Unhooks mouse wheel/scroll event listeners. */
 		unhookScroll(): void;
-		/** Hook touch/pinch event listeners */
+		/** Hooks touch pinch and macOS gesture event listeners. */
 		hookPinch(): void;
-		/** Unhook touch/pinch event listeners */
+		/** Unhooks touch pinch and macOS gesture event listeners. */
 		unhookPinch(): void;
-		/** Hook mouse/touch dragging event listeners */
+		/** Hooks pointer down/move/up listeners for drag panning. */
 		hookDrag(): void;
-		/** Unhook mouse/touch dragging event listeners */
+		/** Unhooks pointer listeners for drag panning. */
 		unhookDrag(): void;
 	}
-	/** Micrio sizing and `<canvas>` controller */
+	/**
+	 * Manages the HTML `<canvas>` element used for WebGL rendering,
+	 * handles resizing, and provides viewport information.
+	 * Accessed via `micrio.canvas`.
+	 */
 	export class Canvas {
 		private micrio;
-		/** The Micrio WebGL rendering `<canvas>` element */
+		/** The main WebGL rendering `<canvas>` element. */
 		readonly element: HTMLCanvasElement;
-		/** Canvas sizing information */
+		/** Object containing current viewport dimensions, position, and ratios. */
 		readonly viewport: Models.Canvas.ViewRect;
-		/** Client is a mobile device, Writable */
+		/** Writable Svelte store indicating if the client is likely a mobile device. */
 		readonly isMobile: Writable<boolean>;
-		/** Client is a mobile device, Writable value */
+		/** Getter for the current value of the {@link isMobile} store. */
 		get $isMobile(): boolean;
+		/**
+		 * Creates a Canvas controller instance.
+		 * @param micrio The main HTMLMicrioElement instance.
+		 */
 		constructor(micrio: HTMLMicrioElement);
-		/** Micrio element resize handler */
-		onresize(): void;
-		/** Get the screen pixel ratio
-		 * @returns The device pixel ratio
+		/**
+		 * Gets the appropriate device pixel ratio for rendering.
+		 * Clamped between 1 and 2, disabled on iOS and if `noRetina` setting is true.
+		 * @param s Optional image settings object to check for `noRetina`.
+		 * @returns The calculated device pixel ratio.
 		 */
 		getRatio: (s?: Partial<Models.ImageInfo.Settings>) => number;
-		/** Set virtual offset margins applied to all viewports
-		 * @param width The offset width in pixels
-		 * @param height The offset height in pixels
+		/**
+		 * Sets virtual offset margins in the Wasm controller.
+		 * This likely affects how viewports are calculated or limited.
+		 * @param width The horizontal offset margin in pixels.
+		 * @param height The vertical offset margin in pixels.
 		*/
 		setMargins(width: number, height: number): void;
 	}
+	/**
+	 * Language-related constants and utilities.
+	 */
+	/**
+	 * The browser's current locale string (e.g., 'en-US', 'nl-NL'), falling back to 'en-EN'.
+	 * Used for initializing the `languageNames` object.
+	 */
 	export const locale: string;
+	/**
+	 * An `Intl.DisplayNames` object configured to provide human-readable language names
+	 * based on the browser's locale. Used for displaying language options in the UI.
+	 * Will be `undefined` if `Intl.DisplayNames` is not supported by the browser.
+	 *
+	 * @example
+	 * ```javascript
+	 * languageNames?.of('nl'); // Output might be "Dutch" (depending on browser locale)
+	 * ```
+	 */
 	export const languageNames: Intl.DisplayNames;
+	/**
+	 * An array of language codes that are typically written Right-to-Left (RTL).
+	 * Used by the `HTMLMicrioElement` to set the `dir="rtl"` attribute when an RTL language is selected.
+	 */
 	export const rtlLanguageCodes: string[];
+	/**
+	 * Interface defining the structure for UI button translations.
+	 * Each key corresponds to a specific UI element's title or label.
+	 */
 	interface ButtonTranslations {
 		close: string;
 		zoomIn: string;
@@ -2187,116 +2217,174 @@ declare module '@micrio/client' {
 		menuToggle: string;
 		waypointFollow: string;
 	}
+	/**
+	 * Object containing translations for UI button titles in different languages.
+	 * The keys are language codes (e.g., 'en', 'nl'), and the values are objects
+	 * conforming to the `ButtonTranslations` interface.
+	 */
 	export const langs: {
 		[key: string]: ButtonTranslations;
 	};
+	/**
+	 * Writable Svelte store holding the currently active `ButtonTranslations` object.
+	 * Defaults to English ('en'). UI components subscribe to this store to display
+	 * translated text based on the currently selected language.
+	 * The language is typically changed by updating the `micrio._lang` store, which
+	 * should then trigger an update to this `i18n` store.
+	 */
 	export const i18n: Writable<ButtonTranslations>;
 	/**
+	 * The main Micrio custom HTML element `<micr-io>`.
+	 * This class acts as the central controller for the Micrio viewer, managing
+	 * the WebGL canvas, WebAssembly module, Svelte UI, state, events, and image loading.
+	 *
+	 * It orchestrates the interaction between different parts of the library and
+	 * exposes methods and properties for controlling the viewer.
+	 *
+	 * @example
+	 * ```html
+	 * <micr-io id="image123"></micr-io>
+	 * <script>
+	 *   const viewer = document.querySelector('micr-io');
+	 *   viewer.open('image456');
+	 *   viewer.addEventListener('marker-click', (e) => console.log(e.detail));
+	 * </script>
+	 * ```
+	 *
 	 * [[include:./ts/element.md]]
+	 *
 	 * @author Marcel Duin <marcel@micr.io>
 	*/
 	export class HTMLMicrioElement extends HTMLElement {
+		/** Observed attributes trigger `attributeChangedCallback` when changed. */
 		static get observedAttributes(): string[];
-		/** The Micrio library version number */
+		/** The Micrio library version number. */
 		static VERSION: string;
-		/** Downloaded JSON files cache store */
+		/** Static cache store for downloaded JSON files (like image info). */
 		static jsonCache: Map<string, Object>;
-		/** All available canvases */
+		/** Array holding all instantiated {@link MicrioImage} objects managed by this element. */
 		readonly canvases: MicrioImage[];
-		/** Current main {@link MicrioImage} store Writable. Its value can be referred to using the {@link $current} property.
-		 * A lot of the app is reactive to this, so only set this using <micr-io>.open();
+		/**
+		 * Writable Svelte store holding the currently active main {@link MicrioImage}.
+		 * Use `<micr-io>.open()` to change the active image.
+		 * Subscribe to this store to react to image changes.
+		 * Access the current value directly using the {@link $current} getter.
 		 */
 		readonly current: Writable<MicrioImage | undefined>;
-		/** Currently visible canvases */
+		/** Writable Svelte store holding an array of currently visible {@link MicrioImage} instances (relevant for split-screen or grid). */
 		readonly visible: Writable<MicrioImage[]>;
-		/** The current active and shown {@link MicrioImage}, returning the current value of the {@link current} store Writable
+		/**
+		 * Getter for the current value of the {@link current} store.
+		 * Provides direct access to the active {@link MicrioImage} instance.
 		 * @readonly
 		*/
 		get $current(): MicrioImage | undefined;
-		/** The virtual camera instance to control the current main image views */
+		/** Getter for the virtual {@link Camera} instance of the currently active image. */
 		get camera(): Camera | undefined;
-		/** The Micrio sizing and `<canvas>` controller */
+		/** The controller managing the HTML `<canvas>` element, resizing, and viewport. */
 		readonly canvas: Canvas;
-		/** User input browser event handlers */
+		/** The controller managing user input events (mouse, touch, keyboard) and dispatching custom events. */
 		readonly events: Events;
-		/** The main state manager. Read more about it in the {@link State} section.*/
+		/** The main state manager, providing access to various application states (UI visibility, active marker, tour, etc.). See {@link State.Main}. */
 		readonly state: State.Main;
-		/** Google analytics plugin */
+		/** The Google Analytics integration controller. */
 		private readonly analytics;
-		/** Router */
+		/** The URL router, handling deep linking and history management. */
 		private readonly _router;
-		/** Barebone texture downloading, uglier but less bandwidth */
+		/** Writable Svelte store indicating if barebone texture downloading is enabled (lower quality, less bandwidth). */
 		readonly barebone: Writable<boolean>;
-		/** Custom settings, if specified, this overwrites any server received data */
+		/** Custom settings object provided programmatically, overriding server-fetched settings. */
 		defaultSettings?: Partial<Models.ImageInfo.Settings>;
-		/** 360 tour Space data */
+		/** Holds data for the current 360 space, if applicable (loaded via `data-space` attribute or API). */
 		spaceData: Models.Spaces.Space | undefined;
-		/** Destroy the Micrio instance and free up all memory */
+		/** Destroys the Micrio instance, cleans up resources, and removes event listeners. */
 		destroy(): void;
-		private printUI;
-		/** Open a Micrio image by ID or {@link Models.ImageInfo.ImageInfo} JSON data
-		 * @param idOrInfo An image ID or a {@link Models.ImageInfo.ImageInfo} JSON object
-		 * @param opts Some opening parameters
+		/**
+		 * Opens a Micrio image by its ID or by providing partial image info data.
+		 * This is the primary method for loading and displaying images.
+		 *
+		 * @param idOrInfo An image ID string (e.g., 'abcdef123') or a partial {@link Models.ImageInfo.ImageInfo} object.
+		 * @param opts Options for opening the image.
+		 * @returns The {@link MicrioImage} instance being opened.
 		*/
 		open(idOrInfo: string | Partial<Models.ImageInfo.ImageInfo>, opts?: {
-			/** Don't focus on an image inside the grid, keep the grid active */
+			/** If true, keeps the grid view active instead of focusing on the opened image. */
 			gridView?: boolean;
-			/** Open the image as a secondary split screen image */
+			/** If true, opens the image as a secondary split-screen view. */
 			splitScreen?: boolean;
-			/** Optional image that is the lead image for split screen */
+			/** The primary image when opening in split-screen mode. Defaults to the current main image. */
 			splitTo?: MicrioImage;
-			/** Passive split screen */
+			/** If true, opens the split-screen view passively (doesn't take focus). */
 			isPassive?: boolean;
-			/** Optional start view */
+			/** An optional starting view `[x0, y0, x1, y1]` to apply immediately. */
 			startView?: Models.Camera.View;
-			/** In case of 360, move into this direction */
+			/** For 360 transitions, provides the direction vector from the previous image. */
 			vector?: Models.Camera.Vector;
 		}): MicrioImage;
-		/** Close an opened MicrioImage
-		 * @param img The currently visible {@link MicrioImage}
+		/**
+		 * Closes an opened MicrioImage.
+		 * For split-screen images, it triggers the split-end transition.
+		 * For main images, it removes the canvas from the Wasm controller.
+		 * @param img The {@link MicrioImage} instance to close.
 		*/
 		close(img: MicrioImage): void;
-		/** Parse a gallery string ([micrioId,width?,height?,type?,format?], ';'-separated)
-		 * and load all relevant image data needed.
-		 * A gallery is basically one giant wide MicrioImage, that has each individual gallery
-		 * image embedded within itself.
-		*/
-		private loadGallery;
+		/** Holds loaded grid info data if applicable. */
 		gridInfoData: {
 			images: Models.ImageInfo.ImageInfo[];
 		} | undefined;
-		private setGrid;
-		private getArchiveIndex;
+		/** Getter for the current language code. */
+		get lang(): string;
+		/** Setter for the current language code. Triggers language change logic. */
+		set lang(l: string);
 	}
+	export interface MicrioUIProps {
+		/** The main HTMLMicrioElement instance. Provided by element.ts */
+		micrio: HTMLMicrioElement;
+		/** If true, suppresses rendering of most UI elements (except markers if data-ui="markers"). */
+		noHTML: boolean;
+		/** If true, suppresses rendering of the Micrio logo. Defaults to `noHTML`. */
+		noLogo?: boolean;
+		/** Loading progress (0-1), used for the progress indicator. */
+		loadingProgress?: number;
+		/** Optional error message to display. */
+		error?: string | undefined;
+	}
+	/**
+	 * Handles integration with Google Tag Manager (gtag.js) for tracking Micrio events.
+	 * Listens to specific Micrio custom events and sends corresponding events to GTM.
+	 */
 	export class GoogleTag {
 		private micrio;
-		/** Google Tag Manager tracker
-		 * @param {!HTMLMicrioElement} micrio The Micrio instance
+		/**
+		 * Creates a GoogleTag instance.
+		 * @param micrio The main HTMLMicrioElement instance.
 		*/
 		constructor(micrio: HTMLMicrioElement);
 	}
-	/** In-WebGL rendered embedded videos, used in <Embed /> */
+	/**
+	 * Manages the loading, playback, and WebGL integration of embedded videos
+	 * that are rendered directly onto the Micrio canvas texture (not as HTML elements).
+	 * Used internally by the `Embed.svelte` component when `printGL` is true.
+	 * Handles HLS playback via hls.js if necessary.
+	 */
 	export class GLEmbedVideo {
 		private wasm;
 		private image;
 		private embed;
 		private paused;
 		private moved;
-		private ism3u;
-		private hlsPlayer;
-		private usVid;
-		private vidRepeatTo;
-		private placeTo;
-		private autoplay;
-		_vid: HTMLVideoElement | undefined;
-		isMounted: boolean;
-		constructor(wasm: Wasm, image: MicrioImage, embed: Models.ImageData.Embed, paused: boolean, moved: () => void);
+		/**
+		 * Creates a GLEmbedVideo instance.
+		 * @param wasm The Wasm controller instance.
+		 * @param image The parent MicrioImage instance where the video is embedded.
+		 * @param embed The embed data object.
+		 * @param paused Initial paused state (e.g., due to pause-on-zoom).
+		 * @param moved Callback function to notify when position/state changes (triggers Wasm render).
+		 */
+		constructor(wasm: Wasm, image: MicrioImage, embed: Models.ImageData.Embed, paused: boolean, // Initial paused state
+		moved: () => void);
+		/** Cleans up resources when the parent Embed component is unmounted. */
 		unmount(): void;
-		private setPlaying;
-		private load;
-		private events;
-		private hook;
-		private unhook;
 	}
 }declare module "svelte/store" {
 	/** Callback to inform of a value updates.