@webority/ui-elements 0.149.0 → 0.152.0

package/types/WuiSavedViews.d.ts

@@ -0,0 +1,41 @@
+import { ElementBase } from "./elementBase.ts";
+interface SavedView {
+    name: string;
+    query: string;
+    shared?: boolean;
+}
+export declare class WuiSavedViews extends ElementBase {
+    static get observedAttributes(): string[];
+    private _doc;
+    private _dom;
+    private _views;
+    private _open;
+    private _busy;
+    private _error;
+    private _trigger;
+    private _onTriggerClick;
+    private _onKeyDown;
+    private _onPointerDown;
+    private _onSubmit;
+    constructor();
+    private get _ownerDoc();
+    private get _ui();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    _reload(): void;
+    _server(): boolean;
+    _canShare(): boolean;
+    _request(intent: string, fields?: Record<string, string>): Promise<boolean>;
+    _build(): void;
+    _render(): void;
+    _commit(views: SavedView[]): void;
+    _setOpen(open: boolean): void;
+    _storage(): {
+        store: Storage;
+        key: string;
+    } | null;
+    _load(): SavedView[];
+    _write(views: SavedView[]): void;
+}
+export {};

package/types/WuiSelect.d.ts

@@ -0,0 +1,147 @@
+import { ElementBase } from "./elementBase.ts";
+import type { ListboxKeyNav } from "./listboxKeyNav.ts";
+import type { SelectOption } from "./select/option.ts";
+import type { SelectHost, SelectPart } from "./select/part.ts";
+export declare class WuiSelect extends ElementBase {
+    static formAssociated: boolean;
+    _internals: Pick<ElementInternals, "setValidity"> | null;
+    _value: string | string[];
+    _optionsProp: SelectOption[] | null;
+    _partOptions: SelectOption[] | null;
+    _known: Map<string, SelectOption>;
+    _loadOptionsFn: LoadOptions | null;
+    _validateFn: ((value: string) => unknown) | null;
+    _declared: DeclaredOption[] | undefined;
+    _query: string;
+    _ownsFilter: boolean;
+    _active: number;
+    _status: "idle" | "loading" | "empty" | "hint";
+    _error: string;
+    _nav: ListboxKeyNav | null;
+    _parts: SelectPart[] | null;
+    _partSig: string;
+    _partsMounted: boolean;
+    _partToken: number;
+    _rendered: boolean;
+    _searchShown: boolean;
+    _defaultValue: string | string[] | undefined;
+    _warnedMode: string | null;
+    _warnedDensity: string | null | undefined;
+    _reposition: () => void;
+    _hoverTimer: ReturnType<typeof setTimeout> | null;
+    _hoverOpened: boolean;
+    _onHoverOver: (e: PointerEvent) => void;
+    _onHoverOut: (e: PointerEvent) => void;
+    _onDocClick: ((e: MouseEvent) => void) | null | undefined;
+    _bindGlobal: () => void;
+    _reanchor?: (() => void) | null;
+    _reanchorScroll?: ((e: Event) => void) | null;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    formResetCallback(): void;
+    get mode(): SelectMode;
+    _checkDensity(): void;
+    set mode(v: string);
+    get value(): string | string[];
+    set value(v: unknown);
+    get options(): SelectOption[];
+    set options(arr: unknown);
+    get loadOptions(): LoadOptions | null;
+    set loadOptions(fn: LoadOptions | null | undefined);
+    get validate(): ((value: string) => unknown) | null;
+    set validate(fn: ((value: string) => unknown) | null | undefined);
+    commit(value: string | string[], meta?: {
+        isCustom?: boolean;
+    }): void;
+    setPartOptions(list: SelectOption[]): void;
+    setStatus(status: "idle" | "loading" | "empty" | "hint"): void;
+    setError(message: string | null | undefined): void;
+    openMenu(): void;
+    closeMenu({ focusControl }?: {
+        focusControl?: boolean;
+    }): void;
+    renderList(): void;
+    render(): void;
+    _accessibleName(): string;
+    _snapshotDeclared(): void;
+    _readOptions(): SelectOption[];
+    _listOptions(): SelectOption[];
+    _declaredSelected(): string[];
+    _preselect(): void;
+    _optionFor(value: string | string[]): SelectOption | undefined;
+    _placeholder(): string | undefined;
+    _hasValue(): boolean;
+    _selectedValues(): string[];
+    _applyValue(): void;
+    _syncMirror(): void;
+    _drawValue(): void;
+    _syncTitle(opt: SelectOption | undefined): void;
+    _syncValueAvatar(): void;
+    _syncValidity(): void;
+    _syncReset(): void;
+    _syncInvalid(): void;
+    _syncError(): void;
+    _refs(): Refs;
+    _menuOpen(): boolean;
+    _hoverZone(target: EventTarget | null): boolean;
+    _hoverEligible(): boolean;
+    _clearHover(): void;
+    _autoSearch(): boolean;
+    _visible(): HTMLElement[];
+    _setActive(index: number, { reveal }?: {
+        reveal?: boolean;
+    }): void;
+    _actionRows(): ActionRow[];
+    _recents(): Recents;
+    _place(): void;
+    _open({ focus }?: {
+        focus?: boolean;
+    }): void;
+    _close({ force }?: {
+        force?: boolean;
+    }): void;
+    _onQueryChange(query: string): void;
+    _pick(optEl: HTMLElement): void;
+    _draftOpens(): boolean;
+    _onKeyDown(e: KeyboardEvent): void;
+    _wire(): void;
+    _teardown(): void;
+    _activePartsList(): SelectPart[];
+    _ensureParts(): void;
+    _mountParts(carry?: Carry): void;
+    _teardownParts(): void;
+    _remountParts(): void;
+    _carry(): Carry;
+}
+type LoadOptions = (query: string, opts: {
+    signal: AbortSignal;
+}) => Promise<SelectOption[]>;
+type DeclaredOption = SelectOption & {
+    selected: boolean;
+};
+type ActionRow = {
+    position: "top" | "bottom";
+    label: string;
+    value: string;
+};
+type Recents = {
+    label: string;
+    options: SelectOption[];
+} | null;
+type Refs = {
+    control: HTMLElement | null;
+    value: HTMLElement | null;
+    menu: HTMLElement | null;
+    list: HTMLElement | null;
+    search: HTMLInputElement | null;
+    input: HTMLInputElement | null;
+};
+type Carry = {
+    draft: string;
+    query: string;
+};
+type SelectMode = SelectHost["mode"];
+export {};

