@pacem/pacem-core 1.0.0-abel

package/typings/index.d.ts

@@ -0,0 +1,2521 @@
+import { Blobs } from '@pacem/pacem-foundation';
+import { Dates } from '@pacem/pacem-foundation';
+import { detect } from '@pacem/pacem-foundation';
+import { Imaging } from '@pacem/pacem-foundation';
+import { Matrix2D } from '@pacem/pacem-foundation';
+import { Point } from '@pacem/pacem-foundation';
+import { Rect } from '@pacem/pacem-foundation';
+import { Strings } from '@pacem/pacem-foundation';
+
+declare abstract class AnimationElement extends PacemItemElement implements Timeline {
+    target: Element;
+    property: string;
+    delay: number;
+    duration: number;
+    easing: Easing;
+    iterations: number;
+    direction: PlaybackDirection;
+    abstract from: any;
+    abstract to: any;
+    abstract startAnimation(): Promise<void>;
+    abstract cancelAnimation(): void;
+}
+
+declare class AnimationEndEvent extends CustomEvent<{}> {
+    constructor();
+}
+
+declare class AnimationEvent_2 extends CustomTypedEvent<AnimationEventArgs> {
+    constructor(args: AnimationEventArgs);
+}
+
+declare type AnimationEventArgs = {
+    time: number;
+    value: number;
+};
+
+export declare namespace Animations {
+    export {
+        Easing,
+        Easings,
+        AnimationEventArgs,
+        AnimationEvent_2 as AnimationEvent,
+        AnimationEndEvent,
+        AnimationStartEvent,
+        TweenService,
+        Timer,
+        Timeline
+    }
+}
+
+declare class AnimationStartEvent extends CustomEvent<{}> {
+    constructor();
+}
+
+declare interface Aria {
+    role: string;
+    readonly attributes: AriaAttributes;
+}
+
+declare interface AriaAttributes {
+    set(name: string, value: string): void;
+    remove(name: string): void;
+    toObject(): {
+        [name: string]: string;
+    };
+}
+
+export declare class AttributeChangeEvent extends CustomTypedEvent<AttributeChangeEventArgs> {
+    constructor(args: AttributeChangeEventArgs);
+}
+
+export declare interface AttributeChangeEventArgs {
+    attributeName: string;
+    oldValue?: string;
+    currentValue: string;
+    firstChange?: boolean;
+}
+
+export declare const AttributeChangeEventName: string;
+
+export declare const avoidHandler: (evt: Event) => void;
+
+export declare namespace Behaviors {
+    export {
+        PacemBehavior
+    }
+}
+
+export declare class CommandEvent extends CustomTypedEvent<CommandEventArgs> {
+    constructor(args: CommandEventArgs);
+}
+
+export declare type CommandEventArgs = {
+    commandName: string;
+    commandArgument: any;
+};
+
+export declare const CommandEventName: string;
+
+export declare namespace Components {
+    export {
+        OnInitialize,
+        OnDestroy,
+        PacemAdapter,
+        PacemAnnihilatorElement,
+        PacemBeforeunloadElement,
+        PacemBroadcastChannelProxyElement,
+        PacemBrowserDetectElement,
+        PacemDataElement,
+        DockMode,
+        PacemDockElement,
+        PacemTransferProxyElement,
+        PacemBodyProxyElement,
+        PacemShellProxyElement,
+        PacemElementProxyElement,
+        PacemEventProxyElement,
+        PacemFetchElement,
+        StateEventArgs,
+        StateEvent,
+        PacemHistoryElement,
+        PacemHtmlProxyElement,
+        PacemIfElement,
+        isItemsContainer,
+        PacemItemElement,
+        ItemRegisterEventName,
+        ItemUnregisterEventName,
+        ItemRegisterEvent,
+        ItemUnregisterEvent,
+        PacemCrossItemsContainerElement,
+        PacemItemsContainerElement,
+        PacemIterableElement,
+        PacemIterativeElement,
+        PacemLayoutProxyElement,
+        PacemMetaProxyElement,
+        PacemOnlineStatusElement,
+        PacemPanelElement,
+        ItemCommandEvent,
+        CustomItemCommandEvent,
+        PacemRepeaterElement,
+        RepeaterItem_2 as RepeaterItem,
+        ResizeEventName,
+        ResizeEventArgs,
+        ResizeEvent,
+        PacemResizeElement,
+        RouterNavigatingEventName,
+        RouterNavigateEventName,
+        RouterNavigateEventArgs,
+        RouterNavigateEvent,
+        RouterNavigatingEvent,
+        PacemRouterElement,
+        ScrollEventName,
+        ScrollEventArgs,
+        ScrollEvent,
+        PacemScrollAwareElement,
+        PacemServiceWorkerProxyElement,
+        KeyboardShortcutExecuteEventName,
+        PacemShortcutElement,
+        PacemSpanElement,
+        PacemStyleProxyElement,
+        PacemTemplateProxyElement,
+        PacemTextElement,
+        PacemTimerElement,
+        PacemTitleProxyElement,
+        PacemTweenElement,
+        RepeaterItemEventArgs,
+        RepeaterItemCreateEventName,
+        RepeaterItemRemoveEventName,
+        RepeaterItemEvent,
+        RepeaterItemCreateEvent,
+        RepeaterItemRemoveEvent,
+        AriaAttributes,
+        Aria,
+        Wai,
+        PacemElement,
+        PacemContentElement,
+        PacemUnsafeContentElement,
+        PacemSafeContentElement,
+        PacemViewportAwareElement,
+        PacemWebWorkerProxyElement,
+        PacemDragDropElement,
+        PacemRescaleElement,
+        PacemRotateElement,
+        SwipeOptions,
+        PacemSwipeElement,
+        AnimationElement,
+        TweenAnimationElement,
+        PacemColorAnimationElement,
+        PacemNumberAnimationElement,
+        PacemPointAnimationElement,
+        PacemStoryboardElement
+    }
+}
+
+export declare function Concurrent(): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
+
+/** To be replaced when Cookie Store API types will be included in TypeScript. */
+export declare 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 declare 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 declare class CurrentIndexChangeEvent extends CustomTypedEvent<IndexChangeEventArgs> {
+    constructor(args: IndexChangeEventArgs);
+}
+
+export declare const CustomElement: (config: CustomElementConfig) => (target: Type<any>) => void;
+
+export declare 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;
+};
+
+declare interface CustomElementRegistry_2 {
+    define(name: string, type: Type<any>, options?: {
+        [key: string]: string;
+    }): any;
+    get(name: string): any;
+    whenDefined(name: string): PromiseLike<void>;
+}
+export { CustomElementRegistry_2 as CustomElementRegistry }
+
+export declare 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;
+}
+
+export declare 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 class CustomItemCommandEvent extends ItemEvent<any> {
+    constructor(evt: CommandEvent);
+}
+
+export declare abstract class CustomTypedEvent<TDetail> extends CustomEvent<TDetail> {
+    constructor(type: string, detail: TDetail, eventInit?: CustomEventInit<TDetail>);
+}
+
+export declare 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;
+}
+
+export declare function Debounce(msecs?: true | number, keyFactory?: (key: String, ...args: any[]) => string): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
+
+export declare class DeepCloner {
+    private constructor();
+    static clone(obj: any): any;
+    private _clone;
+}
+
+/**
+ * Default, and essentially ONLY, property comparer for equalitycheck
+ * @param old value 1
+ * @param val value 2
+ */
+export declare const DefaultComparer: PropertyComparer<any>;
+
+export declare const Defaults: {
+    USE_SHADOW_ROOT: boolean;
+};
+
+export declare 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 enum DockMode {
+    Top = "top",
+    Bottom = "bottom"
+}
+
+declare type DownloadOptions = {
+    filename?: string;
+    mime?: string;
+    credentials?: RequestCredentials;
+    headers?: {
+        [key: string]: string;
+    };
+};
+
+declare 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"
+}
+
+declare class DragDropEvent extends CustomUIEvent<DragDropEventArgsClass | DragDropInitEventArgsClass> {
+    constructor(type: DragDropEventType, args: DragDropEventArgsClass | DragDropInitEventArgsClass, eventInit?: EventInit, evt?: MouseEvent | TouchEvent);
+}
+
+declare type DragDropEventArgs = {
+    element: HTMLElement | SVGElement;
+    placeholder: HTMLElement | SVGElement;
+    origin: Point;
+    currentPosition: Point;
+    initialDelta: Point;
+    startTime: number;
+    data: any;
+    floater: Element;
+    target?: Element;
+};
+
+declare 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;
+}
+
+declare class DragDropEventArgsClass extends DragDropEventArgsBaseClass {
+    private _placeholder;
+    private _data;
+    private constructor();
+    get placeholder(): HTMLElement | SVGElement;
+    get data(): any;
+    static fromArgs(builder: DragDropEventArgs): DragDropEventArgsClass;
+}
+
+declare 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"
+}
+
+declare class DragDropInitEventArgsClass extends DragDropEventArgsBaseClass {
+    private constructor();
+    placeholder: HTMLElement | SVGElement;
+    data: any;
+    static fromArgs(builder: DragDropEventArgs): DragDropInitEventArgsClass;
+}
+
+/**
+ * Interface to be implemented in order to create a proper drag & drop adapter.
+ */
+declare 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;
+}
+
+declare 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"
+}
+
+declare 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"
+}
+
+declare type Easing = (any: any) => any & {
+    css: string;
+};
+
+declare const Easings: any;
+
+export declare const EMPTY_MATCHER: RegExp;
+
+export declare interface EventCoordinates {
+    readonly page: Point;
+    readonly client: Point;
+    readonly screen: Point;
+}
+
+export declare enum EventKeyModifier {
+    AltKey = "Alt",
+    CtrlKey = "Ctrl",
+    ShiftKey = "Shift",
+    MetaKey = "Cmd"
+}
+
+export declare interface EventKeyModifiers extends KeyEventLike {
+}
+
+export declare 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 interface Fetcher extends NotifyPropertyChange {
+    url: string;
+    method: HttpMethod;
+    parameters: {
+        [key: string]: string;
+    };
+    headers: {
+        [key: string]: string;
+    };
+    result: any;
+    fetch: () => PromiseLike<GlobalResponse>;
+}
+
+declare class Fetcher {
+    static isEmpty(r: GlobalResponse): boolean;
+}
+
+declare const FetchErrorEventName = "error";
+
+declare const FetchResultEventName = "fetchresult";
+
+declare const FetchSuccessEventName = "success";
+
+declare type GlobalResponse = Response;
+
+/** @deprecated */
+declare 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_2>;
+    /**
+     * Short-hand for 'GET' requests.
+     */
+    get(url: any, data?: any, headers?: {
+        [key: string]: string;
+    }): DeferPromise<Response_2>;
+    /**
+     * Short-hand for 'POST' requests (content provided as json).
+     */
+    post(url: any, data?: any, headers?: {
+        [key: string]: string;
+    }): DeferPromise<Response_2>;
+}
+
+declare enum HttpMethod {
+    Get = "GET",
+    Post = "POST",
+    Put = "PUT",
+    Delete = "DELETE",
+    Options = "OPTIONS",
+    Head = "HEAD",
+    Patch = "PATCH",
+    Connect = "CONNECT",
+    Trace = "TRACE"
+}
+
+export declare type IndexChangeEventArgs = {
+    currentIndex: number;
+    previousIndex: number;
+};
+
+export declare const INSTANCE_BINDINGS_VAR = "pacem:custom-element:bindings";
+
+export declare const INSTANCE_HOST_VAR = "pacem:custom-element:host";
+
+export declare const INSTANCE_SCOPE_VAR = "pacem:custom-element:scope";
+
+declare function isItemsContainer(object: any): object is ItemsContainer<any>;
+
+declare class ItemCommandEvent extends ItemEvent<CommandEventArgs> {
+    constructor(evt: CommandEvent);
+}
+
+declare class ItemEvent<T> extends CustomTypedEvent<T> {
+    private _originalEvent;
+    constructor(type: string, args: T, _originalEvent: Event);
+    /** Gets the bubbling item's Event. */
+    get srcEvent(): Event;
+}
+
+declare class ItemRegisterEvent<TItem extends PacemItemElement> extends CustomTypedEvent<TItem> {
+    constructor(item: TItem, eventInit?: EventInit);
+}
+
+declare const ItemRegisterEventName = "itemregister";
+
+export declare interface ItemsContainer<TItem> extends NotifyPropertyChange {
+    items: TItem[];
+    register(item: TItem): boolean;
+    unregister(item: TItem): boolean;
+}
+
+declare class ItemUnregisterEvent<TItem extends PacemItemElement> extends CustomTypedEvent<TItem> {
+    constructor(item: TItem, eventInit?: EventInit);
+}
+
+declare const ItemUnregisterEventName = "itemunregister";
+
+export declare interface Iterative<TItem> extends ItemsContainer<TItem> {
+    index: number;
+}
+
+export declare 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;
+}
+
+/** How functions get serialized. */
+export declare 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"
+}
+
+export declare interface JsonSerializationOptions {
+    functions?: JsonFunctionConversion;
+}
+
+declare const KeyboardShortcutExecuteEventName = "execute";
+
+export declare interface KeyEventLike {
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly metaKey: boolean;
+    readonly which?: number;
+}
+
+declare interface Logger {
+    log(level: LogLevel, message: string, category?: string): any;
+}
+
+export declare namespace Logging {
+    export {
+        LogLevel,
+        Logger
+    }
+}
+
+declare enum LogLevel {
+    Trace = "trace",
+    Debug = "debug",
+    Warn = "warn",
+    Error = "error",
+    Info = "info",
+    Log = "log"
+}
+
+export declare namespace Net {
+    export {
+        HttpMethod,
+        Fetcher,
+        OAuthFetchable,
+        FetchResultEventName,
+        FetchErrorEventName,
+        FetchSuccessEventName,
+        StatusCodeError,
+        Response_2 as Response,
+        RequestOptions,
+        Http
+    }
+}
+
+export declare interface NotifyPropertyChange extends EventTarget {
+}
+
+declare interface OAuthFetchable {
+    readonly fetcher?: Fetcher;
+    fetchCredentials: RequestCredentials;
+    fetchHeaders: {
+        [key: string]: string;
+    };
+}
+
+export declare interface OnAdopted {
+    adoptedCallback(): void;
+}
+
+export declare interface OnAttributeChanged {
+    attributeChangedCallback(attrName?: string, oldVal?: string, newVal?: string): void;
+}
+
+export declare interface OnConnected {
+    connectedCallback(): void;
+}
+
+declare interface OnDestroy {
+    destroyCallback(): void;
+}
+
+export declare interface OnDisconnected {
+    disconnectedCallback(): void;
+}
+
+declare interface OnInitialize {
+    initializeCallback(): void;
+}
+
+export declare interface OnPropertyChanged {
+    propertyChangedCallback(name?: string, oldVal?: any, newVal?: any, firstChange?: boolean): void;
+}
+
+export declare interface OnViewActivated {
+    viewActivatedCallback(): void;
+}
+
+/** the overall customelement prefix */
+export declare const P: any;
+
+declare 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 class PacemAnnihilatorElement extends HTMLElement {
+    constructor();
+    connectedCallback(): void;
+}
+
+declare class PacemBeforeunloadElement extends PacemEventTarget {
+    message: string;
+    active: boolean;
+    private _unloadingHandler;
+    viewActivatedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare abstract class PacemBehavior extends 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;
+}
+
+/** Moves its content to the document body and eventually removes it when disconnected. */
+declare class PacemBodyProxyElement extends PacemTransferProxyElement {
+    protected get proxy(): HTMLElement;
+}
+
+declare class PacemBroadcastChannelProxyElement extends PacemEventTarget {
+    #private;
+    message: any;
+    /** @readonly */
+    result: any;
+    channelName: 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 _initializeChannel;
+    private _disposeChannel;
+}
+
+declare 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 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 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;
+}
+
+/** Element that can be used both as ItemElement and ItemsContainer. */
+declare 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;
+}
+
+declare class PacemDataElement extends PacemEventTarget {
+    private storage;
+    constructor(storage?: Storage_2);
+    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;
+}
+
+/** @deprecated */
+declare class PacemDockElement extends PacemEventTarget {
+    private _tweener;
+    constructor(_tweener?: 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;
+}
+
+/**
+ * Pacem Drag & Drop element adapter.
+ */
+declare class PacemDragDropElement extends PacemBehavior implements DragDropper {
+    private _startHandler;
+    protected decorate(element: Element): void;
+    protected undecorate(element: Element): void;
+    addEventListener(type: DragDropEventType, listener: (evt: DragDropEvent) => void, useCapture?: boolean): void;
+    removeEventListener(type: DragDropEventType, listener: (evt: DragDropEvent) => void, useCapture?: boolean): void;
+    dispatchEvent(evt: 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: DragDataMode;
+    /** Gets or sets the floating element while dragging around. */
+    floater: Element;
+    /** Gets or sets the drop mode ("insert", "none"). */
+    dropBehavior: DropBehavior;
+    /** Gets or sets the spill behavior ("revert", "remove", "none") */
+    spillBehavior: DropTargetMissedBehavior;
+    /** Gets or sets the handle selector to be matched when starting the drop gesture. */
+    handleSelector: string;
+}
+
+declare 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: PacemBehavior[];
+}
+
+/** Moves its content to the provided target element. */
+declare class PacemElementProxyElement extends PacemTransferProxyElement {
+    protected get proxy(): HTMLElement;
+    target: HTMLElement;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemEventProxyElement extends PacemEventTarget {
+    target: HTMLElement | Window;
+    event: string;
+    capture: boolean;
+    viewActivatedCallback(): void;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    disconnectedCallback(): void;
+    private _unobserve;
+    private _observe;
+    private _emitHandler;
+}
+
+export declare 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;
+    private _emitCore;
+    handle(evt: Event): any;
+    handle(type: string, detail?: any): any;
+    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: 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: LogLevel, message: string, category?: string): void;
+    /** Refreshes all the properties corresponding to explicit binding attributes. */
+    protected refreshBindings(): void;
+}
+
+declare class PacemFetchElement extends PacemEventTarget implements Fetcher {
+    #private;
+    url: string;
+    method: 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 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;
+}
+
+declare class PacemHtmlProxyElement extends PacemEventTarget {
+    attr: string;
+    value: string;
+    private _html;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _update;
+}
+
+declare class PacemIfElement extends HTMLElement {
+    #private;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    match: boolean;
+}
+
+declare abstract class PacemItemElement extends PacemElement {
+    private _container;
+    protected get container(): ItemsContainer<any>;
+    /** @overridable */
+    protected findContainer(): ItemsContainer<any>;
+    viewActivatedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare 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 abstract class PacemIterableElement extends PacemItemElement {
+    /** @overrides */
+    protected findContainer(): any;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare 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 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 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 class PacemNumberAnimationElement extends TweenAnimationElement<number> {
+    from: number;
+    to: number;
+    protected tweenInterpolationCallback(time: number, progress: number): number;
+}
+
+declare class PacemOnlineStatusElement extends PacemEventTarget {
+    online: boolean;
+    connectedCallback(): void;
+    viewActivatedCallback(): void;
+    disconnectedCallback(): void;
+    private _onlineHandler;
+}
+
+declare class PacemPanelElement extends PacemSafeContentElement {
+}
+
+declare class PacemPointAnimationElement extends TweenAnimationElement<Point> {
+    from: Point;
+    to: Point;
+    protected tweenInterpolationCallback(time: number, progress: number): Point;
+}
+
+/**
+ * <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>
+ */
+declare 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;
+}
+
+declare class PacemRescaleElement extends PacemBehavior implements Rescaler {
+    protected decorate(element: Element): void;
+    protected undecorate(element: Element): void;
+    handles: 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 class PacemResizeElement extends PacemEventTarget {
+    target: Element;
+    watchPosition: boolean;
+    private get _target();
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _previousHeight;
+    private _previousWidth;
+    private _previousTop;
+    private _previousLeft;
+    private _observer;
+    private _handle;
+    private _start;
+    private _stop;
+    private _startWatchIntensively;
+    private _checkSizeHandler;
+    private _assignSizeDebounced;
+    private _checkSize;
+    get currentSize(): ResizeEventArgs;
+    private _dispatchResize;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare class PacemRotateElement extends PacemBehavior implements Rotator {
+    protected decorate(element: Element): void;
+    protected undecorate(element: Element): void;
+    step: number;
+    minRotation: number;
+    maxRotation: number;
+    center: Point;
+    private _startHandler;
+}
+
+declare 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 class PacemSafeContentElement extends PacemContentElement {
+    private _sanitizeLegacy;
+    protected sanitize(html: string | Node): string | Node;
+}
+
+/**
+ * Manages scrolling interactions firing self-referenced ad-hoc events.
+ */
+declare class PacemScrollAwareElement extends PacemEventTarget {
+    viewActivatedCallback(): void;
+    disconnectedCallback(): void;
+    target: HTMLElement | SVGElement;
+    offset: {
+        top: number;
+        left: number;
+    };
+}
+
+declare 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<ArrayBuffer>): Promise<PushSubscription>;
+}
+
+/** Moves its content to the closest shell and eventually removes it when disconnected. */
+declare class PacemShellProxyElement extends PacemTransferProxyElement {
+    protected get proxy(): HTMLElement;
+}
+
+declare 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 class PacemSpanElement extends PacemSafeContentElement {
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    viewActivatedCallback(): void;
+    text: string;
+}
+
+declare class PacemStoryboardElement extends PacemItemsContainerElement<AnimationElement> {
+    validate(item: AnimationElement): boolean;
+    autostart: boolean;
+    /**
+     * Extends or contracts the computed duration
+     * */
+    duration: number;
+    datasource: 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>;
+}
+
+declare 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 class PacemSwipeElement extends PacemBehavior implements Swiper {
+    #private;
+    /** No return point distance on the horizontal axis (defaults to half the device screen width). */
+    snaps: number[];
+    direction: 'horizontal' | 'vertical';
+    options: Partial<SwipeOptions>;
+    /** Handle selector to be matched when starting the drag gesture. */
+    handleSelector: string;
+    protected decorate(element: Element): void;
+    protected undecorate(element: Element): void;
+    viewActivatedCallback(): void;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _setOptions;
+    private _prepareHandler;
+    private _startHandler;
+    private _undo;
+    private _undoHandler;
+}
+
+declare 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 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 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 class PacemTitleProxyElement extends PacemEventTarget {
+    value: string;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    viewActivatedCallback(): void;
+    private _update;
+}
+
+declare 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;
+}
+
+declare class PacemTweenElement extends PacemEventTarget {
+    private _tweener;
+    constructor(_tweener?: 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 class PacemUnsafeContentElement extends PacemContentElement {
+    protected sanitize(html: string): string | Node;
+}
+
+/** @deprecated */
+declare class PacemViewportAwareElement extends PacemEventTarget {
+    visible: boolean;
+    target: HTMLElement | SVGElement;
+    ignoreHorizontal: boolean;
+    viewActivatedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+declare 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;
+}
+
+export declare const PCSS: any;
+
+export declare const preventDefaultHandler: (evt: Event) => void;
+
+export declare class PropertyChangeEvent extends CustomTypedEvent<PropertyChangeEventArgs> {
+    constructor(args: PropertyChangeEventArgs);
+}
+
+export declare interface PropertyChangeEventArgs {
+    propertyName: string;
+    oldValue?: any;
+    currentValue: any;
+    firstChange?: boolean;
+}
+
+export declare const PropertyChangeEventName: string;
+
+export declare type PropertyComparer<T> = (old: T, val: T) => boolean;
+
+export declare 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;
+}
+
+export declare 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;
+};
+
+export declare type PropertyDependencies = {
+    [name: string]: PropertyDependency;
+};
+
+export declare 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;
+};
+
+export declare 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[];
+}
+
+export declare type RegexMatchSegment = {
+    value: string;
+    match: boolean;
+    index: number;
+};
+
+export declare interface Repeater extends HTMLElement {
+    datasource: any[];
+}
+
+export declare 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): RepeaterItem;
+}
+
+export declare 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 class RepeaterItem_2 extends 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;
+}
+
+declare class RepeaterItemCreateEvent extends RepeaterItemEvent {
+    constructor(args: RepeaterItemEventArgs);
+}
+
+declare const RepeaterItemCreateEventName = "repeateritemcreate";
+
+declare abstract class RepeaterItemEvent extends CustomTypedEvent<RepeaterItemEventArgs> {
+    constructor(name: string, args: RepeaterItemEventArgs);
+}
+
+declare type RepeaterItemEventArgs = {
+    dom: Node[];
+    item: any;
+    index: number;
+};
+
+declare class RepeaterItemRemoveEvent extends RepeaterItemEvent {
+    constructor(args: RepeaterItemEventArgs);
+}
+
+declare const RepeaterItemRemoveEventName = "repeateritemremove";
+
+/** @deprecated */
+declare type RequestOptions = {
+    data?: 'string' | {
+        [key: string]: string;
+    };
+    headers?: {
+        [key: string]: string;
+    };
+    method: HttpMethod;
+    progress?: (pct: number) => void;
+};
+
+declare class RescaleEvent extends CustomUIEvent<RescaleEventArgsClass> {
+    constructor(type: RescaleEventType, args: RescaleEventArgsClass, eventInit?: EventInit, evt?: MouseEvent | TouchEvent);
+}
+
+declare type RescaleEventArgs = {
+    element: HTMLElement | SVGElement;
+    origin: Point;
+    currentPosition: Point;
+    startTime: number;
+    handle: string;
+    targetRect?: Rect;
+};
+
+declare class RescaleEventArgsClass {
+    private _builder;
+    private constructor();
+    get currentPosition(): Point;
+    get targetRect(): Rect;
+    get element(): HTMLElement | SVGElement;
+    get handle(): string;
+    static fromArgs(builder: RescaleEventArgs): RescaleEventArgsClass;
+}
+
+declare enum RescaleEventType {
+    Start = "rescalestart",
+    Rescale = "rescale",
+    End = "rescaleend"
+}
+
+declare enum RescaleHandle {
+    All = "all",
+    Top = "top",
+    Left = "left",
+    Right = "right",
+    Bottom = "bottom"
+}
+
+declare 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 class ResizeEvent extends CustomTypedEvent<ResizeEventArgs> {
+    constructor(args: ResizeEventArgs);
+}
+
+declare type ResizeEventArgs = {
+    width: number;
+    height: number;
+    top?: number;
+    left?: number;
+};
+
+declare const ResizeEventName = "resize";
+
+/** @deprecated */
+declare class Response_2 {
+    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;
+}
+
+declare class RotateEvent extends CustomUIEvent<RotateEventArgsClass> {
+    constructor(type: RotateEventType, args: RotateEventArgsClass, eventInit?: EventInit, evt?: MouseEvent | TouchEvent);
+}
+
+declare type RotateEventArgs = {
+    element: HTMLElement | SVGElement;
+    origin: Point;
+    currentPosition: Point;
+    center: Point;
+    startTime: number;
+    /**
+     * In radians, includes loops offset.
+     */
+    rotation: number;
+};
+
+declare class RotateEventArgsClass {
+    private _builder;
+    private constructor();
+    get currentPosition(): Point;
+    get rotation(): number;
+    get element(): HTMLElement | SVGElement;
+    get center(): Point;
+    static fromArgs(builder: RotateEventArgs): RotateEventArgsClass;
+}
+
+declare enum RotateEventType {
+    Start = "rotatestart",
+    Rotate = "rotate",
+    End = "rotateend"
+}
+
+declare 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 type RouteMetadata = {
+    name: string;
+    optional: boolean;
+    index: number;
+};
+
+declare class RouterNavigateEvent extends CustomTypedEvent<RouterNavigateEventArgs> {
+    constructor(path: string | RouterNavigateEventArgs);
+}
+
+declare type RouterNavigateEventArgs = {
+    path: string;
+    title?: string;
+    referrer?: string;
+};
+
+declare const RouterNavigateEventName = "navigate";
+
+declare class RouterNavigatingEvent extends CustomTypedEvent<string> {
+    constructor(path: string);
+}
+
+declare const RouterNavigatingEventName = "navigating";
+
+export declare type RouterState = {
+    [key: string]: string;
+} & {
+    $pathname: string;
+    $path: string;
+    $querystring?: string;
+    $query: {
+        [key: string]: string;
+    };
+    $hash?: string;
+};
+
+declare class ScrollEvent extends CustomTypedEvent<ScrollEventArgs> {
+    constructor(args: ScrollEventArgs);
+}
+
+declare type ScrollEventArgs = {
+    top: number;
+    left: number;
+};
+
+declare const ScrollEventName: string;
+
+declare class StateEvent<T> extends CustomEvent<StateEventArgs<T>> {
+    constructor(type: StateEventType, detail: StateEventArgs<T>);
+}
+
+declare interface StateEventArgs<T> {
+    readonly state: T;
+    readonly canRedo: boolean;
+    readonly canUndo: boolean;
+}
+
+declare type StateEventType = 'push' | 'undo' | 'reset' | 'redo';
+
+declare class StatusCodeError extends Error {
+    private statusCode;
+    constructor(statusCode: number, statusText: string);
+    get status(): number;
+}
+
+export declare const stopPropagationHandler: (evt: Event) => void;
+
+declare class Storage_2 {
+    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;
+}
+export { Storage_2 as Storage }
+
+declare class SwipeEvent extends CustomTypedEvent<SwipeEventArgsClass> {
+    constructor(type: SwipeEventType, args: SwipeEventArgsClass, eventInit?: EventInit);
+}
+
+declare type SwipeEventArgs = {
+    horizontalspeed?: number;
+    verticalspeed?: number;
+    timestamp: number;
+    position: Point;
+    element: HTMLElement | SVGElement;
+    inertia?: number;
+    fling?: number;
+    t0: {
+        timestamp: number;
+        position: Point;
+    };
+    vertical?: boolean;
+};
+
+declare class SwipeEventArgsClass {
+    #private;
+    private _builder;
+    private constructor();
+    get direction(): "down" | "left" | "right" | "up";
+    /** Speed in pixels/second, with sign. */
+    get speed(): number;
+    /** Current offset relative to element's original position. */
+    get delta(): number;
+    get flinging(): boolean;
+    /** Final offset (relative to element's original position) that takes release velocity into account. */
+    get predictedDelta(): number;
+    /** Seconds to reach the final predicted position. */
+    get predictedDuration(): number;
+    get element(): HTMLElement | SVGElement;
+    static fromArgs(builder: SwipeEventArgs): SwipeEventArgsClass;
+}
+
+declare enum SwipeEventType {
+    Swipe = "swipe",
+    Pan = "pan",
+    SwipeLeft = "swipeleft",
+    SwipeRight = "swiperight",
+    SwipeUp = "swipeup",
+    SwipeDown = "swipedown",
+    SwipeAnimationEnd = "swipeanimationend",
+    SwipeLeftAnimationEnd = "swipeleftanimationend",
+    SwipeRightAnimationEnd = "swiperightanimationend",
+    SwipeUpAnimationEnd = "swipeupanimationend",
+    SwipeDownAnimationEnd = "swipedownanimationend"
+}
+
+declare type SwipeOptions = {
+    /** Inertia on release. */
+    inertia: number;
+    /** Drag start threshold (pixels in the swipe direction). */
+    start: number;
+    /** Fling detection threshold on release (pixels/second). */
+    fling: number;
+    /** True when spans must be considered absolute: consistent with the original element position thus updated after each swipe gesture.
+     * Otherwise false (default) and considered relative to the element no matter how many swipe gesture already happened: they remain constant.
+     */
+    autoresetSpans: boolean;
+    /**
+     * When true (default) it allows dragging the swiped element beyond the furthest snap and computes a bounce-back motion to snap the target.
+     * When false, it does not allow dragging beyond the allowed snaps and the motion is constrained inside that range.
+     */
+    bouncy: boolean;
+};
+
+declare interface Swiper {
+    /** Anchoring targets. */
+    readonly snaps: number[];
+    /** Swipe direction. */
+    readonly direction: 'vertical' | 'horizontal';
+    addEventListener(evt: SwipeEventType, listener: (evt: SwipeEvent) => void, useCapture?: boolean): void;
+    removeEventListener(evt: SwipeEventType, listener: (evt: SwipeEvent) => void, useCapture?: boolean): void;
+    dispatchEvent(evt: SwipeEvent): boolean;
+}
+
+export declare abstract class TemplateElement extends HTMLElement {
+}
+
+export declare function Throttle(msecs?: true | number, keyFactory?: (key: String, ...args: any[]) => string): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
+
+declare interface Timeline {
+    target: Element;
+    property: string;
+    delay: number;
+    duration: number;
+    easing: Easing;
+    iterations: number;
+    direction: PlaybackDirection;
+    startAnimation(): any;
+    cancelAnimation(): any;
+}
+
+declare class Timer {
+    #private;
+    private constructor();
+    private _run;
+    static run(callback: (time?: number) => void, fps?: number): Timer;
+    stop(): void;
+}
+
+declare function Transformer_2(name?: string): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
+export { Transformer_2 as Transformer }
+
+export declare type TransformFunction = (value?: any, ...args: any[]) => any;
+
+declare abstract class TweenAnimationElement<T> extends AnimationElement {
+    #private;
+    private _tweener;
+    constructor(_tweener?: TweenService);
+    protected get tweener(): TweenService;
+    abstract from: T;
+    abstract to: T;
+    startAnimation(): Promise<void>;
+    cancelAnimation(): void;
+    protected abstract tweenInterpolationCallback(time: number, progress: number): T;
+}
+
+declare class TweenService {
+    run(from: number, to: number, duration: number, delay?: number, easing?: (time: number) => number, callback?: (time: number, value: number) => void): Promise<void>;
+}
+
+export declare const Type: FunctionConstructor;
+
+export declare interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+
+export declare namespace UI {
+    export {
+        DragDataMode,
+        DropBehavior,
+        DropTargetMissedBehavior,
+        DragDropEventType,
+        DragDropInitEventArgsClass,
+        DragDropEventArgsClass,
+        DragDropEventArgs,
+        DragDropEvent,
+        DragDropper,
+        RescaleHandle,
+        RescaleEventArgs,
+        RescaleEventType,
+        RescaleEventArgsClass,
+        RescaleEvent,
+        Rescaler,
+        RotateEventArgs,
+        RotateEventType,
+        RotateEventArgsClass,
+        RotateEvent,
+        Rotator,
+        SwipeEventArgs,
+        SwipeEventType,
+        SwipeEventArgsClass,
+        SwipeEvent,
+        Swiper
+    }
+}
+
+export declare interface UIEventLike extends KeyEventLike {
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly pageX: number;
+    readonly pageY: number;
+    readonly screenX: number;
+    readonly screenY: number;
+}
+
+export declare 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): Promise<void>;
+    static download(url: string, filename?: string, mime?: string): Promise<void>;
+    static download(url: string, options: DownloadOptions): Promise<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 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 toggleClass(el: HTMLElement | SVGElement, className: string, on: boolean): 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;
+    static togglePart(el: HTMLElement | SVGElement, partName: string, on: boolean): 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;
+    /** Legacy 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;
+    /** Legacy alias for Promise.resolve(). */
+    static fromResult<T>(v: T): Promise<T>;
+    static fromResultAsync<T>(task: () => 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 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 function ViewChild(selector: string): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
+
+declare interface Wai {
+    readonly aria: Aria;
+}
+
+export declare function Watch(config?: WatchConfig): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
+
+export declare const WATCH_PROPS_VAR: string;
+
+export declare 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;
+};
+
+
+
+declare global {
+    namespace Pacem {
+        export {
+            Animations,
+            AttributeChangeEvent,
+            AttributeChangeEventArgs,
+            AttributeChangeEventName,
+            avoidHandler,
+            Behaviors,
+            CommandEvent,
+            CommandEventArgs,
+            CommandEventName,
+            Components,
+            Concurrent,
+            CookieData,
+            CookieStoreLike,
+            CurrentIndexChangeEvent,
+            CustomElement,
+            CustomElementConfig,
+            CustomElementUtils,
+            CustomEventUtils,
+            CustomTypedEvent,
+            CustomUIEvent,
+            Debounce,
+            DeepCloner,
+            DefaultComparer,
+            Defaults,
+            DeferPromise,
+            EMPTY_MATCHER,
+            EventCoordinates,
+            EventKeyModifier,
+            EventKeyModifiers,
+            Expression,
+            IndexChangeEventArgs,
+            INSTANCE_BINDINGS_VAR,
+            INSTANCE_HOST_VAR,
+            INSTANCE_SCOPE_VAR,
+            ItemsContainer,
+            Iterative,
+            Json,
+            JsonFunctionConversion,
+            JsonSerializationOptions,
+            KeyEventLike,
+            Logging,
+            Net,
+            NotifyPropertyChange,
+            OnAdopted,
+            OnAttributeChanged,
+            OnConnected,
+            OnDisconnected,
+            OnPropertyChanged,
+            OnViewActivated,
+            P,
+            PacemEventTarget,
+            PCSS,
+            preventDefaultHandler,
+            PropertyChangeEvent,
+            PropertyChangeEventArgs,
+            PropertyChangeEventName,
+            PropertyComparer,
+            PropertyConverter,
+            PropertyConverters,
+            PropertyDependencies,
+            PropertyDependency,
+            Regex,
+            RegexMatchSegment,
+            Repeater,
+            RepeaterItem,
+            RouterState,
+            stopPropagationHandler,
+            TemplateElement,
+            Throttle,
+            TransformFunction,
+            Type,
+            UI,
+            UIEventLike,
+            Utils,
+            ViewChild,
+            Watch,
+            WATCH_PROPS_VAR,
+            WatchConfig,
+            CustomElementRegistry,
+            Storage,
+            Transformer
+        };
+    }
+}