/**
 * pacem v0.51.10-faraday (https://js.pacem.it)
 * Copyright 2025 Pacem (https://pacem.it)
 * Licensed under Apache-2.0
 */
declare namespace Pacem.Components.UI {
    enum AdapterOrientation {
        Vertical = "vertical",
        Horizontal = "horizontal"
    }
    interface AdapterPageButtonRefreshEventArgs {
        index: number;
        hide: boolean;
        disabled: boolean;
        content: string | Node;
    }
    const AdapterPageButtonRefreshEventName = "pagerefresh";
    class AdapterPageButtonRefreshEvent extends CustomEvent<AdapterPageButtonRefreshEventArgs> {
        constructor(args: AdapterPageButtonRefreshEventArgs);
    }
    class PacemAdapterElement extends PacemAdapter<PacemIterativeElement<any>, any> {
        private _repeater;
        private _prevBtn;
        private _nextBtn;
        private _panel;
        private _swiper;
        private _liPause;
        masterPropertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _previousTabIndex;
        initializeCallback(): void;
        destroyCallback(): void;
        itemPropertyChangedCallback(index: number, name: string, old: any, val: any, first?: boolean): void;
        private _itemCreatedHandler;
        private _pageMap;
        private _fireAdapterPageRefreshCallback;
        private _tickVersion;
        private _handle;
        pausable: boolean;
        interval: number;
        orientation: AdapterOrientation;
        interactive: boolean;
        /** Gets or sets whether swipe gesture is enabled for navigation (also depends on the 'interactive' flag being set to 'true') */
        swipeEnabled: boolean;
        /** Gets or sets whether, by selecting twice an item, you will de-select it and obtain an overall unselected state. */
        deselectable: boolean;
        loop: boolean;
        labelCallback: (item: any, index: number) => string | Node;
        private _index;
        private _paused;
        private _v;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _syncViewWithItems;
        private _toggle;
        private _resetTimer;
        private _next;
        private _previous;
        private _select;
        private _itemRegisterHandler;
        private _itemUnregisterHandler;
        private _keydownHandler;
        private _isDisabled;
        private _isHidden;
        private _disableOrHide;
        private _labelCallback;
    }
}
declare namespace Pacem.Components.UI {
    class PacemAnchorElement extends PacemElement implements Pacem.Net.OAuthFetchable {
        fetchCredentials: RequestCredentials;
        fetchHeaders: {
            [key: string]: string;
        };
        constructor();
        href: string;
        target: string;
        download: string | boolean;
        router: PacemRouterElement;
        private _fetching;
        get fetching(): boolean;
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected emit(evt: Event): void;
        private _download;
    }
}
declare namespace Pacem.Components.UI {
    type ElementOrPoint = Element | Point;
    const ElementOrPointPropertyConverter: PropertyConverter;
}
declare namespace Pacem.Components.UI {
    enum BalloonBehavior {
        Menu = "menu",
        Tooltip = "tooltip",
        Inert = "inert"
    }
    enum BalloonTrigger {
        Hover = "hover",
        Click = "click",
        ContextMenu = "contextmenu",
        Focus = "focus"
    }
    enum BalloonAlignment {
        Start = "start",
        Center = "center",
        End = "end",
        Auto = "auto"
    }
    enum BalloonPosition {
        Top = "top",
        Left = "left",
        Bottom = "bottom",
        Right = "right",
        Auto = "auto",
        HorizontalAuto = "x",
        VerticalAuto = "y"
    }
    enum BalloonSizing {
        Auto = "auto",
        Match = "match"
    }
    const BalloonPopupEventName = "popup";
    const BalloonPopoutEventName = "popout";
    type BalloonOptions = {
        trigger?: BalloonTrigger;
        position?: BalloonPosition;
        size?: BalloonSizing;
        behavior?: BalloonBehavior;
        verticalOffset?: number;
        horizontalOffset?: number;
        track?: boolean;
        /** @deprecated Just use 'track' instead. */
        'trackPosition'?: boolean;
        /** @deprecated Use <pacem-shell-proxy> to wrap the balloon. */
        'moveToRoot'?: boolean;
        hoverDelay?: number;
        hoverTimeout?: number;
        align?: BalloonAlignment;
        /** Optimizes the start- and end-alignments in case of tiny targets. */
        autoAdjust?: boolean;
    };
    class PacemBalloonElement extends PacemElement {
        private _timer;
        private _visible;
        private _options;
        private _originalNeighborhood;
        private _container;
        private _resize;
        private _position;
        target: ElementOrPoint;
        options: BalloonOptions;
        /** Gets whether the balloon is open and visible. */
        get visible(): boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _synchronizeOptions;
        private _ensurePopup;
        private _destroyPopup;
        private _registerEvents;
        private _unregisterEvents;
        private _onLayoutChange;
        private _adjust;
        private _adjustWatchers;
        /**
         * Shows the balloon, if hidden.
         */
        popup(delay?: number): void;
        private _popoutDelegate;
        /**
         * Hides the balloon, if visible.
         */
        popout(delay?: number): void;
        /**
         * Shows the balloon, if hidden. Otherwise hides it.
         */
        toggle(delay?: number): void;
        private _hoverDelegate;
        private _outConditionalDelegate;
        private _mousedownConditionalDelegate;
        private _outDelegate;
        private _toggleDelegate;
        private _removeHandlers;
        private _setHandlers;
    }
}
declare namespace Pacem.Components.UI {
    export enum BinderAnchor {
        Auto = "auto",
        Left = "left",
        Top = "top",
        Right = "right",
        Bottom = "bottom",
        Center = "center"
    }
    export enum BinderEnd {
        Default = "default",
        Arrow = "arrow",
        FatArrow = "fatarrow",
        None = "none"
    }
    export enum BinderTension {
        Mass = "mass",
        Path = "path"
    }
    export const BinderInteractionEventName = "interact";
    export class BinderInteractionEvent extends CustomUIEvent<null> {
        constructor(orig: MouseEvent | KeyboardEvent | TouchEvent);
    }
    type PacemBinderTarget = ElementOrPoint;
    export class PacemBinderElement extends PacemElement {
        from: PacemBinderTarget;
        to: PacemBinderTarget;
        fromAnchor: BinderAnchor;
        toAnchor: BinderAnchor;
        fromEnd: BinderEnd;
        toEnd: BinderEnd;
        tension: BinderTension;
        color: string;
        interactive: boolean;
        connectedCallback(): void;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _broadcastHandler;
        disconnectedCallback(): void;
        private _setPathVisibility;
        private _ensurePath;
        invalidateSize(): void;
        private _path;
        private _svg;
        private _state;
        private _computeAnchorPoints;
        refresh(element: PacemBinderTarget, args?: ResizeEventArgs): void;
        private _draw;
        private _getDefaultEndingPath;
        private _getArrowEndingPath;
        private _getFatArrowEndingPath;
    }
    export {};
}
declare namespace Pacem.Components.UI {
    class PacemBladeElement extends PacemElement {
        open: boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _toggle;
    }
}
declare namespace Pacem.Components.UI {
    class PacemButtonElement extends PacemIterableElement {
        constructor();
        iconGlyph: string;
        iconUrl: string;
        commandName: string;
        commandArgument: any;
        confirmationMessage: string;
        confirmationDialog: PacemDialogBase;
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected emit(evt: Event): void;
    }
}
declare namespace Pacem.Components.UI {
    class PacemButtonsetElement extends PacemIterativeElement<PacemButtonElement> {
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        validate(item: any): item is PacemButtonElement;
    }
}
declare namespace Pacem.Components.UI {
    export enum CalendarZoom {
        Month = "month",
        Week = "week",
        Day = "day"
    }
    export class ViewDateChangeEvent extends CustomTypedEvent<Date> {
        constructor(date: Date);
    }
    export class DateSelectEvent extends CustomTypedEvent<Date> {
        constructor(date: Date);
    }
    export class TimeSelectEvent extends CustomTypedEvent<Date> {
        constructor(date: Date);
    }
    type CalendarDataItem = {
        continuing: {
            start: boolean;
            end: boolean;
        };
        allDay?: boolean;
        day?: number;
        hour?: number;
        span: number;
        caption: string;
        offset?: {
            start: string;
            end: string;
        };
        event: PacemCalendarEventElement;
    };
    export type DateRange = {
        from?: Date;
        to?: Date;
    };
    export class PacemCalendarEventElement extends PacemItemElement {
        start: Date;
        end: Date;
        caption: string;
        place: string;
        allDay: boolean;
        private _handle;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    type CalendarEventEventArgs = {
        event: PacemCalendarEventElement;
        element: HTMLElement;
    };
    export class CalendarEventSelectEvent extends CustomTypedEvent<CalendarEventEventArgs> {
        constructor(args: CalendarEventEventArgs);
    }
    export class CalendarEventUnselectEvent extends CustomTypedEvent<CalendarEventEventArgs> {
        constructor(args: CalendarEventEventArgs);
    }
    export abstract class PacemCalendarBaseElement extends PacemItemsContainerElement<PacemCalendarEventElement> {
        validate(item: PacemCalendarEventElement): boolean;
        viewDate: Date;
        now: Date;
        zoom: CalendarZoom;
        weekStart: 'mon' | 'sun' | 'm' | 's' | 'monday' | 'sunday';
        week: Date[];
        month: Date[][];
        disabledRanges: DateRange[];
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected oneventselect(el: HTMLElement, evt: PacemCalendarEventElement): void;
        protected oneventunselect(el: HTMLElement, evt: PacemCalendarEventElement): void;
        protected getHeaderLabel(d: Date, f: CalendarZoom): string;
        protected getDayLabel(d: Date): string;
        protected getHourLabel(d: Date): string;
        protected getTimeLabel(d: Date): string;
        protected isNow(d: Date, now: Date): boolean;
        protected isToday(d: Date, now: Date): boolean;
        protected isViewDay(d: Date, vd?: Date): boolean;
        protected isDate(expected: Date, d: Date): boolean;
        protected isViewWeek(d: Date): Date;
        protected isViewMonth(d: Date): boolean;
        protected isTimeSlotDisabled(ranges: DateRange[], d: Date, h?: number): boolean;
        private _getWeekStart;
        private _getDatasource;
        private _synchronizeWeek;
    }
    export abstract class PacemCalendarWithEventsBaseElement extends PacemCalendarBaseElement {
        private _datasource;
        private _handle;
        get datasource(): CalendarDataItem[][];
        private _getSortedItems;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected abstract buildDataSource(items: PacemCalendarEventElement[]): CalendarDataItem[][];
    }
    export class PacemAgendaElement extends PacemCalendarWithEventsBaseElement {
        protected buildDataSource(items: PacemCalendarEventElement[]): CalendarDataItem[][];
        private _clock;
        time: Date;
        private _allDayDatasource;
        get allDayDatasource(): CalendarDataItem[];
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    export class PacemCalendarElement extends PacemCalendarWithEventsBaseElement {
        protected buildDataSource(items: PacemCalendarEventElement[]): CalendarDataItem[][];
        date: Date;
        /** Gets or sets the format for the first day of each month. */
        dayLabelFormatter: (d: Date) => string;
        private _formatVersion;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _setDate;
        protected getDayLabel(d: Date, _?: number): string;
    }
    export class PacemClockElement extends PacemElement {
        now: Date;
    }
    export class PacemScheduleElement extends PacemCalendarBaseElement {
        private _calendar;
        private _agenda;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
    }
    export abstract class PacemCalendarRuleBaseElement extends HTMLElement {
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _target;
        protected get target(): PacemCalendarBaseElement;
        private _disabledRanges;
        protected refreshDisabledRanges(): void;
        protected abstract computeDisabledRanges(): DateRange[];
    }
    export class PacemCalendarDayOfWeekRuleElement extends PacemCalendarRuleBaseElement {
        days: string[];
        viewActivatedCallback(): void;
        private _daysOfWeek;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _calendarChangeHandler;
        protected computeDisabledRanges(): DateRange[];
    }
    export {};
}
declare namespace Pacem.Components.UI {
    class PacemCollapseElement extends PacemEventTarget {
        #private;
        collapse: boolean;
        horizontal: boolean;
        private _resizer;
        private _container;
        private _resizeHandler;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _toggle;
    }
}
declare namespace Pacem.Components.UI {
    enum DialogButtons {
        YesNo = "yesno",
        YesNoCancel = "yesnocancel",
        Ok = "ok",
        OkCancel = "okcancel"
    }
    enum DialogButton {
        Yes = "yes",
        No = "no",
        Cancel = "cancel",
        Ok = "ok"
    }
    type DialogResultEventArgs = {
        button: DialogButton;
        state?: any;
    };
    const DialogResultEventName = "commit";
    class DialogResultEvent extends CustomTypedEvent<DialogResultEventArgs> {
        constructor(args: DialogResultEventArgs);
    }
    abstract class PacemDialogBase extends PacemElement {
        /** Gets the current state/datacontext of the dialog.
         * It is automatically destroyed when the dialog closes.
         * (It has not to be set declaratively.) */
        state: any;
        protected abstract get lightbox(): PacemLightboxElement;
        private _deferred;
        open(state?: any): Promise<DialogResultEventArgs>;
        protected commit(btn: DialogButton, evt: Event): void;
    }
    class PacemDialogElement extends PacemDialogBase {
        buttons: DialogButtons;
        okCaption: string;
        yesCaption: string;
        noCaption: string;
        cancelCaption: string;
        private _buttons;
        protected lightbox: PacemLightboxElement;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        open(state?: any): Promise<DialogResultEventArgs>;
        viewActivatedCallback(): void;
        /** Gets the 'ok', 'yes', 'no' and 'cancel' dialog buttons. */
        get dialogButtons(): {
            ok: Element;
            yes: Element;
            no: Element;
            cancel: Element;
        };
    }
}
declare namespace Pacem.Components.UI {
    class PacemDividerElement extends PacemElement {
        constructor();
        orientation: 'vertical' | 'horizontal';
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _syncOrientation;
    }
}
declare namespace Pacem.Components.UI {
    class PacemIconElement extends PacemElement {
        constructor();
        icon: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _setIcon;
    }
}
declare namespace Pacem.Components.UI {
    class PacemImageElement extends PacemElement {
        constructor();
        adapt: 'cover' | 'contain' | 'auto';
        src: string;
        size: {
            width: number;
            height: number;
            weight?: number;
        };
        loading: boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _setLayout;
        private _setSource;
    }
}
declare namespace Pacem.Components.UI {
    class PacemInfiniteScrollerElement extends PacemEventTarget {
        constructor();
        container: string | HTMLElement;
        threshold: number;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        setInfiniteScrollContainer(v?: string | HTMLElement): void;
        private _scrollDelegate;
        private _enabled;
        private _viewportHeight;
        private _innerHeight;
        private _isDocument;
        private _container;
        private _viewport;
        private _scroller;
        private _bottomGap;
        private _emitFetchMore;
        private _doScroll;
        private _computeHeight;
    }
}
declare namespace Pacem.Components.UI {
    abstract class PacemAdaptedIterativeElement<TItem> extends PacemElement {
        protected abstract get adapter(): PacemAdapterElement;
        index: number;
        datasource: TItem[];
        protected isCloseTo(ndx: number, focusndx: number): boolean;
        protected isPrevious(ndx: number, focusndx: number): boolean;
        protected isNext(ndx: number, focusndx: number): boolean;
        private _isNextCore;
        private _isPreviousCore;
        private _isCloseToCore;
    }
}
declare namespace Pacem.Components.UI {
    enum LightboxBehavior {
        ClickOutsideClose = "clickOutsideClose",
        ExplicitClose = "explicitClose"
    }
    class PacemLightboxElement extends PacemElement {
        #private;
        private _keyupHandler;
        private _wrapperMousedownHandler;
        show: boolean;
        modal: boolean;
        behavior: LightboxBehavior;
        private _wrapperElement;
        private _container;
        private _slot;
        private _closeWrapper;
        private _slotchangeHandler;
        private _resetLayout;
        private _toggleCloseVisibility;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _disposeButton;
        private _disposeSlot;
        private _closeHandler;
        private _close;
        private _ensureButton;
        private _lookForAButton;
    }
}
declare namespace Pacem.Components.UI {
    enum LoaderType {
        Spinner = "spin",
        Pacem = "pacem",
        Custom = "custom"
    }
    class PacemLoaderElement extends PacemElement {
        private _spinner;
        private _container;
        private _svgSpinner;
        active: boolean;
        type: LoaderType;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem {
    class MarkdownService {
        #private;
        constructor();
        private _escape;
        toHtml(md: string): string;
        tokenize(md: string): any[];
    }
}
declare namespace Pacem.Components.UI {
    class PacemMarkdownElement extends PacemElement {
        private _md;
        constructor(_md?: MarkdownService);
        value: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        tokens(md?: string): any[];
        html(md?: string): string;
    }
}
declare namespace Pacem.Components.UI {
    class PacemMarqueeElement extends PacemElement {
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _overlapResize;
        private _contentResize;
        private _css;
        private _state;
        private _marquee;
        private _overlap;
        private _resizer;
        /** seconds per 1920px */
        speed: number;
        private _adjust;
    }
}
declare namespace Pacem.Components.UI {
    const MEDIAQUERY_XS = "(max-width: 767px)";
    const MEDIAQUERY_SM = "(min-width: 768px)";
    const MEDIAQUERY_MD = "(min-width: 992px)";
    const MEDIAQUERY_LG = "(min-width: 1200px)";
    const MEDIAQUERY_XL = "(min-width: 1824px)";
    const MEDIAQUERY_HD = "(min-width: 1920px)";
    const MEDIAQUERY_2K = "(min-width: 2048px)";
    const MEDIAQUERY_4K = "(min-width: 3840px)";
    const MEDIAQUERY_PORTRAIT = "(orientation: portrait)";
    const MEDIAQUERY_LANDSCAPE = "(orientation: landscape)";
    const MEDIAQUERY_PREFERS_LIGHT = "(prefers-color-scheme: light)";
    const MEDIAQUERY_PREFERS_DARK = "(prefers-color-scheme: dark)";
    class PacemMediaQueryElement extends PacemEventTarget {
        #private;
        query: string;
        /** @readonly */
        isMatch: boolean;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _changeHandler;
        private _broadcastChange;
        private _init;
    }
}
declare namespace Pacem.Components.UI {
    class PacemMenuElement extends PacemElement {
        open: boolean;
        hideHamburgerButton: boolean;
        hideBackButton: boolean;
        outset: boolean;
        synchronizeShell: boolean;
        private _container;
        private _base;
        private _stopPropagationHandlerConditional;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        connectedCallback(): void;
        private _toggle;
        private _shell;
        private _sync;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    class PacemMenuCursorElement extends PacemElement {
        private _menu;
        viewActivatedCallback(): void;
        connectedCallback(): void;
        disconnectedCallback(): void;
        private _onPathChange;
    }
}
declare namespace Pacem.Components.UI {
    class PacemPagerElement extends PacemElement {
        private _repeater;
        index: number;
        total: number;
        pages: number;
        size: number;
        mode: 'standard' | 'numeric-only';
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _databind;
    }
}
declare namespace Pacem.Components.UI {
    class PacemPictureSourceElement extends PacemItemElement {
        srcset: string;
        media: string;
        type: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    class PacemPictureElement extends PacemItemsContainerElement<PacemPictureSourceElement> {
        constructor();
        validate(item: any): boolean;
        private _picture;
        private _img;
        src: string;
        currentSrc: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _updateCurrentSrcHandler;
        refreshSources(): void;
        private _setSources;
        private _setSource;
        private _setAltText;
    }
}
declare namespace Pacem.Components.UI {
    class PacemProgressbarElement extends PacemElement {
        constructor();
        private _bar;
        private _glow;
        private _caption;
        caption: string;
        percentage: number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components.UI {
    class PacemSidebarElement extends PacemElement {
        #private;
        open: boolean;
        synchronizeShell: boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _sync;
        connectedCallback(): void;
    }
}
declare namespace Pacem.Components.UI {
    class PacemSlideElement extends PacemIterableElement {
    }
    class PacemSlideshowElement extends PacemIterativeElement<PacemSlideElement> {
        validate(item: any): item is PacemSlideElement;
    }
}
declare namespace Pacem.Components.UI.Social {
    class PacemTweetEmbedElement extends PacemElement {
        tweetid: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _scriptsLoaded;
        viewActivatedCallback(): void;
        private _render;
    }
}
declare namespace Pacem.Components.UI {
    enum StickyHeaderVisibility {
        Persistent = "persistent",
        QuickReturn = "quickreturn"
    }
    class PacemStickyHeaderElement extends PacemEventTarget {
        #private;
        threshold: number;
        offset: ScrollEventArgs;
        visible: boolean;
        visibility: StickyHeaderVisibility;
        private _scrollHandler;
        private _ensureScrollAwareElement;
        private _manageOffsetChange;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        connectedCallback(): void;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components.UI {
    class PacemTabElement extends PacemIterableElement {
        #private;
        constructor();
        _slotLabel: HTMLSlotElement;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _slotChangeHandler;
        get content(): NodeList;
        label: string | Node;
        key: string;
    }
    class PacemTabsElement extends PacemIterativeElement<PacemTabElement> {
        private _tweener;
        constructor(_tweener?: Animations.TweenService);
        private _defaultTabAdapter;
        private _tabs;
        private _container;
        private _isUsingDefaultTabAdapter;
        /** Gets or sets the orientation of the default tabs adapter. */
        orientation: AdapterOrientation;
        private _labelCallback;
        private _syncOrientation;
        private _syncVisibility;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        validate(item: any): item is PacemTabElement;
    }
}
declare namespace Pacem.Components.UI {
    class PacemToastElement extends PacemElement {
        autohide: boolean;
        timeout: number;
        show: boolean;
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _handle;
        private _doHide;
        private _show;
        popup(): void;
        /**
         * Opinionated shortcut/utility for toast spinning.
         * @param toaster Toast container
         * @param level Message criticity level
         * @param message The message
         * @param options Further options object
         */
        static toast(toaster: HTMLElement, level: 'info' | 'success' | 'warning' | 'danger' | 'error', message: string | HTMLElement, options?: {
            autohide?: boolean;
            timeout?: number;
            cssClass?: string | string[];
        }): Promise<void>;
        static toast2(toaster: HTMLElement, level: 'info' | 'success' | 'warning' | 'danger' | 'error', message: string | HTMLElement, options?: {
            autohide?: boolean;
            timeout?: number;
            cssClass?: string | string[];
        }): Promise<void>;
    }
}
declare namespace Pacem.Components.UI {
    class PacemTocElement extends PacemElement {
        private _tweener;
        constructor(_tweener?: Animations.TweenService);
        selector: string;
        offset: number;
        target: HTMLElement;
        router: PacemRouterElement;
        /** @readonly */
        hasContent: boolean;
        private _repeater;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        connectedCallback(): void;
        disconnectedCallback(): void;
        viewActivatedCallback(): void;
        private _onScroll;
        private _observer;
        private _items;
        private _observe;
        private _scrollToSelf;
        private _getTop;
        private _scrollTo;
        private _hashChange;
        private _startScrollTo;
        private _update;
        /** DOM might change while interacting with the page, this method allows extemporary resets. */
        refresh(): void;
    }
}
declare namespace Pacem.Components.UI {
    class PacemTunerElement extends PacemElement {
        #private;
        constructor();
        private _canvas;
        private _rail;
        private _counterRail;
        private _tween;
        private _rotate;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        value: number;
        min: number;
        max: number;
        interactive: boolean;
        round: number;
        private _toggleRotate;
        private _angleToValue;
        private _valueToAngle;
        private _rotateStartHandler;
        private _rotateEndHandler;
        private _rotateHandler;
        private _setValue;
        /**
         * Returns the angle between the vertical line through 'center' and the line through 'center' and 'currentPosition'.
         * @param evt
         * @returns
         */
        private _getAngle;
        private _draw;
    }
}
declare namespace Pacem.Components.UI {
    class PacemVibrateElement extends PacemEventTarget {
        pattern: number[];
        vibrate(): void;
    }
}
declare namespace Pacem.Components.UI {
    class PacemViewElement extends PacemEventTarget {
        #private;
        url: string | HTMLTemplateElement | PacemTemplateProxyElement;
        fetching: boolean;
        progress: number;
        renderErrors: boolean;
        followRedirects: boolean;
        /** use it to ensure animation */
        debounce: number;
        private _fetchHandle;
        private _renderHandle;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _isReference;
        private _templateChangeHandler;
        private _dispose;
        private _manage;
        private _manageRef;
        private _setTmpl;
        private _manageUrl;
        private _manageResult;
        private _dispatchRender;
    }
}
declare namespace Pacem.Components.UI {
    class PacemWindowAreaElement extends PacemIterativeElement<PacemWindowElement> {
        validate(item: PacemWindowElement): boolean;
        private _behaviors;
        private _dragDrop;
        private _rescale;
        private _zIndex;
        private _startHandler;
        private _blurHandler;
        private _focusHandler;
        private _incrementZIndex;
        connectedCallback(): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        register(item: PacemWindowElement): boolean;
        unregister(item: PacemWindowElement): boolean;
        private _itemPropertyChangeHandler;
        private _adapterPagerCallback;
        private _syncVisibility;
    }
    class PacemWindowElement extends PacemIterableElement {
        caption: string;
        minimized: boolean;
        floating: boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _syncLayout;
    }
}