package/types/WuiShortcuts.d.ts

@@ -0,0 +1,31 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiShortcuts extends ElementBase {
+    _doc: Document | null;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onClick: (e: MouseEvent) => void;
+    _onDocClick: (e: MouseEvent) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _previous: string | null, value: string | null): void;
+    disconnectedCallback(): void;
+    /** Whether the sheet is showing. */
+    get open(): boolean;
+    set open(v: boolean | string);
+    /**
+     * Shows or hides the sheet; focus goes to its close button, and back to the button on close.
+     * Each real change raises `wui-shortcuts-open-change` and mirrors the state on the `open` attribute.
+     */
+    setOpen(open: boolean, { focus }?: {
+        focus?: boolean;
+    }): void;
+    _sheet(): HTMLElement | null;
+    _syncTrigger(): void;
+    _place(): void;
+    _scope(): HTMLElement | null;
+    _items(): HTMLElement[];
+    _click(e: MouseEvent): void;
+    _tickFocused(): void;
+    _focusSearch(): void;
+    _keydown(e: KeyboardEvent): void;
+}

package/types/WuiShowMore.d.ts

@@ -0,0 +1,16 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiShowMore extends ElementBase {
+    _width: number;
+    _observer: ResizeObserver | null;
+    _toggle: HTMLButtonElement | null;
+    _onClick: () => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Whether the whole text is showing. */
+    get expanded(): boolean;
+    /** Opens or closes the block. Without an argument it flips. */
+    toggle(next?: boolean): void;
+    _sync(): void;
+    _check(): void;
+}

package/types/WuiSlider.d.ts

