@pacem/pacem 1.0.0-amaldi → 1.0.0-archimedes

package/dist/typings/index.d.ts

@@ -1,20 +1,24 @@
 /*!
- * @pacem/pacem v1.0.0-amaldi (https://js.pacem.it)
+ * @pacem/pacem v1.0.0-archimedes (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */
 import { Animations } from '@pacem/pacem-core';
 import { Behaviors } from '@pacem/pacem-core';
+import { Blobs as Blobs_2 } from '@pacem/pacem-foundation';
 import { Components as Components_2 } from '@pacem/pacem-core';
 import { Components as Components_3 } from '@pacem/pacem-ui';
 import { Components as Components_4 } from '@pacem/pacem-maps';
 import { Components as Components_5 } from '@pacem/pacem-scaffolding';
 import { CustomTypedEvent as CustomTypedEvent_2 } from '@pacem/pacem-core';
 import { CustomUIEvent as CustomUIEvent_2 } from '@pacem/pacem-core';
-import { EventKeyModifier } from '@pacem/pacem-core';
+import { Dates as Dates_2 } from '@pacem/pacem-foundation';
+import { detect as detect_2 } from '@pacem/pacem-foundation';
+import { EventKeyModifier as EventKeyModifier_2 } from '@pacem/pacem-core';
 import { Geometry as Geometry_2 } from '@pacem/pacem-numerical';
 import { HistoryService as HistoryService_2 } from '@pacem/pacem-foundation';
 import { HubConnection } from '@microsoft/signalr';
+import { Imaging as Imaging_2 } from '@pacem/pacem-foundation';
 import { ItemsContainer as ItemsContainer_2 } from '@pacem/pacem-core';
 import { Logging as Logging_2 } from '@pacem/pacem-core';
 import { Maps as Maps_2 } from '@pacem/pacem-maps';
@@ -26,12 +30,13 @@ import { OnPropertyChanged as OnPropertyChanged_2 } from '@pacem/pacem-core';
 import { OnViewActivated as OnViewActivated_2 } from '@pacem/pacem-core';
 import { PacemEventTarget as PacemEventTarget_2 } from '@pacem/pacem-core';
 import { Point as Point_2 } from '@pacem/pacem-foundation';
-import { PropertyConverter } from '@pacem/pacem-core';
+import { PropertyConverter as PropertyConverter_2 } from '@pacem/pacem-core';
 import { Rect as Rect_2 } from '@pacem/pacem-foundation';
 import { Rgba as Rgba_2 } from '@pacem/pacem-foundation';
 import { Scaffolding as Scaffolding_3 } from '@pacem/pacem-scaffolding';
 import { Size as Size_2 } from '@pacem/pacem-foundation';
