/**
 * pacem v0.51.10-faraday (https://js.pacem.it)
 * Copyright 2025 Pacem (https://pacem.it)
 * Licensed under Apache-2.0
 */
declare namespace Pacem {
    type PropertyDependency = {
        /** Element to depend upon */
        element: Node;
        /** Property of the element that is needed to observe  */
        property: string;
        /** Path to the value that carries the final piece of information */
        path: string;
        /** Is it a two way binding? or "bind just once" then forget?... */
        mode?: 'twoway' | 'once' | 'oneway';
        twowayAllowed: boolean;
    };
    type PropertyDependencies = {
        [name: string]: PropertyDependency;
    };
    type CustomElementConfig = {
        tagName: string;
        options?: {
            extends: string;
        };
        /** textual templated content */
        template?: string;
        /** location of the templated content to fetch */
        templateUrl?: string;
        /** if `true` and shadow DOM is natively available then the templated content is hosted in a ShadowRoot  */
        shadow?: boolean;
    };
    type WatchConfig = {
        /** Whether to debounce the property change for a while or not (numeric to specify milliseconds) */
        debounce?: boolean | number;
        /** Whether to reflect the property value back to the element attribute, or not (default false) */
        reflectBack?: boolean;
        /** Whether to emit property change event or not (default true) */
        emit?: boolean;
        /** Alias property name */
        /** Property converter */
        converter?: PropertyConverter;
    };
    type TransformFunction = (value: any, ...args: any[]) => any;
    interface OnConnected {
        connectedCallback(): void;
    }
    interface OnDisconnected {
        disconnectedCallback(): void;
    }
    interface OnPropertyChanged {
        propertyChangedCallback(name?: string, oldVal?: any, newVal?: any, firstChange?: boolean): void;
    }
    interface OnAttributeChanged {
        attributeChangedCallback(attrName?: string, oldVal?: string, newVal?: string): void;
    }
    interface OnAdopted {
        adoptedCallback(): void;
    }
    interface OnViewActivated {
        viewActivatedCallback(): void;
    }
    const Type: FunctionConstructor;
    interface Type<T> extends Function {
        new (...args: any[]): T;
    }
    interface CustomElementRegistry {
        define(name: string, type: Type<any>, options?: {
            [key: string]: string;
        }): any;
        get(name: string): any;
        whenDefined(name: string): PromiseLike<void>;
    }
    const WATCH_PROPS_VAR: string;
    const INSTANCE_BINDINGS_VAR = "pacem:custom-element:bindings";
    const INSTANCE_HOST_VAR = "pacem:custom-element:host";
    const INSTANCE_SCOPE_VAR = "pacem:custom-element:scope";
}
declare namespace Pacem {
    class DeferPromise<T> implements PromiseLike<T> {
        private promise;
        private deferred;
        constructor();
        then<TResult1 = T, TResult2 = never>(onCompleted?: ((v: T) => TResult1 | PromiseLike<TResult1>), onFailed?: (v?: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
        /**
         * Occurs whenever the promise concludes (either after completion or error).
         * @param {Function } callback
         */
        finally(callback: (v?: T | any) => void | PromiseLike<void>): this;
        success(callback: (v?: T) => T | PromiseLike<T>): this;
        error(callback: (v?: any) => void | PromiseLike<void>): this;
        static defer<T>(): {
            resolve: (v?: T) => void | PromiseLike<void>;
            reject: (v?: any) => void | PromiseLike<void>;
            promise: DeferPromise<T>;
        };
    }
}
declare namespace Pacem {
    class DeepCloner {
        private constructor();
        static clone(obj: any): any;
        private _clone;
    }
}
declare namespace Pacem {
    /** How functions get serialized. */
    enum JsonFunctionConversion {
        /** Skip functions (default). */
        Ignore = 0,
        /** Functions get referenced from a state in the current DOM. Not suitable for backups or long-term dehydrations. */
        Reference = "reference",
        /** Function gets stringified and then eval(uated) while dehydrating. Functions with a state (impure) might not working properly when used on the dehydrated side. */
        Plain = "plain"
    }
    interface JsonSerializationOptions {
        functions?: JsonFunctionConversion;
    }
    class Json {
        private _options?;
        private constructor();
        static serialize(obj: any, options?: JsonSerializationOptions): string;
        static deserialize(json: string): any;
        private _serialize;
        private _deserialize;
        private _flatten;
        private _revive;
    }
}
declare namespace Pacem {
    export const stopPropagationHandler: (evt: Event) => void;
    export const preventDefaultHandler: (evt: Event) => void;
    export const avoidHandler: (evt: Event) => void;
    type DownloadOptions = {
        filename?: string;
        mime?: string;
        credentials?: RequestCredentials;
        headers?: {
            [key: string]: string;
        };
    };
    export type RouterState = {
        [key: string]: string;
    } & {
        $pathname: string;
        $path: string;
        $querystring?: string;
        $query: {
            [key: string]: string;
        };
        $hash?: string;
    };
    type RouteMetadata = {
        name: string;
        optional: boolean;
        index: number;
    };
    /** To be replaced when Cookie Store API types will be included in TypeScript. */
    export type CookieData = {
        name: string;
        value?: string | null;
        domain?: string;
        expires?: string | number | Date;
        maxAge?: number;
        partitioned?: boolean;
        path?: string;
        sameSite?: 'lax' | 'strict' | 'none';
        secure?: boolean;
    };
    export type CookieStoreLike = {
        delete(c: string | CookieData): Promise<void>;
        get(c: string): Promise<CookieData>;
        set(c?: string | CookieData, value?: string): Promise<void>;
        getAll(c?: string): Promise<CookieData[]>;
        addEventListener: (type: 'change', handler: EventListener) => void;
        removeEventListener: (type: 'change', handler: EventListener) => void;
    };
    export class Utils {
        static get core(): any;
        static get customElements(): any;
        static uniqueId(): number;
        static uniqueCode(): string;
        static randomString(length: number): string;
        static parseDate(input: string | Date | number): Date;
        static copyToClipboard(input: string): Promise<void>;
        static Json: {
            stringify: typeof Json.serialize;
            parse: typeof Json.deserialize;
        };
        static Dates: {
            now: () => Date;
            parse: typeof Utils.parseDate;
            isLeapYear: typeof Dates.isLeapYear;
            daysInMonth: typeof Dates.daysInMonth;
            /**
             * Gets whether a date is an `Invalid Date` or not.
             * @param date
             */
            isDate: typeof Dates.isDate;
            dateOnly: typeof Dates.dateOnly;
            addMonths: typeof Dates.addMonths;
            addDays: typeof Dates.addDays;
            daysBetween: typeof Dates.daysBetween;
        };
        static colorize(element: HTMLElement, rgb: string | [number, number, number]): void;
        static colorize(rgb: string | [number, number, number]): string;
        static cssEscape(input: string): string;
        static Css: {
            colorize: typeof Utils.colorize;
            escape: typeof Utils.cssEscape;
            getVariableValue(name: string): string;
            setVariable(name: string, value: string): void;
            /**
             * Naive O(n^2) implementation for an actual css class presence (definition) in the current DOM.
             * @param name CSS class name
             */
            isClassDefined(name: string): boolean;
            deserializeTransform(element: Element | CSSStyleDeclaration): Matrix2D;
        };
        static leftPad: typeof Strings.leftPad;
        static formatString: typeof Strings.format;
        static diff: typeof Strings.diff;
        static Strings: {
            leftPad: typeof Strings.leftPad;
            format: typeof Strings.format;
            diff: typeof Strings.diff;
            stripHTML: (html: string) => string;
        };
        static Blobs: {
            toDataURL: typeof Blobs.blobToDataURL;
            fromDataURL: typeof Blobs.dataURLToBlob;
            toText: typeof Blobs.blobToText;
            fromText: typeof Blobs.textToBlob;
        };
        static Images: {
            load: typeof Imaging.loadImage;
            resize: typeof Imaging.resizeImage;
        };
        static loadImage(src: string): Promise<HTMLImageElement>;
        static blobToDataURL(blob: Blob): Promise<string>;
        static dataURLToBlob(dataURL: string): Blob;
        static blobToText(blob: Blob, encoding?: string): Promise<string>;
        static textToBlob(content: string, type?: string): Blob;
        /** @deprecated Use {Utils.Images.resize}, instead.
         * Resizes an image when exceeding the provided size constraints.
         * @param img {Blob} Input image
         * @param maxWidth {number} Width constraint
         * @param maxHeight {number} Height constraint
         */
        static resizeImage(img: Blob, maxWidth: number, maxHeight: number, quality?: number): PromiseLike<Blob>;
        /** @deprecated Use {Utils.Images.resize}, instead.
         * Crops an image having the provided url (might be a dataURL) into another having the provided size
         * @param url
         * @param width
         * @param height
         * @param ctx
         */
        static cropImage(url: string, width?: number, height?: number, quality?: number): PromiseLike<string>;
        static getUserMediaFunctions(): any[];
        /**
         * Crops the snapshot of a drawable element onto a provided canvas context. It gets centered in the area and cropped (`cover`-like behavior).
         * @param el drawable element
         * @param ctx canvas context
         * @param sourceWidth forced source width
         * @param sourceHeight forced source height
         */
        static cropImageOntoCanvas(el: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, ctx: CanvasRenderingContext2D, sourceWidth?: number, sourceHeight?: number): void;
        private static get _domURL();
        /**
         * Snapshots a DOM element and returns its blob image representation.
         * @param el Element to snapshot
         * @param background Background color to replace the original
         * @param type Output mimetype (image/png, image/jpeg, images/webp, ...)
         * @param quality Quality ratio between 0..1
         */
        static snapshotElement(el: HTMLElement | SVGElement, background?: string, type?: string, quality?: number): Promise<Blob>;
        static download(content: Blob, filename?: string, mime?: string): PromiseLike<void>;
        static download(url: string, filename?: string, mime?: string): PromiseLike<void>;
        static download(url: string, options: DownloadOptions): PromiseLike<void>;
        static isDOMReady(): boolean;
        static onDOMReady(listener: EventListenerOrEventListenerObject): void;
        /**
         * Moves all the source element children to the target element and returns them as an array of nodes.
         * @param source Source element.
         * @param target Target element.
         */
        static moveChildren(source: Element, target: Element): Node[];
        /**
         * Moves specific nodes to the target element and returns them as an array of nodes.
         * @param nodes Nodes to move.
         * @param target Target element.
         */
        static moveItems(nodes: Node[] | NodeList, target: Element): Node[];
        static is(el: any, selector: string): boolean;
        static lang(el: HTMLElement): string;
        static jsonSortStringify(obj: {}): string;
        static Browsers: {
            detect: typeof Browsers.detect;
        };
        static cookies(cookie?: string): Record<string, string>;
        static Cookies: {
            getAll: (cookieName?: string) => Promise<CookieData[]>;
            stringify: (data: CookieData) => string;
        };
        static isVisible(el: HTMLElement | SVGElement): boolean;
        static hasClass(el: HTMLElement | SVGElement, className: string): boolean;
        static addClass(el: HTMLElement | SVGElement, className: string): void;
        static removeClass(el: HTMLElement | SVGElement, className: string): void;
        static hasPart(el: HTMLElement | SVGElement, partName: string): boolean;
        static addPart(el: HTMLElement | SVGElement, partName: string): void;
        static removePart(el: HTMLElement | SVGElement, partName: string): void;
        /**
         * Retrieve the bounding box of the provided element as of its rendered appearance on the stage (takes transformations into account).
         * @param el The element.
         */
        static offset(el: Element): {
            top: number;
            left: number;
            width: number;
            height: number;
        };
        /**
         * Retrieve the bounding box of the provided element as of its rendered appearance on the stage (takes transformations into account).
         * @param el The element.
         */
        static offsetRect(el: Element): Rect;
        static naturalOffsetTop(el: HTMLElement): number;
        static naturalOffsetLeft(el: HTMLElement): number;
        /**
         * Retrieve the natural bounding box of the provided element (does not takes transformations into account).
         * @param el {HTMLElement} The element.
         */
        static naturalOffset(el: HTMLElement): {
            top: number;
            left: number;
            width: number;
            height: number;
        };
        /**
         * Retrieve the natural bounding box of the provided element (does not takes transformations into account).
         * @param el {HTMLElement} The element.
         */
        static naturalOffsetRect(el: HTMLElement): Rect;
        static deserializeTransform(element: Element): Matrix2D;
        static deserializeTransform(style: CSSStyleDeclaration): Matrix2D;
        static set scrollTop(y: number);
        static set scrollLeft(x: number);
        static get scrollTop(): number;
        static get scrollLeft(): number;
        static get windowSize(): {
            width: number;
            height: number;
        };
        /**
         * Adds a callback at the end of a CSS animation/transition for a given element (execute once).
         * @param element The very element that has to trigger the animation/transitionend event.
         * @param callback Then callback.
         * @param timeout Fallback timeout (ms) in case the animation/transitionend event won't fire.
         */
        static addAnimationEndCallback(element: HTMLElement | SVGElement, callback: (element?: HTMLElement | SVGElement) => void, timeout?: number): void;
        /**
         * Promisifies the addAnimationEndCallback function.
         * @param element The very element that has to trigger the animation/transitionend event.
         * @param timeout Fallback timeout (ms) in case the animation/transitionend event won't fire.
         */
        static waitForAnimationEnd(element: HTMLElement | SVGElement, timeout?: number): Promise<void>;
        /**
         * Waits until the provided timespan elapses.
         * @param msecs timespan in milliseconds
         */
        static idle(msecs: number): Promise<void>;
        /**
         * Increases a callback loop call until cancelation is called.
         * @param callback Callback looped.
         * @param interval First callback call delay in ms (default 500).
         * @param pace Acceleration in ms per loop (default 5).
         * @param min Minimum loop rate in ms (default 20).
         *
         * Use case/example: while keeping a button pressed, the related callback execution increases in frequency.
         */
        static accelerateCallback(callback: (token: {
            cancel: boolean;
        }) => void, interval?: number, pace?: number, min?: number): void;
        static isEmpty(obj: any): boolean;
        static isNull(obj: any): obj is null | undefined;
        static isArray(val: any): val is any[];
        static isNullOrEmpty(val: any): boolean;
        /**
         * It is a `valueOf()` based comparison.
         * @param v1 term 1
         * @param v2 term 2
         */
        static areSemanticallyEqual(v1: any, v2: any): boolean;
        /** Alias for Object.assign */
        static extend: {
            <T extends {}, U>(target: T, source: U): T & U;
            <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
            <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
            (target: object, ...sources: any[]): any;
        };
        static clone<T>(obj: T): T;
        static fromResult<T>(v: T): Promise<T>;
        /**
         * Creates an immutable (readonly) copy of an object while preserving the referential values (shallow immutability).
         * @param obj Input object to be frozen
         */
        static readonlyCopy<T>(obj: {
            [name: string]: T;
        }): Readonly<{
            [name: string]: T;
        }>;
        /**
         * Creates an immutable (readonly) copy of an array while preserving the referential values (shallow immutability).
         * @param obj Input array to be frozen
         */
        static readonlyCopy<T>(array: T[]): ReadonlyArray<T>;
        static fromResultAsync<T>(task: () => T): Promise<T>;
        static URIs: {
            format: (url: string, parameters: {
                [name: string]: string;
            }, removeMatchedParameters?: boolean) => string;
            appendQuery: (url: string, parameters: {
                [name: string]: string;
            }, removeNullEntries?: boolean, hash?: boolean) => string;
            parseQuery: (query?: string | Location) => Record<string, string>;
            hasMandatoryTemplateSegments: (url: any) => boolean;
            parseRoute: (pathTemplate: string) => RouteMetadata[];
            split: (url: string) => {
                protocol?: string;
                domain?: string;
                path: string;
                query?: string;
                hash?: string;
            };
            parseState: (metadata: RouteMetadata[], url: string, path?: string, query?: string, hash?: string) => RouterState;
        };
        /**
         * Ensures the proper parsing of Web API results, including deprecated/legacy Pacem wrapped results.
         */
        static getApiResult(json: any): any;
    }
    export {};
}
declare namespace Pacem {
    class Expression {
        private _fnBody;
        private _voidBody;
        private _pending;
        private _independent;
        private _args;
        private _dependencies;
        private _fn;
        get dependencies(): PropertyDependency[];
        get functionBody(): string;
        get voidBody(): string;
        get pending(): boolean;
        get independent(): boolean;
        evaluate(): any;
        evaluateAsync(): PromiseLike<any>;
        evaluatePlus(args?: {
            [key: string]: any;
        }): any;
        private static _pendingExpression;
        private static _getPendingExpressionSingleton;
        static parse(expression: string, element: HTMLElement): Expression;
    }
}
declare namespace Pacem {
    /** the overall customelement prefix */
    const P: string;
    const PCSS: string;
}
declare namespace Pacem {
    class CustomElementUtils {
        static get polyfilling(): boolean;
        static camelToKebab(camelCased: string): string;
        static kebabToCamel(kebabCased: string): string;
        static getWatchedProperties(target: Type<any>, includeInherited?: boolean): {
            name: string;
            config: WatchConfig;
        }[];
        static getWatchedProperties(element: HTMLElement, includeInherited?: boolean): {
            name: string;
            config: WatchConfig;
        }[];
        static getWatchedProperty(target: HTMLElement, name: string): {
            name: string;
            config: WatchConfig;
        };
        static importjs(src: string, integrity?: string, crossorigin?: boolean): Promise<HTMLElement>;
        static importcss(src: string, integrity?: string, crossorigin?: boolean): Promise<HTMLElement>;
        static import(key: string, tagName: string, attrs: {
            [name: string]: any;
        }, appendTo?: Node): Promise<HTMLElement>;
        static Theme: {
            importWebFonts(): Promise<any>;
        };
        static setAttachedPropertyValue(target: any, name: string, value: any): void;
        static deleteAttachedPropertyValue(target: any, name: string): void;
        static getAttachedPropertyValue(target: any, name: string, ensureValue?: any): any;
        /**
         * Resolves a dotted path into actual values.
         * @param path Dotted path
         * @param scope Root of the path
         */
        static resolvePath(path: string, scope: any): {
            target: {
                value: any;
                name: string;
            };
            parent: {
                value: any;
                path: string;
            };
            root: {
                value: any;
                property: string;
            };
        };
        static set(element: Node, path: string, value: any): void;
        static get(element: Node, path: string): any;
        /**
         * Works for unit-test contexts.
         * @param element
         */
        private static _findScopeContextLegacy;
        static findScopeContext(element: HTMLElement): Document | ShadowRoot;
        static findAncestor(element: Element, predicate: (Node: any) => boolean): any;
        static findAncestorShell(element: Element): HTMLElement;
        static findAncestorOfType<TNode extends Node>(element: Element, ctor: Type<TNode>): TNode;
        static findDescendants(element: Element, predicate: (Node: any) => boolean, firstOnly?: boolean): Node[];
        static findFirstDescendant(element: Element, predicate: (Node: any) => boolean): Node;
        static findAll<T extends Element>(selector?: string, filter?: (e: Element) => boolean): T[];
        /**
         * To be used back again when Edge will allow Comment subclassing
         * https://github.com/Microsoft/ChakraCore/issues/2999 and https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12080908/
         * @param element
         * @param ctor
         * @param upLevels
         */
        static findPreviousSiblingOrAncestorOfType<TNode extends Node>(element: Element, ctor: Type<TNode>, upLevels?: number): TNode;
        /**
         * To be removed when Edge will allow Comment subclassing
         * https://github.com/Microsoft/ChakraCore/issues/2999 and https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12080908/
         * @param element
         * @param predicate
         * @param upLevels
         */
        static findPreviousSiblingOrAncestor(element: Element, predicate: (Node: any) => boolean, upLevels?: number): Node;
        static assignHostContext(host: any, template: HTMLTemplateElement): void;
        static findHostContext(element: HTMLElement): HTMLElement;
        static isBindingAttribute(attr: string): boolean;
        static extractBindingAttributeExpression(attr: string): string;
        static parseBindingAttribute(attr: string, element: HTMLElement): Expression;
        static ensureMember(o: any, name: string, attributes: PropertyDescriptor): PropertyDescriptor;
        /**
         * Strips all the observed attributes of an element and its descendants, in order to seal that dom branch and to avoid bindings evaluation.
         * @param element Input element
         */
        static stripObservedAttributes(element: Element): void;
        /**
         * Freezes all the observed attributes of an element and its descendants, in order to seal that dom branch and to avoid bindings evaluation.
         * @param element Input element
         */
        static freezeObservedAttributes(element: Element): void;
    }
    interface Repeater extends HTMLElement {
        datasource: any[];
    }
    class Repeater {
        /**
         * Seeks for a PacemRepeaterItem element upwards through the DOM tree, given a starting element and the number of nesting levels.
         * @param element {HTMLElement} Element to start the upward search from
         * @param Optional upLevels {Number} 0-based nesting level
         */
        static findItemContext(element: Element, upLevels?: number, logFn?: (message?: string) => void): Pacem.RepeaterItem;
    }
    abstract class RepeaterItem {
        private _placeholder;
        static findUpwards(element: Element, upLevels?: number, logFn?: (message?: string) => void): RepeaterItem;
        static isRepeaterItem(node: Node): boolean;
        static getRepeaterItem(node: Node): RepeaterItem;
        constructor(_placeholder: Node);
        abstract item: any;
        abstract index: number;
        abstract readonly repeater: Repeater;
        get placeholder(): Node;
    }
}
declare namespace Pacem {
    interface EventCoordinates {
        readonly page: Point;
        readonly client: Point;
        readonly screen: Point;
    }
    interface KeyEventLike {
        readonly altKey: boolean;
        readonly ctrlKey: boolean;
        readonly shiftKey: boolean;
        readonly metaKey: boolean;
        readonly which?: number;
    }
    interface UIEventLike extends KeyEventLike {
        readonly clientX: number;
        readonly clientY: number;
        readonly pageX: number;
        readonly pageY: number;
        readonly screenX: number;
        readonly screenY: number;
    }
    interface EventKeyModifiers extends KeyEventLike {
    }
    enum EventKeyModifier {
        AltKey = "Alt",
        CtrlKey = "Ctrl",
        ShiftKey = "Shift",
        MetaKey = "Cmd"
    }
    class CustomEventUtils {
        static isInstanceOf<TEvent extends Event>(evt: Event, type: Type<TEvent>): evt is TEvent;
        static getEventCoordinates(evt: MouseEvent | TouchEvent | UIEventLike): EventCoordinates;
        static getEventKeyModifiers(evt: KeyboardEvent | MouseEvent | TouchEvent | KeyEventLike): EventKeyModifiers;
        /**
         * Matches the provided event against keyboard modifiers and returns 'true' if all the matches are satisfied.
         * @param evt Provided event
         * @param modifiers Array of stringified modifiers ("Ctrl", "Shift", "Alt", "Option", "Win", "Cmd")
         */
        static matchModifiers(evt: KeyboardEvent | MouseEvent | TouchEvent | KeyEventLike, modifiers: string[]): any;
        static matchModifiers(evt: KeyboardEvent | MouseEvent | TouchEvent | KeyEventLike, ...modifiers: EventKeyModifier[]): any;
        static fixEdgeCustomEventSubClassInstance<TEvent extends Event>(evt: TEvent, type: Function): void;
    }
}
declare namespace Pacem {
    abstract class CustomTypedEvent<TDetail> extends CustomEvent<TDetail> {
        constructor(type: string, detail: TDetail, eventInit?: CustomEventInit<TDetail>);
    }
    abstract class CustomUIEvent<TDetail> extends CustomEvent<TDetail> implements UIEventLike {
        #private;
        constructor(type: string, detail: TDetail);
        constructor(type: string, eventInit: CustomEventInit<TDetail>);
        constructor(type: string, detail: TDetail, orig: MouseEvent | TouchEvent | KeyboardEvent);
        constructor(type: string, eventInit: CustomEventInit<TDetail>, orig: MouseEvent | TouchEvent | KeyboardEvent);
        constructor(type: string, detail: TDetail, eventInit: CustomEventInit<TDetail>);
        constructor(type: string, detail: TDetail, eventInit: CustomEventInit<TDetail>, orig: MouseEvent | TouchEvent | KeyboardEvent);
        get originalEvent(): Event;
        get which(): number;
        get altKey(): boolean;
        get shiftKey(): boolean;
        get ctrlKey(): boolean;
        get metaKey(): boolean;
        get pageX(): number;
        get pageY(): number;
        get clientX(): number;
        get clientY(): number;
        get screenX(): number;
        get screenY(): number;
    }
    interface AttributeChangeEventArgs {
        attributeName: string;
        oldValue?: string;
        currentValue: string;
        firstChange?: boolean;
    }
    const AttributeChangeEventName: string;
    class AttributeChangeEvent extends CustomTypedEvent<AttributeChangeEventArgs> {
        constructor(args: AttributeChangeEventArgs);
    }
    interface PropertyChangeEventArgs {
        propertyName: string;
        oldValue?: any;
        currentValue: any;
        firstChange?: boolean;
    }
    const PropertyChangeEventName: string;
    class PropertyChangeEvent extends CustomTypedEvent<PropertyChangeEventArgs> {
        constructor(args: PropertyChangeEventArgs);
    }
    interface NotifyPropertyChange extends EventTarget {
    }
}
declare namespace Pacem {
    interface PropertyConverter {
        /** You can assume `attr` not null, cause it will be processed only in that case. */
        readonly convert: (attr: string, element?: HTMLElement) => any;
        /** You can assume `prop` not null, cause it will be processed only in that case. */
        readonly convertBack?: (prop: any, element?: HTMLElement) => string;
        /** Whether to retry, once more, the conversion attribute-to-property, if no results were yielded before the element was ready and the DOM loaded. */
        readonly retryConversionWhenReady?: boolean;
    }
    const PropertyConverters: {
        None: PropertyConverter;
        String: PropertyConverter;
        StringArray: PropertyConverter;
        Number: PropertyConverter;
        Boolean: PropertyConverter;
        BooleanStrict: PropertyConverter;
        Date: PropertyConverter;
        Datetime: PropertyConverter;
        Json: PropertyConverter;
        Eval: PropertyConverter;
        Element: PropertyConverter;
        Point: PropertyConverter;
        Rect: PropertyConverter;
        Size: PropertyConverter;
    };
}
declare namespace Pacem {
    type PropertyComparer<T> = (old: T, val: T) => boolean;
    /**
     * Default, and essentially ONLY, property comparer for equalitycheck
     * @param old value 1
     * @param val value 2
     */
    const DefaultComparer: PropertyComparer<any>;
}
declare namespace Pacem {
    const CustomElement: (config: CustomElementConfig) => (target: Type<any>) => void;
    function Watch(config?: WatchConfig): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
    function ViewChild(selector: string): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
    function Concurrent(): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
    function Debounce(msecs?: true | number, keyFactory?: (key: String, ...args: any[]) => string): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
    function Throttle(msecs?: true | number, keyFactory?: (key: String, ...args: any[]) => string): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
    function Transformer(name?: string): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
}
declare namespace Pacem.Logging {
    enum LogLevel {
        Trace = "trace",
        Debug = "debug",
        Warn = "warn",
        Error = "error",
        Info = "info",
        Log = "log"
    }
    interface Logger {
        log(level: LogLevel, message: string, category?: string): any;
    }
}
declare namespace Pacem.Components {
    abstract class PacemEventTarget extends HTMLElement implements NotifyPropertyChange, OnPropertyChanged, OnConnected, OnViewActivated, OnDisconnected {
        constructor();
        /**
         * Executes the relevant handler defined in the `on-{evt.type}` attribute, if any.
         * @param evt {Event} the event to be fired
         */
        protected emit(evt: Event): void;
        handle(evt: Event): void;
        private _dontDispatch;
        private _isReady;
        /** Gets whether the element has been completely loaded alongside with the other pieces of the DOM. */
        get isReady(): boolean;
        connectedCallback(): void;
        disconnectedCallback(): void;
        viewActivatedCallback(): void;
        /**
         * Manages the value change of a watched property.
         * @param name {string} property name
         * @param old {any} former property value
         * @param val {any} new/current property value
         * @param first {boolean} whether is the first change (right before view activation) or not
         */
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        /**
         * Wraps the native dispatchEvent in order to emit `on-{evt-type}` handler, if any.
         * @param evt {Event} the event to be fired
         */
        dispatchEvent(evt: Event): boolean;
        protected emitHandler: (evt: Event) => void;
        disabled: boolean;
        logger: Pacem.Logging.Logger;
        /**
         * Logs a message if a logger is available.
         * @param level {LogLevel} Level of log
         * @param message {String} Content
         * @param category {String} Grouping category
         */
        protected log(level: Pacem.Logging.LogLevel, message: string, category?: string): void;
        /** Refreshes all the properties corresponding to explicit binding attributes. */
        protected refreshBindings(): void;
    }
}
declare namespace Pacem {
    interface ItemsContainer<TItem> extends NotifyPropertyChange {
        items: TItem[];
        register(item: TItem): boolean;
        unregister(item: TItem): boolean;
    }
    interface Iterative<TItem> extends ItemsContainer<TItem> {
        index: number;
    }
    type IndexChangeEventArgs = {
        currentIndex: number;
        previousIndex: number;
    };
    class CurrentIndexChangeEvent extends CustomTypedEvent<IndexChangeEventArgs> {
        constructor(args: IndexChangeEventArgs);
    }
}
declare interface Array<T> {
    moveWithin(from: number, to: number): void;
    equalsContent(other: T[]): boolean;
    cloneFrom(other: T[]): void;
    union(other: T[]): T[];
}
declare namespace Pacem {
    const CommandEventName: string;
    type CommandEventArgs = {
        commandName: string;
        commandArgument: any;
    };
    class CommandEvent extends CustomTypedEvent<CommandEventArgs> {
        constructor(args: CommandEventArgs);
    }
}
declare namespace Pacem {
    const Defaults: {
        USE_SHADOW_ROOT: boolean;
    };
}
declare namespace Pacem.RegularExpressions {
    type RegexMatchSegment = {
        value: string;
        match: boolean;
        index: number;
    };
    const EMPTY_MATCHER: RegExp;
    class Regex {
        /**
         * Splits an input string into segments based on a matching pattern.
         * @param input Input string
         * @param pattern RegExp pattern
         */
        static split(input: string, pattern: RegExp): RegexMatchSegment[];
    }
}
type WindowStorage = Storage;
declare namespace Pacem {
    class Storage {
        private _getStorage;
        private _parseValue;
        /**
         * Keeps undefinitely the provided value in a storage.
         * @param name The unique key
         * @param value The value to store
         * @param persistent Whether to use a session `false` or local `true` storage
         */
        setPropertyValue(name: string, value: any, persistent?: boolean): any;
        /**
         * Stores persistently the provided value for the specified amount of seconds.
         * @param name The unique key
         * @param value The value to store
         * @param duration Storage timeout in seconds
         */
        setPropertyValue(name: string, value: any, duration: number): any;
        getPropertyValue(name: string): any;
        clear(): void;
        removeProperty(name: string): void;
    }
}
declare namespace Pacem {
    abstract class TemplateElement extends HTMLElement {
    }
}
declare namespace Pacem {
}
declare namespace Pacem.Animations {
    type Easing = (any: any) => any & {
        css: string;
    };
    const Easings: any;
}
declare namespace Pacem.Animations {
    type AnimationEventArgs = {
        time: number;
        value: number;
    };
    class AnimationEvent extends CustomTypedEvent<AnimationEventArgs> {
        constructor(args: AnimationEventArgs);
    }
    class AnimationEndEvent extends CustomEvent<{}> {
        constructor();
    }
    class AnimationStartEvent extends CustomEvent<{}> {
        constructor();
    }
}
declare namespace Pacem.Animations {
    class Timer {
        #private;
        private constructor();
        private _run;
        static run(callback: (time?: number) => void, fps?: number): Timer;
        stop(): void;
    }
}
declare namespace Pacem.Animations {
    class TweenService {
        run(from: number, to: number, duration: number, delay?: number, easing?: (time: number) => number, callback?: (time: number, value: number) => void): Promise<void>;
    }
}
declare namespace Pacem.Net {
    enum HttpMethod {
        Get = "GET",
        Post = "POST",
        Put = "PUT",
        Delete = "DELETE",
        Options = "OPTIONS",
        Head = "HEAD",
        Patch = "PATCH",
        Connect = "CONNECT",
        Trace = "TRACE"
    }
    class StatusCodeError extends Error {
        private statusCode;
        constructor(statusCode: number, statusText: string);
        get status(): number;
    }
    /** @deprecated */
    class Response {
        constructor(req: XMLHttpRequest, processTime: number);
        private _processTime;
        private _status;
        private _text;
        private _body;
        private _type;
        private _allHeadersRaw;
        private _headers;
        get processTime(): number;
        get headers(): {
            [key: string]: string;
        };
        get size(): number;
        get mime(): string;
        get date(): Date;
        private _parseHeaders;
        get status(): number;
        get text(): string;
        get content(): any;
        get type(): string;
        /**
         * Short-hand utility for getting or parsing json content (if any).
         */
        get json(): any;
    }
    /** @deprecated */
    type RequestOptions = {
        data?: 'string' | {
            [key: string]: string;
        };
        headers?: {
            [key: string]: string;
        };
        method: HttpMethod;
        progress?: (pct: number) => void;
    };
    /** @deprecated */
    class Http {
        constructor();
        /** Gets or sets the Bearer authorization token. */
        accessToken: string;
        /**
         * Executes an asynchronous XMLHttpRequest over the net.
         * @param {String} url - Base url to be requested.
         * @param {Object} [options] - Options for the request.
         * @param {Object} [options.data] - Data to be sent along.
         * @param {String} [options.method=GET] - HTTP Verb to be used.
         * @param {Object} [options.headers] - Key-value pairs of strings.
         * @param {Function} [options.progress] - Callback on retrieval progress.
         */
        request(url: any, options?: RequestOptions): DeferPromise<Response>;
        /**
         * Short-hand for 'GET' requests.
         */
        get(url: any, data?: any, headers?: {
            [key: string]: string;
        }): DeferPromise<Response>;
        /**
         * Short-hand for 'POST' requests (content provided as json).
         */
        post(url: any, data?: any, headers?: {
            [key: string]: string;
        }): DeferPromise<Response>;
    }
}
type GlobalResponse = Response;
declare namespace Pacem.Net {
    interface Fetcher extends NotifyPropertyChange {
        url: string;
        method: HttpMethod;
        parameters: {
            [key: string]: string;
        };
        headers: {
            [key: string]: string;
        };
        result: any;
        fetch: () => PromiseLike<GlobalResponse>;
    }
    interface OAuthFetchable {
        readonly fetcher?: Fetcher;
        fetchCredentials: RequestCredentials;
        fetchHeaders: {
            [key: string]: string;
        };
    }
    const FetchResultEventName = "fetchresult";
    const FetchErrorEventName = "error";
    const FetchSuccessEventName = "success";
    class Fetcher {
        static isEmpty(r: GlobalResponse): boolean;
    }
}
declare namespace Pacem.UI {
    export enum DragDataMode {
        /** Source element is dragged around (floater is the element itself so is the data). */
        Self = "self",
        /** The floater is an element clone, while data is the element itself.  */
        Alias = "alias",
        /** The floater is a clone of the element, while data is a copy of it. */
        Copy = "copy"
    }
    export enum DropBehavior {
        /** Drag & drop task is meant to sort or swap items around. */
        InsertChild = "insert",
        /** Drag & drop task has no logical meaning. Event listeners might be in charge for a specific scenario.  */
        None = "none"
    }
    export enum DropTargetMissedBehavior {
        /** Reverts to the last tracked spot. */
        Revert = "revert",
        /** Deletes item on spill-out. */
        Remove = "remove",
        /** No explicit behavior, might fallback to 'revert' when drop behavior is 'insert'.  */
        None = "none"
    }
    export enum DragDropEventType {
        /** Initial state change before first dragging act. */
        Init = "draginit",
        /** First dragging act. */
        Start = "dragstart",// 'dragstart' might conflict with HTML Drag & Drop API event (and so the others)
        /** Any dragging act. */
        Drag = "drag",
        /** Dropping act. */
        Drop = "drop",
        /** Hovering a drop target. */
        Over = "dragover",
        /** Exiting a drop target. */
        Out = "dragout",
        /** Terminating the drag-drop activities. */
        End = "dragend"
    }
    abstract class DragDropEventArgsBaseClass {
        private _builder;
        protected constructor(_builder: DragDropEventArgs);
        get element(): HTMLElement | SVGElement;
        abstract readonly placeholder: HTMLElement | SVGElement;
        abstract readonly data: any;
        get origin(): Point;
        get initialDelta(): Point;
        get startTime(): number;
        get floater(): Element;
        target: Element;
        currentPosition: Point;
        get delta(): Point;
    }
    export class DragDropInitEventArgsClass extends DragDropEventArgsBaseClass {
        private constructor();
        placeholder: HTMLElement | SVGElement;
        data: any;
        static fromArgs(builder: DragDropEventArgs): DragDropInitEventArgsClass;
    }
    export class DragDropEventArgsClass extends DragDropEventArgsBaseClass {
        private _placeholder;
        private _data;
        private constructor();
        get placeholder(): HTMLElement | SVGElement;
        get data(): any;
        static fromArgs(builder: DragDropEventArgs): DragDropEventArgsClass;
    }
    export type DragDropEventArgs = {
        element: HTMLElement | SVGElement;
        placeholder: HTMLElement | SVGElement;
        origin: Point;
        currentPosition: Point;
        initialDelta: Point;
        startTime: number;
        data: any;
        floater: Element;
        target?: Element;
    };
    export class DragDropEvent extends CustomUIEvent<DragDropEventArgsClass | DragDropInitEventArgsClass> {
        constructor(type: DragDropEventType, args: DragDropEventArgsClass | DragDropInitEventArgsClass, eventInit?: EventInit, evt?: MouseEvent | TouchEvent);
    }
    /**
    * Interface to be implemented in order to create a proper drag & drop adapter.
    */
    export interface DragDropper {
        addEventListener(evt: DragDropEventType, listener: (evt: DragDropEvent) => void, useCapture?: boolean): void;
        removeEventListener(evt: DragDropEventType, listener: (evt: DragDropEvent) => void, useCapture?: boolean): void;
        dispatchEvent(evt: DragDropEvent): boolean;
        /**
        * Enumerates the possible drop targets valid for all the registered draggable elements.
        */
        dropTargets: Element[];
        /**
        * Gets or sets the type of data dragged around (common to all the registered draggable elements).
        */
        mode: DragDataMode;
        /**
        * Element to be used as a dragging placeholder. If not null, will override the floater obtained via the `mode` property.
        */
        floater: Element;
        dropBehavior: DropBehavior;
        spillBehavior: DropTargetMissedBehavior;
    }
    export {};
}
declare namespace Pacem.UI {
    enum RescaleHandle {
        All = "all",
        Top = "top",
        Left = "left",
        Right = "right",
        Bottom = "bottom"
    }
    type RescaleEventArgs = {
        element: HTMLElement | SVGElement;
        origin: Point;
        currentPosition: Point;
        startTime: number;
        handle: string;
        targetRect?: Rect;
    };
    enum RescaleEventType {
        Start = "rescalestart",
        Rescale = "rescale",
        End = "rescaleend"
    }
    class RescaleEventArgsClass {
        private _builder;
        private constructor();
        get currentPosition(): Point;
        get targetRect(): Rect;
        get element(): HTMLElement | SVGElement;
        get handle(): string;
        static fromArgs(builder: RescaleEventArgs): RescaleEventArgsClass;
    }
    class RescaleEvent extends CustomUIEvent<RescaleEventArgsClass> {
        constructor(type: RescaleEventType, args: RescaleEventArgsClass, eventInit?: EventInit, evt?: MouseEvent | TouchEvent);
    }
    interface Rescaler {
        handles: RescaleHandle[];
        minWidth: number;
        maxWidth: number;
        maxHeight: number;
        minHeight: number;
        keepProportions: boolean;
        addEventListener(evt: RescaleEventType, listener: (evt: RescaleEvent) => void, useCapture?: boolean): void;
        removeEventListener(evt: RescaleEventType, listener: (evt: RescaleEvent) => void, useCapture?: boolean): void;
        dispatchEvent(evt: RescaleEvent): boolean;
    }
}
declare namespace Pacem.UI {
    type RotateEventArgs = {
        element: HTMLElement | SVGElement;
        origin: Point;
        currentPosition: Point;
        center: Point;
        startTime: number;
        /**
         * In radians, includes loops offset.
         */
        rotation: number;
    };
    enum RotateEventType {
        Start = "rotatestart",
        Rotate = "rotate",
        End = "rotateend"
    }
    class RotateEventArgsClass {
        private _builder;
        private constructor();
        get currentPosition(): Point;
        get rotation(): number;
        get element(): HTMLElement | SVGElement;
        get center(): Point;
        static fromArgs(builder: RotateEventArgs): RotateEventArgsClass;
    }
    class RotateEvent extends CustomUIEvent<RotateEventArgsClass> {
        constructor(type: RotateEventType, args: RotateEventArgsClass, eventInit?: EventInit, evt?: MouseEvent | TouchEvent);
    }
    interface Rotator {
        center?: Point;
        /** Gets or sets the minimum allowed rotation in radians */
        minRotation?: number;
        /** Gets or sets the maximum allowed rotation in radians */
        maxRotation?: number;
        /** Gets or sets the step constrained amount in radians */
        step?: number;
        addEventListener(evt: RotateEventType, listener: (evt: RotateEvent) => void, useCapture?: boolean): void;
        removeEventListener(evt: RotateEventType, listener: (evt: RotateEvent) => void, useCapture?: boolean): void;
        dispatchEvent(evt: RotateEvent): boolean;
    }
}
declare namespace Pacem.UI {
    type SwipeEventArgs = {
        horizontalspeed: number;
        verticalspeed: number;
        timestamp: number;
        position: Point;
        element: HTMLElement | SVGElement;
        t0: {
            timestamp: number;
            position: Point;
        };
    };
    enum SwipeEventType {
        Swipe = "swipe",
        SwipeLeft = "swipeleft",
        SwipeRight = "swiperight",
        SwipeAnimationEnd = "swipeanimationend",
        SwipeLeftAnimationEnd = "swipeleftanimationend",
        SwipeRightAnimationEnd = "swiperightanimationend"
    }
    class SwipeEventArgsClass {
        private _builder;
        private constructor();
        get direction(): "left" | "right";
        get speed(): number;
        get element(): HTMLElement | SVGElement;
        static fromArgs(builder: SwipeEventArgs): SwipeEventArgsClass;
    }
    class SwipeEvent extends CustomTypedEvent<SwipeEventArgsClass> {
        constructor(type: SwipeEventType, args: SwipeEventArgsClass, eventInit?: EventInit);
    }
    interface Swiper {
        readonly threshold: number;
        addEventListener(evt: SwipeEventType, listener: (evt: SwipeEvent) => void, useCapture?: boolean): void;
        removeEventListener(evt: SwipeEventType, listener: (evt: SwipeEvent) => void, useCapture?: boolean): void;
        dispatchEvent(evt: SwipeEvent): boolean;
    }
}
declare namespace Pacem.Behaviors {
    abstract class PacemBehavior extends Pacem.Components.PacemEventTarget {
        #private;
        protected abstract decorate(element: Element): any;
        protected abstract undecorate(element: Element): any;
        register(element: Element): void;
        unregister(element: Element): void;
        protected has(element: Element): boolean;
    }
}
declare namespace Pacem.Components {
    /**
     * Pacem Drag & Drop element adapter.
     */
    class PacemDragDropElement extends Pacem.Behaviors.PacemBehavior implements Pacem.UI.DragDropper {
        private _startHandler;
        protected decorate(element: Element): void;
        protected undecorate(element: Element): void;
        addEventListener(type: Pacem.UI.DragDropEventType, listener: (evt: Pacem.UI.DragDropEvent) => void, useCapture?: boolean): void;
        removeEventListener(type: Pacem.UI.DragDropEventType, listener: (evt: Pacem.UI.DragDropEvent) => void, useCapture?: boolean): void;
        dispatchEvent(evt: Pacem.UI.DragDropEvent): boolean;
        /** Gets or sets the amount of milliseconds to wait, while pressing on the draggable object, until the object itself must be considered "locked to drag". */
        lockTimeout: number;
        /** Gets or sets the drop targets (array of elements). */
        dropTargets: Element[];
        /** Gets or sets the drag mode ("self", "alias", "copy"). */
        mode: Pacem.UI.DragDataMode;
        /** Gets or sets the floating element while dragging around. */
        floater: Element;
        /** Gets or sets the drop mode ("insert", "none"). */
        dropBehavior: Pacem.UI.DropBehavior;
        /** Gets or sets the spill behavior ("revert", "remove", "none") */
        spillBehavior: Pacem.UI.DropTargetMissedBehavior;
        /** Gets or sets the handle selector to be matched when starting the drop gesture. */
        handleSelector: string;
    }
}
declare namespace Pacem.Components {
    type RepeaterItemEventArgs = {
        dom: Node[];
        item: any;
        index: number;
    };
    const RepeaterItemCreateEventName = "repeateritemcreate";
    const RepeaterItemRemoveEventName = "repeateritemremove";
    abstract class RepeaterItemEvent extends CustomTypedEvent<RepeaterItemEventArgs> {
        constructor(name: string, args: RepeaterItemEventArgs);
    }
    class RepeaterItemCreateEvent extends RepeaterItemEvent {
        constructor(args: RepeaterItemEventArgs);
    }
    class RepeaterItemRemoveEvent extends RepeaterItemEvent {
        constructor(args: RepeaterItemEventArgs);
    }
    interface AriaAttributes {
        set(name: string, value: string): void;
        remove(name: string): void;
        toObject(): {
            [name: string]: string;
        };
    }
    interface Aria {
        role: string;
        readonly attributes: AriaAttributes;
    }
    interface Wai {
        readonly aria: Aria;
    }
    class PacemElement extends PacemEventTarget implements Wai {
        #private;
        constructor(role?: string, aria?: {
            [name: string]: string;
        });
        get aria(): Aria;
        private _aria;
        static get emittedEventTypes(): Readonly<string[]>;
        connectedCallback(): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _tabIndex;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        cssClass: {
            [key: string]: boolean;
        } | string[];
        cssPart: {
            [key: string]: boolean;
        } | string[];
        css: {
            [key: string]: string;
        };
        hide: boolean;
        tooltip: string;
        tabOrder: number;
        culture: string;
        behaviors: Pacem.Behaviors.PacemBehavior[];
    }
    abstract class PacemContentElement extends PacemElement {
        protected abstract sanitize(html: string | Node): string | Node;
        content: string | Node;
        private _original;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _isContentNullOrEmpty;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _fillContent;
    }
    class PacemUnsafeContentElement extends PacemContentElement {
        protected sanitize(html: string): string | Node;
    }
    class PacemSafeContentElement extends PacemContentElement {
        protected sanitize(html: string | Node): string | Node;
    }
}
declare namespace Pacem.Components {
    class PacemRescaleElement extends Pacem.Behaviors.PacemBehavior implements Pacem.UI.Rescaler {
        protected decorate(element: Element): void;
        protected undecorate(element: Element): void;
        handles: Pacem.UI.RescaleHandle[];
        minWidth: number;
        maxWidth: number;
        minHeight: number;
        maxHeight: number;
        keepProportions: boolean;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _syncHandles;
        private _bag;
        private _setFrame;
        private _removeFrame;
        private _startHandler;
    }
}
declare namespace Pacem.Components {
    class PacemRotateElement extends Pacem.Behaviors.PacemBehavior implements Pacem.UI.Rotator {
        protected decorate(element: Element): void;
        protected undecorate(element: Element): void;
        step: number;
        minRotation: number;
        maxRotation: number;
        center: Point;
        private _startHandler;
    }
}
declare namespace Pacem.Components {
    class PacemSwipeElement extends Pacem.Behaviors.PacemBehavior implements Pacem.UI.Swiper {
        private _startHandler;
        /** No return point distance on the horizontal axis (defaults to half the device screen width). */
        threshold: number;
        includeMouse: boolean;
        protected decorate(element: Element): void;
        protected undecorate(element: Element): void;
    }
}
declare namespace Pacem.Components {
    interface OnInitialize {
        initializeCallback(): void;
    }
    interface OnDestroy {
        destroyCallback(): void;
    }
    abstract class PacemAdapter<TIterative extends Iterative<TItem>, TItem> extends PacemElement implements OnInitialize, OnDestroy {
        private _element;
        /** Gets the adapted element. */
        protected get master(): TIterative;
        /** Gets whether this adapter has been initialized or not. */
        get initialized(): boolean;
        private _propertyChangeHandler;
        /**
         * Handles the property changes for the master element.
         * @param name Name of the property that has changed
         * @param old Previous value
         * @param val Current value
         * @param first Is it the startup change?
         */
        masterPropertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        /**
         * Handles the property changes for item elements.
         * @param index Index of the element among the items
         * @param name Name of the property that has changed
         * @param old Previous value
         * @param val Current value
         * @param first Is it the startup change?
         */
        itemPropertyChangedCallback(index: number, name: string, old: any, val: any, first?: boolean): void;
        /** Called righat after the adapter 'initialize'. */
        initializeCallback(): void;
        destroyCallback(): void;
        initialize(adapted: TIterative): void;
        destroy(): void;
        disconnectedCallback(): void;
        private _adjustFocusIndex;
        private _getNextAvailable;
        private _getPreviousAvailable;
        private _getAvailable;
        /**
         * Returns whether the provided index is close (adjacent or equal) to the current one in focus.
         * @param ndx index to be checked
         */
        isClose(ndx: number): boolean;
        /**
         * Returns whether the provided index is adjacent (previous on the list) to the current one in focus.
         * @param ndx index to be checked
         */
        isPrevious(ndx: number): boolean;
        /**
         * Returns whether the provided index is adjacent (next on the list) to the current one in focus.
         * @param ndx index to be checked
         */
        isNext(ndx: number): boolean;
        select(ndx: number): void;
        /**
         * Sets the new iterative's index to the closest available previous item.
         * @param loop When `true` (default) it allows modular previous
         */
        previous(): void;
        previous(loop: boolean): void;
        /**
         * Sets the new iterative's index to the closest available next item.
         * @param loop When `true` (default) it allows modular next
         */
        next(): void;
        next(loop: boolean): void;
    }
}
declare namespace Pacem.Components {
    class PacemAnnihilatorElement extends HTMLElement {
        constructor();
        connectedCallback(): void;
    }
}
declare namespace Pacem {
    const RouterNavigatingEventName = "navigating";
    const RouterNavigateEventName = "navigate";
    type RouterNavigateEventArgs = {
        path: string;
        title?: string;
        referrer?: string;
    };
    class RouterNavigateEvent extends Pacem.CustomTypedEvent<RouterNavigateEventArgs> {
        constructor(path: string | RouterNavigateEventArgs);
    }
    class RouterNavigatingEvent extends Pacem.CustomTypedEvent<string> {
        constructor(path: string);
    }
}
declare namespace Pacem.Components {
    type RouterState = {
        [key: string]: string;
    } & {
        $pathname: string;
        $path: string;
        $querystring?: string;
        $query: {
            [key: string]: string;
        };
        $hash?: string;
    };
    class PacemRouterElement extends PacemEventTarget {
        #private;
        template: string;
        state: RouterState;
        path: string;
        parseState(state?: {
            [key: string]: string;
        }): RouterState;
        navigate(path: string, title?: string): any;
        navigate(state: {
            [key: string]: string;
        }, title?: string): any;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        connectedCallback(): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _onPopState;
        /**
         * Merged to provided state into the current one and returns the resulting path (including current querystring and hash).
         * @param state Piece of new state to be merged
         */
        private _stringifyMergedState;
        private _parseTemplate;
        private _segmentateUrl;
        private _parseState;
    }
}
declare namespace Pacem.Components {
    class PacemBeforeunloadElement extends PacemEventTarget {
        message: string;
        active: boolean;
        private _unloadingHandler;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components {
    class PacemBrowserDetectElement extends PacemEventTarget {
        #private;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        userAgent: string;
        get browser(): string;
        get version(): string;
        private _detect;
    }
}
declare namespace Pacem.Components {
    class PacemDataElement extends PacemEventTarget {
        private storage;
        constructor(storage?: Storage);
        model: any;
        persistAs: string;
        /** Debounces the model change */
        debounce: number;
        /** Throttles the model change if debounce is > 0 */
        throttle: boolean;
        private _handle;
        private _flag;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components {
    class PacemTweenElement extends PacemEventTarget implements OnPropertyChanged {
        private _tweener;
        constructor(_tweener?: Animations.TweenService);
        easing: (time: number) => number;
        from: number;
        to: number;
        duration: number;
        delay: number;
        start: boolean;
        value: number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        run(): Promise<void>;
        private _animate;
    }
}
declare namespace Pacem.Components {
    enum DockMode {
        Top = "top",
        Bottom = "bottom"
    }
    class PacemDockElement extends PacemEventTarget implements OnPropertyChanged {
        private _tweener;
        constructor(_tweener?: Animations.TweenService);
        mode: DockMode;
        dock: boolean;
        target: HTMLElement;
        delay: number;
        transitionDuration: number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _animate;
        private _setOffset;
        private _resetOffset;
        private _compute;
        private _doDock;
    }
}
declare namespace Pacem.Components {
    abstract class PacemTransferProxyElement extends PacemEventTarget {
        protected abstract get proxy(): HTMLElement;
        private _dom;
        private _children;
        get dom(): Element[];
        viewActivatedCallback(): void;
        protected moveContent(to: Element): void;
        disconnectedCallback(): void;
    }
    /** Moves its content to the document body and eventually removes it when disconnected. */
    class PacemBodyProxyElement extends PacemTransferProxyElement {
        protected get proxy(): HTMLElement;
    }
    /** Moves its content to the closest shell and eventually removes it when disconnected. */
    class PacemShellProxyElement extends PacemTransferProxyElement {
        protected get proxy(): HTMLElement;
    }
    /** Moves its content to the provided target element. */
    class PacemElementProxyElement extends PacemTransferProxyElement {
        protected get proxy(): HTMLElement;
        target: HTMLElement;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
}
declare namespace Pacem.Components {
    class PacemEventProxyElement extends PacemEventTarget {
        target: HTMLElement | Window;
        event: string;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _unobserve;
        private _observe;
        private _emitHandler;
    }
}
declare namespace Pacem.Components {
    class PacemFetchElement extends PacemEventTarget implements Net.Fetcher {
        #private;
        url: string;
        method: Net.HttpMethod;
        parameters: {
            [key: string]: string;
        };
        headers: {
            [key: string]: string;
        };
        credentials: 'omit' | 'same-origin' | 'include';
        mode: 'cors' | 'no-cors' | 'navigate' | 'same-origin';
        cache: RequestCache;
        fetching: boolean;
        /** Gets or sets whether to trigger a fetch whenever a significant property has changed (default: true). */
        autofetch: boolean;
        as: 'object' | 'text' | 'blob' | 'image';
        type: 'json' | 'raw';
        debounce: number;
        throttle: boolean;
        /** Gets or sets whether to compare parameter and header single values prior to trigger a new fetch execution (default false). */
        diffByValues: boolean;
        result: any;
        private _handle;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _delayAndConditionallyFetch;
        private _abortPending;
        /** Returns a promise to a request having an already-consumed response body. */
        fetch(): Promise<Response>;
        private _acceptFetchResult;
    }
}
declare namespace Pacem.Components {
    type StateEventType = 'push' | 'undo' | 'reset' | 'redo';
    export interface StateEventArgs<T> {
        readonly state: T;
        readonly canRedo: boolean;
        readonly canUndo: boolean;
    }
    export class StateEvent<T> extends CustomEvent<StateEventArgs<T>> {
        constructor(type: StateEventType, detail: StateEventArgs<T>);
    }
    export class PacemHistoryElement extends PacemEventTarget {
        #private;
        state: any;
        maxlength: number;
        /** @readonly*/
        canUndo: boolean;
        /** @readonly*/
        canRedo: boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _handleStateChange;
        redo(): void;
        reset(): void;
        undo(): void;
        private _synchronize;
    }
    export {};
}
declare namespace Pacem.Components {
    class PacemHtmlProxyElement extends PacemEventTarget {
        attr: string;
        value: string;
        private _html;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _update;
    }
}
declare namespace Pacem.Components {
    class PacemIfElement extends HTMLElement {
        #private;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        match: boolean;
    }
}
declare namespace Pacem.Components {
    class PacemTextElement extends HTMLElement implements OnPropertyChanged, OnConnected {
        constructor();
        private _text;
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
        /**
         * Gets or sets the plain text to display.
         */
        text: string;
    }
}
declare namespace Pacem.Components {
    const ScrollEventName: string;
    type ScrollEventArgs = {
        top: number;
        left: number;
    };
    class ScrollEvent extends CustomTypedEvent<ScrollEventArgs> {
        constructor(args: ScrollEventArgs);
    }
    /**
     * Manages scrolling interactions firing self-referenced ad-hoc events.
     */
    class PacemScrollAwareElement extends PacemEventTarget {
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        target: HTMLElement | SVGElement;
        offset: {
            top: number;
            left: number;
        };
    }
}
declare namespace Pacem.Components {
    class PacemViewportAwareElement extends PacemEventTarget {
        visible: boolean;
        target: HTMLElement | SVGElement;
        ignoreHorizontal: boolean;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components {
    const ResizeEventName = "resize";
    type ResizeEventArgs = {
        width: number;
        height: number;
        top?: number;
        left?: number;
    };
    class ResizeEvent extends CustomTypedEvent<ResizeEventArgs> {
        constructor(args: ResizeEventArgs);
    }
    class PacemResizeElement extends PacemEventTarget {
        target: Element;
        watchPosition: boolean;
        private get _target();
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private get _usePolyfill();
        private _previousHeight;
        private _previousWidth;
        private _previousTop;
        private _previousLeft;
        private _observer;
        private _mutationObserver;
        private _handle;
        private _start;
        private _stop;
        private _startWatchIntensively;
        private _checkSizeHandler;
        private _assignSizeDebounced;
        private _checkSize;
        get currentSize(): ResizeEventArgs;
        private _dispatchResize;
        connectedCallback(): void;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components {
    const PositionChangeEventName = "positionchange";
    type PositionChangeEventArgs = {
        top: number;
        left: number;
    };
    class PositionChangeEvent extends CustomTypedEvent<PositionChangeEventArgs> {
        constructor(args: PositionChangeEventArgs);
    }
    class PacemPositionElement extends PacemEventTarget implements OnConnected, OnDisconnected, OnPropertyChanged {
        constructor();
        target: HTMLElement;
        private get _target();
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _timer;
        private previousTop;
        private previousLeft;
        private start;
        private _check;
        private _change;
        connectedCallback(): void;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components {
    type ElementBounds = {
        left: number;
        top: number;
        width: number;
        height: number;
    };
    class AdjustEvent extends CustomTypedEvent<ElementBounds> {
        constructor(size: ElementBounds);
    }
    class PacemOverlayElement extends PacemEventTarget {
        constructor();
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _timer;
        private _previousHeight;
        private _previousWidth;
        private _previousTop;
        private _previousLeft;
        private start;
        private _check;
        target: HTMLElement;
        private _adjust;
        connectedCallback(): void;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components {
    class PacemPanelElement extends PacemSafeContentElement {
    }
}
declare namespace Pacem.Components {
    class PacemSpanElement extends PacemSafeContentElement {
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        text: string;
    }
}
declare namespace Pacem.Components {
    class PacemTemplateProxyElement extends /*PacemEventTarget*/ TemplateElement {
        target: HTMLTemplateElement;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        addEventListener(type: 'templatechange', listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        removeEventListener(type: 'templatechange', listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
    }
}
declare namespace Pacem.Components {
    class ItemEvent<T> extends CustomTypedEvent<T> {
        private _originalEvent;
        constructor(type: string, args: T, _originalEvent: Event);
        /** Gets the bubbling item's Event. */
        get srcEvent(): Event;
    }
    export class ItemCommandEvent extends ItemEvent<CommandEventArgs> {
        constructor(evt: CommandEvent);
    }
    export class CustomItemCommandEvent extends ItemEvent<any> {
        constructor(evt: CommandEvent);
    }
    /**
     * <pacem-repeater datasource="[{id:'first', items:['a','b','c']}, ...]">
     * <ol>
     *    <li>
     *      <template>
     *          <pacem-repeater datasource={{ ^item.items }}>
     *              <template>
     *                  <pacem-span text="{{ ^^item.id+': ': ^item.toUpperCase()  }}"></pacem-span>
     *              </template>
     *          </pacem-repeater>
     *      </template>
     *    </li>
     * </ol>
     * </pacem-repeater>
     */
    export class PacemRepeaterElement extends PacemEventTarget implements Repeater {
        datasource: any[];
        private _childItems;
        private _itemTemplate;
        private _childTemplatePlaceholder;
        private _fragment;
        removeItem(index: number): void;
        private _setItem;
        private _removeItems;
        private _setupItem;
        databind(): void;
        private _databind;
        private _onCommand;
        private _refreshItemTemplateHandler;
        private _buildupItemTemplate;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
    }
    export class RepeaterItem extends Pacem.RepeaterItem {
        private _repeater;
        private _template;
        private _fragment;
        private _holder;
        constructor(_repeater: PacemRepeaterElement, _template: HTMLTemplateElement, _fragment: DocumentFragment, _holder: HTMLTemplateElement | PacemTemplateProxyElement);
        /** @internal */
        append(): void;
        /** @internal */
        redrawEventually(tmpl: HTMLTemplateElement, frag: DocumentFragment): void;
        get dom(): Node[];
        get repeater(): PacemRepeaterElement;
        /** @internal */
        remove(): void;
        get index(): number;
        set index(v: number);
        get item(): any;
        set item(v: any);
        private _alterEgos;
    }
    export {};
}
declare namespace Pacem.Components {
    abstract class PacemItemElement extends PacemElement {
        private _container;
        protected get container(): ItemsContainer<any>;
        /** @overridable */
        protected findContainer(): ItemsContainer<any>;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
    }
    function isItemsContainer(object: any): object is ItemsContainer<any>;
    const ItemRegisterEventName = "itemregister";
    const ItemUnregisterEventName = "itemunregister";
    class ItemRegisterEvent<TItem extends PacemItemElement> extends CustomTypedEvent<TItem> {
        constructor(item: TItem, eventInit?: EventInit);
    }
    class ItemUnregisterEvent<TItem extends PacemItemElement> extends CustomTypedEvent<TItem> {
        constructor(item: TItem, eventInit?: EventInit);
    }
    /** Element that can be used both as ItemElement and ItemsContainer. */
    abstract class PacemCrossItemsContainerElement<TItem extends PacemItemElement> extends PacemItemElement implements ItemsContainer<TItem> {
        constructor(role?: string, aria?: {
            [name: string]: string;
        });
        private _registrar;
        items: TItem[];
        abstract validate(item: TItem): boolean;
        /**
         * Registers a new item among the items.
         * @param item {TItem} Item to be enrolled
         */
        register(item: TItem): boolean;
        /**
         * Removes an existing element from the items.
         * @param item {TItem} Item to be removed
         */
        unregister(item: TItem): boolean;
    }
    abstract class PacemItemsContainerElement<TItem extends PacemItemElement> extends PacemElement implements ItemsContainer<TItem> {
        constructor(role?: string, aria?: {
            [name: string]: string;
        });
        private _registrar;
        items: TItem[];
        abstract validate(item: TItem): boolean;
        /**
         * Registers a new item among the items.
         * @param item {TItem} Item to be enrolled
         */
        register(item: TItem): boolean;
        /**
         * Removes an existing element from the items.
         * @param item {TItem} Item to be removed
         */
        unregister(item: TItem): boolean;
    }
}
declare namespace Pacem.Components {
    abstract class PacemIterableElement extends PacemItemElement {
        /** @overrides */
        protected findContainer(): any;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
    }
    abstract class PacemIterativeElement<TItem extends PacemIterableElement> extends PacemItemsContainerElement<TItem> implements Iterative<TItem> {
        adapter: PacemAdapter<PacemIterativeElement<TItem>, TItem>;
        index: number;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _checkIndex;
        disconnectedCallback(): void;
    }
}
declare namespace Pacem.Components {
    class PacemLayoutProxyElement extends PacemEventTarget {
        #private;
        attr: string;
        value: string;
        connectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _update;
    }
}
declare namespace Pacem.Components {
    class PacemMetaProxyElement extends PacemEventTarget {
        name: string;
        itemprop: string;
        content: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _update;
    }
}
declare namespace Pacem.Components {
    class PacemOnlineStatusElement extends PacemEventTarget {
        online: boolean;
        connectedCallback(): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _onlineHandler;
    }
}
declare namespace Pacem.Components {
    class PacemServiceWorkerProxyElement extends PacemEventTarget {
        /** @readonly */
        registration: ServiceWorkerRegistration;
        /** @readonly */
        pushSubscription: PushSubscription;
        src: string;
        publicKey: string;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _tryUnregister;
        private _tryRegister;
        unsubscribe(subscription?: PushSubscription): Promise<boolean>;
        subscribe(publicKey?: string | Uint8Array): Promise<PushSubscription>;
    }
}
declare namespace Pacem.Components {
    const KeyboardShortcutExecuteEventName = "execute";
    class PacemShortcutElement extends PacemEventTarget {
        combination: string;
        target: EventTarget;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        private _removeHandler;
        private _addHandler;
        private _accumulator;
        private _shortcutHandler;
    }
}
declare namespace Pacem.Components {
    class PacemStyleProxyElement extends PacemEventTarget {
        src: string;
        cssText: string;
        cssReady: boolean;
        private _style;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _idleWhileReady;
        private _fetch;
    }
}
declare namespace Pacem.Components {
    class PacemTimerElement extends PacemEventTarget {
        constructor();
        interval: number;
        private _handle;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
        private _restart;
    }
}
declare namespace Pacem.Components {
    class PacemTitleProxyElement extends PacemEventTarget {
        value: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _update;
    }
}
declare namespace Pacem.Components {
    class PacemWebWorkerProxyElement extends PacemEventTarget {
        message: any;
        /** @readonly */
        result: any;
        src: string;
        autosend: boolean;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        disconnectedCallback(): void;
        send(message?: any): void;
        private _messageHandler;
        private _errorHandler;
        private _worker;
        private _initializeWorker;
        private _disposeWorker;
    }
}
declare namespace Pacem.Components {
    abstract class AnimationElement extends PacemItemElement implements Pacem.Animations.Timeline {
        target: Element;
        property: string;
        delay: number;
        duration: number;
        easing: Pacem.Animations.Easing;
        iterations: number;
        direction: PlaybackDirection;
        abstract from: any;
        abstract to: any;
        abstract startAnimation(): Promise<void>;
        abstract cancelAnimation(): void;
    }
    abstract class TweenAnimationElement<T> extends AnimationElement {
        #private;
        private _tweener;
        constructor(_tweener?: Animations.TweenService);
        protected get tweener(): Animations.TweenService;
        abstract from: T;
        abstract to: T;
        startAnimation(): Promise<void>;
        cancelAnimation(): void;
        protected abstract tweenInterpolationCallback(time: number, progress: number): T;
    }
}
declare namespace Pacem.Components {
    class PacemColorAnimationElement extends TweenAnimationElement<string> {
        #private;
        from: string;
        to: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        viewActivatedCallback(): void;
        private _precomputeColors;
        private _precomputeFrom;
        private _precomputeTo;
        private _precomputeColor;
        private _parseColor;
        protected tweenInterpolationCallback(time: number, progress: number): string;
    }
}
declare namespace Pacem.Components {
    class PacemNumberAnimationElement extends TweenAnimationElement<number> {
        from: number;
        to: number;
        protected tweenInterpolationCallback(time: number, progress: number): number;
    }
}
declare namespace Pacem.Components {
    class PacemPointAnimationElement extends TweenAnimationElement<Point> {
        from: Point;
        to: Point;
        protected tweenInterpolationCallback(time: number, progress: number): Point;
    }
}
declare namespace Pacem.Animations {
    interface Timeline {
        target: Element;
        property: string;
        delay: number;
        duration: number;
        easing: Pacem.Animations.Easing;
        iterations: number;
        direction: PlaybackDirection;
        startAnimation(): any;
        cancelAnimation(): any;
    }
}
declare namespace Pacem.Components {
    class PacemStoryboardElement extends PacemItemsContainerElement<AnimationElement> {
        validate(item: AnimationElement): boolean;
        autostart: boolean;
        /**
         * Extends or contracts the computed duration
         * */
        duration: number;
        datasource: Pacem.Animations.Timeline[];
        private _adaptedDatasource;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _buildDatasourceFromItems;
        private _buildDatasourceFromDatasource;
        private _animate;
        cancelAnimation(): void;
        startAnimation(): Promise<any>;
    }
}