@@ -0,0 +1,126 @@
+import { ElementBase } from "./elementBase.ts";
+/**
+ * <wui-slider> — single-thumb and dual-thumb (range) slider control.
+ *
+ * Single-thumb mode: attributes `value` (current value), `min`/`max`/`step`, `name` (for form submission).
+ * Dual-thumb (range) mode: attributes `start`/`end` (range bounds), `start-name`/`end-name` for form submission.
+ * Presence of the `range` attribute switches to dual-thumb mode.
+ *
+ * Rendering: horizontal track with filled segment and one or two thumb buttons (role="slider").
+ * Keyboard: arrow keys ±step, PageUp/Down ±10*step, Home/End to min/max.
+ * Range mode: thumbs cannot cross each other.
+ * Events: 'change' fires on commit (pointerup, key release); 'slide' fires during drag with detail {value} or {start,end}.
+ * Form: hidden mirror input(s) via syncFormMirror pattern (single mode) or dual mirrors (range mode).
+ *
+ * @property min Default 0
+ * @property max Default 100
+ * @property step Default 1
+ * @property value Current value (single mode)
+ * @property start Range start (range mode)
+ * @property end Range end (range mode)
+ * @property name Field name (single mode)
+ * @property startName Field name for range start
+ * @property endName Field name for range end
+ * @property disabled Disables interaction
+ * @property readonly Shows the value without letting it change; the value still posts
+ * @property loading Locks interaction while the value is being fetched
+ * @property size Control size — 'sm' or 'lg'
+ * @property showValue Shows a label with current value
+ * @property unit Suffix for the value label (e.g. '%')
+ */
+export declare class WuiSlider extends ElementBase {
+    static formAssociated: boolean;
+    _internals: ElementInternals | null;
+    _value: number;
+    _start: number;
+    _end: number;
+    _isDragging: boolean;
+    _dragThumb: string | null;
+    _pointerDownListener: ((e: PointerEvent) => void) | null;
+    _pointerMoveListener: ((e: PointerEvent) => void) | null;
+    _pointerUpListener: (() => void) | null;
+    _thumbKeyListener: ((e: KeyboardEvent) => void) | null;
+    _trackClickListener: ((e: MouseEvent) => void) | null;
+    _rendered?: boolean;
+    _defaultsCaptured?: boolean;
+    _defaultValue?: number;
+    _defaultStart?: number;
+    _defaultEnd?: number;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    get value(): number;
+    set value(v: number | string);
+    get start(): number;
+    set start(v: number | string);
+    get end(): number;
+    set end(v: number | string);
+    attributeChangedCallback(name: string, _old: string | null, _val: string | null): void;
+    formResetCallback(): void;
+    /**
+     * Update internal state from an attribute without triggering a re-render.
+     * Called on attributeChangedCallback for value/bounds changes pre-render.
+     */
+    _updateFromAttribute(name: string): void;
+    _isRange(): boolean;
+    _min(): number;
+    _max(): number;
+    _step(): number;
+    _clamp(val: number): number;
+    /**
+     * Snap a value to the nearest step increment, counted FROM min — a step grid anchored at 0
+     * lands on values the control can never legally hold (min=5 step=10 would snap 6 to 10).
+     */
+    _snapToStep(val: number): number;
+    /**
+     * Capture initial values for formResetCallback.
+     */
+    _captureDefaults(): void;
+    _resetSingle(): void;
+    _resetRange(): void;
+    /**
+     * Render the slider markup once on connection.
+     */
+    render(): void;
+    /**
+     * Format a value with optional unit suffix.
+     */
+    _formatValue(val: number): string;
+    /**
+     * Place the fill and the thumbs for the current value(s).
+     *
+     * `left`/`right` carry the raw percentage; `--wui-t` (0..1) on each thumb and
+     * `--wui-fill-start` / `--wui-fill-end` on the fill let the theme inset the travel by
+     * half a thumb, so a thumb at min or max stays inside the track instead of hanging
+     * half off its end. The theme owns the thumb size, so the inset lives in CSS, not here.
+     */
+    _placeParts(): void;
+    /**
+     * Sync the visual slider thumb positions and aria attributes after a value change.
+     */
+    _syncValue(): void;
+    /**
+     * Sync form mirror input(s).
+     */
+    _syncMirrors(): void;
+    _syncSingleMirror(): void;
+    _syncRangeMirrors(): void;
+    /**
+     * Create/update a range-mode mirror input.
+     */
+    _mirrorRange(kind: "start" | "end", name: string | null, val: number): void;
+    /**
+     * Calculate the value from a pointer/click position on the track.
+     */
+    _valueAtPosition(clientX: number): number;
+    /**
+     * Determine which thumb is nearest to a position (for track clicks in range mode).
+     */
+    _nearestThumb(val: number): "start" | "end";
+    /**
+     * Wire up pointer and keyboard listeners.
+     */
+    _wire(): void;
+    _teardown(): void;
+    disconnectedCallback(): void;
+}