-import { Type } from '@pacem/pacem-core';
+import { Strings as Strings_2 } from '@pacem/pacem-foundation';
+import { Type as Type_2 } from '@pacem/pacem-core';
 import { UI as UI_2 } from '@pacem/pacem-core';
 
 declare enum AdapterOrientation {
@@ -191,6 +196,21 @@ export declare class Arrays {
     static chunkify(source: any[], size: number): any[][];
 }
 
+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;
+
 declare type AzureMapsAddress = {
     country: string;
     countryCode: string;
@@ -362,7 +382,7 @@ export declare class Blobs {
 
 declare type BlobTextEncoding = 'utf-8' | 'utf-16' | 'utf-16be' | 'utf-16le' | 'iso-8859-1' | 'ascii';
 
-declare const BooleanOrNumberConverter: PropertyConverter;
+declare const BooleanOrNumberConverter: PropertyConverter_2;
 
 declare interface Box3D {
     minX: number;
@@ -547,15 +567,17 @@ export declare class Colors {
     static interpolate(cieXYZ1: CieXYZ, cieXYZ2: CieXYZ, weight1?: number, weight2?: number): CieXYZ;
 }
 
-declare class CommandEvent extends CustomTypedEvent<CommandEventArgs> {
+export declare class CommandEvent extends CustomTypedEvent<CommandEventArgs> {
     constructor(args: CommandEventArgs);
 }
 
-declare type CommandEventArgs = {
+export declare type CommandEventArgs = {
     commandName: string;
     commandArgument: any;
 };
 
+export declare const CommandEventName: string;
+
 declare type CommandMetadata = {
     name: string;
     tooltip?: string;
@@ -766,6 +788,8 @@ declare function computePlaneNormal(a: Vector3D, b: Vector3D, c: Vector3D): Vect
  */
 declare function computeSharpVertexNormals(geometry: MeshGeometry): void;
 
+export declare function Concurrent(): (target: any, key: string, descriptor?: PropertyDescriptor) => void;
+
 declare interface ContenteditableCommand {
     exec(...args: any[]): Promise<unknown>;
 }
@@ -792,7 +816,7 @@ declare class ContenteditableUtils {
     static findSurroundingNode(range: Range, tagName: string): Element;
     static findSurroundingNode(node: Node, tagName: string): Element;
     static findSurroundingNode(range: Range, filter: (node: Node) => boolean): Element;
-    static findSurroundingNode<TNode extends Node>(range: Range, type: Type<TNode>): TNode;
+    static findSurroundingNode<TNode extends Node>(range: Range, type: Type_2<TNode>): TNode;
     static findSurroundingBlockElement(range: Range): Element;
     static findSurroundingSiblingBlockElements(range: Range): Element[];
     static findContainingRootElements(range: Range): Element[];
@@ -808,6 +832,28 @@ declare class ContenteditableUtils {
 
 declare const CONTENTELEMENT_BUTTONCOMMAND_TEMPLATE: string;
 
+/** 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;
+};
+
 declare type CornerRadius = {
     rx: CornerRadiusComponent;
     ry: CornerRadiusComponent;
@@ -824,15 +870,151 @@ declare enum CornerType {
     Cut = "cut"
 }
 
+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);
 }
 
-declare abstract class CustomTypedEvent<TDetail> extends CustomEvent<TDetail> {
+export declare abstract class CustomTypedEvent<TDetail> extends CustomEvent<TDetail> {
     constructor(type: string, detail: TDetail, eventInit?: CustomEventInit<TDetail>);
 }
 
-declare abstract class CustomUIEvent<TDetail> extends CustomEvent<TDetail> implements UIEventLike {
+export declare abstract class CustomUIEvent<TDetail> extends CustomEvent<TDetail> implements UIEventLike {
     #private;
     constructor(type: string, detail: TDetail);
     constructor(type: string, eventInit: CustomEventInit<TDetail>);
@@ -863,7 +1045,7 @@ export declare namespace DataAnalysis {
         Lagrangian,
         Pchip,
         Newton,
-        Utils_2 as Utils,
+        Utils_3 as Utils,
         SearchFunction,
         SearchFunctions
     }
@@ -1049,6 +1231,14 @@ declare class DateSelectEvent extends CustomTypedEvent_2<Date> {
     constructor(date: Date);
 }
 
+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;
+}
+
 export declare class DeepMerger {
     private constructor();
     static merge<S extends PlainObject, T extends PlainObject>(source: S, target?: T): T & S;
@@ -1058,6 +1248,36 @@ declare const DEFAULT_ATTRIBUTION = "";
 
 declare const DEFAULT_TILES = "";
 
+/**
+ * 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 type DependsOn = {
     prop: string;
     alias?: string;
@@ -1155,6 +1375,15 @@ declare enum DockMode {
     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",
@@ -1559,7 +1788,48 @@ declare enum EditMode {
 
 declare type ElementOrPoint = Element | Point_2;
 
-declare const ElementOrPointPropertyConverter: PropertyConverter;
+declare const ElementOrPointPropertyConverter: PropertyConverter_2;
+
+export declare const EMPTY_MATCHER: RegExp;
+
+export declare interface EventCoordinates {
+    readonly page: Point_2;
+    readonly client: Point_2;
+    readonly screen: Point_2;
+}
+
+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 type ExtraRule = (Compile_2.Rule | {
     rule: Compile_2.Rule;
@@ -1770,7 +2040,7 @@ export declare namespace Geometry {
     export {
         LinearAlgebra,
         Segment,
-        Utils,
+        Utils_2 as Utils,
         Polygon,
         Ray,
         Utils3D
@@ -1894,6 +2164,17 @@ export declare type ImagingResizeOptions = {
     background?: string;
 };
 
+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 interface Interaction {
     time: number;
     cursor: Point_2;
@@ -1985,7 +2266,7 @@ declare class ItemRegisterEvent<TItem extends PacemItemElement> extends CustomTy
 
 declare const ItemRegisterEventName = "itemregister";
 
-declare interface ItemsContainer<TItem> extends NotifyPropertyChange {
+export declare interface ItemsContainer<TItem> extends NotifyPropertyChange {
     items: TItem[];
     register(item: TItem): boolean;
     unregister(item: TItem): boolean;
@@ -1997,13 +2278,38 @@ declare class ItemUnregisterEvent<TItem extends PacemItemElement> extends Custom
 
 declare const ItemUnregisterEventName = "itemunregister";
 
-declare interface Iterative<TItem> extends ItemsContainer<TItem> {
+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";
 
-declare interface KeyEventLike {
+export declare interface KeyEventLike {
     readonly altKey: boolean;
     readonly ctrlKey: boolean;
     readonly shiftKey: boolean;
@@ -2180,9 +2486,9 @@ declare class LatLngBounds {
     static equals(a: LatLngBounds, b: LatLngBounds): boolean;
 }
 
-declare const LatLngBoundsConverter: PropertyConverter;
+declare const LatLngBoundsConverter: PropertyConverter_2;
 
-declare const LatLngConverter: PropertyConverter;
+declare const LatLngConverter: PropertyConverter_2;
 
 declare interface LatLngOptions {
     provider: 'osm' | 'leaflet' | 'azure' | 'google' | 'gmaps' | 'leafletjs';
@@ -2793,7 +3099,7 @@ declare abstract class NodeGeometry {
 
 declare function NotifyChange(callback: (property?: string, old?: any, val?: any) => void): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
 
-declare interface NotifyPropertyChange extends EventTarget {
+export declare interface NotifyPropertyChange extends EventTarget {
 }
 
 export declare class NullChecker {
@@ -2810,13 +3116,21 @@ export declare class Numbers {
 
 export declare namespace NumberTheory {
     export {
-        Utils_3 as Utils
+        Utils_4 as Utils
     }
 }
 
 declare type NumericKeySelector<T> = (item: T, index?: number) => number;
 
-declare interface OnConnected {
+export declare interface OnAdopted {
+    adoptedCallback(): void;
+}
+
+export declare interface OnAttributeChanged {
+    attributeChangedCallback(attrName?: string, oldVal?: string, newVal?: string): void;
+}
+
+export declare interface OnConnected {
     connectedCallback(): void;
 }
 
@@ -2824,7 +3138,7 @@ declare interface OnDestroy {
     destroyCallback(): void;
 }
 
-declare interface OnDisconnected {
+export declare interface OnDisconnected {
     disconnectedCallback(): void;
 }
 
@@ -2832,11 +3146,11 @@ declare interface OnInitialize {
     initializeCallback(): void;
 }
 
-declare interface OnPropertyChanged {
+export declare interface OnPropertyChanged {
     propertyChangedCallback(name?: string, oldVal?: any, newVal?: any, firstChange?: boolean): void;
 }
 
-declare interface OnViewActivated {
+export declare interface OnViewActivated {
     viewActivatedCallback(): void;
 }
 
@@ -3019,7 +3333,7 @@ declare type OrbitCameraConfiguration = {
 declare type OrbitCameraControl = {
     enabled: boolean;
     button?: number;
-    modifiers?: EventKeyModifier[];
+    modifiers?: EventKeyModifier_2[];
 };
 
 declare interface OrthographicCamera extends Camera {
@@ -3041,6 +3355,9 @@ declare interface OverlayAdapter {
     drawOverlay(item: PacemMapOverlayElement): void;
 }
 
+/** the overall customelement prefix */
+export declare const P: any;
+
 declare abstract class Pacem2DAdapterElement extends PacemEventTarget_2 {
     protected DefaultShapeValues: {
         stroke: string;
@@ -4980,7 +5297,7 @@ declare class PacemEventProxyElement extends PacemEventTarget {
     private _emitHandler;
 }
 
-declare abstract class PacemEventTarget extends HTMLElement implements NotifyPropertyChange, OnPropertyChanged, OnConnected, OnViewActivated, OnDisconnected {
+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.
@@ -7850,6 +8167,8 @@ declare class Pchip implements Interpolator {
     static create(values: number[]): Pchip;
 }
 
+export declare const PCSS: any;
+
 declare interface PerspectiveCamera extends Camera {
     type: "perspective";
     /** Vertical field of view in degrees. */
@@ -7943,9 +8262,9 @@ declare interface Point3D {
     z: number;
 }
 
-declare const Point3DConverter: PropertyConverter;
+declare const Point3DConverter: PropertyConverter_2;
 
-declare const Point3DOrNumberConverter: PropertyConverter;
+declare const Point3DOrNumberConverter: PropertyConverter_2;
 
 declare type PointerEventLike = MouseEvent | PointerEvent | TouchEvent;
 
@@ -8039,6 +8358,65 @@ declare class PresentationState {
     static combine(lhs: PresentationState, rhs: PresentationState, precomputedMatrix?: Matrix2D_2): PresentationState;
 }
 
+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;
+};
+
 declare type PropertyMetadata = {
     prop: string;
     type: 'object' | 'array' | string | /* let the possibility to inject custom scaffolding elements */ PropertyMetadataFieldFactory;
@@ -8198,7 +8576,7 @@ declare class Quaternion_2 {
     static dot(q1: Quaternion_2, q2: Quaternion_2): number;
 }
 
-declare const QuaternionConverter: PropertyConverter;
+declare const QuaternionConverter: PropertyConverter_2;
 
 declare interface RadialGradient extends Gradient {
     center: Point_2;
@@ -8254,6 +8632,21 @@ export declare class Rect {
     static expand(rect: Rect, ...points: Point[]): Rect;
 }
 
+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;
+};
+
 declare interface Renderable {
     stage?: Stage_3;
     position: Vector3D;
@@ -8291,11 +8684,11 @@ declare interface Renderer {
     render: (tree: Token[]) => string;
 }
 
-declare interface Repeater extends HTMLElement {
+export declare interface Repeater extends HTMLElement {
     datasource: any[];
 }
 
-declare class Repeater {
+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
@@ -8304,7 +8697,7 @@ declare class Repeater {
     static findItemContext(element: Element, upLevels?: number, logFn?: (message?: string) => void): RepeaterItem;
 }
 
-declare abstract class RepeaterItem {
+export declare abstract class RepeaterItem {
     private _placeholder;
     static findUpwards(element: Element, upLevels?: number, logFn?: (message?: string) => void): RepeaterItem;
     static isRepeaterItem(node: Node): boolean;
@@ -8473,6 +8866,12 @@ declare interface Rotator {
     dispatchEvent(evt: RotateEvent): boolean;
 }
 
+declare type RouteMetadata = {
+    name: string;
+    optional: boolean;
+    index: number;
+};
+
 declare class RouterNavigateEvent extends CustomTypedEvent<RouterNavigateEventArgs> {
     constructor(path: string | RouterNavigateEventArgs);
 }
@@ -8491,7 +8890,7 @@ declare class RouterNavigatingEvent extends CustomTypedEvent<string> {
 
 declare const RouterNavigatingEventName = "navigating";
 
-declare type RouterState = {
+export declare type RouterState = {
     [key: string]: string;
 } & {
     $pathname: string;
@@ -8828,9 +9227,9 @@ declare class StageEvent extends UI2DEvent<Stage> {
 declare type StageOptions = {
     panControl: boolean;
     zoomControl: boolean;
-    panModifiers: EventKeyModifier[];
-    zoomModifiers: EventKeyModifier[];
-    clickModifiers: EventKeyModifier[];
+    panModifiers: EventKeyModifier_2[];
+    zoomModifiers: EventKeyModifier_2[];
+    clickModifiers: EventKeyModifier_2[];
 };
 
 declare enum StalePropertyFlag {
@@ -8880,6 +9279,8 @@ declare enum StickyHeaderVisibility {
     QuickReturn = "quickreturn"
 }
 
+export declare const stopPropagationHandler: (evt: Event) => void;
+
 declare class Storage_2 {
     private _getStorage;
     private _parseValue;
@@ -8901,6 +9302,7 @@ declare class Storage_2 {
     clear(): void;
     removeProperty(name: string): void;
 }
+export { Storage_2 as Storage }
 
 export declare class Strings {
     /** @deprecated Use String.prototype.padStart() instead. */
@@ -9012,7 +9414,7 @@ declare interface Swiper {
     dispatchEvent(evt: SwipeEvent): boolean;
 }
 
-declare abstract class TemplateElement extends HTMLElement {
+export declare abstract class TemplateElement extends HTMLElement {
 }
 
 declare interface Text_2 extends UiObject {
@@ -9026,6 +9428,8 @@ declare interface Text_2 extends UiObject {
     textAnchor?: 'start' | 'middle' | 'end';
 }
 
+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;
@@ -9075,6 +9479,11 @@ declare type TrackingData = {
     current: number;
 };
 
+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;
@@ -9091,6 +9500,12 @@ 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;
+}
+
 declare type TypeMetadata = {
     display?: DisplayMetadata;
     props: PropertyMetadata[];
@@ -9280,7 +9695,7 @@ declare abstract class UiElement extends DrawableElement implements UiObject {
     };
 }
 
-declare interface UIEventLike extends KeyEventLike {
+export declare interface UIEventLike extends KeyEventLike {
     readonly clientX: number;
     readonly clientY: number;
     readonly pageX: number;
@@ -9294,7 +9709,285 @@ declare interface UiObject extends Drawable {
     readonly transformMatrix?: Matrix2D_2;
 }
 
-declare class Utils {
+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_2.isLeapYear;
+        daysInMonth: typeof Dates_2.daysInMonth;
+        /**
+         * Gets whether a date is an `Invalid Date` or not.
+         * @param date
+         */
+        isDate: typeof Dates_2.isDate;
+        dateOnly: typeof Dates_2.dateOnly;
+        addMonths: typeof Dates_2.addMonths;
+        addDays: typeof Dates_2.addDays;
+        daysBetween: typeof Dates_2.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_2;
+    };
+    static leftPad: typeof Strings_2.leftPad;
+    static formatString: typeof Strings_2.format;
+    static diff: typeof Strings_2.diff;
+    static Strings: {
+        leftPad: typeof Strings_2.leftPad;
+        format: typeof Strings_2.format;
+        diff: typeof Strings_2.diff;
+        stripHTML: (html: string) => string;
+    };
+    static Blobs: {
+        toDataURL: typeof Blobs_2.blobToDataURL;
+        fromDataURL: typeof Blobs_2.dataURLToBlob;
+        toText: typeof Blobs_2.blobToText;
+        fromText: typeof Blobs_2.textToBlob;
+    };
+    static Images: {
+        load: typeof Imaging_2.loadImage;
+        resize: typeof Imaging_2.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_2;
+    };
+    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_2;
+    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_2;
+    static deserializeTransform(element: Element): Matrix2D_2;
+    static deserializeTransform(style: CSSStyleDeclaration): Matrix2D_2;
+    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;
+}
+
+declare class Utils3D {
+    /**
+     * Computes the intersection between a ray and a triangle in the 3D space - if any - using the Möller–Trumbore algorithm.
+     * @param ray Array of two points identifying a ray.
+     * @param triangle Array of three points identifying a triangle.
+     * @returns Intersection point if any, otherwise null.
+     */
+    static intersect(ray: Ray, triangle: [Point3D, Point3D, Point3D]): Point3D | null;
+}
+
+declare class Utils_2 {
     /**
      * Computes the slope (in radians) of the segment joining two points.
      * @param p1 Point 1
@@ -9463,18 +10156,8 @@ declare class Utils {
     static convexHull(points: Point_2[]): Point_2[];
 }
 
-declare class Utils3D {
-    /**
-     * Computes the intersection between a ray and a triangle in the 3D space - if any - using the Möller–Trumbore algorithm.
-     * @param ray Array of two points identifying a ray.
-     * @param triangle Array of three points identifying a triangle.
-     * @returns Intersection point if any, otherwise null.
-     */
-    static intersect(ray: Ray, triangle: [Point3D, Point3D, Point3D]): Point3D | null;
-}
-
 /** Utility tools about statistics, probability, data analysis... */
-declare class Utils_2 {
+declare class Utils_3 {
     static sum<T>(set: T[], selector: NumericKeySelector<T>): number;
     static sum(set: number[]): number;
     static mean<T>(set: T[], selector: NumericKeySelector<T>): number;
@@ -9525,7 +10208,7 @@ declare class Utils_2 {
 }
 
 /** Utility tools about number theory, 'diophantine' stuff... */
-declare class Utils_3 {
+declare class Utils_4 {
     static lcd(...args: number[]): number;
     static gcd(a: number, b: number): any;
     static rebaseInt(v: number | string, from: number, to: number): string;
@@ -9686,6 +10369,8 @@ declare type ViewBoxAspectRatio = 'none' | {
     slice?: boolean;
 };
 
+export declare function ViewChild(selector: string): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
+
 declare class ViewDateChangeEvent extends CustomTypedEvent_2<Date> {
     constructor(date: Date);
 }
@@ -9694,6 +10379,22 @@ 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 type WGSLModifierDelegates = {
     vertexInput?: string | VertexInputModifierDelegate;
     vertexOutput?: string | VertexOutputModifierDelegate;
@@ -9710,27 +10411,64 @@ declare global {
         export {
             Angle,
             Arrays,
+            AttributeChangeEvent,
+            AttributeChangeEventArgs,
+            AttributeChangeEventName,
+            avoidHandler,
             Blobs,
             Charts,
             CieXYZ,
             Colors,
+            CommandEvent,
+            CommandEventArgs,
+            CommandEventName,
             Compile,
             Components,
+            Concurrent,
+            CookieData,
+            CookieStoreLike,
+            CurrentIndexChangeEvent,
+            CustomElement,
+            CustomElementConfig,
+            CustomElementUtils,
+            CustomEventUtils,
+            CustomTypedEvent,
+            CustomUIEvent,
             DataAnalysis,
             Dates,
+            Debounce,
+            DeepCloner,
             DeepMerger,
+            DefaultComparer,
+            Defaults,
+            DeferPromise,
             detect,
             DiffMode,
             DiffToken,
             DiffTokenType,
             Drawing,
             Drawing3D,
+            EMPTY_MATCHER,
+            EventCoordinates,
+            EventKeyModifier,
+            EventKeyModifiers,
+            Expression,
             Fx,
             Geometry,
             HistoryService,
             Hsla,
             Imaging,
             ImagingResizeOptions,
+            IndexChangeEventArgs,
+            INSTANCE_BINDINGS_VAR,
+            INSTANCE_HOST_VAR,
+            INSTANCE_SCOPE_VAR,
+            ItemsContainer,
+            Iterative,
+            Json,
+            JsonFunctionConversion,
+            JsonSerializationOptions,
+            KeyEventLike,
             Keys,
             L10n,
             LinearAlgebra,
@@ -9741,19 +10479,57 @@ declare global {
             Matrix2D,
             Media,
             Networking,
+            NotifyPropertyChange,
             NullChecker,
             Numbers,
             NumberTheory,
+            OnAdopted,
+            OnAttributeChanged,
+            OnConnected,
+            OnDisconnected,
+            OnPropertyChanged,
+            OnViewActivated,
             OpenApi,
+            P,
+            PacemEventTarget,
             parseAsNumericalArray,
+            PCSS,
             Plus,
             Point,
+            preventDefaultHandler,
+            PropertyChangeEvent,
+            PropertyChangeEventArgs,
+            PropertyChangeEventName,
+            PropertyComparer,
+            PropertyConverter,
+            PropertyConverters,
+            PropertyDependencies,
+            PropertyDependency,
             Rect,
+            Regex,
+            RegexMatchSegment,
+            Repeater,
+            RepeaterItem,
             Rgba,
+            RouterState,
             Scaffolding,
             Size,
+            stopPropagationHandler,
             Strings,
-            UI
+            TemplateElement,
+            Throttle,
+            TransformFunction,
+            Type,
+            UI,
+            UIEventLike,
+            Utils,
+            ViewChild,
+            Watch,
+            WATCH_PROPS_VAR,
+            WatchConfig,
+            CustomElementRegistry,
+            Storage,
+            Transformer
         };
     }
 }