declare module '@micrio/client' {
	import type { Readable, Writable } from 'svelte/store';
	/**
	 * Defines the current version of the Micrio library.
	 * This constant is used internally and exposed statically via `HTMLMicrioElement.VERSION`.
	 */
	export const VERSION = "5.3.2";
	/**
	 * 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>;
	export type PREDEFINED = [string, Models.ImageInfo.ImageInfo, Models.ImageData.ImageData | undefined];
	/** 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;
	/** 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;
	/**
	 * 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;
	/**
	 * 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 {
			/**
			 * Defines the types of actions that can be performed on a Grid instance,
			 * often triggered by marker data (`gridAction`) or tour events.
			 */
			enum GridActionType {
				/** Focus on specific images within the grid, hiding others. Data: comma-separated image IDs. */
				focus = 0,
				/** Animate the main grid view to fit the bounding box of specified images. Data: comma-separated image IDs. */
				flyTo = 1,
				/** Focus on images containing markers with a specific tag. Data: tag name. */
				focusWithTagged = 2,
				/** 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 initial layout and view. */
				reset = 4,
				/** Navigate back one step in the grid layout history. */
				back = 5,
				/** Instantly switch a focused image back to its position within the grid layout (used internally?). */
				switchToGrid = 6,
				/** Filter the grid to show only images that are part of the currently active marker tour. */
				filterTourImages = 7,
				/** 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 {
			/**
			 * Defines the available timing functions for camera animations (flyToView, flyToCoo).
			 * These correspond to standard CSS easing functions.
			 */
			enum TimingFunction {
				'ease' = 0,// Default ease-in-out
				'ease-in' = 1,
				'ease-out' = 2,
				'linear' = 3
			}
		}
	}
	/**
	 * 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 [x, y] and scale [z]. For 360, also includes [yaw, pitch]. For Omni, also includes [frameIndex]. */
		readonly center: Models.Camera.Coords;
		/**
		 * 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;
		/**
		 * 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?: {
			/** If true, allows setting a view outside the normal image boundaries. */
			noLimit?: boolean;
			/** If true (for 360), corrects the view based on the `trueNorth` setting. */
			correctNorth?: boolean;
			/** If true, prevents triggering a Wasm render after setting the view. */
			noRender?: boolean;
			/** If provided, interprets `v` relative to this sub-area instead of the full image. */
			area?: Models.Camera.View;
		}): void;
		/**
		 * 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 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 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;
		/** Gets the current camera zoom scale. */
		getScale: () => number;
		/**
		 * 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;
		/**
		 * 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;
		/**
		 * Sets the camera zoom scale instantly.
		 * @param s The target scale.
		*/
		setScale: (s: number) => void;
		/** Gets the scale at which the image fully covers the viewport. */
		getCoverScale: () => number;
		/**
		 * Gets the minimum allowed zoom scale for the image.
		 * @returns The minimum scale.
		*/
		getMinScale: () => number;
		/**
		 * Sets the minimum allowed zoom scale.
		 * @param s The minimum scale to set.
		*/
		setMinScale(s: number): void;
		/**
		 * 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 if the camera is currently zoomed in to its maximum limit. */
		isZoomedIn: () => boolean;
		/**
		 * 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;
		/**
		 * 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;
		/**
		 * 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;
		/** Gets whether the cover limit is currently enabled. */
		getCoverLimit: () => boolean;
		/**
		 * 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;
		/**
		 * 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 (0-1). */
			progress?: number;
			/** Base the progress override on this starting view. */
			prevView?: Models.Camera.View;
			/** If true, performs a "jump" animation (zooms out then in). */
			isJump?: boolean;
			/** For Omni objects: the target image frame index to animate to. */
			omniIndex?: number;
			/** If true (for 360), ignores the `trueNorth` correction. */
			noTrueNorth?: boolean;
			/** If provided, interprets `view` relative to this sub-area. */
			area?: Models.Camera.View;
			/** If true, respects the image's maximum zoom limit during animation. */
			limitZoom?: boolean;
		}) => Promise<void>;
		/**
		 * 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>;
		/**
		 * 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>;
		/**
		 * 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>;
		/**
		 * 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>;
		/**
		 * 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>;
		/**
		 * 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>;
		/**
		 * 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;
		/** Stops any currently running camera animation immediately. */
		stop(): void;
		/** Pauses the current camera animation. */
		pause(): void;
		/** Resumes a paused camera animation. */
		resume(): void;
		/** Returns true if the camera is currently performing a kinetic pan/zoom (coasting). */
		aniIsKinetic(): boolean;
		/** Gets the current viewing direction (yaw) in 360 mode.
		 * @returns The current yaw in radians.
		 */
		getDirection: () => number;
		/**
		 * 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;
		/**
		 * Gets the current viewing pitch in 360 mode.
		 * @returns The current pitch in radians.
		*/
		getPitch: () => number;
		/**
		 * 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?: {
			/** If true, sets the area instantly without animation. */
			direct?: boolean;
			/** If true, prevents dispatching view updates during the animation. */
			noDispatch?: boolean;
			/** If true, prevents triggering a Wasm render after setting the area. */
			noRender?: boolean;
		}): void;
		/** Sets the 3D rotation for an embedded image (used for placing embeds in 360 space). */
		setRotation(rotX?: number, rotY?: number, rotZ?: number): void;
		/** [Omni] Gets the current rotation angle in degrees based on the active frame index. */
		getOmniRotation(): number;
		/** [Omni] Gets the frame index corresponding to a given rotation angle (radians). */
		getOmniFrame(rot?: number): number | undefined;
		/** [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;
	}
	/**
	 * 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;
		/** Flag indicating if the Wasm module has been loaded and initialized. */
		ready: boolean;
		/** Shared WebAssembly memory instance. */
		private memory;
		/**
		 * Creates the Wasm controller instance.
		 * @param micrio The main HTMLMicrioElement instance.
		*/
		constructor(micrio: HTMLMicrioElement);
		/**
		 * Loads and instantiates the WebAssembly module.
		 * @returns A Promise that resolves when the Wasm module is ready.
		*/
		load(): Promise<void>;
		/** Unbinds event listeners, stops rendering, and cleans up resources. */
		unbind(): void;
		/**
		 * 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;
		/** Removes a canvas instance from the Wasm module. */
		removeCanvas(c: MicrioImage): void;
		/** Requests the next animation frame to trigger the `draw` method. */
		render(): void;
		/** Add a child image to the current canvas, either embed or independent canvas */
		private addImage;
		/** 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>;
	}
	/**
	 * 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;
		/** Getter for the current active image/frame index from the Wasm module. */
		get currentIndex(): number;
		/**
		 * 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;
		/**
		 * Animates smoothly to a target index using requestAnimationFrame.
		 * @param idx The target index.
		 */
		animateTo(idx: number): void;
	}
	/**
	 * # Micrio State management
	 *
	 * 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.
	 *
	 * 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 {
		/** Represents the entire serializable state of a Micrio instance. */
		type MicrioStateJSON = {
			/** The ID of the currently active main image. */
			id: string;
			/** Array containing the state of each individual image canvas. */
			c: ImageState[];
			/** Optional information about the currently active tour [tourId, currentTime?, pausedState?]. */
			t?: [string, number?, string?];
			/** Reference to the currently active HTMLMediaElement (unused?). */
			m?: HTMLMediaElement;
		};
		/** 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 (`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;
			/** 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>;
			/** Getter for the current value of the {@link tour} store. */
			get $tour(): Models.ImageData.VideoTour | Models.ImageData.MarkerTour | undefined;
			/** 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>;
			/** Writable Svelte store holding the ID of the marker currently being hovered over. */
			readonly markerHoverId: Writable<string | undefined>;
			/** Getter for the current value of the {@link marker} store. */
			get $marker(): Models.ImageData.Marker | undefined;
			/** Writable Svelte store holding the marker object whose popup is currently displayed. */
			readonly popup: Writable<Models.ImageData.Marker | undefined>;
			/** 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 state stores. */
			ui: {
				/** Writable store controlling the visibility of the main UI controls (bottom right). */
				controls: Writable<boolean>;
				/** Writable store controlling the visibility of zoom buttons. */
				zoom: Writable<boolean>;
				/** Writable store controlling the visibility of all UI elements (e.g., for fullscreen or specific modes). */
				hidden: Writable<boolean>;
			};
			/**
			 * 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.
			 *
			 * @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 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>;
		}
		/**
		* # MicrioImage state controller (`micrioImage.state`)
		*
		* Manages the state specific to a single {@link MicrioImage} instance,
		* primarily its viewport and currently opened marker.
		*/
		class Image {
			private image;
			/** Writable Svelte store holding the current viewport [x0, y0, x1, y1] of this image. */
			readonly view: Writable<Models.Camera.View | undefined>;
			/** Getter for the current value of the {@link view} store. */
			get $view(): Models.Camera.View | undefined;
			/**
			 * 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>;
			/** Getter for the current value of the {@link marker} store. */
			get $marker(): Models.ImageData.Marker | undefined;
			/** Writable Svelte store holding the currently displayed layer index (for Omni objects). */
			readonly layer: Writable<number>;
		}
	}
	/**
	 * 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 [x0, y0, x1, y1] defining placement within a parent canvas (for embeds/galleries). */
			area?: Models.Camera.View;
			/** For split screen, the primary image this one is secondary to. */
			secondaryTo?: MicrioImage;
			/** If true, passively follows the view changes of the primary split-screen image. */
			isPassive?: boolean;
			/** If true, this image is embedded within another image (affects rendering/camera). */
			isEmbed?: boolean;
			/** If true, uses the parent image's camera instead of creating its own (for switch/omni galleries). */
			useParentCamera?: boolean;
		};
		/** The unique identifier (Micrio ID) for this image. */
		readonly id: string;
		/** A unique instance identifier (UUID) generated for this specific instance. */
		readonly uuid: string;
		/** 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>;
		/** Getter for the current value of the {@link info} store.
		 * @readonly
		*/
		get $info(): Models.ImageInfo.ImageInfo | undefined;
		/** 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>;
		/** Getter for the current value of the {@link settings} store. */
		get $settings(): Models.ImageInfo.Settings;
		/** 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>;
		/** Getter for the current value of the {@link data} store. */
		get $data(): Models.ImageData.ImageData | undefined;
		/** State manager specific to this image instance (view, active marker, etc.). See {@link State.Image}. */
		readonly state: State.Image;
		/** The virtual camera instance controlling the view for this image. */
		camera: Camera;
		/** Svelte Writable store holding the HTMLVideoElement if this image represents a video. */
		readonly video: Writable<HTMLVideoElement | undefined>;
		/** Svelte Writable store indicating if this image's canvas is currently visible and being rendered.
		 * @readonly
		*/
		readonly visible: Writable<boolean>;
		/** Album information if this image is part of a V5 album. */
		album?: Models.Album | undefined;
		/** Gallery swiper instance, if this image is part of a swipe gallery. */
		swiper: GallerySwiper | undefined;
		/** Stores the camera view state when a marker is opened, used to return to the previous view. */
		openedView: Models.Camera.View | undefined;
		/** Base path URI for fetching `data.[lang].json` files. */
		dataPath: string;
		/** Stores an error message if loading failed. */
		error: string | undefined;
		/** 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>;
		/** Array of child {@link MicrioImage} instances embedded within this image. */
		readonly embeds: MicrioImage[];
		/** Grid controller instance, if this image is a grid container. */
		grid: Grid | undefined;
		/** Base path for fetching image tiles. */
		tileBase: string | undefined;
		/**
		 * 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;
		/** Gets the HTMLMediaElement associated with a video embed ID. */
		getEmbedMediaElement(id: string): HTMLMediaElement | undefined;
		/** Fades in the image smoothly or instantly. */
		fadeIn(direct?: boolean): void;
		/** Fades out the image smoothly or instantly. */
		fadeOut(direct?: boolean): void;
	}
	/**
	 * Micrio grid display controller
	 * @author Marcel Duin <marcel@micr.io>
	 */
	/**
	 * 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;
		/** Array of {@link MicrioImage} instances currently part of the grid definition (loaded). */
		readonly images: MicrioImage[];
		/** Array of {@link MicrioImage} instances currently visible in the grid layout. */
		current: MicrioImage[];
		/** If true, the HTML grid overlay remains visible and interactive even when an image is focused. */
		clickable: boolean;
		/** Writable Svelte store holding the currently focused {@link MicrioImage} instance, or undefined if in grid view. */
		readonly focussed: Writable<MicrioImage | undefined>;
		/** Getter for the current value of the {@link focussed} store. */
		get $focussed(): MicrioImage | undefined;
		/** Writable Svelte store holding an array of {@link MicrioImage} instances whose markers should be displayed in the grid view. */
		readonly markersShown: Writable<MicrioImage[]>;
		/** Array storing the history of grid layouts for back navigation. */
		history: Models.Grid.GridHistory[];
		/** Writable Svelte store indicating the current depth in the grid history stack. */
		depth: Writable<number>;
		/** Default animation duration (seconds) when transitioning *into* a new layout or focused view. */
		aniDurationIn: number;
		/** Default animation duration (seconds) when transitioning *out* of a focused view or going back in history. */
		aniDurationOut: number;
		/** Delay (seconds) between individual image transitions for 'delayed' effects. */
		transitionDelay: number;
		/**
		 * 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);
		/**
		 * 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?: {
			/** If true, does not add the previous layout to the history stack. */
			noHistory?: boolean;
			/** If true, keeps the HTML grid element in the DOM (used internally). */
			keepGrid?: boolean;
			/** If true, arranges images in a single horizontal row. */
			horizontal?: boolean;
			/** Overrides the default animation duration for the main grid view transition. */
			duration?: number;
			/** If provided, animates the main grid view to this viewport rectangle. */
			view?: Models.Camera.View;
			/** If true, skips the main grid camera animation. */
			noCamAni?: boolean;
			/** If true, forces area animation even for images not currently visible. */
			forceAreaAni?: boolean;
			/** If true, does not unfocus the currently focused image when setting a new layout. */
			noBlur?: boolean;
			/** If true, skips the fade-in animation for new images. */
			noFade?: boolean;
			/** Specifies the transition animation type (e.g., 'crossfade', 'slide-left', 'behind-delayed'). */
			transition?: Models.Grid.GridSetTransition;
			/** If true, forces animation even if duration is 0. */
			forceAni?: boolean;
			/** If true, limits individual image views to cover their grid cell. */
			coverLimit?: boolean;
			/** If true, sets the initial view of images to cover their grid cell (but doesn't enforce limit). */
			cover?: boolean;
			/** Scale factor (0-1) applied to each grid cell (creates margins). */
			scale?: number;
			/** Overrides the automatic calculation of grid columns. */
			columns?: number;
		}): Promise<MicrioImage[]>;
		/**
		 * 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;
		/**
		 * 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;
		/** Fade out unused images in the grid
		 * @param images The images to hide
		*/
		private removeImages;
		/** Checks whether current viewed image is (part of) grid */
		insideGrid(): boolean;
		/** Reset the grid to its initial layout
		 * @param duration Duration in seconds
		 * @param noCamAni Don't do any camera animating
		 * @param forceAni Force animation on all grid images
		 * @returns Promise when the transition is complete
		*/
		reset(duration?: number, noCamAni?: boolean, forceAni?: boolean): Promise<MicrioImage[]>;
		/** Fly to the viewports of any markers containing a class name
		 * @param tag The class name to match
		 * @param duration Optional duration in ms
		 * @param noZoom Don't zoom into the markers, just filter the images
		 * @returns Promise when the transition is complete
		*/
		flyToMarkers(tag?: string, duration?: number, noZoom?: boolean): Promise<MicrioImage[]>;
		/** Go back one step in the grid history
		 * @param duration Optional duration for transition
		 * @returns Promise when the transition is complete
		*/
		back(duration?: number): Promise<void>;
		/** 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>;
		/** Unfocusses any currently focussed image */
		blur(): void;
		/** Do an (external) action
		 * @param action The action type enum or string
		 * @param data Optional action data
		 * @param duration Optional action duration
		*/
		action(action: Enums.Grid.GridActionType | string, data?: string, duration?: number): void;
		/** Enlarge a specific image idx of the currently shown grid
		 * @param idx The image index of the current grid
		 * @param width The image target number of columns
		 * @param height The image target number of rows
		 * @returns Promise when the transition is completed
		*/
		enlarge(idx: number, width: number, height?: number): Promise<MicrioImage[]>;
		/** Get the relative in-grid viewport of the image */
		getRelativeView(image: MicrioImage, view: Models.Camera.View): Models.Camera.View;
	}
	/**
	 * 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>
	 */
	/**
	 * 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;
		/**
		 * 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;
		/** 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);
		/** Starts or resumes tour playback. */
		play(): void;
		/** Pauses the tour playback. */
		pause(): void;
		/**
		 * Seeks the tour to a specific progress percentage.
		 * @param perc The target progress (0-1).
		 */
		private setProgress;
	}
	/**
	 * # Micrio JSON data model
	 *
	 * This page details the data models used by Micrio.
	 *
	 * This data is created in the [Micrio editor](https://dash.micr.io/), and published as static JSON file per image, and optionally any language-specific data such as image markers, tours, audio, etc.
	 *
	 * Each Micrio image uses two data sources, which are retrieved from the Micrio servers:
	 *
	 * 1. **{@link ImageInfo}**: `info.json`: the base image data such as resolution, image type, and basic image settings. This is accessible in JS as {@link MicrioImage.info} as the Readable store, and {@link MicrioImage.$info} for its current value.
	 *
	 * 2. **{@link ImageData}**: `pub.json`: all published image content, which is accessible in JS as {@link MicrioImage.data} as the Writable store, and {@link MicrioImage.$data} for its current value.
	 *
	 */
	export namespace Models {
		type RevisionType = {
			[key: string]: number;
		};
		/**
		 * # Base image data
		 *
		 * The MicrioData.ImageInfo.ImageInfo JSON data object, used to pass to {@link HTMLMicrioElement.open}.
		 *
		 * The static image information, such as original resolution, image type, title, and all non-language specific **settings** ({@link ImageInfo.Settings}), such as initial viewport, camera behavior, and 360&deg; settings.
		 *
		 * The only required field is `id`. If only the `id` field is specified, Micrio attempts to download the additional image data by itself (`info.json`), published by the Micrio servers. This data will also include image title, and any custom viewing settings set in the image editor.
		 *
		 * This is a minimal accepted example:
		 *
		 * ```json
		 * {
		 * 	"id": "dzzLm",
		 * }
		 * ```
		 *
		 * If you have manually entered the image `width` and `height`, _it will not download_ the `info.json` file, assuming you have provided correct and complete data:
		 *
		 * ```json
		 * {
		 * 	"id": "dzzLm",
		 * 	"width": 41472,
		 * 	"height": 30219
		 * }
		 * ```
		 *
		 * Optionally, when using {@link HTMLMicrioElement} `<micr-io>` tag attributes, these will overwrite whatever is loaded from the server. So if in the Micrio editor you have enabled the fullscreen toggle button, you can disable it in your own HTML using `<micr-io data-fullscreen="false">`.
		 *
		 *
		 */
		namespace ImageInfo {
			/** A Micrio image's main static image data object */
			type ImageInfo = {
				/** The image id */
				id: string;
				/** The image base path URI, with a trailing `/`
				 * @default https://b.micr.io/
				*/
				path: string;
				/** The Micrio version this image was created in
				 * @default autoloaded
				*/
				version: number;
				/** Created date */
				created?: number;
				/** For V5+: published revisions per language */
				revision?: RevisionType;
				/** The original image width
				 * @default autoloaded
				*/
				width: number;
				/** The original image height
				 * @default autoloaded
				*/
				height: number;
				/** The original tile size in px
				 * @default autoloaded
				*/
				tileSize: number;
				/** Use an alternative image ID for the image tiles */
				tilesId?: string;
				/** Use an alternative basePath for image tiles */
				tileBasePath?: string;
				/** Optional custom file extension for tiles */
				tileExtension?: string;
				/** Force the `path` attribute to be used to get the info.json data */
				forceInfoPath?: boolean;
				/** The image settings, such as viewport/UI settings, camera and user event behavior
				 * NOTE: to modify this at runtime, use the MicrioImage.settings Writable store.
				*/
				settings?: Partial<ImageInfo.Settings>;
				/** Optional organisation data */
				organisation?: ImageInfo.Organisation;
				/** The image title (default: autoloaded) */
				title?: string;
				/** The initial data language */
				lang?: string;
				/** The image is 360 degrees */
				is360?: boolean;
				/** The image tiles are in WebP format */
				isWebP?: boolean;
				/** The image tiles are in PNG format */
				isPng?: boolean;
				/** The tiled image is in DeepZoom format */
				isDeepZoom?: boolean;
				/** The image has a IIIF source */
				isIIIF?: boolean;
				/** Use a custom, single source uri for the zoomable image / video */
				isSingle?: boolean;
				/** A custom format (`dz` for DeepZoom, `iiif` for IIIF) */
				format?: string;
				/** Optional IIIF source for tiles */
				iiifManifest?: string;
				/** The album (V5+) ID */
				albumId?: string;
				/** The 360 tour space ID */
				spacesId?: string;
			};
			interface Organisation {
				name: string;
				slug: string;
				baseUrl?: string;
				href?: string;
				logo?: Assets.Image;
				gtmId?: string;
				branding?: boolean;
				fontFamily?: string;
			}
			/** Micrio image settings, which is on load included as {@link ImageInfo}`.settings`. */
			type Settings = {
				/** The starting viewport (`[x0,y0,x1,y1]`) */
				view?: Camera.View;
				/** Restrict navigation to this viewport (`[x0,y0,x1,y1]`) */
				restrict?: Camera.View;
				/** Load a cover-initing image focussed on this coordinate (`[x, y]`) */
				focus?: [number, number];
				/** When opening the image without a predefined deeplink, open this */
				start?: {
					type: ('marker' | 'markerTour' | 'tour' | 'page');
					id: string;
				};
				/** Use a custom uri for the info json file */
				infoUrl?: string;
				/** Force refresh for published data JSON file */
				forceDataRefresh?: boolean;
				/** Render this image as a static image */
				static?: boolean;
				/** Use a custom thumbnail image uri */
				thumbSrc?: string;
				/** The starting viewport. Possible values `cover` and `contain`. Defaults to `contain` */
				initType?: string;
				/** The user cannot zoom out more than a fully covered view */
				limitToCoverScale?: boolean;
				/** Initialize the image when the container is scrolled into view (default: `false`) */
				lazyload?: number;
				/** Don't load any custom JS or CSS scripts */
				noExternals?: boolean;
				/** Don't load this image's {@link ImageData.ImageData} (markers, tours, etc) */
				skipMeta?: boolean;
				/** Don't auto-load first available non-preferred data language */
				onlyPreferredLang?: boolean;
				/** Do a crossfade when navigating between images (default: true) */
				fadeBetween?: boolean;
				/** Optional image crossfade duration, in seconds */
				crossfadeDuration?: number;
				/** Embedded images/videos fade in/out duration, in seconds */
				embedFadeDuration?: number;
				/** When being re-shown, always restart */
				embedRestartWhenShown?: boolean;
				/** Don't stop drawing frames when idle */
				keepRendering?: boolean;
				/** Don't load GTM module */
				noGTag?: boolean;
				/** With routing enabled, enable marker/tour deeplinks */
				routerMarkerTours?: boolean;
				/** Skip the deepest zoom levels */
				skipBaseLevels?: number;
				/** The camera animation speed (default: 1) */
				camspeed?: number;
				/** Kinetic dragging sensitivity (default: 1) */
				dragElasticity?: number;
				/** The maximum zoom level in % of the original (default: 1) */
				zoomLimit?: number;
				/** Turn off support for high DPI screens */
				noRetina?: boolean;
				/** Adjust the maximum zoom of high DPI screens to that of regular displays */
				zoomLimitDPRFix?: boolean;
				/** Allow the user to pan and zoom out of image bounds */
				freeMove?: boolean;
				/** When navigating back to this image from another image, reset the initial view */
				resetView?: boolean;
				/** Don't smooth out pixels when zooming in > 100% */
				noSmoothing?: boolean;
				/** Hook user events (default: true) */
				hookEvents?: boolean;
				/** Hook keyboard controls (default: false) */
				hookKeys?: boolean;
				/** Don't allow the user to zoom in or out */
				noZoom?: boolean;
				/** Use the mousewheel or trackpad scrolling for zooming (default: true) */
				hookScroll?: boolean;
				/** Allow pinch to zoom on touch devices (default: true) */
				hookPinch?: boolean;
				/** Allow panning through the image (default: true) */
				hookDrag?: boolean;
				/** Force two-finger panning on touch devices (default: false) */
				twoFingerPan?: boolean;
				/** Force using the CTRL/CMD-keys to zoom in using scrolling (default: false) */
				controlZoom?: boolean;
				/** Don't allow less than minimum scale zooming when pinching */
				pinchZoomOutLimit?: boolean;
				/** Don't load any UI elements */
				noUI?: boolean;
				/** Don't show any controls in the UI */
				noControls?: boolean;
				/** Show a fullscreen button if supported */
				fullscreen?: boolean;
				/** Don't show the Micrio logo on the top left */
				noLogo?: boolean;
				/** Don't show the organisation logo on the top right */
				noOrgLogo?: boolean;
				/** Don't show the menu bar with tours and custom pages */
				noToolbar?: boolean;
				/** Show an info modal with the image title and description */
				showInfo?: boolean;
				/** Show a social sharing button */
				social?: boolean;
				/** Show the minimap (default: true) */
				minimap?: boolean;
				/** Don't fade out the minimap (default: false) */
				alwaysShowMinimap?: boolean;
				/** The minimap maximum width, in px (default: 200) */
				minimapWidth?: number;
				/** The minimap maximum height, in px (default: 160) */
				minimapHeight?: number;
				/** More natural camera zooming animation during transitions (default: `true`) */
				doTourJumps?: boolean;
				/** Enable the audio controller (default: `true`) */
				audio?: boolean;
				/** The starting audio volume [0-1] (default: `1`) */
				startVolume?: number;
				/** The audio volume when other media is playing `[0-1]` (default: `0`) */
				mutedVolume?: number;
				/** Mute the audio when the current browser tab loses focus */
				muteOnBlur?: boolean;
				/** The physical width of the object in cm */
				cmWidth?: number;
				/** The physical height of the object in cm */
				cmHeight?: number;
				/** Overlapping markers are clustered */
				clusterMarkers?: boolean;
				/** The clustered marker radius */
				clusterMarkerRadius?: number;
				/** A static split-screen Micrio Image ID */
				micrioSplitLink?: string;
				/** When this is a secondary image in split screen, allow independent navigating */
				secondaryInteractive?: boolean;
				/** When this is a secondary image, don't follow the main image's navigation */
				noFollow?: boolean;
				/** Dark/light theme */
				theme?: ("dark" | "light" | "os");
				/** Load a custom JS file with this image */
				js?: {
					/** The asset href */
					href: string;
				};
				/** Load a custom CSS file with this image */
				css?: {
					/** The asset href */
					href: string;
				};
				/** All markers are scaled with the image */
				markersScale?: boolean;
				/** Albums */
				gallery?: GallerySettings;
				album?: AlbumInfo; /** V5 only */
				/** FOR OMNI OBJECTS */
				omni?: OmniSettings;
				/** Optional marker settings */
				_markers?: MarkerSettings;
				/** Optional settings for 360 images/video */
				_360?: {
					/** A 360 video object */
					video?: Assets.Video;
					/** Y rotation true north correction */
					trueNorth?: number;
					/** 2D embed X rotation in 360 */
					rotX?: number;
					/** 2D embed Y rotation in 360 */
					rotY?: number;
					/** 2D embed Z rotation in 360 */
					rotZ?: number;
					/** 2D embed IFRAME scale */
					scale?: number;
				};
				/** Freeform custom settings, this is the "Custom JSON" field in the image editor */
				_meta?: {
					[key: string]: any;
				};
				/** UI customizations */
				ui?: Partial<UserInterfaceSettings>;
				/** Grid: can click individual grid images */
				gridClickable?: boolean;
				/** Grid: transition duration, in seconds */
				gridTransitionDuration?: number;
				/** Grid: transition duration going back, in seconds */
				gridTransitionDurationOut?: number;
				/** ADVANCED: A fragment shader for WebGL postprocessing
				 * This shader MUST have and use:
				 * uniform sampler2D u_image; // the render buffer texture
				 * varying vec2 v_texCoord;   // the texture coordinate
				 * uniform float u_time;	  // elapsed time in seconds
				*/
				postProcessingFragmentShader?: string;
			};
			type GallerySettings = {
				/** Gallery has an associated .bin archive with thumbnails */
				archive?: string;
				/** Archive layer offset */
				archiveLayerOffset?: number;
				/** Gallery sorting */
				sort?: ('name' | '-name' | 'created' | '-created');
				/** Gallery type */
				type?: ('swipe' | 'swipe-full' | 'switch' | 'omni' | 'grid');
				/** The gallery opening image ID */
				startId?: string;
				/** Pages are combined to 2x1 spreads */
				isSpreads?: boolean;
				/** For spreads, number of cover pages to show as single page */
				coverPages?: number;
				revisions?: {
					[key: string]: RevisionType;
				};
			};
			type OmniSettings = {
				/** Number of frames */
				frames: number;
				/** Starting frame index */
				startIndex: number;
				/** The camera field of view in radians */
				fieldOfView: number;
				/** The camera vertical angle in radians */
				verticalAngle: number;
				/** The distance of the object center to the camera */
				distance: number;
				/** Adjust the center for an object */
				offsetX: number;
				/** Put the labels on the side of the object */
				sideLabels?: boolean;
				/** Which frame is 0deg rotation */
				frontIndex?: number;
				/** Layers */
				layers?: {
					i18n: {
						[key: string]: string | undefined;
					};
				}[];
				/** Optional starting layer idx */
				layerStartIndex?: number;
				/** Hide the rotation dial */
				noDial?: boolean;
				/** Show degrees on dial */
				showDegrees?: boolean;
				/** Gallery is omni object photography over 2 axes */
				twoAxes?: boolean;
				/** Don't add key bindings for rotating */
				noKeys?: boolean;
			};
			/** Image-wide marker settings */
			type MarkerSettings = {
				/** An image-wise custom marker icon */
				markerIcon?: Assets.Image;
				/** The default marker color */
				markerColor?: string;
				/** The default marker size in px */
				markerSize?: string;
				/** Zoom out when closing a marker */
				zoomOutAfterClose?: boolean;
				/** Relative speed factor when zooming out after close */
				zoomOutAfterCloseSpeed?: number;
				/** Always show the titles for all markers */
				showTitles?: boolean;
				/** Don't print any marker titles at all */
				noTitles?: boolean;
				/** Don't scale titles if marker is scaling */
				titlesNoScale?: boolean;
				/** All markers are sized to their viewports */
				viewportIsMarker?: boolean;
				/** All marker embeds are printed in HTML, not WebGL */
				embedsInHtml?: boolean;
				/** Auto-start a marker tour when just opening marker */
				autoStartTour?: boolean;
				/** Always auto-start a marker tour from the beginning */
				autoStartTourAtBeginning?: boolean;
				/** Auto-progress a tour step when marker media has ended */
				tourAutoProgress?: boolean;
				/** Tour controls in popup */
				tourControlsInPopup?: boolean;
				/** Show tour step counter in marker popup */
				tourStepCounterInPopup?: boolean;
				/** Allow marker popups to be minimized */
				canMinimizePopup?: boolean;
				/** Svelte transition-in animation for popup */
				popupAnimation?: any;
				/** Place primary body text above any media in popup */
				primaryBodyFirst?: boolean;
				/** Prevent all autoplay */
				preventAutoPlay?: boolean;
				/** Don't do anything when clicking markers */
				noMarkerActions?: boolean;
				/** Hide markers when tour is running */
				hideMarkersDuringTour?: boolean;
				/** Keep popup opened in between marker tour steps */
				keepPopupsDuringTourTransitions?: boolean;
				/** Optional custom uploaded icons */
				customIcons?: Assets.Image[];
			};
			/** Custom interface settings */
			type UserInterfaceSettings = {
				controls?: {
					/** Show the culture switch button if there are multiple available languages */
					cultureSwitch?: boolean;
					/** Serial tour timebar clicking other segment always goes to start of chapter */
					serialTourNoTimeScrub?: boolean;
				};
				icons?: {
					/** The raw SVG string for zoom-in */
					zoomIn?: string;
					/** The raw SVG string for zoom-out */
					zoomOut?: string;
					/** The raw SVG string for fullscreen-start */
					fullscreenEnter?: string;
					/** The raw SVG string for fullscreen-stop */
					fullscreenLeave?: string;
					/** The raw SVG string for close */
					close?: string;
					/** Next step button */
					next?: string;
					/** Previous step button */
					prev?: string;
					/** Play button */
					play?: string;
					/** Pause button */
					pause?: string;
					/** Subtitles icon */
					subtitles?: string;
					/** Subtitles turned off icon */
					subtitlesOff?: string;
					/** Muted icon */
					muted?: string;
					/** Unmuted icon */
					unmuted?: string;
					/** Arrow up icon */
					up?: string;
					/** Arrow down icon */
					down?: string;
				};
			};
		}
		/**
		* # Image content data
		*
		* The image content {@link ImageData} JSON object, which is accessible as {@link MicrioImage.data} as the Writable store, and {@link MicrioImage.$data} for its current value.
		*
		* This JSON data includes, for all published languages for this image:
		*
		* * Markers
		* * Marker tours
		* * Video tours
		* * Audio, music
		* * In-image embeds
		* * Custom menu screens and content pages
		*
		* To access the data of the current viewed image, use:
		*
		* ```js
		* // The current shown image value of the .data store Writable
		* const data = micrio.$current.$data;
		*
		* if(data) console.log(`The current image has ${data.markers.length} markers!`);
		* else console.warn('The current image has no data set.');
		* ```
		*
		* To subscribe to any data changes:
		*
		* ```js
		* micrio.$current.data.subscribe(data => {
		* 	console.log('Image has new or updated data!', data);
		* })
		* ```
		*
		* To set your own custom data:
		*
		* ```js
		* micrio.$current.data.set({
		* 	"markers": [
		* 		{
		* 			"i18n": {
		* 				"en": {
		* 					"title": "This is a test marker!"
		*				}
		*			},
		* 			"x": .5,
		* 			"y": .5
		* 		}
		* 	]
		* })
		* ```
		*
		* Or to update an existing loaded data object:
		*
		* ```js
		* micrio.$current.data.update(data => {
		* 	data.markers.push({
		* 		"i18n": {
		* 			"en": {
		* 				"title": "This is a newly added marker"
		*			}
		*		},
		* 		"x": .6,
		* 		"y": .5
		* 	});
		* 	return data;
		* })
		* ```
		*/
		namespace ImageData {
			/** The main data JSON structure */
			type ImageData = {
				/** V5+: Save revision */
				revision?: RevisionType;
				/** Localized image details */
				i18n?: {
					[key: string]: ImageDetailsCultureData;
				};
				/** Markers */
				markers?: ImageData.Marker[];
				/** Marker tours */
				markerTours?: ImageData.MarkerTour[];
				/** Video tours */
				tours?: ImageData.VideoTour[];
				/** In-image embeds */
				embeds?: ImageData.Embed[];
				/** Custom menu pages */
				pages?: ImageData.Menu[];
				/** Music playlist */
				music?: {
					/** The audio assets */
					items: Assets.Audio[];
					/** Loop the playlist */
					loop: boolean;
					/** The music audio volume [0-1] (default: `1`) */
					volume?: number;
				};
			};
			interface ImageDetailsCultureData {
				/** Optional lang-specific image title */
				title?: string;
				/** Optional lang-specific image description */
				description?: string;
				/** Image copyright information */
				copyright?: string;
				/** Original source URI */
				sourceUrl?: string;
			}
			interface MarkerCultureData {
				/** The main marker title */
				title?: string;
				/** The marker url slug */
				slug?: string;
				/** Alternative title to display as marker label */
				label?: string;
				/** Marker main body HTML */
				body?: string;
				/** Marker secondary body HTML */
				bodySecondary?: string;
				/** Audio asset */
				audio?: Assets.Audio;
				/** An optional iframe embed url */
				embedUrl?: string;
				/** Embed title */
				embedTitle?: string;
				/** Embed description */
				embedDescription?: string;
			}
			/** A Marker */
			type Marker = {
				/** The marker ID */
				id: string;
				/** The relative marker X coordinate [0-1] */
				x: number;
				/** The relative marker Y coordinate [0-1] */
				y: number;
				i18n?: {
					[key: string]: MarkerCultureData;
				};
				/** Omni-objects: radius from center */
				radius?: number;
				/** Rotation is concave: it's on the back of a front-rounded shape */
				backside?: boolean;
				/** Omni-objects: offset rotation in radians */
				rotation?: number;
				/** Omni-objects: custom visibility between these radians */
				visibleArc?: [number, number];
				/** The viewport to zoom to when the marker is opened */
				view?: Camera.View;
				/** If an image has multiple layers, switch to this layer */
				imageLayer?: number;
				/** Content type, for displaying */
				type?: ('default' | 'image' | 'audio' | 'video' | 'media' | 'link' | 'waypoint' | 'cluster');
				/** Popup type */
				popupType: ('popup' | 'popover' | 'none' | 'micrioLink');
				/** Custom marker tags which will be also used as classnames on the marker elements */
				tags: string[];
				/** Autoplay the audio asset when the marker is opened */
				audioAutoPlay?: boolean;
				/** Autoplay video embed when the marker is opened */
				embedAutoPlay?: boolean;
				/** Don't draw a marker element */
				noMarker?: boolean;
				/** A custom HTML element instead of the default <button> */
				htmlElement?: HTMLElement;
				/** Having the embed iframe printed mutes audio */
				embedMutesAudio?: boolean;
				/** Images inside marker popup */
				images?: Assets.Image[];
				/** Video tour which plays when the marker is opened */
				videoTour?: VideoTour;
				/** Positional audio asset */
				positionalAudio?: Assets.AudioLocation;
				/** Optional function that overrides all behavior */
				onclick?: (m: ImageData.Marker) => void;
				/** Additional options */
				data?: MarkerData;
			};
			/** Optional individual marker settings */
			type MarkerData = {
				/** A custom marker icon image */
				icon?: Assets.Image;
				/** A predefined custom icon idx in MarkerSettings */
				customIconIdx?: number;
				/** This marker links to this image */
				micrioLink?: Partial<ImageInfo.ImageInfo>;
				/** This marker opens secondary split image with id */
				micrioSplitLink?: string;
				/** Don't animate the camera when opening this marker */
				noAnimate?: boolean;
				/** Show the title below the marker
				 * @deprecated Use the main marker setting for this
				*/
				showTitle?: boolean;
				/** Don't open a large image viewer/gallery on image click */
				preventImageOpen?: boolean;
				/** Force a marker popup no matter what */
				notEmpty?: boolean;
				/** Jump the camera when opening this marker */
				doJump?: boolean;
				/** This marker is not closeable */
				alwaysOpen?: boolean;
				/** The marker scales with the zooming image */
				scales?: boolean;
				/** Grid tour transition animation */
				gridTourTransition?: Grid.MarkerFocusTransition;
				/** Optional custom settings. This is the "Custom JSON" field in the marker editor */
				_meta?: {
					/** For in grid multi-image tour, this step is in grid view */
					gridView?: boolean;
					/** Custom grid actions, action and action data |-separated */
					gridAction?: string;
					/** When opening this marker inside a grid, resize the tile to this */
					gridSize?: number | string;
					/** Any other value is accepted */
					[key: string]: any;
				};
			};
			/**
			 * An embedded element inside the main image. This could be an image,
			 * iframe embed, or simple empty HTML element (Spaces).
			 * This is created in the [Micrio editor](https://dash.micr.io/) or Spaces.
			 */
			type Embed = Partial<ImageInfo.ImageInfo> & {
				/** The area inside the main image to place the embed */
				area: Camera.View;
				/** Original asset url */
				src?: string;
				/** An optional iframe src url */
				frameSrc?: string;
				/** Autoplay YT/Vimeo */
				autoplayFrame?: boolean;
				/** Optional title */
				title?: string;
				/** An optional Micrio ID */
				micrioId?: string;
				/** Optional image width */
				width?: number;
				/** Optional image height */
				height?: number;
				/** Optional isPng */
				isPng?: boolean;
				/** IsWebP */
				isWebP?: boolean;
				/** Opacity */
				opacity?: number;
				/** Click interaction */
				clickAction?: ('markerId' | 'href');
				/** Click action target */
				clickTarget?: string;
				/** Opens link in new window */
				clickTargetBlank?: boolean;
				/** Unique instance ID */
				uuid?: string;
				/** Relative scale for IFRAME embed in 360 */
				scale?: number;
				/** X rotation in 360 */
				rotX?: number;
				/** Y rotation in 360 */
				rotY?: number;
				/** Z rotation in 360 */
				rotZ?: number;
				scaleX?: number;
				scaleY?: number;
				/** A video asset */
				video?: Assets.Video & {
					/** Don't play video when smaller than % of screen */
					pauseWhenSmallerThan?: number;
					/** Don't play video when larger than % of screen */
					pauseWhenLargerThan?: number;
				};
				/** Hide while not playing video/media */
				hideWhenPaused?: boolean;
			};
			interface TourCultureData {
				/** The tour title */
				title?: string;
				/** The tour url slug */
				slug?: string;
				/** The tour description */
				description?: string;
			}
			/** The MicrioTour abstract shared class for both {@link MarkerTour} and {@link VideoTour}
			 * @abstract
			*/
			type Tour = {
				/** The tour id */
				id: string;
				/** Localized tour culture data */
				i18n?: {
					[key: string]: TourCultureData;
				};
				/** Auto-minimize controls while playing and idle */
				minimize?: boolean;
				/** Cannot close this tour */
				cannotClose?: boolean;
				/** Exit the tour on finish */
				closeOnFinish?: boolean;
			};
			/** A single videotour timeline viewport */
			type VideoTourView = {
				/** Start time in seconds */
				start: number;
				/** End time in seconds */
				end: number;
				/** Viewport name */
				title?: string;
				/** View rectangle */
				rect: Camera.View;
			};
			interface VideoTourCultureData extends TourCultureData {
				/** The tour duration in seconds */
				duration: number;
				/** An optional audio file */
				audio?: Assets.Audio;
				/** Optional subtitles */
				subtitle?: Assets.Subtitle;
				/** The timeline data */
				timeline: VideoTourView[];
				/** Custom events in tour timeline */
				events: Event[];
			}
			/**
			 * A Micrio video tour -- a timed sequence of viewport, with optional audio file.
			 * This is created in the [Micrio editor](https://dash.micr.io/).
			 */
			type VideoTour = Tour & {
				/** Localized videotour culture data */
				i18n?: {
					[key: string]: VideoTourCultureData;
				};
				/** Don't hide the markers when running */
				keepMarkers?: boolean;
				/** Don't disable user navigation when running */
				keepInteraction?: boolean;
				/** Current running tour instance */
				instance?: VideoTourInstance;
			};
			/** Timed events inside a {@link ImageData.VideoTour} */
			type Event = {
				/** Start time in seconds */
				start: number;
				/** End time in seconds */
				end: number;
				/** Custom event name */
				action?: string;
				/** Custom event data */
				data?: string;
				/** Optional ID to hook to */
				id?: string;
				/** The event is currently active */
				active?: boolean;
			};
			/**
			 * A Micrio marker tour -- a sequence of markers, which the user can navigate
			 * through. This is created in the [Micrio editor](https://dash.micr.io/).
			 */
			type MarkerTour = Tour & {
				/** Tour steps */
				steps: string[];
				/** No user controls */
				noControls?: boolean;
				/** Optional tour image asset */
				image?: Assets.Image;
				/** This is a scrolling tour */
				scrollable?: boolean;
				/** Don't reset view when tour ends */
				keepLastStep?: boolean;
				/** Chapter-based multi-video serial tour */
				isSerialTour?: boolean;
				/** Print the chapters in the interface */
				printChapters?: boolean;
				/** Internally generated propagated step data by Micrio */
				stepInfo?: MarkerTourStepInfo[];
				/** Internally calculated total duration, sum of all step durations */
				duration?: number;
				/** Current tour step getter */
				currentStep?: number;
				/** Start on this tour step */
				initialStep?: number;
				/** Go to next step -- for running tours */
				next?: () => void;
				/** Go to prev step -- for running tours */
				prev?: () => void;
				/** Go to step -- for running tours */
				goto?: (n: number) => void;
			};
			/** Auto generated metadata for marker tours */
			type MarkerTourStepInfo = {
				markerId: string;
				marker: Marker;
				micrioId: string;
				duration: number;
				imageHasOtherMarkers?: boolean;
				startView?: Camera.View;
				chapter?: number;
				/** For in grid multi-image tour, stay in the grid view */
				gridView?: boolean;
				/** Media current time */
				currentTime?: number;
				/** Media has ended */
				ended?: boolean;
				hasSubtitle?: boolean;
			};
			interface MenuPageButton {
				/** Localized button title */
				i18nTitle: {
					[key: string]: string;
				};
				/** Button action type */
				type: ('close' | 'marker' | 'mtour' | 'vtour' | 'link');
				/** The action value */
				action?: string;
				/** Link opens in net tab */
				blankTarget?: boolean;
			}
			interface MenuCultureData {
				/** The menu title */
				title?: string;
				/** For page: iframe embed */
				embed?: string;
				/** For page: content HTML */
				content?: string;
			}
			/**
			 * A custom pop-out menu containing content pages or direct external links to
			 * websites, or direct links to opening a marker.
			 * This is created in the [Micrio editor](https://dash.micr.io/).
			 */
			type Menu = {
				/** The menu ID */
				id: string;
				/** Localized culture data */
				i18n?: {
					[key: string]: MenuCultureData;
				};
				/** Child menu elements */
				children?: Menu[];
				/** Open this marker when clicking menu */
				markerId?: string;
				/** Direct link url for menu button */
				link?: string;
				/** Opens the link in a new window */
				linkTargetBlank?: boolean;
				/** Optional direct action function when clicked */
				action?: Function;
				/** For page: page image */
				image?: Assets.Image;
				/** Custom page action buttons */
				buttons?: MenuPageButton[];
			};
		}
		namespace Assets {
			type BaseAsset = {
				/** The asset title (not filename) */
				title: string;
				/** The asset file name */
				fileName?: string;
				/** The file uri */
				src: string;
				/** File size in bytes */
				size: number;
				/** Created */
				uploaded: number;
			};
			type Audio = BaseAsset & {
				/** The sample duration */
				duration: number;
				/** The sample volume */
				volume: number;
			};
			type AudioLocation = Audio & {
				/** Autoplay the sample */
				alwaysPlay: boolean;
				/** Loop the audio */
				loop: boolean;
				/** Pause X seconds between plays */
				repeatAfter: number;
				/** Don't play on mobile */
				noMobile: boolean;
				/** The radius of the audible circle */
				radius: number;
			};
			/** An image asset uploaded in the Micrio editor */
			type Image = BaseAsset & {
				id?: string;
				/** The image original width */
				width: number;
				/** The image original height */
				height: number;
				/** If the image is available as Micrio image, its ID */
				micrioId?: string;
				/** If the image has a Micrio version, optional alternative image tile ID */
				tilesId?: string;
				/** Is PNG */
				isPng?: boolean;
				/** IsWebP */
				isWebP?: boolean;
				/** Used DeepZoom format */
				isDeepZoom?: boolean;
				/** V5+: Translatable description */
				i18n?: {
					[key: string]: {
						title?: string;
						description?: string;
					};
				};
			};
			type Video = BaseAsset & {
				/** The video width */
				width: number;
				/** The video height */
				height: number;
				/** The video duration */
				duration: number;
				/** Video is muted */
				muted: boolean;
				/** Video loops */
				loop: boolean;
				/** Video loops after X seconds waiting */
				loopAfter?: number;
				/** Video autoplays */
				autoplay: boolean;
				/** Cloudflare Stream ID */
				streamId?: string;
				/** Show controls */
				controls: boolean;
				/** Video has alpha transparency */
				transparent: boolean;
				/** Video has a separately uploaded Mac H265 transparent src */
				hasH265?: boolean;
			};
			type Subtitle = BaseAsset;
		}
		/** 360 tours, formerly SPACES */
		namespace Spaces {
			interface SpaceImage {
				/** The Micrio ID */
				id: string;
				/** X position of 360 image in zone */
				x: number;
				/** Y position of 360 image in zone */
				y: number;
				/** Z position of 360 image in zone */
				z: number;
				/** RotationY => .trueNorth */
				rotationY: number;
			}
			interface Space {
				/** The 360 image */
				images: SpaceImage[];
				/** The zone name */
				name: string;
				/** 360 linked Micrio IDs */
				links: [string, string, {
					[key: string]: WayPointSettings;
				}?][];
				/** Custom icon lib */
				icons?: Assets.Image[];
				/** Multi-image marker tours */
				markerTours?: ImageData.MarkerTour[];
			}
			interface WaypointInterface {
				el?: HTMLElement;
				settings: WayPointSettings;
				coords: WaypointCoords;
				deleted?: boolean;
			}
			interface WayPointSettings {
				i18n: {
					[key: string]: {
						title: string;
					};
				};
				/** A predefined custom icon idx */
				customIconIdx?: number;
				coords?: WaypointCoords;
			}
			type DirectionVector = [number, number, number];
			interface WaypointCoords {
				x: number;
				y: number;
				baseScale: number;
				scale: number;
				rotX: number;
				rotY: number;
				rotZ: number;
				custom?: boolean;
			}
		}
		/** OmniImages */
		namespace Omni {
			interface Frame {
				id: string;
				image: MicrioImage;
				visible: Writable<boolean>;
				frame: number;
				thumbSrc?: string;
				baseTileIdx: number;
				ptr: number;
				opts: {
					area: Camera.View;
				};
			}
		}
		namespace Grid {
			/** Grid .focus() transition from current view */
			type MarkerFocusTransition = ('crossfade' | 'slide' | 'slide-horiz' | 'slide-vert' | 'slide-up' | 'slide-down' | 'slide-right' | 'slide-left' | 'swipe' | 'swipe-horiz' | 'swipe-vert' | 'swipe-up' | 'swipe-down' | 'swipe-right' | 'swipe-left' | 'behind' | 'behind-left' | 'behind-right');
			type GridSetTransition = ('crossfade' | 'behind' | 'behind-delayed' | 'appear-delayed');
			/** Virtual ImageInfo extension to support grid logic */
			interface GridImage extends Partial<ImageInfo.ImageInfo> {
				size: [number, number?];
				area?: Camera.View;
				view?: Camera.View;
			}
			interface GridHistory {
				layout: string;
				horizontal: boolean;
				view?: Camera.View;
			}
			interface GridImageOptions {
				view?: Camera.View;
				area?: Camera.View;
				size?: number[];
			}
			interface FocusOptions {
				/** Optional target image view */
				view?: Camera.View;
				/** Transition duration in ms */
				duration?: number;
				/** Transition animation, defaults to crossfade */
				transition?: Grid.MarkerFocusTransition;
				/** Set the target viewport immediately */
				noViewAni?: boolean;
				/** Animate the previously focussed image to this view during exit transition */
				exitView?: Camera.View;
				/** Limit the focussed image to cover view, defaults to false */
				coverLimit?: boolean;
				/** Open as cover view, but don't limit it */
				cover?: boolean;
				/** Blur the image during transition, in pixels */
				blur?: number;
			}
		}
		/** Albums */
		interface AlbumInfo {
			/** The album ID */
			id: string;
			/** The album name */
			name: string;
			/** The album UX type */
			type: ('swipe' | 'switch' | 'grid');
			/** The album image sorting */
			sort?: ('name' | '-name' | 'created' | '-created');
			/** Album pages are shown as book spreads */
			isSpreads?: boolean;
			/** The number of single cover pages in case of spreads */
			coverPages?: number;
			/** Published revision number */
			revision: number;
			/** Available page data (markers, etc) */
			published: {
				[key: string]: RevisionType;
			};
			/** Album organisation */
			organisation?: ImageInfo.Organisation;
		}
		interface Album {
			/** The number of pages in this album */
			numPages: number;
			/** The current page index */
			currentIndex: number;
			/** The album info */
			info?: AlbumInfo;
			/** Go to previous page */
			prev: () => void;
			/** Go to next page */
			next: () => void;
			/** Go to specific page index */
			goto: (n: number) => void;
			/** Album has been initialized and hooked */
			hooked?: boolean;
		}
		namespace Camera {
			/** A viewport rectangle */
			type View = number[] | Float64Array;
			/** Coordinate tuple, [x, y, scale] */
			type Coords = [number, number, number?] | Float64Array;
			/** A 360 vector for use in Spaces */
			type Vector = {
				direction: number;
				distanceX: number;
				distanceY: number;
			};
			type TimingFunction = ('ease' | 'ease-in' | 'ease-out' | 'linear');
			interface AnimationOptions {
				/** Animation duration in ms */
				duration?: number;
				/** Limit the viewport to fill the screen */
				limit?: boolean;
				/** In case of automatic duration, speed factor (1 = 100%) */
				speed?: number;
				/** Transition timing function */
				timingFunction?: TimingFunction;
			}
		}
		namespace Embeds {
			interface EmbedOptions {
				/** The embed opacity */
				opacity?: number;
				/** Do not print this embed until this zoom level (% of original) */
				fromScale?: number;
				/** The embed will have a minimal memory footprint, without its own camera */
				asImage?: boolean;
				/** Fit the embed's original size into the specified area. Defaults to 'stretch' */
				fit?: ('contain' | 'cover' | 'stretch');
			}
		}
		namespace State {
			/** Popover interface state type */
			interface PopoverType {
				contentPage?: ImageData.Menu;
				image?: MicrioImage;
				marker?: ImageData.Marker;
				markerTour?: ImageData.MarkerTour;
				gallery?: Assets.Image[];
				galleryStart?: string;
				showLangSelect?: boolean;
			}
		}
		namespace Canvas {
			interface ViewRect {
				width: number;
				height: number;
				left: number;
				top: number;
				ratio: number;
				scale: number;
				portrait: boolean;
			}
		}
		type MicrioEvent<T = any> = Event & {
			detail: T;
		};
		interface MicrioEventDetails {
			'show': HTMLMicrioElement;
			'pre-info': ImageInfo.ImageInfo;
			'pre-data': {
				[micrioId: string]: ImageData.ImageData;
			};
			'print': ImageInfo.ImageInfo;
			'load': MicrioImage;
			'lang-switch': string;
			'zoom': {
				image: MicrioImage;
				view: Camera.View;
			};
			'move': {
				image: MicrioImage;
				view: Camera.View;
			};
			'draw': void;
			'resize': DOMRect;
			'panstart': void;
			'panend': {
				duration: number;
				movedX: number;
				movedY: number;
			};
			'pinchstart': void;
			'pinchend': {
				duration: number;
				movedX: number;
				movedY: number;
			};
			'marker-open': ImageData.Marker;
			'marker-opened': ImageData.Marker;
			'marker-closed': ImageData.Marker;
			'tour-start': ImageData.Tour;
			'tour-stop': ImageData.Tour;
			'tour-minimize': ImageData.Tour;
			'tour-step': ImageData.MarkerTour;
			'serialtour-play': ImageData.MarkerTour;
			'serialtour-pause': ImageData.MarkerTour;
			'videotour-start': ImageData.VideoTour;
			'videotour-stop': ImageData.VideoTour;
			'videotour-play': void;
			'videotour-pause': void;
			'tour-ended': ImageData.VideoTour;
			'tour-event': ImageData.Event;
			'audio-init': void;
			'audio-mute': void;
			'audio-unmute': void;
			'autoplay-blocked': void;
			'media-play': void;
			'media-pause': void;
			'media-ended': void;
			'timeupdate': number;
			'page-open': ImageData.Menu;
			'page-closed': ImageData.Menu;
			'gallery-show': number;
			'grid-init': Grid;
			'grid-load': void;
			'grid-layout-set': Grid;
			'grid-focus': MicrioImage;
			'grid-blur': void;
			'splitscreen-start': MicrioImage;
			'splitscreen-stop': MicrioImage;
			'update': Array<string>;
		}
		type MicrioEventMap = {
			[K in keyof MicrioEventDetails]: MicrioEvent<MicrioEventDetails[K]>;
		};
		namespace Attributes {
			interface MicrioCustomAttributes {
				/** The image ID */
				'id'?: string;
				/** The data language code to use. Default: 'en' */
				'lang'?: string;
				/** For custom hosted Micrio images, specify the root URL. Default: Based on image */
				'data-path'?: string;
				/** Set this to 'cover' to start the image using the full viewport. Default: undefined */
				'data-inittype'?: string;
				/** The user cannot zoom out further than the full viewport. Default: undefined */
				'data-coverlimit'?: boolean;
				/** Only start loading the image when it's been scrolled into the user's view. Default: false */
				'lazyload'?: boolean;
				/** Do not load any metadata (markers, tours, etc). Default: false */
				'data-skipmeta'?: boolean;
				/** Simulate an <img/> element. No logo, loader bar, and no event listeners. Default: false */
				'data-static'?: boolean;
				/** Read and write deeplinks to opened tours and markers. Default: null */
				'data-router'?: string;
				/** Sending user input as GA Events to any available GTag instance (does nothing if none). Default: true */
				'data-gtag'?: boolean;
				/** Set the speed factor for camera animations. Default: 1 */
				'data-camspeed'?: number;
				/** Can pan outside the image's limits. Default: false */
				'data-freemove'?: boolean;
				/** Set the percentage (1=100%) of how far a user can zoom in. Default: 1 */
				'data-zoomlimit'?: number;
				/** Set the initial viewport rectangle of the image. Default: [0,0,1,1] */
				'data-view'?: number[];
				/** Set focus point of the image, treated as the center in case of image overflows. Default: [0.5, 0.5] */
				'data-focus'?: number[];
				/** Keep drawing frames, even if there is no movement. Default: false */
				'data-keeprendering'?: boolean;
				/** When turned off, high DPI screens will have its zoom limited to visually 100% of pixel size. Default: true */
				'data-normalize-dpr'?: boolean;
				/** No event handlers will be set up, and the image will be non-interactive. Default: true */
				'data-events'?: boolean;
				/** Use your keyboard to navigate through the image. Default: false */
				'data-keys'?: boolean;
				/** Use trackpad/touchscreen pinching for zooming. Default: true */
				'data-pinch-zoom'?: boolean;
				/** Use mousewheel/trackpad scrolling for zooming. Default: true */
				'data-scroll-zoom'?: boolean;
				/** The user must press CTRL/CMD when zooming with the mousewheel. Default: false */
				'data-control-zoom'?: boolean;
				/** Requires the user to use two fingers to pan the image on touch devices. Default: false */
				'data-two-finger-pan'?: boolean;
				/** The user cannot zoom at all. Default: true */
				'data-zooming'?: boolean;
				/** Use dragging and touch events for panning. Default: true */
				'data-dragging'?: boolean;
				/** No HTML UI elements will be printed. Default: true */
				'data-ui'?: boolean;
				/** No control buttons will be printed. Default: true */
				'data-controls'?: boolean;
				/** Show a fullscreen switching button on supported platforms. Default: true */
				'data-fullscreen'?: boolean;
				/** Show a social sharing link menu. Default: false */
				'data-social'?: boolean;
				/** The Micrio logo is displayed. Default: true */
				'data-logo'?: boolean;
				/** The optional Organisation logo (top right) will be hidden. Default: true */
				'data-logo-org'?: boolean;
				/** No top menu bar will be printed. Default: true */
				'data-toolbar'?: boolean;
				/** Show an image info panel with the title and description. Default: false */
				'data-show-info'?: boolean;
				/** An interactive minimap will be shown. Default: false */
				'data-minimap'?: boolean;
				/** The minimap will always be visible. Default: true */
				'data-minimap-hide'?: boolean;
				/** The minimap height in pixels. Default: 160 */
				'data-minimap-height'?: number;
				/** The minimap width in pixels. Default: 200 */
				'data-minimap-width'?: number;
				/** All audio will be disabled if this attribute is present. */
				'muted'?: boolean;
				/** The general sound volume for music/sfx (between 0 and 1). Default: 1 */
				'volume'?: number;
				/** Fade music to this volume while other audio plays (between 0 and 1). Default: 0 */
				'data-mutedvolume'?: number;
				/** Configuration for the grid which the viewer will use. */
				'data-grid'?: string;
				/** Toggle limited rendering mode in WebAssembly. */
				'data-limited'?: boolean;
			}
		}
	}
	/**
	 * 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 object used as the render target for the main scene. */
		frameBuffer: WebGLFramebuffer;
		/**
		 * 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;
	}
	/**
	 * 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 {
		/** Writable Svelte store indicating if event handling is currently enabled. Set to false during tours or animations. */
		enabled: Writable<boolean>;
		/** Getter for the current value of the {@link enabled} store. */
		get $enabled(): boolean;
		/** Current pinch zoom factor relative to the start of the pinch. Undefined when not pinching. */
		pinchFactor: number | undefined;
		/**
		 * 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;
		/** Hooks all necessary event listeners based on current settings. */
		hook(): void;
		/** Unhooks all attached event listeners. */
		unhook(): void;
		/** Hooks keyboard event listeners. */
		hookKeys(): void;
		/** Unhooks keyboard event listeners. */
		unhookKeys(): void;
		/** Hooks zoom-related event listeners (pinch, scroll, double-tap/click). */
		hookZoom(): void;
		/** Unhooks zoom-related event listeners. */
		unhookZoom(): void;
		/** Hooks mouse wheel/scroll event listeners. */
		hookScroll(): void;
		/** Unhooks mouse wheel/scroll event listeners. */
		unhookScroll(): void;
		/** Hooks touch pinch and macOS gesture event listeners. */
		hookPinch(): void;
		/** Unhooks touch pinch and macOS gesture event listeners. */
		unhookPinch(): void;
		/** Hooks pointer down/move/up listeners for drag panning. */
		hookDrag(): void;
		/** Unhooks pointer listeners for drag panning. */
		unhookDrag(): void;
	}
	/**
	 * 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 main WebGL rendering `<canvas>` element. */
		readonly element: HTMLCanvasElement;
		/** Object containing current viewport dimensions, position, and ratios. */
		readonly viewport: Models.Canvas.ViewRect;
		/** Writable Svelte store indicating if the client is likely a mobile device. */
		readonly isMobile: Writable<boolean>;
		/** 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);
		/**
		 * 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;
		/**
		 * 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;
		zoomOut: string;
		fullscreenToggle: string;
		switchLanguage: string;
		share: string;
		audioMute: string;
		audioUnmute: string;
		closeMarker: string;
		tourStepNext: string;
		tourStepPrev: string;
		tourStop: string;
		minimize: string;
		play: string;
		pause: string;
		stop: string;
		subtitlesToggle: string;
		galleryPrev: string;
		galleryNext: string;
		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. */
		static VERSION: string;
		/** Static cache store for downloaded JSON files (like image info). */
		static jsonCache: Map<string, Object>;
		/** Array holding all instantiated {@link MicrioImage} objects managed by this element. */
		readonly canvases: MicrioImage[];
		/**
		 * 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>;
		/** Writable Svelte store holding an array of currently visible {@link MicrioImage} instances (relevant for split-screen or grid). */
		readonly visible: Writable<MicrioImage[]>;
		/**
		 * Getter for the current value of the {@link current} store.
		 * Provides direct access to the active {@link MicrioImage} instance.
		 * @readonly
		*/
		get $current(): MicrioImage | undefined;
		/** Getter for the virtual {@link Camera} instance of the currently active image. */
		get camera(): Camera | undefined;
		/** The controller managing the HTML `<canvas>` element, resizing, and viewport. */
		readonly canvas: Canvas;
		/** The controller managing user input events (mouse, touch, keyboard) and dispatching custom events. */
		readonly events: Events;
		/** The main state manager, providing access to various application states (UI visibility, active marker, tour, etc.). See {@link State.Main}. */
		readonly state: State.Main;
		/** The Google Analytics integration controller. */
		private readonly analytics;
		/** The URL router, handling deep linking and history management. */
		private readonly _router;
		/** Writable Svelte store indicating if barebone texture downloading is enabled (lower quality, less bandwidth). */
		readonly barebone: Writable<boolean>;
		/** Custom settings object provided programmatically, overriding server-fetched settings. */
		defaultSettings?: Partial<Models.ImageInfo.Settings>;
		/** Holds data for the current 360 space, if applicable (loaded via `data-space` attribute or API). */
		spaceData: Models.Spaces.Space | undefined;
		addEventListener<K extends keyof Models.MicrioEventMap>(type: K, listener: (this: HTMLMicrioElement, ev: Models.MicrioEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
		addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMicrioElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
		addEventListener(type: string, listener: (this: HTMLMicrioElement, ev: Event) => any, options?: boolean | AddEventListenerOptions): void;
		removeEventListener<K extends keyof Models.MicrioEventMap>(type: K, listener: (this: HTMLMicrioElement, ev: Models.MicrioEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
		removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLMicrioElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
		removeEventListener(type: string, listener: (this: HTMLMicrioElement, ev: Event) => any, options?: boolean | EventListenerOptions): void;
		/** Destroys the Micrio instance, cleans up resources, and removes event listeners. */
		destroy(): void;
		/**
		 * 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?: {
			/** If true, keeps the grid view active instead of focusing on the opened image. */
			gridView?: boolean;
			/** If true, opens the image as a secondary split-screen view. */
			splitScreen?: boolean;
			/** The primary image when opening in split-screen mode. Defaults to the current main image. */
			splitTo?: MicrioImage;
			/** If true, opens the split-screen view passively (doesn't take focus). */
			isPassive?: boolean;
			/** An optional starting view `[x0, y0, x1, y1]` to apply immediately. */
			startView?: Models.Camera.View;
			/** For 360 transitions, provides the direction vector from the previous image. */
			vector?: Models.Camera.Vector;
		}): 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;
		/** Holds loaded grid info data if applicable. */
		gridInfoData: {
			images: Models.ImageInfo.ImageInfo[];
		} | undefined;
		/** 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;
		/**
		 * Creates a GoogleTag instance.
		 * @param micrio The main HTMLMicrioElement instance.
		*/
		constructor(micrio: HTMLMicrioElement);
	}
	/**
	 * 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;
		/**
		 * 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;
	}
}declare module "svelte/store" {
	/** Callback to inform of a value updates.
	*/
	export type Subscriber<T> = (value: T) => void;
	/** Unsubscribes from value updates.
	*/
	export type Unsubscriber = () => void;
	/** Callback to update a value.
	*/
	export type Updater<T> = (value: T) => T;
	/** Cleanup logic callback. */
	type Invalidator<T> = (value?: T) => void;
	/** Start and stop notification callbacks.
	 * @internal
	*/
	export type StartStopNotifier<T> = (set: Subscriber<T>) => Unsubscriber | void;
	/** Readable interface for subscribing. See the main SvelteStore article on how to use it in Micrio. */
	export interface Readable<T> {
		/**
		 * Subscribe on value changes.
		 * @param run subscription callback
		 * @param invalidate cleanup callback
		 */
		subscribe(this: void, run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
	}
	/** Writable interface for both updating and subscribing. See the main SvelteStore article on how to use it in Micrio. */
	export interface Writable<T> extends Readable<T> {
		/**
		 * Set value and inform subscribers.
		 * @param value to set
		 */
		set(this: void, value: T): void;
		/**
		 * Update value using callback and inform subscribers.
		 * @param updater callback
		 */
		update(this: void, updater: Updater<T>): void;
	}
	/**
	 * Creates a `Readable` store that allows reading by subscription.
	 * @internal
	 * @param value initial value
	 * @param {StartStopNotifier}start start and stop notifications for subscriptions
	 */
	export function readable<T>(value?: T, start?: StartStopNotifier<T>): Readable<T>;
	/**
	 * Create a `Writable` store that allows both updating and reading by subscription.
	 * @internal
	 * @param {*=}value initial value
	 * @param {StartStopNotifier=}start start and stop notifications for subscriptions
	 */
	export function writable<T>(value?: T, start?: StartStopNotifier<T>): Writable<T>;
	/** One or more `Readable`s.
	 * @internal
	*/
	type Stores = Readable<any> | [Readable<any>, ...Array<Readable<any>>] | Array<Readable<any>>;
	/** One or more values from `Readable` stores.
	 * @internal
	*/
	type StoresValues<T> = T extends Readable<infer U> ? U : {
		[K in keyof T]: T[K] extends Readable<infer U> ? U : never;
	};
	/**
	 * Derived value store by synchronizing one or more readable stores and
	 * applying an aggregation function over its input values.
	 *
	 * @internal
	 * @param stores - input stores
	 * @param fn - function callback that aggregates the values
	 * @param initial_value - when used asynchronously
	 */
	export function derived<S extends Stores, T>(stores: S, fn: (values: StoresValues<S>, set: (value: T) => void) => Unsubscriber | void, initial_value?: T): Readable<T>;
	/**
	 * Derived value store by synchronizing one or more readable stores and
	 * applying an aggregation function over its input values.
	 *
	 * @internal
	 * @param stores - input stores
	 * @param fn - function callback that aggregates the values
	 * @param initial_value - initial value
	 */
	export function derived<S extends Stores, T>(stores: S, fn: (values: StoresValues<S>) => T, initial_value?: T): Readable<T>;
	/**
	 * Derived value store by synchronizing one or more readable stores and
	 * applying an aggregation function over its input values.
	 *
	 * @internal
	 * @param stores - input stores
	 * @param fn - function callback that aggregates the values
	 */
	export function derived<S extends Stores, T>(stores: S, fn: (values: StoresValues<S>) => T): Readable<T>;
	/**
	 * Get the current value from a store by subscribing and immediately unsubscribing.
	 * @internal
	 * @param store readable
	 */
	 export function get<T>(store: Readable<T>): T;

}