package/types/WuiSortable.d.ts

@@ -0,0 +1,127 @@
+import { ElementBase } from "./elementBase.ts";
+/**
+ * <wui-sortable> - a list whose items the person reorders by pointer drag or by keyboard.
+ * Light DOM, no third-party drag library. The behaviour behind AppSortableList / <app-sortable-list>,
+ * and the piece a board (kanban) or a tree reuses to drag between lists.
+ *
+ * Markup contract. Every direct child that carries `data-id` is an item; anything else (the
+ * hidden form inputs and the live region this element appends) is ignored. An item holds an
+ * optional drag handle as a DIRECT child with class `wui-sortable-handle` (a <button>), which
+ * is also what the keyboard drives:
+ *
+ *   <wui-sortable name="order" aria-label="Priorities" role="list">
+ *     <div role="listitem" data-id="a" data-label="Alpha">
+ *       <button type="button" class="wui-sortable-handle" aria-label="Reorder Alpha"></button>
+ *       ...content...
+ *     </div>
+ *   </wui-sortable>
+ *
+ * Attributes
+ *   name         Form field name. Posts the order as one hidden input per item, all under this
+ *                name (`order=a&order=b&order=c`), so model binding reads it as a list.
+ *   handle       Present: a pointer drag starts only from the handle. Absent: from anywhere on
+ *                the item except links, buttons, inputs and other interactive content.
+ *   disabled     No item can be picked up.
+ *   group        Lists sharing a non-empty group name accept each other's items (pointer drag
+ *                only; the keyboard moves within one list).
+ *   orientation  vertical (default) | horizontal. Horizontal also handles a wrapping row of items.
+ * Item attributes
+ *   data-id        Required. The id reported in the order.
+ *   data-label     Name used in announcements; falls back to the item's text, then the id.
+ *   data-disabled  This item cannot be picked up (other items can still move past it).
+ *
+ * Properties
+ *   controlled  Boolean, set by a framework wrapper that owns the order. A move between lists then
+ *          leaves the dragged node in its origin list and only reports the change, so the
+ *          wrapper's own re-render moves the item (a framework cannot tolerate a node that was
+ *          moved to another parent behind its back).
+ *   order  Array of item ids in DOM order. Setting it reorders the DOM to match (unknown ids are
+ *          ignored, unlisted items follow) and fires no event. Ignored while a drag is live.
+ *
+ * Events (all bubble; listen on the element and check event.target when lists nest)
+ *   wui-sortable:start   detail { id }                 a pointer drag began.
+ *   wui-sortable:change  detail { ids, id, fromIndex, toIndex, from, to }
+ *                        The order changed. `ids` is THIS list's new order. `from` and `to` are the
+ *                        source and destination elements. A move between lists fires on both lists,
+ *                        each with its own `ids`. Fires once per completed drag or keyboard drop.
+ *   wui-sortable:end     detail { id, cancelled }      a pointer drag finished (after any change).
+ *
+ * Pointer: mouse and pen start after 4px of movement; touch starts at once from the handle, and
+ * after a 250ms hold from the item body (so a swipe still scrolls). A ghost copy follows the
+ * pointer, and the scroll container (or the window) scrolls when the pointer nears its edge.
+ * Escape cancels.
+ *
+ * Keyboard: focus an item's handle, Space or Enter lifts it, Arrow keys move it one place (Home and
+ * End jump to the ends), Space or Enter drops it, Escape puts it back. Moving away from the handle
+ * drops it. Every step is announced through an aria-live region the element owns.
+ */
+type DragState = {
+    item: HTMLElement;
+    pointerId: number;
+    startX: number;
+    startY: number;
+    x: number;
+    y: number;
+    slop: number;
+    ready: boolean;
+    started: boolean;
+    timer: ReturnType<typeof setTimeout> | null;
+    raf: number;
+    list: WuiSortable;
+    ghost: HTMLElement | null;
+    offsetX: number;
+    offsetY: number;
+    fromIndex: number;
+};
+type KeyLift = {
+    item: HTMLElement;
+    handle: HTMLElement;
+    fromIndex: number;
+};
+export declare class WuiSortable extends ElementBase {
+    _drag: DragState | null;
+    _kb: KeyLift | null;
+    _moving: boolean;
+    controlled: boolean;
+    _observer: MutationObserver | null;
+    _onDragStart: (e: Event) => void;
+    _onDocTouchMove: (e: TouchEvent) => void;
+    _onSelectStart: (e: Event) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    get order(): (string | null)[];
+    set order(ids: readonly unknown[] | null);
+    _items(): HTMLElement[];
+    _itemFrom(node: Element | null): HTMLElement | null;
+    _itemDisabled(item: Element): boolean;
+    _horizontal(): boolean;
+    _syncMirrors(): void;
+    _insertAt(item: HTMLElement, index: number): void;
+    _indexFor(item: HTMLElement, x: number, y: number): number;
+    _peers(): WuiSortable[];
+    _labelOf(item: HTMLElement): string | null;
+    _announce(text: string): void;
+    _position(item: HTMLElement): string;
+    _onPointerDown(e: PointerEvent): void;
+    _onDocMove(e: PointerEvent): void;
+    _onDocUp(e: PointerEvent): void;
+    _onDocCancel(e: PointerEvent): void;
+    _onDocKey(e: KeyboardEvent): void;
+    _begin(): void;
+    _moveGhost(): void;
+    _update(): void;
+    _scrollTick(): void;
+    _finish(cancelled: boolean): void;
+    _settle(item: HTMLElement, fromList: WuiSortable, fromIndex: number, toList: WuiSortable): void;
+    _emit(target: EventTarget, type: string, detail: object): void;
+    _abort(): void;
+    _onKeyDown(e: KeyboardEvent): void;
+    _onFocusOut(e: FocusEvent): void;
+    _liftKeyboard(item: HTMLElement, handle: HTMLElement): void;
+    _dropKeyboard(cancelled: boolean): void;
+    _moveFocused(move: () => void, handle: HTMLElement): void;
+}
+export {};

