@virtualdisplay.io/client 4.0.0-alpha.3 → 4.0.0-alpha.30

package/dist/index.d.ts

@@ -0,0 +1,660 @@
+/** The app types this protocol version knows. The wire field stays a plain
+ * string on purpose: a newer viewer may report a type this bundle predates,
+ * and the host must receive it to fail visibly (never a quiet downgrade). */
+type AppType = 'viewer' | 'configurator';
+/** What a configurator app's submit form renders. Any field may be absent; an
+ * absent field means the form's own default. */
+interface AppSubmitSettings {
+    readonly fields?: string[];
+    readonly ctaLabel?: string;
+    readonly privacyUrl?: string;
+}
+/**
+ * How a model's annotations present to the visitor: never (hide), always
+ * (show), or under their own control via a viewer toggle, starting visible
+ * (toggle-shown) or hidden (toggle-hidden). Resolved per app, defaulting to
+ * hide.
+ */
+type AnnotationVisibility = 'hide' | 'show' | 'toggle-shown' | 'toggle-hidden';
+/**
+ * Which viewer controls the model shows, as configured for it. Sent with the
+ * mapping; every field is optional and an absent field means the viewer's own
+ * default.
+ */
+interface ViewerSettings {
+    readonly ar?: boolean;
+    readonly fullscreen?: boolean;
+    readonly screenshot?: boolean;
+    readonly cameraControls?: boolean;
+    /**
+     * The resolved per-app annotation mode. Present only when the model has
+     * annotations, so a control can never render with nothing to govern;
+     * absent means there is nothing to show or toggle.
+     */
+    readonly annotations?: AnnotationVisibility;
+    readonly language?: string;
+    /** Where the attribute controls sit: in-frame bottom-left (default) or a docked right panel. */
+    readonly configuratorLayout?: 'inframe-bottom-left' | 'sidebar-right' | 'hidden';
+}
+/**
+ * Camera movement limits sent to the client via CONFIG.
+ * Used to disable camera control buttons when a limit is reached.
+ * Units match the camera position: zoom = percentage (0–200), tilt/rotate = degrees.
+ */
+interface CameraLimits {
+    readonly minZoom?: number;
+    readonly maxZoom?: number;
+    readonly minTilt?: number;
+    readonly maxTilt?: number;
+    readonly minRotate?: number;
+    readonly maxRotate?: number;
+}
+/** Per selector, the values the buyer can still pick right now. */
+interface SelectableAttribute {
+    readonly name: string;
+    readonly selectable: string[];
+    /**
+     * The control should not render at all: a dimension whose component is
+     * currently hidden by its show-when conditions (parametric dimensions).
+     * Different from an empty `selectable`, which greys values out but keeps
+     * the control visible. Absent means visible.
+     */
+    readonly hidden?: boolean;
+}
+/**
+ * What the configurator does with a matched configuration.
+ */
+declare const AVAILABILITY: {
+    /** Price and submit button both shown (default). */
+    readonly AVAILABLE: "available";
+    /** Price shown, submit hidden (sold out / coming soon). */
+    readonly VIEW_ONLY: "view_only";
+    /** Behaves exactly like an unpriced combination: no price, no button. */
+    readonly HIDDEN: "hidden";
+};
+type Availability = (typeof AVAILABILITY)[keyof typeof AVAILABILITY];
+/**
+ * One pricing rule: a subset of attribute values mapped to a reference and a
+ * price.
+ */
+interface PricingRule {
+    /**
+     * The attribute name→value pairs this rule names. `{}` is a catch-all;
+     * omitted names are wildcards. A rule matches when every pair equals the
+     * current selection; the rule naming the most attributes wins.
+     */
+    readonly attributes: Record<string, string>;
+    /** The customer's own identifier (SKU, EAN, artikelnummer, name code). */
+    readonly reference: string;
+    /** Price in minor units (cents), exactly as the source displays it. */
+    readonly priceCents: number;
+    readonly availability: Availability;
+    /** Provenance (manual | imported); audit-only, unused by the resolver. */
+    readonly source: 'manual' | 'imported';
+}
+/**
+ * A model's pricing document. The viewer's fetcher merges it into the model
+ * metadata and the server forwards it to the client via {@link PricingMessage}.
+ */
+interface PricingDocument {
+    /** Optimistic-concurrency version from the editor; unused by the viewer. */
+    readonly version: number;
+    /** Customer-authored CTA label; null when the adapter's defaultLabel fills in. */
+    readonly buttonLabel: string | null;
+    /** ISO 4217 currency code for price formatting. */
+    readonly currency: string;
+    /** VAT label for bare embeds, e.g. "incl. btw". */
+    readonly vatDisplay: string;
+    readonly rules: PricingRule[];
+}
+
+/**
+ * Annotation display: show or hide the model's existing markers.
+ */
+declare class Annotations {
+    private readonly send;
+    /** Whose pins this facade toggles: a pin lives in one model's local space. */
+    private readonly instance;
+    setEnabled(enabled: boolean): void;
+}
+
+type SelectableSnapshot = readonly SelectableAttribute[];
+
+/**
+ * Camera control API for positioning and zoom
+ * Uses chaining pattern for building commands
+ */
+declare class Camera {
+    private readonly send;
+    private commands;
+    /**
+     * Rotate camera horizontally
+     * @param degrees - Absolute rotation in degrees (0 = front view)
+     * @throws VirtualdisplayError if value is not a finite number
+     */
+    rotate(degrees: number): this;
+    /**
+     * Tilt camera vertically
+     * @param degrees - Absolute tilt in degrees (0 = top view, 90 = horizontal)
+     * @throws VirtualdisplayError if value is not a finite number
+     */
+    tilt(degrees: number): this;
+    /**
+     * Zoom camera
+     * @param percentage - Zoom percentage (100 = normal, >100 = zoom in, <100 = zoom out)
+     * @throws VirtualdisplayError if value is not a finite number
+     */
+    zoom(percentage: number): this;
+    /**
+     * Execute accumulated camera commands
+     * @throws VirtualdisplayError if no commands have been accumulated
+     */
+    set(): void;
+    private validateFiniteNumber;
+    /**
+     * Reset camera to initial position
+     * This is not chainable and executes immediately
+     */
+    reset(): void;
+}
+
+/**
+ * Camera position state object
+ */
+interface CameraPositionState {
+    rotation: number;
+    tilt: number;
+    zoom: number;
+}
+/**
+ * Camera position state
+ * Tracks current rotation, tilt, zoom, and movement limits from server updates.
+ */
+declare class CameraPosition {
+    private readonly state;
+    private limitsState;
+    private readonly changeCallbacks;
+    /**
+     * Get current rotation in degrees
+     */
+    get rotation(): number;
+    /**
+     * Get current tilt in degrees
+     */
+    get tilt(): number;
+    /**
+     * Get current zoom percentage
+     */
+    get zoom(): number;
+    /**
+     * Subscribe to camera position changes. Also fires when the viewer reports new
+     * movement limits, so controls can re-evaluate their disabled state without a
+     * second callback.
+     */
+    onChange(callback: (position: CameraPositionState) => void): void;
+    /**
+     * Current camera movement limits (set from CONFIG message).
+     * Undefined until the server sends limits in its CONFIG payload.
+     */
+    get limits(): CameraLimits | undefined;
+}
+
+/**
+ * The buyer's current configuration once it resolves to a price. `availability`
+ * is `available` (price + submit) or `view_only` (price, no submit); a matched
+ * `hidden` rule and a no-match both surface as `undefined` instead.
+ */
+interface ResolvedConfiguration {
+    readonly attributes: Record<string, string>;
+    readonly reference: string;
+    /** Price in minor units (cents), exactly as the source displays it. */
+    readonly price: number;
+    readonly currency: string;
+    readonly availability: 'available' | 'view_only';
+}
+/**
+ * What submit hands to the host: the buyer's selection and the reference to act
+ * on. Deliberately carries no price — the shop's checkout price is binding and
+ * ours is display-only, so handing it into the cart hand-off would only invite a
+ * wrong-price error. Price stays on the display side (`current`, `onChange`).
+ */
+interface SubmittedConfiguration {
+    readonly attributes: Record<string, string>;
+    readonly reference: string;
+}
+/** Options for {@link Configuration.onSubmit}. */
+interface SubmitOptions {
+    /** Fallback button label when the customer authored none (the adapter brings it). */
+    readonly defaultLabel?: string;
+}
+/**
+ * Resolves the current selection to a reference and a price, and carries it to
+ * the host page. `onChange` fires with the resolved configuration, or
+ * `undefined` when nothing matches; `onSubmit` registers the handler the CTA
+ * hands that configuration to.
+ */
+declare class Configuration {
+    private readonly dispatchChange;
+    private readonly dispatchSubmit;
+    private pricing;
+    private selection;
+    private resolved;
+    private readonly changeCallbacks;
+    private readonly renderCallbacks;
+    private submitCallback;
+    private submitDefaultLabel;
+    /** The resolved configuration, or undefined when nothing matches. */
+    get current(): ResolvedConfiguration | undefined;
+    /** The VAT label for bare embeds (e.g. "incl. btw"), or undefined without pricing. */
+    get vatDisplay(): string | undefined;
+    /**
+     * The CTA label: the customer's `button_label`, or the adapter's `defaultLabel`
+     * when that is empty. Undefined when neither is set — a button must know what
+     * it says, so the CTA does not render.
+     */
+    get buttonLabel(): string | undefined;
+    /**
+     * Whether the current configuration may be submitted: a handler is registered
+     * and the configuration is either price-less or an `available` priced one. The
+     * CTA's visibility ({@link submitEnabled}) layers a label requirement on top of
+     * this; a programmatic `submit()` does not need a label.
+     */
+    private get submittable();
+    /**
+     * Whether the CTA should render: the configuration is submittable and a label
+     * exists. A button must say something, so an empty label hides the CTA rather
+     * than rendering blank.
+     */
+    get submitEnabled(): boolean;
+    /**
+     * Subscribe to configuration changes. Fires after every selection change with
+     * the resolved configuration, including undefined when nothing matches.
+     */
+    onChange(callback: (configuration: ResolvedConfiguration | undefined) => void): void;
+    /**
+     * Register the submit handler the CTA hands the configuration to. Registering
+     * one is what switches the button on (capability driven). `defaultLabel` fills
+     * in when the customer authored no button label.
+     */
+    onSubmit(callback: (configuration: SubmittedConfiguration) => void | Promise<unknown>, options?: SubmitOptions): void;
+    /**
+     * Hand the current configuration to the registered handler and fire the
+     * bubbling `vd:configuration-submit` event. No-op without a handler or a
+     * resolved configuration. Returns the handler's promise so the caller can
+     * reflect the result (bezig / gelukt / mislukt).
+     */
+    submit(): Promise<void>;
+    private recompute;
+    private notifyRender;
+    private resolve;
+}
+
+/** The focus state reported to `onChange` and the `vd:focus-change` event. */
+interface FocusState {
+    readonly component: string;
+    readonly attributes: string[];
+}
+/**
+ * Isolate and frame one component, or return to the overview. Alongside
+ * `onChange` the container dispatches a bubbling `vd:focus-change` event, so a
+ * page can react without registering a callback.
+ */
+declare class Focus {
+    private readonly send;
+    private readonly dispatch;
+    /** Which instance this facade addresses; every message it sends carries it. */
+    private readonly instance;
+    private focused;
+    private attributes;
+    private readonly changeCallbacks;
+    /** The focused component name, or null in overview. */
+    get current(): string | null;
+    /**
+     * Focus a component by name. Sends a focus message to the viewer.
+     * @throws VirtualdisplayError if component is not a non-empty string
+     */
+    set(component: string): void;
+    /** Return to the overview — unfocus the current component. */
+    clear(): void;
+    /**
+     * Subscribe to focus changes. The callback fires with the focus state when a
+     * component is focused, and with null when returning to overview.
+     */
+    onChange(callback: (state: FocusState | null) => void): void;
+}
+
+/**
+ * Error codes for Virtualdisplay client errors
+ */
+declare const ERROR_CODES: {
+    readonly NO_MAPPING: "NO_MAPPING";
+    readonly ATTRIBUTE_NOT_FOUND: "ATTRIBUTE_NOT_FOUND";
+    readonly VALUE_NOT_FOUND: "VALUE_NOT_FOUND";
+    readonly PARENT_NOT_FOUND: "PARENT_NOT_FOUND";
+    readonly INVALID_PARAMETER: "INVALID_PARAMETER";
+    readonly SNAPSHOT_FAILED: "SNAPSHOT_FAILED";
+};
+type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];
+/**
+ * Custom error class for Virtualdisplay client errors
+ */
+declare class VirtualdisplayError extends Error {
+    readonly code: ErrorCode;
+    constructor(message: string, code: ErrorCode);
+    static valueNotFound(attributeName: string, valueName: string): VirtualdisplayError;
+    static parentNotFound(selector: string): VirtualdisplayError;
+    static invalidParameter(reason: string): VirtualdisplayError;
+}
+
+interface PhotoData {
+    readonly filename: string;
+    readonly data: string;
+}
+/**
+ * Represents a photo being captured
+ * Pure domain object that manages callbacks for when the photo is developed
+ */
+declare class Photo {
+    private readonly filename;
+    private readonly developedCallbacks;
+    private readonly errorCallbacks;
+    private developed;
+    private failed;
+    private photoData;
+    /**
+     * Register a callback for when the photo is developed
+     * If the photo is already developed, the callback is called immediately
+     *
+     * @param callback Function to call with photo data
+     * @returns This Photo instance for chaining
+     */
+    onDeveloped(callback: (photo: PhotoData) => void): this;
+    /**
+     * Register a callback for when the photo capture fails
+     *
+     * @param callback Function to call with error
+     * @returns This Photo instance for chaining
+     */
+    onError(callback: (error: VirtualdisplayError) => void): this;
+    /**
+     * Get the filename for this photo
+     */
+    getFilename(): string;
+}
+
+/**
+ * API for taking screenshots of the 3D model
+ * Following the camera analogy: take() triggers capture, onDeveloped() gets result
+ */
+declare class Snapshot {
+    private readonly send;
+    private readonly validExtensions;
+    private readonly pendingPhotos;
+    /**
+     * Take a snapshot of the current 3D model view
+     *
+     * @param filename The filename for the snapshot (must include valid extension)
+     * @returns Photo object for registering callbacks
+     * @throws VirtualdisplayError if filename is invalid
+     */
+    take(filename: string): Photo;
+    /**
+     * Fail any pending photos and forget them. Called from client destroy
+     * so callers awaiting onError() see a deterministic outcome instead of
+     * leaking captures whose results will never arrive.
+     */
+    clear(): void;
+    /**
+     * Validate filename has a valid image extension
+     */
+    private validateFilename;
+}
+
+/**
+ * Pure domain entity representing a single attribute value
+ * No side effects - only state
+ */
+declare class AttributeValue {
+    readonly value: string;
+    readonly attribute: string;
+    private isSelectedValue;
+    get isSelected(): boolean;
+}
+
+/**
+ * Represents a single attribute with its available values
+ * Flat API - no source/target translation, works with server values directly
+ */
+declare class Attribute {
+    readonly name: string;
+    readonly defaultValue: string | undefined;
+    private readonly values;
+    private readonly onSelect;
+    private onChangeCallback?;
+    /**
+     * Select a value for this attribute
+     * @throws {VirtualdisplayError} When value not found
+     */
+    select(value: string): void;
+    getValues(): AttributeValue[];
+    getValue(value: string): AttributeValue | undefined;
+    /** The currently selected value, or undefined before any selection lands. */
+    get selected(): string | undefined;
+    /**
+     * Register callback that fires when selection changes
+     * Receives the newly selected AttributeValue
+     */
+    onChange(callback: (selectedValue: AttributeValue) => void): void;
+    private createValues;
+}
+
+/**
+ * The client's DOM event names, in one registry. The two selection events are
+ * what `client.on(...)` subscribes to; the other three bubble out of the
+ * container, so the host page can reach them with `addEventListener`.
+ */
+declare const VD_EVENTS: {
+    /** Attribute selection requested (cancelable, does not bubble). `detail`: `{ attribute, value }`. */
+    readonly SELECT: "vd:select";
+    /** Attribute selection applied (does not bubble). `detail`: `{ attribute, value }`. */
+    readonly SELECTED: "vd:selected";
+    /** Focus changed (bubbles). `detail`: `{ component, attributes }`, or `null` for the overview. */
+    readonly FOCUS_CHANGE: "vd:focus-change";
+    /** Resolved configuration changed (bubbles). `detail`: the resolved configuration, or `null` when nothing matches. */
+    readonly CONFIGURATION_CHANGE: "vd:configuration-change";
+    /** Configuration submitted (bubbles). `detail`: the resolved configuration handed to the host. */
+    readonly CONFIGURATION_SUBMIT: "vd:configuration-submit";
+};
+type VdEvent = typeof VD_EVENTS[keyof typeof VD_EVENTS];
+
+interface MutationFailedEvent {
+    readonly attribute: string;
+    readonly value: string;
+}
+/**
+ * Which app the viewer resolved, as handed to an `onAppResolved` callback.
+ */
+interface ResolvedAppInfo {
+    /** Known values: `AppType`. An unknown value means a newer server; report it, never downgrade to a viewer. */
+    readonly appType: string;
+    readonly name: string;
+    /** The app's public slug (the address a submit POSTs to). Absent from a pre-slug server. */
+    readonly slug?: string;
+    readonly submit?: AppSubmitSettings;
+}
+interface VirtualdisplaySelectEvent {
+    readonly attribute: string;
+    readonly value: string;
+    preventDefault(): void;
+}
+interface VirtualdisplaySelectedEvent {
+    readonly attribute: string;
+    readonly value: string;
+}
+type VirtualdisplayUiEventMap = {
+    [VD_EVENTS.SELECT]: VirtualdisplaySelectEvent;
+    [VD_EVENTS.SELECTED]: VirtualdisplaySelectedEvent;
+};
+type VirtualdisplayUiEventType = keyof VirtualdisplayUiEventMap;
+
+/**
+ * The shared client composition root: wires the transport, facades and UI, and
+ * exposes the integrator-facing API.
+ */
+declare class BaseClient {
+    private readonly attributes;
+    private readonly selectableState;
+    private readonly readyStateTracker;
+    private readonly messenger;
+    private readonly cameraApi;
+    private readonly cameraPositionApi;
+    private readonly focusApi;
+    private readonly configurationApi;
+    private readonly snapshotApi;
+    private readonly annotationsApi;
+    private readonly eventBus;
+    private readonly ui;
+    private readonly options;
+    private readonly serverHost;
+    private readonly iframeParams;
+    private readonly arActivation;
+    private readonly syncTracker;
+    private iframe;
+    private container;
+    private readyCallbacks;
+    private readonly mutationFailedCallbacks;
+    private viewerSessionId;
+    private resolvedApp;
+    private readonly appResolvedCallbacks;
+    private createStandardInterface;
+    private sendControlAnnotationToggle;
+    private wireIncomingMessages;
+    private handleAppResolved;
+    private handleSession;
+    private notifyMutationFailed;
+    private notifyReady;
+    private dispatchFocusChange;
+    private dispatchConfigurationChange;
+    private dispatchConfigurationSubmit;
+    private handleConfig;
+    private echoAnnotationsDifference;
+    private trackFullscreen;
+    private initializeLogging;
+    private createAndConnectIframe;
+    select(name: string, value: string): void;
+    getValues(name: string): AttributeValue[];
+    getValue(name: string, value: string): AttributeValue | undefined;
+    onChange(name: string, callback: (selectedValue: AttributeValue) => void): void;
+    getAttribute(name: string): Attribute | undefined;
+    get isReady(): boolean;
+    onReady(callback: (client: this) => void): void;
+    onMutationFailed(callback: (event: MutationFailedEvent) => void): void;
+    /**
+     * Subscribe to which values can be picked right now, per attribute. Fires
+     * immediately when a snapshot already arrived. A model with no exclusions
+     * never sends one, so this never fires and everything stays selectable.
+     */
+    onSelectableChange(callback: (snapshot: SelectableSnapshot) => void): void;
+    /**
+     * Subscribe to which app this viewer resolved (type, name, public submit
+     * settings). Reported once by the viewer after its resolve; fires immediately
+     * when the report already arrived, so registration order does not matter.
+     */
+    onAppResolved(callback: (app: ResolvedAppInfo) => void): void;
+    /** The selectable values for one attribute right now, or null when unrestricted. */
+    getSelectable(name: string): readonly string[] | null;
+    /**
+     * Start the AR flow directly, as the built-in AR button would. Does nothing
+     * when `viewerSettings.ar` is off or the build composes no AR flow.
+     */
+    activateAr(): void;
+    on<T extends VirtualdisplayUiEventType>(type: T, callback: (event: VirtualdisplayUiEventMap[T]) => void): void;
+    get annotations(): Annotations;
+    get camera(): Camera;
+    get focus(): Focus;
+    get configuration(): Configuration;
+    get cameraPosition(): CameraPosition;
+    get snapshot(): Snapshot;
+    /** The viewer's tracking session id, for a host page to correlate its own actions. */
+    get sessionId(): string | undefined;
+    get viewerSettings(): ViewerSettings;
+    destroy(): void;
+}
+
+/**
+ * The integrator-facing viewer settings override. Identical to the wire
+ * `ViewerSettings`, except `annotations` also accepts the legacy booleans:
+ * they normalise before the merge (`true` → `show`, `false` → `hide`), so
+ * existing mounts keep compiling while the package is in alpha.
+ */
+type ViewerSettingsOverride = Omit<Partial<ViewerSettings>, 'annotations'> & {
+    readonly annotations?: boolean | AnnotationVisibility;
+};
+/**
+ * Options shared by both address forms.
+ */
+interface ClientOptionsBase {
+    readonly parent: string | HTMLElement;
+    readonly debug?: boolean | undefined;
+    readonly language?: string | undefined;
+    /** W3C traceparent string to propagate to the viewer iframe for end-to-end tracing. */
+    readonly traceparent?: string | undefined;
+    /**
+     * A source viewer session id to restore into this mount (ar-session-handoff): the
+     * iframe's metadata fetch merges that session's latest configuration into the
+     * attribute defaults, so the viewer boots straight into it. Internal option, used
+     * by the AR landing, not a customer-facing setting.
+     */
+    readonly session?: string | undefined;
+    /**
+     * Override viewer settings from metadata. Omitted fields use the metadata value.
+     * A warning is logged when an override differs from the metadata value.
+     */
+    readonly viewerSettings?: ViewerSettingsOverride;
+}
+/**
+ * What the client shows, given either way of naming it: `{ app }`, an app's
+ * public link key, or `{ license, model }`, which resolves to that model's
+ * default app. Given both, `app` wins and the pair is ignored with a warning.
+ */
+type ClientAddress = {
+    readonly app: string;
+    readonly license?: string | undefined;
+    readonly model?: string | undefined;
+} | {
+    readonly license: string;
+    readonly model: string;
+    readonly app?: undefined;
+};
+/**
+ * Configuration options for VirtualdisplayClient
+ */
+type ClientOptions = ClientOptionsBase & ClientAddress;
+
+/**
+ * The logger the client exposes: the same four levels as the base logger, but
+ * accepting any value as attributes so callers can pass an Error or a bare value.
+ */
+interface ClientLogger {
+    debug: (msg: string, attrs?: unknown) => void;
+    info: (msg: string, attrs?: unknown) => void;
+    warn: (msg: string, attrs?: unknown) => void;
+    error: (msg: string, attrs?: unknown) => void;
+}
+declare let logger: ClientLogger;
+declare function enableDebugMode(): void;
+declare function isDebugMode(): boolean;
+
+/**
+ * The Virtualdisplay client: point it at a container and an app or model, and it
+ * renders the viewer with the standard interface, the configurator and AR.
+ */
+declare class VirtualdisplayClient extends BaseClient {
+    private readonly syncStatusTracker;
+    constructor(options: ClientOptions);
+    /** Subscribe to the live sync channel's connection state (ar-session-handoff). Latest-wins, no buffering. */
+    onSyncChange(callback: (connected: boolean) => void): void;
+}
+
+export { AVAILABILITY, Annotations, Attribute, AttributeValue, Camera, CameraPosition, Configuration, ERROR_CODES, Focus, Photo, Snapshot, VD_EVENTS, VirtualdisplayClient, VirtualdisplayError, enableDebugMode, isDebugMode, logger };
+export type { AnnotationVisibility, AppSubmitSettings, AppType, Availability, CameraLimits, CameraPositionState, ClientAddress, ClientLogger, ClientOptions, ClientOptionsBase, ErrorCode, FocusState, MutationFailedEvent, PhotoData, PricingDocument, PricingRule, ResolvedAppInfo, ResolvedConfiguration, SelectableAttribute, SelectableSnapshot, SubmitOptions, SubmittedConfiguration, VdEvent, ViewerSettings, ViewerSettingsOverride, VirtualdisplaySelectEvent, VirtualdisplaySelectedEvent, VirtualdisplayUiEventMap, VirtualdisplayUiEventType };