@ouidesigner/ouider 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,1245 @@
+import RouteParser from 'route-parser';
+
+type ProvideFunction<T> = () => T;
+type Provider<T = any> = {
+    value?: T;
+    provide?: ProvideFunction<T>;
+};
+interface Plugin<T> {
+    install(app: App, options?: T): void;
+}
+/** Injection token key */
+type InjectionKey = string;
+/** Providers type */
+type Providers = Map<InjectionKey, Provider>;
+/**
+ * OUIDesigner App
+ */
+declare class App {
+    private root;
+    private options?;
+    static currentApp: App | null;
+    private providers;
+    /**
+     * Provide a value through a key to all the app globally
+     * @param token the registration key
+     * @param value the provider value
+     */
+    provide<T>(token: InjectionKey, value: T | (() => T)): void;
+    /**
+     * Get globally a provider through a given key
+     * @param token the key to look up globally
+     * @returns a provider value
+     */
+    inject<T>(token: InjectionKey): T | undefined;
+    /**
+     * Register a plugin to be used by this app
+     * @param plugin the plugin to register
+     * @returns `this` App instance
+     */
+    use<T>(plugin: Plugin<T>, options?: T): this;
+    constructor(root: ComponentConstructor<any, any>, options?: {
+        css?: string;
+    } | undefined);
+    /**
+     * Mount the App in a host element
+     * @param selector the host element where the app's root component should be mounted
+     */
+    mount(selector: string): Promise<void>;
+}
+/**
+ * Provide a value through a key to all the app globally
+ * @param token the registration key
+ * @param value the provider value
+ */
+declare function provide<T>(token: InjectionKey, value: T | (() => T)): void;
+/**
+ * Get globally a provider through a given key
+ * @param token the key to look up globally
+ * @returns a provider value
+ */
+declare function inject<T>(token: InjectionKey): T | undefined;
+
+type QueryFilter = "children" | "classes" | "style" | "attributes";
+declare namespace ODOM {
+    export class BatchActions {
+        private actions;
+        constructor();
+        exec(): Promise<any>;
+        add(action: () => void): this;
+        commit(): Promise<void>;
+    }
+    export class BatchUpdates {
+        private node;
+        private operations;
+        constructor(node: OObject);
+        accept(other: BatchUpdates): void;
+        exec(immediate?: boolean): Promise<any>;
+        private append;
+        add(fn: keyof OElement, node?: OObject, ...args: any[]): BatchUpdates;
+        add(fn: () => any): BatchUpdates;
+        addEventListener(event: string, callback: (...args: any[]) => void, options?: EventListenerOptions, policy?: EventControlPolicy): BatchUpdates;
+        setProperty(key: string, value: any): BatchUpdates;
+        dettachEventListener(cbId: string): BatchUpdates;
+        invoke(fn: string, ...args: any[]): BatchUpdates;
+        dispatchEvent(eventName: string, eventClass?: string, initDict?: any): BatchUpdates;
+        addClass(...tokens: string[]): BatchUpdates;
+        removeClass(...tokens: string[]): BatchUpdates;
+        setAttribute(name: string, value: string): BatchUpdates;
+        removeAttribute(name: string): BatchUpdates;
+        appendChild(child: ONode): BatchUpdates;
+        removeChild(child: ONode): BatchUpdates;
+        remove(): BatchUpdates;
+        removeAndRelease(): BatchUpdates;
+        release(): BatchUpdates;
+        innerHTML(html: string): BatchUpdates;
+        replaceChildNode(node: ONode, child: ONode): BatchUpdates;
+        replaceWith(node: ONode): BatchUpdates;
+        after(toInsert: ONode): BatchUpdates;
+        setInnerText(text: string): BatchUpdates;
+        setContentText(text: string): BatchUpdates;
+        insertBefore(node: ONode, element: ONode): BatchUpdates;
+        setInputValue(value: string): BatchUpdates;
+        setStyle(key: string, value: any): BatchUpdates;
+    }
+    export type NodeType = 'Element' | 'Text' | 'Comment' | 'Attribute' | 'Unknown';
+    type Attributes = {
+        name: string;
+        value: string;
+    }[];
+    export class OObject {
+        uid: string;
+        tag: string;
+        constructor(uid: string, tag: string);
+        static toInstance(obj: OObject): OObject;
+        release(): Promise<void>;
+        addEventListener(event: string, callback: (...args: any[]) => void, extra?: {
+            options?: EventListenerOptions;
+            policy?: EventControlPolicy;
+        }): Promise<string>;
+        dettachEventListener(cbId: string): Promise<void>;
+        invoke<T>(fn: string, ...args: any[]): Promise<T | null>;
+        invokeAndHold(fn: string, ...args: any[]): Promise<OObject | null>;
+        getProperty<T>(name: string): Promise<T | null>;
+        getPropertyAndHold<T>(name: string): Promise<OObject | null>;
+        setProperty<T>(name: string, value: T): Promise<void>;
+        indexAccessAndHold(index: number): Promise<OObject | null>;
+        indexAccess(index: number): Promise<unknown>;
+        dispatchEvent(eventName: string, eventClass?: string, initDict?: any): Promise<void>;
+        updates(): BatchUpdates;
+        batches(): BatchUpdates;
+        get ref(): {
+            __ref__: string;
+        };
+    }
+    export abstract class ONode extends OObject {
+        textContent?: string | null;
+        type: NodeType;
+        attributes: Attributes;
+        children?: ONode[];
+        classes?: string[];
+        style?: string;
+        constructor(node: OObject);
+    }
+    export class OElement extends ONode {
+        private _hydrated;
+        constructor(node: OObject);
+        addClass(...tokens: string[]): Promise<void>;
+        removeClass(...tokens: string[]): Promise<void>;
+        setAttribute(name: string, value: string): Promise<void>;
+        removeAttribute(name: string): Promise<void>;
+        appendChild(child: ONode): Promise<void>;
+        set innerHTML(value: string);
+        cloneNode(state: boolean): Promise<OElement | null>;
+        remove(): Promise<void>;
+        removeAndRelease(): Promise<void>;
+        removeChild(child: ONode): Promise<void>;
+        replaceChildNode(node: ONode, child: ONode): Promise<void>;
+        replaceWith(node: ONode): Promise<void>;
+        after(toInsert: ONode): Promise<void>;
+        setHTML(html: string): Promise<void>;
+        HTML(): Promise<string>;
+        setInnerText(text: string): Promise<void>;
+        setContentText(text: string): Promise<void>;
+        getContentText(): Promise<string>;
+        content(): Promise<string>;
+        childNodes(): Promise<OElement[]>;
+        hasAttribute(name: string): boolean;
+        getAttribute(name: string): Promise<string>;
+        attribute(name: string): string | null;
+        nextSibling(): Promise<OElement | null>;
+        getAttributeNames(): Promise<string[]>;
+        parentNode(): Promise<OElement | null>;
+        insertBefore(node: ONode, element: ONode): Promise<void>;
+        setInputValue(value: string): Promise<void>;
+        inputValue(): Promise<string>;
+        get hydrated(): boolean;
+        hydrate(): void;
+        query(selector: string, filter?: QueryFilter[]): Promise<OElement | null>;
+        queryAll(selector: string, filter?: QueryFilter[]): Promise<OElement[] | null>;
+        setStyle(key: string, value: any): Promise<void>;
+        animate(keyframes: OUIDKeyframes, options?: OUIDAnimationOptions): Promise<OAnimation | null>;
+    }
+    export class OAnimation extends OObject {
+        private pendingEffectFragments;
+        private pendingEffectTiming?;
+        private pendingRawKeyframes?;
+        private effectFlushScheduled;
+        constructor(obj: OObject);
+        set(keyframes: OUIDKeyframes, options?: OUIDAnimationOptions): this;
+        timing(options: OUIDAnimationOptions): this;
+        timingFunction(value: string): this;
+        commitEffects(): Promise<this>;
+        property(property: string, from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions, unit?: string): this;
+        transformList(from: string[], to: string[], options?: OUIDAnimationOptions): this;
+        scale(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        scaleX(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        scaleY(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        scaleZ(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        scale3d(from: OUIDVector3Value, to: OUIDVector3Value, options?: OUIDAnimationOptions): this;
+        perspective(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        matrix(from: number[], to: number[], options?: OUIDAnimationOptions): this;
+        matrix3d(from: number[], to: number[], options?: OUIDAnimationOptions): this;
+        rotate(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        rotateX(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        rotateY(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        rotateZ(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        rotate3d(x: number, y: number, z: number, from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        skew(from: OUIDVector2Value, to: OUIDVector2Value, options?: OUIDAnimationOptions): this;
+        skewX(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        skewY(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        translate(from: OUIDVector2Value, to: OUIDVector2Value, options?: OUIDAnimationOptions): this;
+        translateX(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        translateY(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        translateZ(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        translate3d(from: OUIDVector3Value, to: OUIDVector3Value, options?: OUIDAnimationOptions): this;
+        top(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        right(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        left(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        bottom(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        opacity(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        width(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        height(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        minWidth(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        minHeight(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        maxWidth(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        maxHeight(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        margin(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        marginTop(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        marginRight(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        marginBottom(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        marginLeft(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        padding(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        paddingTop(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        paddingRight(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        paddingBottom(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        paddingLeft(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        borderRadius(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        borderWidth(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        outlineWidth(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        gap(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        rowGap(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        columnGap(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        fontSize(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        lineHeight(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        letterSpacing(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        zIndex(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        flexGrow(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        flexShrink(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        color(from: string, to: string, options?: OUIDAnimationOptions): this;
+        backgroundColor(from: string, to: string, options?: OUIDAnimationOptions): this;
+        borderColor(from: string, to: string, options?: OUIDAnimationOptions): this;
+        outlineColor(from: string, to: string, options?: OUIDAnimationOptions): this;
+        boxShadow(from: string, to: string, options?: OUIDAnimationOptions): this;
+        textShadow(from: string, to: string, options?: OUIDAnimationOptions): this;
+        clipPath(from: string, to: string, options?: OUIDAnimationOptions): this;
+        backgroundPosition(from: string, to: string, options?: OUIDAnimationOptions): this;
+        backgroundSize(from: string, to: string, options?: OUIDAnimationOptions): this;
+        objectPosition(from: string, to: string, options?: OUIDAnimationOptions): this;
+        filter(from: string, to: string, options?: OUIDAnimationOptions): this;
+        backdropFilter(from: string, to: string, options?: OUIDAnimationOptions): this;
+        blur(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        brightness(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        contrast(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        grayscale(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        hueRotate(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        invert(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        saturate(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        sepia(from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        dropShadow(from: string, to: string, options?: OUIDAnimationOptions): this;
+        transform(from: string, to: string, options?: OUIDAnimationOptions): this;
+        css(property: string, from: OUIDAnimationValue, to: OUIDAnimationValue, options?: OUIDAnimationOptions): this;
+        play(): Promise<void>;
+        pause(): Promise<void>;
+        cancel(): Promise<void>;
+        finish(): Promise<void>;
+        reverse(): Promise<void>;
+        commitStyles(): Promise<void>;
+        persist(): Promise<void>;
+        updatePlaybackRate(playbackRate: number): Promise<void>;
+        playState(): Promise<string | null>;
+        currentTime(): Promise<number | null>;
+        setCurrentTime(value: number | null): Promise<void>;
+        playbackRate(): Promise<number | null>;
+        setPlaybackRate(value: number): Promise<void>;
+        private queueEffect;
+        private mergeTiming;
+        private scheduleEffectFlush;
+    }
+    export class CanvasGradient extends OObject {
+        constructor(obj: OObject);
+        addColorStop(offset: number, color: string): this;
+    }
+    export class DOMMatrix extends OObject {
+        batch: BatchUpdates;
+        constructor(obj: OObject);
+        static new(): Promise<DOMMatrix>;
+        static new(initString: string): Promise<DOMMatrix>;
+        static new(initArray: number[]): Promise<DOMMatrix>;
+        invertSelf(): this;
+        multiplySelf(): DOMMatrix;
+        premultiplySelf(): DOMMatrix;
+        rotateAxisAngleSelf(rotX?: number, rotY?: number, rotZ?: number, angle?: number): this;
+        rotateFromVectorSelf(rotX?: number, rotY?: number): this;
+        rotateSelf(rotX?: number, rotY?: number, rotZ?: number): this;
+        scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): this;
+        scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): this;
+        setMatrixValue(transformList: string): this;
+        skewXSelf(sX: number): this;
+        skewYSelf(sX: number): this;
+        translateSelf(translateX: number, translateY: number, translateZ?: number): this;
+        commit(): Promise<void>;
+        is2D(): Promise<boolean>;
+        isIdentity(): Promise<boolean>;
+        flipX(): Promise<DOMMatrix | null>;
+        flipY(): Promise<DOMMatrix | null>;
+        inverse(): Promise<DOMMatrix | null>;
+        multiply(other?: DOMMatrix): Promise<DOMMatrix | null>;
+        rotate(rotX?: number, rotY?: number, rotZ?: number): Promise<DOMMatrix | null>;
+        rotateAxisAngle(rotX?: number, rotY?: number, rotZ?: number, angle?: number): Promise<DOMMatrix | null>;
+        rotateFromVector(rotX?: number, rotY?: number): Promise<DOMMatrix | null>;
+        scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): Promise<DOMMatrix | null>;
+        scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): Promise<DOMMatrix | null>;
+        skewX(sX?: number): Promise<DOMMatrix | null>;
+        skewY(sY?: number): Promise<DOMMatrix | null>;
+        toJSON(): Promise<any>;
+        toString(): Promise<string | null>;
+        translate(translateX?: number, translateY?: number, translateZ?: number): Promise<DOMMatrix | null>;
+    }
+    export class CanvasPattern extends OObject {
+        constructor(obj: OObject);
+        setTransform(matrix: DOMMatrix): Promise<void>;
+    }
+    export class Canvas2DContext extends OObject {
+        private batch;
+        constructor(uid: string);
+        arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
+        arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+        bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;
+        clearRect(x: number, y: number, width: number, height: number): this;
+        clip(path?: CanvasPath2D): Canvas2DContext;
+        clip(fillRule?: 'nonzero' | 'evenodd'): Canvas2DContext;
+        clip(path: CanvasPath2D, fillRule?: 'nonzero' | 'evenodd'): Canvas2DContext;
+        beginPath(): this;
+        closePath(): this;
+        createConicGradient(startAngle: number, x: number, y: number): Promise<CanvasGradient | null>;
+        createLinearGradient(x0: number, y0: number, x1: number, y1: number): Promise<CanvasGradient | null>;
+        createPattern(image: OObject, repetition?: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat' | ''): Promise<CanvasPattern | null>;
+        createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): Promise<CanvasGradient | null>;
+        drawImage(image: Image | OObject, dx: number, dy: number): Canvas2DContext;
+        drawImage(image: Image | OObject, dx: number, dy: number, dWidth: number, dHeight: number): Canvas2DContext;
+        drawImage(image: Image | OObject, sx: number, sy: number, sWidth: number, sHeight: number, dx: number, dy: number, dWidth: number, dHeight: number): Canvas2DContext;
+        ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
+        fill(path?: CanvasPath2D | 'nonzero' | 'evenodd', fillRule?: 'nonzero' | 'evenodd'): this;
+        fillRect(x: number, y: number, width: number, height: number): this;
+        fillText(text: string, x: number, y: number, maxWidth?: number): this;
+        getImageData(sx: number, sy: number, sw: number, sh: number, settings?: {
+            colorSpace: 'srgb' | 'display-p3';
+            pixelFormat: 'rgba-unorm8' | 'rgba-float16';
+        }): Promise<OObject | null>;
+        getLineDash(): Promise<number[] | null>;
+        getTransform(): Promise<DOMMatrix | null>;
+        isContextLost(): Promise<boolean | null>;
+        isPointInPath(x: number, y: number, fillRule?: 'nonzero' | 'evenodd'): Promise<boolean | null>;
+        isPointInPath(path: CanvasPath2D, x: number, y: number, fillRule?: 'nonzero' | 'evenodd'): Promise<boolean | null>;
+        isPointInStroke(x: number, y: number): Promise<boolean>;
+        isPointInStroke(path: CanvasPath2D, x: number, y: number): Promise<boolean>;
+        lineTo(x: number, y: number): Canvas2DContext;
+        measureText(text: number): Promise<number>;
+        moveTo(x: number, y: number): Canvas2DContext;
+        putImageData(imageData: OObject, dx: number, dy: number): Canvas2DContext;
+        putImageData(imageData: OObject, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): Canvas2DContext;
+        quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): this;
+        rect(x: number, y: number, width: number, height: number): this;
+        reset(): void;
+        resetTransform(): void;
+        restore(): BatchUpdates;
+        rotate(angle: number): Canvas2DContext;
+        roundRect(x: number, y: number, width: number, height: number, radii: number | number[]): this;
+        save(): BatchUpdates;
+        scale(x: number, y: number): Canvas2DContext;
+        setLineDash(segments: number[]): Promise<void | null>;
+        setTransform(matrix: DOMMatrix): void;
+        setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+        stroke(path?: CanvasPath2D): Canvas2DContext;
+        strokeRect(x: number, y: number, width: number, height: number): Canvas2DContext;
+        strokeText(text: string, x: number, y: number, maxWidth?: number): Canvas2DContext;
+        transform(a: number, b: number, c: number, d: number, e: number, f: number): Canvas2DContext;
+        translate(x: number, y: number): Canvas2DContext;
+        set fillStyle(value: string | CanvasGradient | CanvasPattern);
+        setFillStyle(style: string | CanvasGradient | CanvasPattern): Canvas2DContext;
+        set filter(value: string);
+        setFilter(filter: string): this;
+        set font(value: string);
+        setFont(font: string): this;
+        set fontKerning(value: string);
+        setFontKerning(kerning: string): this;
+        set fontStretch(value: string);
+        setFontStretch(value: string): this;
+        set fontVariantCaps(value: string);
+        setFontVariantCaps(value: string): this;
+        set globalAlpha(value: number);
+        setGlobalAlpha(value: number): this;
+        set globalCompositeOperation(value: string);
+        setGlobalCompositeOperation(value: string): this;
+        set imageSmoothingEnabled(value: boolean);
+        setImageSmoothingEnabled(value: boolean): this;
+        set imageSmoothingQuality(value: string);
+        setImageSmoothingQuality(value: string): this;
+        set letterSpacing(value: string);
+        setLetterSpacing(value: string): this;
+        set lineCap(value: string);
+        setLineCap(value: string): this;
+        set lineDashOffset(value: number);
+        setLineDashOffset(value: number): this;
+        set lineJoin(value: string);
+        setLineJoin(value: string): this;
+        set lineWidth(value: number);
+        setLineWidth(value: number): this;
+        set miterLimit(value: number);
+        setMiterLimit(value: number): this;
+        set shadowBlur(value: number);
+        setShadowBlur(value: number): this;
+        set shadowColor(value: string);
+        setShadowColor(value: string): this;
+        set shadowOffsetX(value: number);
+        setShadowOffsetX(value: number): this;
+        set shadowOffsetY(value: number);
+        setShadowOffsetY(value: number): this;
+        set strokeStyle(value: any);
+        setStrokeStyle(value: any): this;
+        set textAlign(value: string);
+        setTextAlign(value: string): this;
+        set textBaseline(value: string);
+        setTextBaseline(value: string): this;
+        set wordSpacing(value: string);
+        setWordSpacing(value: string): this;
+        set textRendering(value: string);
+        setTextRendering(value: string): this;
+        commit(): Promise<void>;
+    }
+    export class Image extends OObject {
+        constructor(obj: OObject);
+        static new(width?: number, height?: number): Promise<Image | null>;
+        width(): Promise<number>;
+        height(): Promise<number>;
+        naturalWidth(): Promise<number>;
+        naturalHeight(): Promise<number>;
+        src(): Promise<string | null>;
+        currentSrc(): Promise<string | null>;
+        setSrc(src: string): Promise<void>;
+    }
+    export class CanvasPath2D extends OObject {
+        private batch;
+        constructor(obj: OObject);
+        static create(): Promise<CanvasPath2D | null>;
+        addPath(path: CanvasPath2D): this;
+        arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
+        arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+        bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;
+        quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): this;
+        closePath(): this;
+        ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
+        moveTo(x: number, y: number): this;
+        lineTo(x: number, y: number): this;
+        rect(x: number, y: number, width: number, height: number): this;
+        roundRect(x: number, y: number, width: number, height: number, radii: number | number[]): this;
+        commit(parent?: BatchUpdates): Promise<void>;
+    }
+    export class CanvasElement extends OElement {
+        constructor(node: OElement);
+        width(): Promise<number | null>;
+        height(): Promise<number | null>;
+        setWidth(width: number): Promise<void>;
+        setHeight(height: number): Promise<void>;
+        getContext(context: string): Promise<Canvas2DContext | null>;
+        static of(selector: string, filter?: QueryFilter[], nodeId?: string): Promise<CanvasElement | null>;
+    }
+    export {  };
+}
+interface EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    capture?: boolean;
+}
+interface EventControlPolicy {
+    alwaysPreventDefault?: boolean;
+    alwaysStopPropagation?: boolean;
+    alwaysStopImmediatePropagation?: boolean;
+    payload?: "none" | "value" | "target" | "full";
+}
+type OUIFontDescriptorOptions = Partial<FontFaceDescriptors> & {
+    style?: string;
+    weight?: string;
+    stretch?: string;
+    unicodeRange?: string;
+    variant?: string;
+    featureSettings?: string;
+    variationSettings?: string;
+    display?: string;
+    ascentOverride?: string;
+    descentOverride?: string;
+    lineGapOverride?: string;
+};
+type OUIFontLoadOptions = OUIFontDescriptorOptions & {
+    family: string;
+    source: string;
+};
+type OUIFontLoadResult = {
+    family: string;
+    source: string;
+    uid?: string;
+    status: string;
+    mode: "font-face" | "style";
+};
+type OUIDAnimationValue = number | string;
+type OUIDVector2Value = OUIDAnimationValue | [OUIDAnimationValue, OUIDAnimationValue] | {
+    x: OUIDAnimationValue;
+    y?: OUIDAnimationValue;
+};
+type OUIDVector3Value = OUIDAnimationValue | [OUIDAnimationValue, OUIDAnimationValue, OUIDAnimationValue] | {
+    x: OUIDAnimationValue;
+    y?: OUIDAnimationValue;
+    z?: OUIDAnimationValue;
+};
+type OUIDKeyframes = Keyframe[] | PropertyIndexedKeyframes | null;
+type OUIDAnimationTiming = KeyframeAnimationOptions & {
+    timingFunction?: string;
+};
+type OUIDAnimationOptions = number | OUIDAnimationTiming;
+type HostEventCallback<T = any> = (data: T, event: HostEvent<T>) => void;
+interface HostEvent<T = any> {
+    type: string;
+    data: T;
+    timestamp?: number;
+    source?: string;
+}
+type OUIDBackButtonHandler = () => boolean | void;
+type OUIDBackButtonUnsubscribe = () => void;
+interface OUIDBridgeInterface {
+    invoke(name: string, ...args: any[]): Promise<any>;
+    emit(event: string, data: any): void;
+    subscribe(event: string, callback: (id: string, data: string) => void): void;
+    launch(): OUIDLaunchOptions;
+    readonly app: OUIDAppController;
+    readonly system: OUIDSystemController;
+    readonly permissions: OUIDPermissionController;
+    openAbout(): Promise<OUIDPermissionSettingsResult | null>;
+    openSettings(): Promise<OUIDPermissionSettingsResult | null>;
+    addHostEventListener<T = any>(event: string, callback: HostEventCallback<T>): Promise<string>;
+    removeHostEventListener(listenerId: string): Promise<void>;
+    onHostEvent<T = any>(event: string, callback: HostEventCallback<T>): Promise<() => Promise<void>>;
+}
+type OUIDLaunchOptions = {
+    initialRoute?: string | null;
+    params: Record<string, any>;
+};
+type OUIDMiniAppNavigationMode = "push" | "replace" | "modal";
+type OUIDMiniAppExitOptions = {
+    reason?: string;
+    result?: Record<string, any>;
+};
+type OUIDOpenMiniAppOptions = {
+    appId: string;
+    route?: string | null;
+    initialRoute?: string | null;
+    params?: Record<string, any>;
+    mode?: OUIDMiniAppNavigationMode;
+};
+type OUIDMiniAppNavigationResult = {
+    status: "success" | "error" | string;
+    handled?: boolean;
+    appId?: string;
+    mode?: OUIDMiniAppNavigationMode | string;
+    message?: string;
+    code?: string;
+};
+type OUIDThemeMode = "system" | "light" | "dark";
+type OUIDResolvedThemeMode = "light" | "dark";
+type OUIDThemeState = {
+    mode: OUIDThemeMode;
+    resolvedMode: OUIDResolvedThemeMode;
+    systemMode: OUIDResolvedThemeMode;
+};
+type OUIDThemeChangeHandler = (theme: OUIDThemeState) => void;
+type OUIDPlatform = "android" | "ios" | "web" | "unknown";
+type OUIDSystemTheme = "light" | "dark" | "system" | "unknown";
+type OUIDAppStateName = "active" | "inactive" | "background";
+type OUIDSafeArea = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+type OUIDSystemInfo = {
+    brand: string;
+    model: string;
+    pixelRatio: number;
+    screenWidth: number;
+    screenHeight: number;
+    windowWidth: number;
+    windowHeight: number;
+    statusBarHeight: number;
+    language: string;
+    version: string;
+    system: string;
+    platform: OUIDPlatform | string;
+    fontSize: number;
+    safeArea: OUIDSafeArea;
+    theme: OUIDSystemTheme | string;
+    abi: string;
+    deviceAbi: string[];
+    cpuType: string;
+    memorySize: number;
+    benchmarkLevel: number;
+};
+type OUIDAppStateInfo = {
+    state: OUIDAppStateName;
+    previousState?: OUIDAppStateName;
+    timestamp: number;
+    focused?: boolean;
+    visibility?: "visible" | "hidden";
+};
+type OUIDAppStateChangeHandler = (state: OUIDAppStateInfo, event: HostEvent<OUIDAppStateInfo>) => void;
+type OUIDPermissionState = "prompt" | "granted" | "denied" | "notDeclared" | string;
+type OUIDPermissionStatus = {
+    permission: string;
+    access: string[];
+    reason: string | null;
+    targets: string[];
+    state: OUIDPermissionState;
+    declared: boolean;
+    granted: boolean;
+};
+type OUIDPermissionSettingsResult = {
+    permissions: OUIDPermissionStatus[];
+};
+interface BatchOperation {
+    fn: string;
+    args: any[];
+}
+interface BridgeCallOperation {
+    id: string;
+    fn: string;
+    args: any[];
+}
+type BridgeCallMode = "serial" | "parallel";
+interface BridgeCallOptions {
+    mode?: BridgeCallMode;
+}
+interface NativeCallOperation {
+    id: string;
+    fn: string;
+    args: any[];
+}
+declare var WebOUID: {
+    invoke: (id: string, name: string, argsJson: string) => void;
+} | undefined;
+type RequestData = {
+    method: string;
+    headers: Record<string, string>;
+    body: any;
+    credentials: "include" | "omit" | "same-origin";
+};
+declare class OUIDThemeController {
+    private state;
+    private handlers;
+    private initialized;
+    private cssInstalled;
+    private hostUnsubscribe?;
+    get mode(): OUIDThemeMode;
+    get resolvedMode(): OUIDResolvedThemeMode;
+    get systemMode(): OUIDResolvedThemeMode;
+    get isDark(): boolean;
+    install(preferredMode?: OUIDThemeMode): Promise<OUIDThemeState>;
+    read(): OUIDThemeState;
+    refresh(fallbackMode?: OUIDThemeMode): Promise<OUIDThemeState>;
+    setMode(mode: OUIDThemeMode): Promise<OUIDThemeState>;
+    onChange(handler: OUIDThemeChangeHandler): () => void;
+    private installCss;
+    private subscribeHostChanges;
+    private update;
+    private apply;
+}
+declare class OUIDAppController {
+    private backButtonHandlers;
+    constructor();
+    exit(options?: OUIDMiniAppExitOptions): Promise<OUIDMiniAppNavigationResult | null>;
+    openMiniApp(options: OUIDOpenMiniAppOptions): Promise<OUIDMiniAppNavigationResult | null>;
+    canOpenMiniApp(appId: string): Promise<boolean>;
+    onBackButton(handler: OUIDBackButtonHandler): OUIDBackButtonUnsubscribe;
+    private handleBackButton;
+}
+declare class OUIDSystemController {
+    getInfo(): Promise<OUIDSystemInfo | null>;
+    getAppState(): Promise<OUIDAppStateInfo | null>;
+    onAppStateChange(handler: OUIDAppStateChangeHandler): Promise<() => Promise<void>>;
+    onForeground(handler: OUIDAppStateChangeHandler): Promise<() => Promise<void>>;
+    onBackground(handler: OUIDAppStateChangeHandler): Promise<() => Promise<void>>;
+    onInactive(handler: OUIDAppStateChangeHandler): Promise<() => Promise<void>>;
+}
+declare class OUIDPermissionController {
+    private readonly bridge;
+    constructor(bridge: {
+        invoke(name: string, ...args: any[]): Promise<any>;
+    });
+    private native;
+    query(): Promise<OUIDPermissionSettingsResult>;
+    query(permission: string): Promise<OUIDPermissionStatus>;
+    request(permission: string): Promise<OUIDPermissionStatus>;
+    requestMany(permissions?: string[]): Promise<OUIDPermissionSettingsResult>;
+    openSettings(): Promise<OUIDPermissionSettingsResult>;
+    openAbout(): Promise<OUIDPermissionSettingsResult>;
+}
+declare class OUIDBridge implements OUIDBridgeInterface {
+    private callbacks;
+    private DOM_EVENT_LISTENERS;
+    private HOST_EVENT_LISTENERS;
+    private timers;
+    private listeners;
+    readonly app: OUIDAppController;
+    readonly system: OUIDSystemController;
+    readonly theme: OUIDThemeController;
+    readonly permissions: OUIDPermissionController;
+    constructor();
+    config(): OUIDBridge;
+    launch(): OUIDLaunchOptions;
+    invoke(name: string, ...args: any[]): Promise<any>;
+    registerComponent(tag: string, compClass: OComponentType<any, any>): void;
+    unregisterComponent(tag: string, compClass: OComponentType<any, any>): void;
+    /**
+     * Make a synchronous class
+     * @param name the name without '_oui' prefix
+     * @param args the arguments list
+     * @returns a promise of T
+     */
+    call<T>(name: string, ...args: any[]): Promise<T | null>;
+    callMany<T extends Record<string, any> = Record<string, any>>(operations: BridgeCallOperation[], options?: BridgeCallOptions): Promise<T>;
+    readMany<T extends Record<string, any> = Record<string, any>>(operations: BridgeCallOperation[]): Promise<T>;
+    callNativeMany<T extends Record<string, any> = Record<string, any>>(operations: NativeCallOperation[]): Promise<T>;
+    emit(event: string, data: any): void;
+    /**
+     *
+     * @param event Create a subscription for a given event name, should be possible to register only once ??
+     * @param callback
+     */
+    subscribe(event: string, callback: (id: string, ...args: any[]) => void): void;
+    private parseHostEvent;
+    addHostEventListener<T = any>(event: string, callback: HostEventCallback<T>): Promise<string>;
+    removeHostEventListener(listenerId: string): Promise<void>;
+    onHostEvent<T = any>(event: string, callback: HostEventCallback<T>): Promise<() => Promise<void>>;
+    query(selector: string, filter?: QueryFilter[], nodeId?: string): Promise<ODOM.OElement | null>;
+    queryAll(selector: string, filter?: QueryFilter[], nodeId?: string): Promise<ODOM.OElement[] | null>;
+    createElement(tag: string, props?: Record<string, string>): Promise<ODOM.OElement | null>;
+    createComment(data: string): Promise<ODOM.OElement | null>;
+    addEventListener(node: ODOM.OObject | 'window' | 'document', event: string, callback: (...args: any[]) => void, extra?: {
+        options?: EventListenerOptions;
+        policy?: EventControlPolicy;
+    }): Promise<string>;
+    dettachEventListener(cbId: string): Promise<void>;
+    createComponentStyles(css: string, inject?: boolean): Promise<ODOM.OElement | null>;
+    appendComponentStyles(cssNode: string): Promise<void>;
+    rejectComponentStyles(cssNode: ODOM.ONode): Promise<void>;
+    loadFont(options: OUIFontLoadOptions): Promise<OUIFontLoadResult | null>;
+    loadFont(family: string, source: string, descriptors?: OUIFontDescriptorOptions): Promise<OUIFontLoadResult | null>;
+    unloadFont(font: string | OUIFontLoadResult | ODOM.OObject, source?: string): Promise<{
+        removed: number;
+    } | null>;
+    createAnimation(target: ODOM.OObject | string, keyframes: OUIDKeyframes, options?: OUIDAnimationOptions): Promise<ODOM.OAnimation | null>;
+    getOObject(id: string): Promise<ODOM.OObject | null>;
+    acquireObject(name: string): Promise<ODOM.OObject | null>;
+    setTimeout(callback: () => void, delay: number): Promise<number>;
+    clearTimeout(id: number): Promise<void>;
+    setInterval(callback: () => void, delay: number): Promise<number>;
+    clearInterval(id: number): Promise<void>;
+    fetch(url: string, input: RequestData, encodeAs: "json"): Promise<any>;
+    fetch(url: string, input: RequestData, encodeAs: "text"): Promise<string>;
+    fetch(url: string, input: RequestData, encodeAs: "base64"): Promise<string>;
+    fetch(url: string, input: RequestData, encodeAs: "buffer"): Promise<ODOM.OObject>;
+    alert(message: string): Promise<void>;
+    prompt(message: string): Promise<void>;
+    openAbout(): Promise<OUIDPermissionSettingsResult | null>;
+    openSettings(): Promise<OUIDPermissionSettingsResult | null>;
+    newObject(ctr: string, ...args: any[]): Promise<ODOM.OObject | null>;
+    requestAnimationFrame(callback: (fps: number) => void): Promise<number>;
+    cancelAnimationFrame(id: number): Promise<void>;
+    batchActions(operations: BatchOperation[]): Promise<void>;
+    nextTick(cb: () => void): void;
+    readFile(file: ODOM.OObject): Promise<unknown>;
+}
+declare const OUID: OUIDBridge & Record<string, (...args: any[]) => Promise<any>>;
+declare global {
+    var OUID: OUIDBridge & Record<string, (...args: any[]) => Promise<any>>;
+    var __ouid_handle_back_button__: (() => boolean) | undefined;
+}
+
+type TemplateFn = (scope: any) => string;
+declare class RenderContext {
+    private app;
+    component: OComponent<Record<string, any>, Record<string, any>>;
+    private parentContext;
+    static PROVIDE_TOKEN: string;
+    static MOUNTED_COMPONENTS_TOKEN: string;
+    static STYLE_REF: WeakMap<any, number>;
+    private bindings;
+    private directives;
+    private mountedComponents;
+    private componentsRegistry;
+    private updatingDirectives;
+    private updatingBindings;
+    private _stack;
+    private flatStack;
+    private viewUpdates;
+    private mountedQueue;
+    constructor(app: App, component: OComponent<Record<string, any>, Record<string, any>>, parentContext: RenderContext | null, ...frames: Record<string, any>[]);
+    get hostElement(): ODOM.OElement;
+    get stack(): Record<string, any>[];
+    set stack(value: Record<string, any>[]);
+    private getRoot;
+    enqueueMounted(fn: () => void): void;
+    flushMounted(): Promise<void>;
+    getMountedComponent(node: ODOM.OElement): OComponent | undefined;
+    bind(binding: Binding): void;
+    directive(directive: Directive): void;
+    evaluateExpression(expr: string | null | undefined): boolean;
+    private resolveScope;
+    resolve(key: string | null | undefined, ...additionFrames: Record<string, any>[]): any;
+    /**
+     * Handing (o-model) like (ngModel) update, we should support mutliple syntaxe like o-mode="value" where value is defined directly on the component
+     * o-model="data['key']" where data is either defined on the component, of in the enclosing scope in case of for-loop for instance
+     * */
+    updateValue(key: string, value: any): void;
+    push(frame: Record<string, any>): void;
+    pop(): void;
+    resolveTag(tag: string): OComponentType<any, any> | undefined;
+    updateBindings(): Promise<void>;
+    updateBinding(binding: Binding): Promise<void>;
+    updateDirectives(): Promise<void>;
+    private render;
+    private expandClass;
+    private expandStyle;
+    private expandStandardAttributes;
+    private setRefValue;
+    handleElementNode(node: ODOM.OElement, options?: {
+        skipSlotted?: boolean;
+        deferUpdates?: boolean;
+    }): Promise<void>;
+    handleTextNode(node: ODOM.OElement): void;
+    collectDepsForBindingsAndDirectives(): void;
+    private scheduleReactiveFlush;
+    private flushReactiveUpdate;
+    private componentAttributes;
+    mountComponent<T extends Record<string, any>, O extends Record<string, string>>(hostNode: ODOM.OElement, component: OComponentType<T, O>, parentContext: RenderContext | null, props?: Record<string, {
+        name: string;
+        value: any;
+        expr?: string;
+    }>, emits?: O): Promise<OComponent>;
+    unmountComponent(node: ODOM.OElement): Promise<void>;
+}
+type Binding = {
+    type: 'model';
+    node: ODOM.OElement;
+    key: string;
+    context: RenderContext;
+    modelValue?: any;
+} | {
+    type: 'interpolation';
+    node: ODOM.OElement;
+    key: string;
+    templateFn: TemplateFn;
+    context: RenderContext;
+} | {
+    type: 'attribute';
+    node: ODOM.OElement;
+    key: string;
+    template: string | null;
+    context: RenderContext;
+} | {
+    type: 'prop';
+    node: ODOM.OElement;
+    key: string;
+    template: string;
+    context: RenderContext;
+};
+type ForChild = {
+    node: ODOM.OElement;
+    ctx: RenderContext;
+    stop?: () => void;
+};
+type Directive = {
+    type: 'if' | 'for';
+    node: ODOM.OElement;
+    expr?: string;
+    placeholder: ODOM.OElement;
+    context: RenderContext;
+    active?: boolean;
+    renderedNode?: ODOM.OElement;
+    list?: string;
+    item?: string;
+    children?: Map<any, ForChild>;
+    key?: string;
+    destroy?: boolean;
+};
+declare function node<P extends Record<string, any>, O extends Record<string, any>>(component: string, p?: P, children?: RenderNode[], emits?: O): Promise<RenderNode>;
+declare function o<P extends Record<string, any>, O extends Record<string, any>>(component: ComponentConstructor<P, O>, props: P, emits?: O): OComponent<P>;
+declare function o<P extends Record<string, any>, O extends Record<string, any>>(component: OComponentType<P, O>, props: P, emits?: O): Promise<OComponent<P>>;
+
+declare class Emits<O extends Record<string, any>> {
+    private events;
+    constructor(events: O);
+    emit(event: keyof O, ...args: any): void;
+}
+
+interface Ref<T> {
+    value: T;
+    __isRef: true;
+}
+
+type Stated<T> = Ref<T>;
+declare function isStated<T>(ob: any): ob is Stated<T>;
+declare function stated<T>(obj: T): Stated<T>;
+declare class State<S extends Record<string, any> = any> {
+    private readonly _ctx;
+    constructor(componentInstance: any);
+    wrap<T>(value: T): Stated<T>;
+    computed<T>(getter: () => T): Stated<T>;
+    watchEffect(fn: (onCleanup: (cb: () => void) => void) => void): () => void;
+    get value(): S;
+}
+
+type ComponentProps<K extends Record<string, any>> = K;
+declare class RenderNode {
+    private node;
+    private children;
+    constructor(node: ODOM.OElement | string, children?: RenderNode[]);
+    attachTo(host: ODOM.OElement): void;
+    static of(node: ODOM.OElement | string, children?: RenderNode[]): RenderNode;
+    addChild(node: RenderNode): RenderNode;
+}
+declare class StyleData {
+    private data;
+    private css;
+    constructor(data: Record<string, StyleData | string>, css: string);
+    toString(): string;
+    static of(data: Record<string, StyleData | string>, ...css: string[]): StyleData;
+}
+/**
+ * Component decorator, it allow an auto registration of components
+ * @param options
+ * @returns
+ */
+declare function Component(options: {
+    template: string;
+    tag: string;
+    use?: Record<string, OComponentType>;
+    css?: string;
+    hostClasses?: string | string[];
+}): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => {
+    new (...args: any[]): {
+        template: string;
+        css: string | undefined;
+        tag: string;
+        use: Record<string, OComponentType<{}, {}>> | undefined;
+        hostClasses: string | string[] | undefined;
+        hash: string;
+    };
+} & T;
+interface Component<P extends Record<string, any>, O extends Record<string, any>> {
+    state: State<any>;
+    readonly emits: Emits<O>;
+    readonly props: ComponentProps<P>;
+    onActivated(): void;
+    onDeactivated(): void;
+    onMounted(): void;
+    willMount(): void;
+    willUnmount(): void;
+    provide<T>(key: string, value: T): void;
+    inject<T>(key: string): T | undefined;
+    render?(ctx: RenderContext): RenderNode | null | Promise<RenderNode | null>;
+    style?(): StyleData | null;
+    decorateHostElement(hostElement: ODOM.OElement): Promise<void>;
+}
+interface ComponentConstructor<P extends Record<string, any>, O extends Record<string, any>> {
+    new (props?: P, emits?: O): Component<P, O>;
+}
+declare function createComponent<P extends Record<string, any>, O extends Record<string, any>>(ctr: ComponentConstructor<P, O>, props?: P, emits?: O): Component<P, O>;
+declare class OComponent<P extends Record<string, any> = {}, O extends Record<string, any> = {}> implements Component<P, O> {
+    state: State<any>;
+    private parent?;
+    readonly emits: Emits<O>;
+    readonly props: ComponentProps<P>;
+    private provides;
+    constructor(props?: P, emits?: O);
+    onActivated(): void;
+    onDeactivated(): void;
+    onMounted(): void;
+    willMount(): void;
+    willUnmount(): void;
+    /** Provide a value for descendants */
+    provide<T>(key: string, value: T): void;
+    /** Inject a value from nearest ancestor */
+    inject<T>(key: string): T | undefined;
+    render?(ctx: RenderContext): RenderNode | null | Promise<RenderNode | null>;
+    style?(): StyleData | null;
+    decorateHostElement(hostElement: ODOM.OElement): Promise<void>;
+}
+type LazyLoader<P extends Record<string, any>, O extends Record<string, any>> = () => Promise<{
+    default: ComponentConstructor<P, O>;
+}>;
+type OComponentType<P extends Record<string, any> = {}, O extends Record<string, any> = {}> = ComponentConstructor<P, O> | LazyLoader<P, O>;
+
+/**
+ * Component responsible for display routes
+ * Usage: `<o-router></o-router>`
+ */
+declare class ORouter extends OComponent {
+    private router;
+    willMount(): void;
+    onMounted(): void;
+    willUnmount(): void;
+}
+declare const ROUTER_INJECTION_TOKEN = "OROUTER_TOKEN";
+declare const ACTIVE_ROUTE_TOKEN = "ACTIVE_ROUTE";
+declare const CURRENT_ROUTE_TOKEN = "CURRENT_ROUTE";
+type RouteTransition = 'none' | 'slide' | 'fade';
+type RouteNavigationMode = 'stack' | 'tab';
+type RouteCacheStrategy = 'stack' | 'route' | 'none';
+interface RouteMeta {
+    navigation?: RouteNavigationMode;
+    transition?: RouteTransition;
+    keepAlive?: boolean;
+    preload?: boolean;
+}
+interface Route {
+    path: string;
+    name: string;
+    component?: OComponentType<any, any>;
+    redirectTo?: string | {
+        name: string;
+    };
+    transition?: RouteTransition;
+    beforeEnter?: RouteGaurdFunction | RouteGaurdFunction[];
+    meta?: RouteMeta;
+}
+declare function useRouter(): Router | undefined;
+declare class OLink extends OComponent<{
+    to?: string | RouteLocation;
+    replace?: boolean;
+    activeClass?: string;
+}> {
+    active: Stated<boolean>;
+    activeClass: string;
+    private removeAfterEach?;
+    onMounted(): void;
+    willUnmount(): void;
+    navigate(): void;
+    onKeydown(event: any): void;
+    private syncActive;
+    private resolveTo;
+}
+declare function createRouter(routes: Routes, options?: RouterOptions): Router;
+type Routes = Array<Route>;
+type MatchedRoute = {
+    route: Route;
+    params: Record<string, any>;
+    query: Record<string, string>;
+    hash: string;
+    parser: RouteParser;
+};
+type Promised<T> = T | Promise<T>;
+type RouteLocationNamed = {
+    name: string;
+    params?: Record<string, any>;
+    query?: Record<string, string>;
+};
+type RouteLocation = {
+    name?: string;
+    path?: string;
+    params?: Record<string, any>;
+    query?: Record<string, string>;
+    hash?: string;
+    absolute?: boolean;
+    mode?: RouteNavigationMode;
+    transition?: RouteTransition;
+};
+type RouteLocationNormalized = {
+    url: string;
+    fullPath: string;
+    path: string;
+    name: string;
+    params: Record<string, any>;
+    query: Record<string, string>;
+    hash: string;
+    route: Route;
+};
+type RouteGuardReturn = void | boolean | RouteLocation;
+type RouteGaurdFunction = (to: RouteLocationNormalized, from?: RouteLocationNormalized | null) => Promised<RouteGuardReturn>;
+interface RouteGuard {
+    type: 'before' | 'after';
+    fn: RouteGaurdFunction;
+}
+type NavigationResultType = 'success' | 'cancelled' | 'redirected' | 'duplicated' | 'not-found' | 'failed';
+interface NavigationResult {
+    type: NavigationResultType;
+    to?: RouteLocationNormalized;
+    from?: RouteLocationNormalized | null;
+    redirectedTo?: RouteLocationNormalized;
+    error?: unknown;
+}
+type RouteScrollPosition = {
+    top?: number;
+    left?: number;
+};
+type RouteScrollBehavior = (to: RouteLocationNormalized, from?: RouteLocationNormalized | null) => Promised<RouteScrollPosition | false | void>;
+interface RouterOptions {
+    defaultTransition?: RouteTransition;
+    transitionDuration?: number;
+    notFound?: string | RouteLocation;
+    backFallback?: RouteLocation;
+    scrollRestoration?: boolean;
+    scrollBehavior?: RouteScrollBehavior;
+    cache?: {
+        strategy?: RouteCacheStrategy;
+        max?: number;
+    };
+    preload?: {
+        tabs?: boolean;
+        routes?: string[];
+        delay?: number;
+    };
+}
+declare class Router implements Plugin<any> {
+    routes: Routes;
+    private windowObject;
+    private guards;
+    private eventRegistration;
+    private compiled;
+    private outletEl;
+    private boundComponent;
+    private outletConfigured;
+    private stack;
+    private tabStacks;
+    private activeTabKey;
+    private routeCache;
+    private currentEntry;
+    private currentPath;
+    private pendingNav;
+    private queuedNav;
+    private historyIndex;
+    private bindToken;
+    private preloadTimer;
+    private preloadStarted;
+    private preloadingRoutes;
+    private readonly activeRoute;
+    readonly currentRoute: Stated<RouteLocationNormalized | null>;
+    private readonly options;
+    constructor(routes: Routes, options?: RouterOptions);
+    install(app: App): void;
+    resolveByName(name: string): MatchedRoute | null;
+    mapPath(parser: RouteParser, params?: Record<string, any>, query?: Record<string, any>, hash?: string): string | null;
+    resolve(url: string, seen?: Set<string>): MatchedRoute | null;
+    private parseUrl;
+    private stringifyPath;
+    private resolveRedirect;
+    private resolveNotFound;
+    replace(options: RouteLocation): Promise<NavigationResult>;
+    push(options: RouteLocation, replace?: boolean): Promise<NavigationResult>;
+    resolveLocation(options: RouteLocation): RouteLocationNormalized | null;
+    href(options: RouteLocation): string;
+    isActive(options: RouteLocation, exact?: boolean): boolean;
+    canGoBack(): boolean;
+    private resolveNavigationTarget;
+    private resolveWithoutNotFound;
+    private navigate;
+    pop(options?: {
+        fallback?: RouteLocation;
+    }): Promise<NavigationResult>;
+    back(options?: {
+        fallback?: RouteLocation;
+    }): Promise<NavigationResult>;
+    backOrExit(): Promise<NavigationResult>;
+    private beforeRouteGoing;
+    private afterRouteGoing;
+    bind(component: ORouter): Promise<() => void>;
+    private resolveLaunchInitialRoute;
+    private renderInitialPath;
+    private setupHistoryTracking;
+    private handlePopState;
+    private readHistoryState;
+    private safelyResolvePath;
+    private commitHistory;
+    private withTimeout;
+    private isCurrentBinding;
+    private enqueueNavigation;
+    private renderPath;
+    private renderMatched;
+    private createNavigationPlan;
+    private toRouteLocation;
+    private updateActiveRoute;
+    private isRouteRedirect;
+    private resolveRouteNavigationMode;
+    private resolveRouteTransition;
+    private routeCacheKey;
+    private shouldKeepAlive;
+    private getActiveStack;
+    private setActiveStack;
+    private isEntryInAnyStack;
+    private resolveRouteEntry;
+    private scheduleRoutePreload;
+    private preloadCandidates;
+    private preloadRoutes;
+    private bringEntryToFront;
+    private prepareCachedEntry;
+    private trimRouteCache;
+    private applyStackChange;
+    private releaseEntryIfUnused;
+    private captureScroll;
+    private applyScroll;
+    private unmountEntry;
+    private runTransition;
+    private waitForTransition;
+    /**
+     * Get href from location and then remove the host part return the path only plus the query and hash
+     */
+    private resolvePath;
+    unbind(): void;
+    private runTransitionNone;
+    private runTransitionFade;
+    private runTransitionPush;
+    private runTransitionPop;
+    beforeEach(fn: RouteGaurdFunction): (() => void);
+    afterEach(fn: RouteGaurdFunction): (() => void);
+}
+
+declare class OIcon extends OComponent {
+    render(_: RenderContext): RenderNode;
+    style(): StyleData | null;
+}
+
+declare function components(): Record<string, OComponent<any, any>>;
+
+export { ACTIVE_ROUTE_TOKEN, App, type BatchOperation, type Binding, type BridgeCallMode, type BridgeCallOperation, type BridgeCallOptions, CURRENT_ROUTE_TOKEN, Component, type ComponentConstructor, type ComponentProps, type Directive, Emits, type EventControlPolicy, type EventListenerOptions, type HostEvent, type HostEventCallback, type InjectionKey, type LazyLoader, type NativeCallOperation, type NavigationResult, type NavigationResultType, OComponent, type OComponentType, ODOM, OIcon, OLink, ORouter, OUID, type OUIDAnimationOptions, type OUIDAnimationTiming, type OUIDAnimationValue, OUIDAppController, type OUIDAppStateChangeHandler, type OUIDAppStateInfo, type OUIDAppStateName, type OUIDBackButtonHandler, type OUIDBackButtonUnsubscribe, OUIDBridge, type OUIDBridgeInterface, type OUIDKeyframes, type OUIDLaunchOptions, type OUIDMiniAppExitOptions, type OUIDMiniAppNavigationMode, type OUIDMiniAppNavigationResult, type OUIDOpenMiniAppOptions, OUIDPermissionController, type OUIDPermissionSettingsResult, type OUIDPermissionState, type OUIDPermissionStatus, type OUIDPlatform, type OUIDResolvedThemeMode, type OUIDSafeArea, OUIDSystemController, type OUIDSystemInfo, type OUIDSystemTheme, type OUIDThemeChangeHandler, OUIDThemeController, type OUIDThemeMode, type OUIDThemeState, type OUIDVector2Value, type OUIDVector3Value, type OUIFontDescriptorOptions, type OUIFontLoadOptions, type OUIFontLoadResult, type Plugin, type Promised, type Provider, type Providers, ROUTER_INJECTION_TOKEN, RenderContext, RenderNode, type Route, type RouteCacheStrategy, type RouteGaurdFunction, type RouteGuard, type RouteGuardReturn, type RouteLocation, type RouteLocationNamed, type RouteLocationNormalized, type RouteMeta, type RouteNavigationMode, type RouteScrollBehavior, type RouteScrollPosition, type RouteTransition, Router, type RouterOptions, type Routes, State, type Stated, StyleData, WebOUID, components, createComponent, createRouter, inject, isStated, node, o, provide, stated, useRouter };