package/types/WuiTimePicker.d.ts

@@ -0,0 +1,68 @@
+import { ElementBase } from "./elementBase.ts";
+interface Hm {
+    h: number;
+    m: number;
+}
+type CloseOptions = {
+    commit?: boolean;
+    refocus?: boolean;
+};
+export declare class WuiTimePicker extends ElementBase {
+    static formAssociated: boolean;
+    _internals: ElementInternals | null;
+    _value: string;
+    _uid: string;
+    _typedError: string;
+    _typeahead: string;
+    _typeaheadTimer: number | undefined;
+    _rendered?: boolean;
+    _defaultValue?: string;
+    _isOpen?: (() => boolean) | null;
+    _lastPointer?: string | null;
+    _open: (opts?: {
+        focus?: boolean;
+    }) => void;
+    _close: (opts?: CloseOptions) => void;
+    _bindGlobal: () => void;
+    _onDocClick?: ((e: MouseEvent) => void) | null;
+    _onDocKey?: ((e: KeyboardEvent) => void) | null;
+    _onHostKey?: ((e: KeyboardEvent) => void) | null;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, val: string | null): void;
+    formResetCallback(): void;
+    get value(): string;
+    set value(v: string);
+    _format(): string;
+    _step(): number;
+    _bounds(): {
+        min: number;
+        max: number;
+    };
+    _allowed(h: number, m: number): boolean;
+    _times(): Hm[];
+    _refusal(hm: Hm): string;
+    render(): void;
+    _input(): HTMLInputElement | null;
+    _pop(): HTMLDivElement | null;
+    _syncFormValue(): void;
+    _syncAttrs(): void;
+    _syncText(): void;
+    _syncInvalid(): void;
+    _commitText(): boolean;
+    _pending(): Hm | null;
+    _columnsHtml(): string;
+    _selectedIn(key: string | undefined, hm: Hm | null): string | null;
+    _optionEnabled(key: string | undefined, v: string | undefined, hm: Hm | null): boolean;
+    _syncColumns({ scroll }?: {
+        scroll?: boolean;
+    }): void;
+    _pick(key: string | undefined, v: string | undefined): void;
+    _position(): void;
+    _onColumnKey(e: KeyboardEvent): void;
+    _wire(): void;
+    _teardown(): void;
+    disconnectedCallback(): void;
+}
+export {};

package/types/WuiTour.d.ts

