@webority/ui-elements 0.148.0 → 0.150.0

package/types/WuiDatePicker.d.ts

@@ -0,0 +1,59 @@
+import { ElementBase } from "./elementBase.ts";
+type DateParts = {
+    y: number;
+    m: number;
+    d: number;
+};
+interface DayLimits {
+    dayDisabled(y: number, m: number, d: number): boolean;
+    monthDisabled(y: number, m: number): boolean;
+    yearDisabled(y: number): boolean;
+}
+export declare class WuiDatePicker extends ElementBase {
+    static formAssociated: boolean;
+    static get observedAttributes(): string[];
+    _internals: ElementInternals | null;
+    _value: string;
+    _defaultValue?: string;
+    _rendered?: boolean;
+    _viewY: number;
+    _viewM: number;
+    _mode: string | undefined;
+    _focus: DateParts | null;
+    _slide: string;
+    _viewNavigated?: boolean;
+    _openFn?: () => void;
+    _closeFn?: () => void;
+    _bindGlobal?: () => void;
+    _onKeyBound?: (e: KeyboardEvent) => void;
+    _onDocClick?: ((e: MouseEvent) => void) | null;
+    _onDocKey?: ((e: KeyboardEvent) => void) | null;
+    _onHostKey?: ((e: KeyboardEvent) => void) | null;
+    get _open(): () => void;
+    get _close(): () => void;
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, val: string | null): void;
+    _syncInvalid(): void;
+    formResetCallback(): void;
+    get value(): string;
+    set value(v: string | null | undefined);
+    _firstDay(): number;
+    render(): void;
+    _syncFormValue(): void;
+    _syncTrigger(): void;
+    _limits(): DayLimits;
+    _renderView(): void;
+    _daysHtml(): string;
+    _monthsHtml(): string;
+    _yearsHtml(): string;
+    _focusActive(): void;
+    _position(trigger: HTMLElement, pop: HTMLElement): void;
+    _setFocus(y: number, m: number, d: number, slide?: string): void;
+    _seek(y: number, m: number, d: number, step: number): Date | null;
+    _onKey(e: KeyboardEvent): void;
+    _wire(): void;
+    _teardown(): void;
+    disconnectedCallback(): void;
+}
+export {};

package/types/WuiDateRange.d.ts

@@ -0,0 +1,61 @@
+import type { Preset } from "./datePresets.ts";
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiDateRange extends ElementBase {
+    static formAssociated: boolean;
+    _internals: ElementInternals | null;
+    _start: string;
+    _end: string;
+    _hover: string;
+    _viewY: number;
+    _viewM: number;
+    _rendered: boolean | undefined;
+    _defaultStart: string | undefined;
+    _defaultEnd: string | undefined;
+    _presetList: Preset[] | undefined;
+    _bindGlobal: (() => void) | undefined;
+    _open: () => void;
+    _close: () => void;
+    _onDocClick: ((e: MouseEvent) => void) | null | undefined;
+    _onDocKey: ((e: KeyboardEvent) => void) | null | undefined;
+    _onHostKey: ((e: KeyboardEvent) => void) | null | undefined;
+    _reanchor?: (() => void) | null;
+    _reanchorScroll?: ((e: Event) => void) | null;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, _val: string | null): void;
+    _syncInvalid(): void;
+    get value(): {
+        start: string;
+        end: string;
+    };
+    set value(v: {
+        start: string;
+        end: string;
+    } | null | undefined);
+    _firstDay(): number;
+    _label(): {
+        text: string;
+        empty: boolean;
+    };
+    render(): void;
+    formResetCallback(): void;
+    _syncTrigger(): void;
+    _syncMirrors(): void;
+    _mirror(kind: "start" | "end", name: string | null, val: string): void;
+    _limits(): (y: number, m: number, d: number) => boolean;
+    _monthHtml(y: number, m: number): string;
+    _presetOptions(): {
+        timeZone: string;
+        financialYearStart: number;
+    };
+    _presetsHtml(): string;
+    _renderView(): void;
+    _paint(): void;
+    _position(trigger: HTMLElement, pop: HTMLElement): void;
+    _pick(iso: string): void;
+    _applyPreset({ start, end }: Preset): void;
+    _wire(): void;
+    _teardown(): void;
+    disconnectedCallback(): void;
+}