@@ -0,0 +1,117 @@
+import { ElementBase } from "./elementBase.ts";
+import { createProgress } from "./tourProgress.ts";
+import { type SeenOutcome, type SeenStore } from "./tourSeenStore.ts";
+declare const DEFAULT_LABELS: {
+    back: string;
+    next: string;
+    skip: string;
+    done: string;
+    mediaPause: string;
+    mediaPlay: string;
+    endTitle: string;
+    endMessage: string;
+    endButton: string;
+};
+type LabelKey = keyof typeof DEFAULT_LABELS;
+type TourStep = {
+    target: string;
+    title?: string | undefined;
+    description: string;
+    media?: string;
+    mediaAlt?: string;
+    mediaPoster?: string;
+    mediaType?: string;
+    advanceOn?: string;
+    actionLabel?: string;
+};
+type StepBeforeHook = (step: TourStep, index: number) => void | Promise<void>;
+type CloseReason = "finished" | "skipped" | "next" | "alreadySeen" | "noTargets";
+type CloseVia = "button" | "escape" | null;
+type StepPosition = {
+    index: number | null;
+    position: number | null;
+    total: number | null;
+};
+type LocatedStep = {
+    index: number;
+    target: HTMLElement | SVGElement | null;
+};
+type EndText = {
+    title: string;
+    message: string;
+    button: string;
+    nextLabel: string;
+    nextHref: string;
+};
+export declare class WuiTour extends ElementBase {
+    seenStore: SeenStore | null;
+    onBeforeStep: StepBeforeHook | null;
+    _run: number;
+    _running: boolean;
+    _layer: HTMLDivElement | null;
+    _outer: HTMLElement | null;
+    _shadow: ShadowRoot | null;
+    _unbindAdvance: (() => void) | null;
+    _ending: AbortController | null;
+    _seenMark: Promise<void> | null;
+    _steps: TourStep[];
+    _progress: ReturnType<typeof createProgress>;
+    _firstIndex: number;
+    _returnFocus: Element | null;
+    _current: LocatedStep | null;
+    _moving: boolean;
+    _card: HTMLDivElement | null;
+    _spot: HTMLDivElement | null;
+    _live: HTMLElement | null;
+    _onKey: ((e: KeyboardEvent) => void) | null;
+    _onFocusIn: ((e: FocusEvent) => void) | null;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+    get tourId(): string;
+    set tourId(v: string | null | undefined);
+    get isolated(): boolean;
+    set isolated(v: boolean | string);
+    _stepList(): TourStep[];
+    _stepAt(index: number): TourStep;
+    _store(): SeenStore | null;
+    _label(key: LabelKey): string;
+    _endDialogText(): EndText | null;
+    _markSeen(outcome: SeenOutcome): Promise<void> | null;
+    /** Start the tour. A no-op while one is running. */
+    start(): Promise<void>;
+    _start(run: number): Promise<void>;
+    /**
+     * Show the next step with a visible target, or finish after the last, through the closing
+     * dialog when it is on; the promise then settles once the dialog is dismissed. A no-op unless a
+     * step is showing.
+     */
+    next(): Promise<void>;
+    /** Show the previous step with a visible target, as Back does. A no-op unless a step is showing. */
+    back(): Promise<void>;
+    /**
+     * Show step `index`, or the first step after it with a visible target; past the last, the tour
+     * finishes as Next would. A no-op unless a step is showing.
+     * @param index
+     */
+    goTo(index: number): Promise<void>;
+    /** Close the tour without a reason, a seen mark or an event; a closing dialog that showed has already marked it seen. */
+    stop(): void;
+    _locate(from: number, direction: number, run: number): Promise<LocatedStep | null>;
+    _beforeStep(step: TourStep, index: number): Promise<void>;
+    _build(): void;
+    _active(): Element | null;
+    _show(located: LocatedStep): void;
+    _place(): void;
+    _follow(): void;
+    _move(direction: number): Promise<void>;
+    _go(from: number, direction: number): Promise<void>;
+    _showEnd(text: EndText): Promise<"next" | "done">;
+    _key(e: KeyboardEvent): void;
+    _teardown(): void;
+    _close(reason: "finished" | "skipped" | "next", via?: CloseVia): Promise<boolean>;
+    _finish(reason: CloseReason, step?: StepPosition, via?: CloseVia): void;
+}
+export {};