package/types/WuiDock.d.ts

@@ -0,0 +1,20 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiDock extends ElementBase {
+    private _pointerMoveListener;
+    private _pointerLeaveListener;
+    private _frame;
+    private _pointerX;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, _val: string | null): void;
+    _maxScale(): number;
+    _radius(): number;
+    _magnifyEnabled(): boolean;
+    /** Distance-based magnification for one frame's pointer position. */
+    _applyMagnification(): void;
+    _resetMagnification(): void;
+    _wire(): void;
+    _teardown(): void;
+}

package/types/WuiDrawer.d.ts

@@ -0,0 +1,65 @@
+import { ElementBase } from "./elementBase.ts";
+interface DragState {
+    grip: HTMLElement;
+    id: number;
+    startY: number;
+    lastY: number;
+    lastT: number;
+    velocity: number;
+    moved: boolean;
+    offset?: number;
+}
+export declare class WuiDrawer extends ElementBase {
+    _doc: Document | null;
+    _media: MediaQueryList | null;
+    _shown: boolean;
+    _locked: boolean;
+    _opener: HTMLElement | SVGElement | null;
+    _snap: number;
+    _drag: DragState | null;
+    _onMedia: () => void;
+    _onClick: (e: MouseEvent) => void;
+    _onPointerDown: (e: PointerEvent) => void;
+    _onPointerMove: (e: PointerEvent) => void;
+    _onPointerUp: (e: PointerEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onHostKey: (e: KeyboardEvent) => void;
+    _onTransitionEnd: (e: TransitionEvent) => void;
+    _announced: boolean;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    get isOpen(): boolean;
+    /** Opens the drawer; `opener` is the control focus returns to (defaults to the focused one). */
+    show(opener?: HTMLElement): void;
+    /** Closes the drawer without asking. */
+    hide(): void;
+    _points(): number[];
+    _sheet(): boolean;
+    _syncMode(): void;
+    _applyPoints(): void;
+    _setSnap(index: number): void;
+    _open(): void;
+    _close(): void;
+    _settle(): void;
+    _announce(): void;
+    _release(): void;
+    _document(): Document;
+    _panel(): HTMLElement | null;
+    _focusables(): HTMLElement[];
+    _focusIn(): void;
+    _dismissible(): boolean;
+    _requestClose(): boolean;
+    _click(e: MouseEvent): void;
+    _keyDown(e: KeyboardEvent): void;
+    _trapTab(e: KeyboardEvent): void;
+    _handleKey(e: KeyboardEvent): void;
+    _pointerDown(e: PointerEvent): void;
+    _viewport(): number;
+    _pointerMove(e: PointerEvent): void;
+    _pointerUp(e: PointerEvent): void;
+    _endDrag(): void;
+}
+export {};

package/types/WuiFileViewer.d.ts

@@ -0,0 +1,111 @@
+import { ElementBase } from "./elementBase.ts";
+import type { MediaPrefs } from "./fileViewerMedia.ts";
+import type { PdfPrefs } from "./fileViewerPdf.ts";
+export type FileKind = "pdf" | "image" | "video" | "audio";
+type FileViewerPrefs = PdfPrefs & MediaPrefs;
+interface ViewShell {
+    host: WuiFileViewer;
+    start: HTMLElement;
+    center: HTMLElement;
+    end: HTMLElement;
+    search: HTMLElement;
+    body: HTMLElement;
+    prefs: FileViewerPrefs;
+    name: () => string;
+    print: () => boolean;
+    savePrefs: (changes: Partial<FileViewerPrefs>) => void;
+    loaded: (detail: {
+        kind: string;
+        pages: number;
+    }) => void;
+    fail: (error: unknown) => void;
+}
+interface FileView {
+    load(): void | Promise<void>;
+    destroy(): void;
+    seekTo?: (seconds: number) => void;
+}
+interface FileViewerParts {
+    toolbar: HTMLElement;
+    start: HTMLElement;
+    name: HTMLElement;
+    center: HTMLElement;
+    end: HTMLElement;
+    viewEnd: HTMLElement;
+    downloadLink: HTMLAnchorElement;
+    fullscreen: HTMLButtonElement;
+    actionsBox: HTMLElement;
+    search: HTMLElement;
+    body: HTMLElement;
+}
+/** The kind of viewer a file needs, from its MIME type, else its extension: "pdf", "image", "video", "audio" or null. */
+export declare function fileKind(type?: string | null, name?: string | null): FileKind | null;
+export declare function fileNameFromUrl(src: string | null | undefined): string;
+export declare class WuiFileViewer extends ElementBase {
+    /** The asset-base used when the attribute is not set; the browser build sets it. */
+    static defaultAssetBase: string;
+    static get observedAttributes(): string[];
+    uid: string;
+    _prefs: FileViewerPrefs;
+    _hostPrefs: boolean | undefined;
+    _onFullscreen: () => void;
+    _view: FileView | null | undefined;
+    _loadId: number | undefined;
+    _actionsBox: HTMLElement | undefined;
+    _parts: FileViewerParts;
+    constructor();
+    get src(): string;
+    set src(v: string | null | undefined);
+    get name(): string;
+    set name(v: string | null | undefined);
+    get type(): string;
+    set type(v: string | null | undefined);
+    get viewKey(): string;
+    set viewKey(v: string | null | undefined);
+    get download(): boolean;
+    set download(v: boolean | string);
+    get print(): boolean;
+    set print(v: boolean | string);
+    get workerSrc(): string;
+    set workerSrc(v: string | null | undefined);
+    get captions(): string;
+    set captions(v: string | null | undefined);
+    get assetBase(): string;
+    set assetBase(v: string | null | undefined);
+    /** The current view settings. Setting them hands storage to the host (see the header). */
+    get prefs(): FileViewerPrefs;
+    set prefs(v: FileViewerPrefs | null | undefined);
+    /** The toolbar box holding the host's own controls (slot="actions"). */
+    get actionsContainer(): HTMLElement | null;
+    /**
+     * Moves an open video or audio file to `seconds` from its start, kept within its length, and
+     * returns true. With no video or audio open (no file, another kind of file, or the player's
+     * code still loading: call it from the load event to be sure) it does nothing and returns false.
+     * @param seconds
+     * @returns
+     */
+    seekTo(seconds: number): boolean;
+    /** The name shown and used for print and download. */
+    displayName(): string;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(attr: string, oldValue: string | null, newValue: string | null): void;
+    _close(): void;
+    _open(): Promise<void>;
+    _shell(loadId: number | undefined): ViewShell;
+    _render(): void;
+    _syncDownload(): void;
+    _syncPrint(): void;
+    _status(message: string, { offerDownload }?: {
+        offerDownload?: boolean;
+    }): void;
+    _settle(message: string, options?: {
+        offerDownload?: boolean;
+    }): void;
+    _fail(error: unknown): void;
+    toggleFullscreen(): void;
+    _syncFullscreen(): void;
+    _readPrefs(): FileViewerPrefs;
+    _savePrefs(changes: Partial<FileViewerPrefs>): void;
+}
+export {};

package/types/WuiHoverCard.d.ts

@@ -0,0 +1,29 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiHoverCard extends ElementBase {
+    _doc: Document | null;
+    _timer: ReturnType<typeof setTimeout> | null;
+    _described: HTMLElement | null;
+    _refocusing: boolean;
+    _onOver: (e: PointerEvent) => void;
+    _onOut: (e: PointerEvent) => void;
+    _onFocusIn: (e: FocusEvent) => void;
+    _onFocusOut: (e: FocusEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    get isOpen(): boolean;
+    connectedCallback(): void;
+    attributeChangedCallback(): void;
+    disconnectedCallback(): void;
+    get _trigger(): HTMLElement | null;
+    get _panel(): HTMLElement | null;
+    get _anchor(): HTMLElement | null;
+    _zone(node: EventTarget | null): "panel" | "trigger" | null;
+    _delay(attribute: string, fallback: number): number;
+    _clear(): void;
+    _syncOpen(): void;
+    _schedule(open: boolean): void;
+    _setOpen(open: boolean): void;
+    _reposition(): void;
+    _describe(panel: HTMLElement): void;
+}

package/types/WuiImageCrop.d.ts

@@ -0,0 +1,119 @@
+import { ElementBase } from "./elementBase.ts";
+import { parseAspect } from "./imageCrop.ts";
+export interface CropRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface CropSize {
+    w: number;
+    h: number;
+}
+export interface CropPoint {
+    x: number;
+    y: number;
+}
+export interface CropDrag {
+    id: number;
+    corner: string | null | undefined;
+    x: number;
+    y: number;
+    start: CropRect;
+}
+export interface CropPinch {
+    distance: number;
+    zoom: number;
+    done: boolean;
+}
+export interface CropOutputOptions {
+    type?: string;
+    maxBytes?: number;
+    size?: number;
+}
+export interface CropFileOptions extends CropOutputOptions {
+    name?: string;
+}
+export interface CropView {
+    scale: number;
+    left: number;
+    top: number;
+    iw: number;
+    ih: number;
+}
+export declare class WuiImageCrop extends ElementBase {
+    _rect: CropRect | null;
+    _base: CropRect | null;
+    _natural: CropSize | null;
+    _source: CropSize | null;
+    _rotation: number;
+    _drag: CropDrag | null;
+    _pointers: Map<number, CropPoint>;
+    _pinch: CropPinch | null;
+    _previewPending: boolean;
+    _resizeObserver: ResizeObserver | null;
+    _rendered?: boolean;
+    _stageEl: HTMLElement | null;
+    _imgEl: HTMLImageElement | null;
+    _frameEl: HTMLElement | null;
+    _sliderEl: HTMLInputElement | null;
+    _toolsEl: HTMLElement | null;
+    _previewBoxEl: HTMLElement | null;
+    _liveEl: HTMLElement | null;
+    static get observedAttributes(): string[];
+    constructor();
+    get _stage(): HTMLElement;
+    get _img(): HTMLImageElement;
+    get _frame(): HTMLElement;
+    get _slider(): HTMLInputElement;
+    get _tools(): HTMLElement;
+    get _previewBox(): HTMLElement;
+    get _live(): HTMLElement;
+    get src(): string;
+    set src(v: string | null | undefined);
+    get aspect(): ReturnType<typeof parseAspect>;
+    set aspect(v: number | string | null | undefined);
+    get round(): boolean;
+    set round(v: boolean);
+    get rotatable(): boolean;
+    set rotatable(v: boolean);
+    get previews(): string;
+    set previews(v: string | number[] | null | undefined);
+    get rect(): CropRect | null;
+    get rotation(): number;
+    set rotation(v: number | string);
+    get zoom(): number;
+    set zoom(v: number | string);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    render(): void;
+    _applyRound(): void;
+    _rebuildHandles(): void;
+    _renderPreviews(): void;
+    _loadImage(): void;
+    _resetRect(): void;
+    _observe(): void;
+    _view(): CropView;
+    _paint(): void;
+    _schedulePreviews(): void;
+    _drawPreviews(): void;
+    _drawCrop(ctx: CanvasRenderingContext2D, r: CropRect, w: number, h: number): void;
+    _announce(): void;
+    _say(): void;
+    /** Turn the image a quarter clockwise. A square or free frame keeps covering the same part. */
+    rotate(): void;
+    /** Back to the picture as loaded: no turn, the largest frame, zoom 1. */
+    reset(): void;
+    _wire(): void;
+    _onKey(e: KeyboardEvent): void;
+    /**
+     * Render the crop to a Blob of the asked image type (PNG when a canvas cannot encode it), kept
+     * under `maxBytes` by lowering JPEG/WEBP quality and then the pixel size. `size` makes the
+     * longest side exactly that many pixels, scaled up or down; without it the crop keeps its own
+     * pixels, capped at 4096. Resolves null when there is no image yet or the canvas cannot encode.
+     */
+    toBlob({ type, maxBytes, size }?: CropOutputOptions): Promise<Blob | null>;
+    /** The crop as a File named after the original, for a form or an upload. */
+    toFile({ name, type, maxBytes, size }?: CropFileOptions): Promise<File | null>;
+}

package/types/WuiInlineEdit.d.ts

@@ -0,0 +1,65 @@
+import { ElementBase } from "./elementBase.ts";
+import { type InlineEditFailedDetail, type InlineEditSavedDetail, type InlineEditType } from "./inlineEditText.ts";
+import { type HttpKind } from "./server/wuiHttp.ts";
+type SaveOutcome = {
+    ok: true;
+    text?: string;
+} | {
+    ok: false;
+    kind: HttpKind;
+    message: string;
+};
+interface ShownSnapshot {
+    html: string;
+    empty: boolean;
+}
+type InlineEditControl = HTMLElement & {
+    value: string;
+    select?: () => void;
+};
+export declare class WuiInlineEdit extends ElementBase {
+    _wired: boolean;
+    _editing: boolean;
+    _busy: boolean;
+    _draft: string | null;
+    _pressed: boolean;
+    _popupOpen: boolean;
+    _savedTimer: ReturnType<typeof setTimeout> | null;
+    /** Set by the page in controlled mode, to be awaited on save. */
+    save?: (next: string) => Promise<void> | void;
+    /** Set by the page, to return a refusal message for a value, or null to accept it. */
+    validate?: (next: string) => string | null;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /** Open the control, unless disabled or saving. */
+    edit(): void;
+    /** Close the control and keep the value as it was. */
+    cancel(): void;
+    _onClick(e: Event): void;
+    _onKeyCapture(): void;
+    _onKeyDown(e: KeyboardEvent): void;
+    _onFocusOut(e: FocusEvent): void;
+    _onPointerDown(): void;
+    _onPointerUp(): void;
+    _releasePress(): void;
+    _onChange(e: Event): void;
+    _commit(next: string): Promise<void>;
+    _persist(next: string, controlled: boolean): Promise<SaveOutcome>;
+    _close(): void;
+    _focusControl(control: InlineEditControl): void;
+    _showValue(value: string): void;
+    _readShown(): ShownSnapshot | null;
+    _restoreShown(shown: ShownSnapshot): void;
+    _showText(text: string, empty: boolean): void;
+    _setError(message: string | null): void;
+    _setState(state: string | null): void;
+    _announce(message: string | null): void;
+    _fire(type: string, detail: InlineEditSavedDetail | InlineEditFailedDetail): void;
+    _control(): InlineEditControl | null;
+    _value(): string;
+    _type(): InlineEditType;
+}
+export {};

package/types/WuiLeadPopup.d.ts

@@ -0,0 +1,83 @@
+import { ElementBase } from "./elementBase.ts";
+type FieldKey = "name" | "email" | "phone" | "company" | "message" | "consent";
+type TriggerName = "exit" | "delay" | "scroll" | "pages";
+type FailureReason = "gate" | "network" | "server";
+type CloseReason = "escape" | "backdrop" | "dismiss" | "submitted" | "secondary";
+type MemoryState = "shown" | "submitted";
+interface SessionRecord {
+    start: number;
+    maxScroll: number;
+    pages: string[];
+}
+interface MemoryRecord {
+    state: MemoryState;
+    at: string;
+}
+export declare class WuiLeadPopup extends ElementBase {
+    _uid: string;
+    _rendered: boolean;
+    _open: boolean;
+    _opened: boolean;
+    _posting: boolean;
+    _stale: boolean;
+    _armed: boolean;
+    _session: SessionRecord | null;
+    _returnTo: HTMLElement | SVGElement | null;
+    _prevOverflow: string;
+    _delayTimer: ReturnType<typeof setTimeout> | null;
+    _closeTimer: ReturnType<typeof setTimeout> | null;
+    _modal?: boolean;
+    _onMouseLeave: (e: MouseEvent) => void;
+    _onVisibility: () => void;
+    _onScroll: () => void;
+    static get observedAttributes(): string[];
+    constructor();
+    get isOpen(): boolean;
+    set isOpen(value: boolean);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    /** Opens the popup. A trigger opens it once per page load and only when memory allows; "manual" always opens. */
+    open(trigger?: TriggerName | "manual"): void;
+    /** Closes the popup and returns focus to the element that had it. */
+    close(reason?: CloseReason): void;
+    _release(): void;
+    _root(): ShadowRoot;
+    _dialog(): HTMLDialogElement;
+    _emit(name: string, detail: unknown): void;
+    _text(name: string, fallback?: string): string;
+    _number(name: string, fallback: number): number;
+    get preview(): boolean;
+    set preview(v: boolean | string);
+    _fieldKeys(): FieldKey[];
+    _requiredKeys(): FieldKey[];
+    _label(key: FieldKey | "consentLink"): string;
+    _postedName(key: FieldKey): string;
+    _maxLength(key: FieldKey): number | undefined;
+    _triggers(): TriggerName[];
+    _render(): void;
+    _fieldMarkup(key: FieldKey, required: boolean): string;
+    _wire(): void;
+    _showForm(): void;
+    _showSuccess(): void;
+    _setFieldError(key: FieldKey, message: string): HTMLElement;
+    _validate(): Record<string, string | boolean> | null;
+    _setBusy(busy: boolean): void;
+    _fail(reason: FailureReason, message: string): void;
+    _onSubmit(event: Event): Promise<void>;
+    _post(values: Record<string, string | boolean>): Promise<void>;
+    _readJson(response: Response): Promise<unknown | null>;
+    _succeed(values: Record<string, string | boolean>, body: unknown): void;
+    _arm(): void;
+    _disarm(): void;
+    _trackScroll(): void;
+    _fine(): boolean;
+    _engaged(): boolean;
+    _sessionKey(): string;
+    _loadSession(): SessionRecord;
+    _saveSession(): void;
+    _readMemory(): MemoryRecord | null;
+    _blocked(): boolean;
+    _remember(state: MemoryState): void;
+}
+export {};

package/types/WuiLightbox.d.ts

@@ -0,0 +1,80 @@
+import { ElementBase } from "./elementBase.ts";
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+interface LightboxItem {
+    link: HTMLAnchorElement;
+    src: string;
+    alt: string;
+    caption: string;
+    name: string;
+}
+/** Keeps a zoom factor inside the range the lightbox allows. */
+export declare function clampZoom(zoom: number): number;
+/**
+ * Keeps a pan inside the zoomed image: it may not slide further than the edge of the stage
+ * reaches. An axis where the zoomed image is smaller than the stage does not pan.
+ * @param pan
+ * @param zoom
+ * @param stage  The visible box.
+ * @param image  The image's size at zoom 1.
+ */
+export declare function clampPan(pan: Point, zoom: number, stage: Size, image: Size): Point;
+/** +1 (next) or -1 (previous) for a sideways swipe long enough and flat enough, else 0. */
+export declare function swipeStep(dx: number, dy: number): number;
+export declare class WuiLightbox extends ElementBase {
+    private _ui;
+    private _index;
+    private _zoom;
+    private _pan;
+    private _pointers;
+    private _gesture;
+    private _lastTap;
+    private _returnTo;
+    private _lockedOverflow;
+    private _onClick;
+    static get observedAttributes(): string[];
+    constructor();
+    private get _view();
+    get download(): boolean;
+    set download(v: unknown);
+    get label(): string;
+    set label(v: unknown);
+    get layout(): "gallery" | "single";
+    set layout(v: unknown);
+    get isOpen(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    _syncOpenIndex(): void;
+    _links(): HTMLAnchorElement[];
+    _items(): LightboxItem[];
+    /**
+     * Opens the dialog on the image at `index`.
+     * @param index
+     * @returns false when the gallery has no image.
+     */
+    open(index?: number): boolean;
+    close(): void;
+    _teardown(): void;
+    _build(): void;
+    /** Shows the image after (+1) or before (-1) the current one, wrapping at the ends. */
+    step(delta: number): void;
+    _show(index: number, items: LightboxItem[]): void;
+    _syncZoomButtons(): void;
+    _setZoom(zoom: number): void;
+    _clampedPan(pan: Point): Point;
+    _applyTransform(): void;
+    _onKeyDown(e: KeyboardEvent): void;
+    _trapTab(e: KeyboardEvent): void;
+    _onWheel(e: WheelEvent): void;
+    _onPointerDown(e: PointerEvent): void;
+    _onPointerMove(e: PointerEvent): void;
+    _onPointerEnd(e: PointerEvent, completed: boolean): void;
+}
+export {};