glass-easel 0.2.0 → 0.3.0

package/dist/glass_easel.d.ts

@@ -0,0 +1,2546 @@
+/**
+ * The style scope identifier
+ *
+ * It is actually a non-negative integer.
+ *
+ * Specifically, `0` represents *global* scope, which means it is a global style in stylesheets.
+ * However, in elements, `0` means it does not match any stylesheets other than the global styles.
+ */
+type StyleScopeId = number;
+/**
+ * Style scope manager
+ */
+declare class StyleScopeManager {
+    static globalScope(): StyleScopeId;
+    register(name: string): StyleScopeId;
+    queryName(id: StyleScopeId): string | undefined;
+}
+/**
+ * Class manager for non-virtual `Element`
+ */
+declare class ClassList {
+    constructor(element: Element$4, externalNames: string[] | undefined, owner: ClassList | null, styleScope: number, extraStyleScope: number | undefined, styleScopeManager: StyleScopeManager | undefined);
+    toggle(name: string, force?: boolean, segmentIndex?: StyleSegmentIndex): boolean;
+    contains(name: string, segmentIndex?: StyleSegmentIndex): boolean;
+    /** Set class string */
+    setClassNames(names: string | string[], segmentIndex?: StyleSegmentIndex): boolean;
+    /** Returns space separated class string */
+    getClassNames(segmentIndex?: StyleSegmentIndex): string;
+}
+
+type DataPath = Array<string | number>;
+type MultiPaths = DataPath[];
+declare const parseSinglePath: (str: string) => DataPath;
+declare const parseMultiPaths: (str: string | readonly string[]) => MultiPaths;
+
+type data_path_DataPath = DataPath;
+type data_path_MultiPaths = MultiPaths;
+declare const data_path_parseMultiPaths: typeof parseMultiPaths;
+declare const data_path_parseSinglePath: typeof parseSinglePath;
+declare namespace data_path {
+  export { type data_path_DataPath as DataPath, type data_path_MultiPaths as MultiPaths, data_path_parseMultiPaths as parseMultiPaths, data_path_parseSinglePath as parseSinglePath };
+}
+
+/**
+ * Interface that can be implement dynamically
+ *
+ * A `TraitBehavior` is like a TypeScript interface, but can be implemented dynamically.
+ * It requires the implementors to implement `TIn` .
+ * Also, it can provide do a transform from `TIn` to `TOut` as common logic of the trait.
+ */
+declare class TraitBehavior<TIn extends {
+    [key: string]: unknown;
+}, TOut extends {
+    [key: string]: unknown;
+} = TIn> {
+    ownerSpace: ComponentSpace;
+}
+
+/** A group of components for cross-component using */
+declare class ComponentSpace {
+    styleScopeManager: StyleScopeManager;
+    /**
+     * Create a new component space
+     *
+     * The `defaultComponent` is the default component path.
+     * It should be defined soon after creation.
+     * A `baseSpace` can be provided as a "base" component space -
+     * every component alias (and behavior alias) in the space will be imported when creation.
+     * However, if any new component is added to the base space after the creation,
+     * it will not be added to the created space.
+     */
+    constructor(defaultComponent?: string, baseSpace?: ComponentSpace, styleScopeManager?: StyleScopeManager, allowUnusedNativeNode?: boolean);
+    /**
+     * Update the default component options for this space
+     *
+     * The new options will be merged with existing options.
+     */
+    updateComponentOptions(componentOptions: ComponentOptions): void;
+    getComponentOptions(): NormalizedComponentOptions;
+    /**
+     * Set (or update) a global using component item
+     *
+     * This will allow all the components in this component space using this component automatically,
+     * without declaring it with `using` or `usingComponents` again.
+     * The target can also be a tag name of a native node.
+     */
+    setGlobalUsingComponent(key: string, target: GeneralComponentDefinition | string): void;
+    /**
+     * Import another component space
+     *
+     * The components in the imported space can be used by components in this space.
+     * The `protoDomain` should be URL-like, i.e. `space://another-space` .
+     * When using, the components in the imported space should be specified with `protoDomain` .
+     * For example, if `protoDomain` is `space://another-space` and one imported component has alias `my-comp` ,
+     * then it should be specified with `space://another-space/my-comp` .
+     * If `privateUse` set to false, only component alias in the imported space can be used;
+     * the original name of components is imported otherwise.
+     */
+    importSpace(protoDomain: string, space: ComponentSpace, privateUse: boolean): void;
+    /**
+     * Get a component by the `path`
+     *
+     * The component `is` is actually treated as the "path" of the component.
+     * In other words, the component `is` field can be a string like `path/to/the/component` .
+     * Other components can be used by the component with "relative path" specified.
+     * In this method, if the `path` is given as a relative path (not started with `/` ),
+     * it will be converted according to the `basePath` .
+     * If the `path` is given as a URL-like format,
+     * the component will be searched in imported component spaces ( `importSpace()` for details).
+     */
+    getComponentByUrl(path: string, basePath: string): GeneralComponentDefinition;
+    /**
+     * Get a component by the `path`
+     *
+     * Similar to `getComponentByUrl()` ,
+     * but returns `null` instead of the default component if no component was found.
+     */
+    getComponentByUrlWithoutDefault(path: string, relPath: string): GeneralComponentDefinition | null;
+    private getComponent;
+    getDefaultComponent(): GeneralComponentDefinition | null;
+    isDefaultComponent(def: GeneralComponentDefinition): boolean;
+    getGlobalUsingComponent(key: string): GeneralComponentDefinition | NativeNodeDefinition | null;
+    /**
+     * Get a behavior by the `path`
+     *
+     * Similar to `getComponentByUrlWithoutDefault()` but for behaviors.
+     */
+    getBehaviorByUrl(path: string, relPath: string): GeneralBehavior | null;
+    /** Register a component in this space */
+    defineComponent<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(def: ComponentParams<TData, TProperty, TMethod> & ThisType<ComponentInstance<TData, TProperty, TMethod>>): ComponentDefinition<TData, TProperty, TMethod>;
+    /** Register a behavior in this space */
+    defineBehavior<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(def: ComponentParams<TData, TProperty, TMethod> & ThisType<ComponentInstance<TData, TProperty, TMethod>>): Behavior<TData, TProperty, TMethod, never>;
+    /** Register a component or a behavior with chaining API */
+    define(is?: string): BehaviorBuilder;
+    /**
+     * Register a component or a behavior with chaining API (with method caller type specified)
+     *
+     * This API is generally designed for adapters which require special method callers.
+     */
+    defineWithMethodCaller(is?: string): BehaviorBuilder<Empty, Empty, Empty, Empty, never, never>;
+    /**
+     * Start a series of components and behaviors registration
+     *
+     * In most cases, `groupRegister` is prefered.
+     */
+    startGroupRegister(): void;
+    /**
+     * End a series of components and behaviors registration
+     *
+     * In most cases, `groupRegister` is prefered.
+     */
+    endGroupRegister(): void;
+    /**
+     * Group a series of components and behaviors registration
+     *
+     * If any placeholder should be replaced,
+     * the replacement will happen after the whole series of registration.
+     */
+    groupRegister<R>(cb: () => R): R | undefined;
+    /**
+     * Assign a public alias to a component
+     *
+     * The alias can be used in other component spaces which imported this component space.
+     * One component may have multiple aliases.
+     */
+    exportComponent(alias: string, is: string): void;
+    /** Get a component by its exported alias */
+    getExportedComponent(alias: string): GeneralComponentDefinition | undefined;
+    /** Get a behavior by its exported alias */
+    getExportedBehavior(alias: string): GeneralBehavior | undefined;
+    /**
+     * Assign a public alias to a behavior
+     *
+     * The alias can be used in other component spaces which imported this component space.
+     * One behavior may have multiple aliases.
+     */
+    exportBehavior(alias: string, is: string): void;
+    /**
+     * Set a listener which will be called when a placeholded component is used.
+     *
+     * This can be used as a hint for a component that should be registered later.
+     * If `isPub` is false, the `alias` is the path of the component, a.k.a. `is` .
+     * Otherwise, it is the exported `alias` instead.
+     */
+    setComponentWaitingListener(listener: ((isPub: boolean, alias: string, owner: GeneralComponent) => void) | null): void;
+    /**
+     * Create a component by URL
+     *
+     * This `url` can contain params (started with "?" character).
+     * The params will try to be set to component properties (if matches the property name).
+     */
+    createComponentByUrl(tagName: string, url: string, genericTargets: {
+        [name: string]: string;
+    } | null, backendContext: GeneralBackendContext | null): GeneralComponent;
+    /**
+     * Define a trait behavior
+     *
+     * A trait behavior
+     * Optionally, the trait behavior can add a conversion function.
+     * This function can convert the implementation to another interface.
+     */
+    defineTraitBehavior<TIn extends {
+        [key: string]: any;
+    }>(): TraitBehavior<TIn, TIn>;
+    defineTraitBehavior<TIn extends {
+        [key: string]: any;
+    }, TOut extends {
+        [key: string]: any;
+    }>(trans: (impl: TIn) => TOut): TraitBehavior<TIn, TOut>;
+}
+declare const getDefaultComponentSpace: () => ComponentSpace;
+
+type DevtoolInterface = {
+    now: () => number;
+    addTimelineEvent: (time: number, type: string, data?: Record<string, unknown>) => void;
+    addTimelineComponentEvent: (time: number, type: string, component: GeneralComponent, data?: Record<string, unknown>) => void;
+    addTimelinePerformanceMeasureStart: (time: number, type: string, component: GeneralComponent | string | null, data?: Record<string, unknown>) => void;
+    addTimelinePerformanceMeasureEnd: (time: number) => void;
+    addTimelineBackendWaterfall: (type: string, times: [
+        number,
+        number,
+        number
+    ], data?: Record<string, unknown>) => void;
+};
+
+declare class VirtualNode extends Element$4 {
+    [VIRTUAL_NODE_SYMBOL]: true;
+    is: string;
+    constructor();
+    static isVirtualNode: (e: any) => e is VirtualNode;
+    static create(virtualName: string, owner: ShadowRoot): VirtualNode;
+}
+
+type Node$1 = TextNode | Element$4;
+interface NodeCast {
+    /**
+     * Cast a node to a text node
+     *
+     * Returns `null` if the element is not a text node.
+     */
+    asTextNode(): TextNode | null;
+    /**
+     * Cast a node to an element (native node, virtual node, or component node)
+     *
+     * Returns `null` if the element is not a text node.
+     */
+    asElement(): Element$4 | null;
+    /**
+     * Cast an element to a native node
+     *
+     * Returns `null` if the element is not a native node.
+     */
+    asNativeNode(): NativeNode | null;
+    /**
+     * Cast an element to a virtual node
+     *
+     * Returns `null` if the element is not a virtual node.
+     */
+    asVirtualNode(): VirtualNode | null;
+    /**
+     * Cast an element to the instance of the specified component
+     *
+     * Returns `null` if the element is not the instance of the specified component.
+     */
+    asInstanceOf<UData extends DataList, UProperty extends PropertyList, UMethod extends MethodList>(componentDefinition: ComponentDefinition<UData, UProperty, UMethod>): ComponentInstance<UData, UProperty, UMethod> | null;
+}
+declare const dumpSingleElementToString: (elem: any) => string;
+declare const dumpElementToString: (elem: any, composed: boolean, tabDepth?: number) => string;
+declare const dumpElement: (elem: any, composed: boolean) => void;
+
+declare class TextNode implements NodeCast {
+    ownerShadowRoot: ShadowRoot;
+    parentNode: Element$4 | null;
+    parentIndex: number;
+    containingSlot: Element$4 | null | undefined;
+    slotNodes: Node[] | undefined;
+    slotIndex: number | undefined;
+    constructor(text: string, owner: ShadowRoot);
+    static isTextNode: (e: any) => e is TextNode;
+    static create(text: string, ownerShadowRoot: ShadowRoot): TextNode;
+    asTextNode(): TextNode;
+    asElement(): null;
+    asNativeNode(): null;
+    asVirtualNode(): null;
+    asInstanceOf(): null;
+    /** Destroy the backend element */
+    destroyBackendElement(): void;
+    /** Destroy the backend element on next detach */
+    destroyBackendElementOnDetach(): void;
+    /** Get the backend element */
+    getBackendElement(): GeneralBackendElement | null;
+    /** Get composed parent (including virtual nodes) */
+    getComposedParent(): Element$4 | null;
+    get $$(): GeneralBackendElement | null;
+    get textContent(): string;
+    set textContent(text: string);
+}
+
+declare const ELEMENT_SYMBOL: unique symbol;
+declare const NATIVE_NODE_SYMBOL: unique symbol;
+declare const VIRTUAL_NODE_SYMBOL: unique symbol;
+declare const COMPONENT_SYMBOL: unique symbol;
+
+declare class NativeNode extends Element$4 {
+    [NATIVE_NODE_SYMBOL]: true;
+    is: string;
+    stylingName: string;
+    constructor();
+    static isNativeNode: (e: any) => e is NativeNode;
+    static create(tagName: string, owner: ShadowRoot, stylingName?: string, placeholderHandlerRemover?: () => void): NativeNode;
+    setModelBindingListener(propName: string, listener: ModelBindingListener): void;
+    getModelBindingListeners(): {
+        [name: string]: ModelBindingListener;
+    };
+}
+
+declare const enum SlotMode {
+    Direct = 0,
+    Single = 1,
+    Multiple = 2,
+    Dynamic = 3
+}
+declare class ShadowRoot extends VirtualNode {
+    constructor();
+    static isShadowRoot: (e: any) => e is ShadowRoot;
+    static createShadowRoot(host: GeneralComponent): ShadowRoot;
+    getHostNode(): GeneralComponent;
+    createTextNode(text?: string): TextNode;
+    createNativeNode(tagName: string): NativeNode;
+    createVirtualNode(virtualName?: string): VirtualNode;
+    createNativeNodeWithInit(tagName: string, stylingName: string, placeholderHandlerRemover: (() => void) | undefined, initPropValues?: (comp: NativeNode) => void): NativeNode;
+    /**
+     * Create a component if possible
+     *
+     * Placeholding status should be checked with `checkComponentPlaceholder` .
+     * This function may create a native node if the using target is native node.
+     */
+    createComponent(tagName: string, usingKey?: string, genericTargets?: {
+        [key: string]: string;
+    }, placeholderCallback?: (c: GeneralComponentDefinition) => void, initPropValues?: (comp: GeneralComponent | NativeNode) => void): GeneralComponent | NativeNode;
+    createComponentByDef(tagName: string, componentDef: GeneralComponentDefinition): GeneralComponent;
+    /**
+     * Create a component if the given tag name is a component in the space, or a native node if not
+     *
+     * The component `using` map is not used.
+     * Consider using `checkComponentPlaceholder` to check if the tag name is in the `using` map.
+     * The global using registered with `ComponentSpace.prototype.getGlobalUsingComponent` is still used.
+     */
+    createComponentOrNativeNode(tagName: string, genericTargets?: {
+        [key: string]: string;
+    }, initPropValues?: (comp: GeneralComponent | NativeNode) => void): GeneralComponent | NativeNode;
+    /**
+     * Find whether this component is placeholding or not
+     *
+     * This method will only find in the component `using` list and `generics` list.
+     * If not found, returns `undefined` .
+     * If the placeholder will be used, returns `true` ; `false` otherwise.
+     */
+    checkComponentPlaceholder(usingKey: string): boolean | undefined;
+    getElementById(id: string): Element$4 | undefined;
+    /** Get the slot element with the specified name */
+    getSlotElementFromName(name: string): Element$4 | Element$4[] | null;
+    /**
+     * Get the slot element for the slot content
+     *
+     * The provided node must be a valid child node of the host of this shadow root.
+     * Otherwise the behavior is undefined.
+     */
+    getContainingSlot(elem: Node$1 | null): Element$4 | null;
+    /**
+     * Get the elements that should be composed in specified slot
+     *
+     * This method always returns a new array (or null if the specified slot is invalid).
+     * It is convenient but less performant.
+     * For better performance, consider using `forEachNodeInSpecifiedSlot` .
+     */
+    getSlotContentArray(slot: Element$4): Node$1[] | null;
+    /**
+     * Iterate slots
+     */
+    forEachSlot(f: (slot: Element$4) => boolean | void): void;
+    /**
+     * Iterate through elements ahd their corresponding slots (including slots-inherited nodes)
+     * @param f A function to execute for each element. Return false to break the iteration.
+     * @returns A boolean indicating whether the iteration is complete.
+     */
+    forEachNodeInSlot(f: (node: Node$1, slot: Element$4 | null | undefined) => boolean | void): boolean;
+    /**
+     * Iterate through elements of a specified slot (including slots-inherited nodes)
+     * @param f A function to execute for each element. Return false to break the iteration.
+     * @returns A boolean indicating whether the iteration is complete.
+     */
+    forEachNodeInSpecifiedSlot(slot: Element$4 | null, f: (node: Node$1) => boolean | void): boolean;
+    /**
+     * Iterate through elements ahd their corresponding slots (NOT including slots-inherited nodes)
+     * @param f A function to execute for each element. Return false to break the iteration.
+     * @returns A boolean indicating whether the iteration is complete.
+     */
+    forEachSlotContentInSlot(f: (node: Node$1, slot: Element$4 | null | undefined) => boolean | void): boolean;
+    /**
+     * Iterate through elements of a specified slot (NOT including slots-inherited nodes)
+     * @param f A function to execute for each element. Return false to break the iteration.
+     * @returns A boolean indicating whether the iteration is complete.
+     */
+    forEachSlotContentInSpecifiedSlot(slot: Element$4 | null, f: (node: Node$1) => boolean | void): boolean;
+    /**
+     * Check whether a node is connected to this shadow root
+     */
+    isConnected(node: Node$1): boolean;
+    /**
+     * Set the dynamic slot handlers
+     *
+     * If the handlers have not been set yet,
+     * the `insertSlotHandler` will be called for each slot that has been added to the shadow tree,
+     * otherwise call `updateSlotHandler` for each slots.
+     */
+    setDynamicSlotHandler(requiredSlotValueNames: string[], insertSlotHandler: (slots: {
+        slot: Element$4;
+        name: string;
+        slotValues: {
+            [name: string]: unknown;
+        };
+    }[]) => void, removeSlotHandler: (slots: Element$4[]) => void, updateSlotHandler: (slot: Element$4, slotValues: {
+        [name: string]: unknown;
+    }, updatePathTree: {
+        [name: string]: true;
+    }) => void): void;
+    /**
+     * Use the same dynamic slot handlers with the `source`
+     */
+    useDynamicSlotHandlerFrom(source: ShadowRoot): void;
+    /**
+     * Update a slot value
+     *
+     * The updated value should be applied with `applySlotValueUpdates` call.
+     */
+    replaceSlotValue(slot: Element$4, name: string, value: unknown): void;
+    /**
+     * Apply slot value updates
+     */
+    applySlotValueUpdates(slot: Element$4): void;
+    applySlotUpdates(): void;
+    /**
+     * Get slot mode
+     */
+    getSlotMode(): SlotMode;
+}
+
+type GeneralFuncType = (this: any, ...args: any[]) => any;
+declare class FuncArr<F extends GeneralFuncType> {
+    empty: boolean;
+    private _$type;
+    private _$arr;
+    constructor(type: string);
+    add(func: F): void;
+    remove(func: F): F | null;
+    call(caller: ThisParameterType<F>, args: Parameters<F>, relatedComponent?: AnyComponent): boolean;
+}
+declare function safeCallback<F extends GeneralFuncType>(this: void, type: string, method: F, caller: ThisParameterType<F>, args: Parameters<F>, relatedComponent?: AnyComponent): ReturnType<F> | undefined;
+
+/**
+ * Options for an event
+ */
+type EventOptions = {
+    originalEvent?: unknown;
+    bubbles?: boolean;
+    composed?: boolean;
+    capturePhase?: boolean;
+    extraFields?: {
+        [key: string]: unknown;
+    };
+    handleListenerReturn?: (ret: unknown) => boolean | void;
+};
+/**
+ * Options for an event listener
+ */
+type EventListenerOptions = {
+    /** Always stop bubbling after this listener */
+    final?: boolean;
+    /** Mark mutated after this listener (ignored if `final` is true) */
+    mutated?: boolean;
+    /** Listen in the capture phase */
+    capture?: boolean;
+    /** The same as `capture` for compatibility */
+    useCapture?: boolean;
+};
+/**
+ * Event bubbling control
+ */
+declare const enum EventBubbleStatus {
+    Normal = 0,
+    NoDefault = 1
+}
+type EventListener<TDetail> = (ev: ShadowedEvent<TDetail>) => boolean | void;
+declare const enum MutLevel {
+    None = 0,
+    Mut = 1,
+    Final = 2
+}
+type ShadowedEvent<TDetail> = Required<Event<TDetail>> & {
+    target: Element$4;
+    mark: {
+        [name: string]: unknown;
+    } | null;
+    currentTarget: Element$4;
+};
+declare class Event<TDetail> {
+    type: string;
+    timeStamp: number;
+    detail: TDetail;
+    bubbles: boolean;
+    composed: boolean;
+    constructor(name: string, detail: TDetail, options?: EventOptions);
+    getEventBubbleStatus(): EventBubbleStatus;
+    wrapShadowedEvent(targetCaller: Element$4, mark: {
+        [name: string]: unknown;
+    } | null, currentTargetCaller: Element$4): ShadowedEvent<TDetail>;
+    getEventName(): string;
+    getOriginalEvent(): unknown;
+    preventDefault(): void;
+    defaultPrevented(): boolean;
+    stopPropagation(): void;
+    propagationStopped(): boolean;
+    markMutated(): void;
+    mutatedMarked(): boolean;
+    listenerReturnHandler(): ((ret: unknown) => boolean | void) | undefined;
+    callListener(currentTarget: Element$4, mark: Record<string, unknown> | null, target: Element$4, isCapture: boolean): void;
+    dispatch(target: Element$4, externalTarget?: GeneralBackendElement): void;
+    static dispatchEvent<TDetail>(target: Element$4, event: Event<TDetail>): void;
+    static dispatchExternalEvent<TDetail>(component: GeneralComponent, target: GeneralBackendElement, event: Event<TDetail>): void;
+    static triggerEvent<TDetail>(this: void, target: Element$4, name: string, detail: TDetail, options?: EventOptions): void;
+    static triggerExternalEvent<TDetail>(this: void, component: GeneralComponent, target: GeneralBackendElement, name: string, detail: TDetail, options?: EventOptions): void;
+}
+
+/**
+ * An external shadow root
+ *
+ * It can be used to build an external component.
+ * External component is a customizable subtree that can be composed with normal components.
+ * It allows third-party frameworks to render a subtree and then compose it together.
+ * However, the subtree must be created in the same backend context.
+ */
+interface ExternalShadowRoot {
+    root: GeneralBackendElement;
+    slot: GeneralBackendElement;
+    getIdMap(): {
+        [id: string]: GeneralBackendElement;
+    };
+    handleEvent<T>(target: GeneralBackendElement, event: Event<T>): void;
+    setListener<T>(elem: GeneralBackendElement, ev: string, listener: (event: ShadowedEvent<T>) => unknown): void;
+}
+
+/**
+ * A template engine that handles the template part of a component
+ */
+interface TemplateEngine {
+    /**
+     * Preprocess a behavior and generate a preprocessed template
+     *
+     * This function is called during component prepare.
+     * The `_$template` field of the behavior is designed to be handled by the template engine,
+     * and should be preprocessed in this function.
+     */
+    create(behavior: GeneralBehavior, componentOptions: NormalizedComponentOptions): Template;
+}
+/**
+ * A preprocessed template
+ */
+interface Template {
+    /**
+     * Create a template instance for a component instance
+     */
+    createInstance(elem: GeneralComponent, createShadowRoot: (component: GeneralComponent) => ShadowRoot): TemplateInstance;
+    /**
+     * Update the content of the template (optional)
+     *
+     * Implement this function if template update is needed (usually used during development).
+     * The behavior is always the object which used when creation.
+     */
+    updateTemplate?(behavior: GeneralBehavior): void;
+}
+/**
+ * A template instance that works with a component instance
+ */
+interface TemplateInstance {
+    /**
+     * The shadow root of the component
+     *
+     * This field should not be changed.
+     */
+    shadowRoot: ShadowRoot | ExternalShadowRoot;
+    /**
+     * Apply the updated template content (optional)
+     *
+     * Implement this function if template update is needed (usually used during development).
+     * The template is always the object which used when creation.
+     */
+    updateTemplate?(template: Template, data: DataValue): void;
+    initValues(data: DataValue): void;
+    updateValues(data: DataValue, changes: DataChange[]): void;
+}
+
+type template_engine_Template = Template;
+type template_engine_TemplateEngine = TemplateEngine;
+type template_engine_TemplateInstance = TemplateInstance;
+declare namespace template_engine {
+  export type { template_engine_Template as Template, template_engine_TemplateEngine as TemplateEngine, template_engine_TemplateInstance as TemplateInstance };
+}
+
+/**
+ * The deep copy strategy
+ *
+ * Higher level indicates more accuracy but probably less performance.
+ */
+declare enum DeepCopyKind {
+    /**
+     * Avoid deep copy
+     *
+     * This avoids any copy, and recursive objects can be handled without any failing.
+     * However, changing non-copied data will sometimes break the logic.
+     */
+    None = "none",
+    /**
+     * Do a simple deep copy
+     *
+     * This simply clones each enumerable fields in an object to a new object.
+     * It causes stack overflow in recursive objects.
+     * Everything in prototypes is ignored.
+     */
+    Simple = "simple",
+    /**
+     * Do a deep copy with recursion detection
+     *
+     * This clones each enumerable fields in an object to a new object.
+     * It can handle recursive objects by recursive detection.
+     * Everything in prototypes is ignored.
+     */
+    SimpleWithRecursion = "simple-recursion"
+}
+/**
+ * Options for a component
+ */
+type ComponentOptions = {
+    /** Is external component or not */
+    externalComponent?: boolean;
+    /** The host node tag name (only valid in external components) */
+    hostNodeTagName?: string;
+    /** The template engine */
+    templateEngine?: TemplateEngine;
+    /** The style scope */
+    styleScope?: StyleScopeId;
+    /** An extra style scope assigned to the component */
+    extraStyleScope?: StyleScopeId | null;
+    /** Enable multiple slots or not */
+    multipleSlots?: boolean;
+    /** Enable dynamic slots or not */
+    dynamicSlots?: boolean;
+    /** Enable direct slots or not */
+    directSlots?: boolean;
+    /** Write property values of components to backend with `setAttribute` */
+    reflectToAttributes?: boolean;
+    /** Allow properties and methods to be able to visit directly in component instance */
+    writeFieldsToNode?: boolean;
+    /** Write node ID to backend node */
+    writeIdToDOM?: boolean;
+    /** Use the methods in method caller as the event handlers or not */
+    useMethodCallerListeners?: boolean;
+    /** Generate a prefix for ID written to backend node */
+    idPrefixGenerator?: ((this: GeneralComponent) => string) | null;
+    /** Filter some fields out when applying to templates */
+    pureDataPattern?: RegExp | null;
+    /** Decide how to deep copy component data when updates */
+    dataDeepCopy?: DeepCopyKind;
+    /** Decide how to deep copy when a property changes */
+    propertyPassingDeepCopy?: DeepCopyKind;
+    /** Enable listener change events or not */
+    listenerChangeLifetimes?: boolean;
+    /** Component host node is virtual or not */
+    virtualHost?: boolean;
+    /** Init component with property values or not */
+    propertyEarlyInit?: boolean;
+};
+type NormalizedComponentOptions = {
+    externalComponent: boolean;
+    hostNodeTagName: string;
+    templateEngine: TemplateEngine | null;
+    styleScope: StyleScopeId | null;
+    extraStyleScope: StyleScopeId | null;
+    multipleSlots: boolean;
+    dynamicSlots: boolean;
+    directSlots: boolean;
+    reflectToAttributes: boolean;
+    writeFieldsToNode: boolean;
+    writeIdToDOM: boolean;
+    useMethodCallerListeners: boolean;
+    idPrefixGenerator: ((this: GeneralComponent) => string) | null;
+    pureDataPattern: RegExp | null;
+    dataDeepCopy: DeepCopyKind;
+    propertyPassingDeepCopy: DeepCopyKind;
+    listenerChangeLifetimes: boolean;
+    virtualHost: boolean;
+    propertyEarlyInit: boolean;
+};
+/**
+ * Options for global environment
+ */
+type EnvironmentOptions = {
+    /** The default component space */
+    defaultComponentSpace: ComponentSpace | null;
+    /** Throw errors when errors caught in event callbacks (useful in testing scripts) */
+    throwGlobalError: boolean;
+    /** Write some extra attributes to DOM backend (for testing) */
+    writeExtraInfoToAttr: boolean;
+    /** The default backend context */
+    backendContext: GeneralBackendContext | null;
+    /** The devtool interface */
+    devtool: DevtoolInterface | null;
+};
+/**
+ * The default options
+ */
+declare const globalOptions: NormalizedComponentOptions & EnvironmentOptions;
+
+declare const enum NormalizedPropertyType {
+    Invalid = "invalid",
+    Any = "any",
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Object = "object",
+    Array = "array",
+    Function = "function"
+}
+type PropertyDefinition = {
+    type: NormalizedPropertyType;
+    optionalTypes: NormalizedPropertyType[] | null;
+    value: unknown;
+    default: (() => unknown) | undefined;
+    observer: ((newValue: unknown, oldValue: unknown) => void) | null;
+    comparer: ((newValue: unknown, oldValue: unknown) => boolean) | null;
+    reflectIdPrefix: boolean;
+};
+declare const enum DeepCopyStrategy {
+    None = 0,
+    Simple = 1,
+    SimpleWithRecursion = 2
+}
+type DataValue = unknown;
+type DataObserver = (...values: unknown[]) => void;
+type DataChange = DataReplace | DataSplice;
+type DataReplace = [DataPath, DataValue, RequireComparer, undefined];
+type RequireComparer = true | undefined;
+type DataSplice = [DataPath, DataValue[], number, number];
+type PropertyChange = {
+    propName: string;
+    prop: PropertyDefinition;
+    oldValue: unknown;
+    newValue: unknown;
+    skipModelListener: boolean;
+};
+type DataUpdateCallback = (data: {
+    [name: string]: DataValue;
+}, combinedChanges: DataChange[]) => void;
+type ModelBindingListener = (value: DataValue) => void;
+type ObserverNode = {
+    listener?: number[];
+    wildcard?: number[];
+    sub: {
+        [name: string]: ObserverNode;
+    };
+};
+declare class DataGroupObserverTree {
+    propFields: {
+        [name: string]: PropertyDefinition;
+    };
+    observerTree: ObserverNode;
+    observers: DataObserverWithPath[];
+    constructor(propFields: {
+        [name: string]: PropertyDefinition;
+    });
+    cloneSub(): DataGroupObserverTree;
+    addObserver(func: DataObserver, dataPath: MultiPaths): void;
+}
+type DataObserverWithPath = {
+    path: MultiPaths;
+    f: DataObserver;
+};
+/** A data wrapper for data operations such as `setData` */
+declare class DataGroup<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> {
+    data: DataWithPropertyValues<TData, TProperty>;
+    innerData: {
+        [key: string]: DataValue;
+    } | null;
+    private _$comp;
+    private _$pureDataPattern;
+    private _$dataDeepCopy;
+    private _$propertyPassingDeepCopy;
+    private _$reflectToAttributes;
+    private _$propFields;
+    private _$observerTree;
+    private _$observers;
+    private _$observerStatus;
+    private _$modelBindingListener;
+    private _$updateListener?;
+    private _$pendingChanges;
+    private _$doingUpdates;
+    private _$generateInnerData;
+    constructor(associatedComponent: ComponentInstance<TData, TProperty, TMethod> | null, data: DataWithPropertyValues<TData, TProperty>, pureDataPattern: RegExp | null, dataDeepCopy: DeepCopyStrategy, propertyPassingDeepCopy: DeepCopyStrategy, reflectToAttributes: boolean, observerTree: DataGroupObserverTree);
+    /** Create a simple data group */
+    static create(data: {
+        [key: string]: DataValue;
+    }): DataGroup<any, PropertyList, MethodList>;
+    /** Set a callback for every grouped update */
+    setUpdateListener(updateListener: DataUpdateCallback): void;
+    /** Replace the underlying data */
+    replaceWholeData(data: DataWithPropertyValues<TData, TProperty>): void;
+    /** Add a new common data change to queue */
+    replaceDataOnPath(path: DataPath, newData: DataValue): void;
+    /** Add a new array splice operation to queue */
+    spliceArrayDataOnPath(path: DataPath, index: number | undefined, del: number | undefined, inserts: DataValue[]): void;
+    /**
+     * Add a new property change to queue
+     *
+     * (Generally designed for template engines.)
+     * If the `propName` is a property,
+     * the `newData` will be deep-copied according to the `propertyPassingDeepCopy` configuration.
+     * Otherwise, it returns false.
+     */
+    replaceProperty(propName: string, newData: DataValue): boolean;
+    /** Discard changes in queue and generate a new queue with specified changes */
+    setChanges(changes: DataChange[]): void;
+    /** Get the data change queue */
+    getChanges(): DataChange[];
+    /**
+     * Set a callback when a specified property changes
+     *
+     * (Generally designed for template engines.)
+     */
+    setModelBindingListener(propName: string, listener: ModelBindingListener): void;
+    /** Apply all changes in queue */
+    applyDataUpdates(skipModelListener?: boolean): void;
+}
+type GeneralDataGroup = DataGroup<DataList, PropertyList, MethodList>;
+
+type Empty = Record<never, never>;
+type IsEmpty<T> = Equal<T, Empty>;
+type NewField<TObject, TField extends string, TValueType> = Extract<keyof TObject, TField> extends never ? TValueType : never;
+type NewFieldList<TObject, TNewObject> = Extract<keyof TObject, keyof TNewObject> extends never ? TNewObject : never;
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+/**
+ * UnionToIntersection<'foo' | 42 | true> = 'foo' & 42 & true
+ * UnionToIntersection<(() => 'foo') | ((i: 42) => true)> = (() => 'foo') & ((i: 42) => true)
+ */
+type UnionToIntersection<T> = (T extends unknown ? (arg: T) => void : never) extends (args: infer Arg) => void ? Arg : never;
+/**
+ * Merge<{ foo: string }, { bar: number }> = { foo: string, bar: number }
+ */
+type Merge<U> = U extends infer T ? {
+    [K in keyof T]: T[K];
+} : never;
+/**
+ * IsAny<any> = true
+ * IsAny<{}> = false
+ */
+type IsAny<T> = (<S>(S: S) => S extends T ? 1 : 2) extends <R>(R: R) => R extends any ? 1 : 2 ? true : false;
+/**
+ * IsNever<never> = true
+ * IsNever<unknown> = false
+ * IsNever<any> = false
+ */
+type IsNever<T> = [T] extends [never] ? true : false;
+type SetDataStringPath<K extends string | number, Prefix extends string> = [Prefix] extends [never] ? `${K}` : K extends number ? `${Prefix}[${K}]` : `${Prefix}.${K}`;
+type Tuple<T, Res extends 1[] = []> = 0 extends 1 ? never : Res['length'] extends T ? Res : Tuple<T, [...Res, 1]>;
+type Subtract<M extends number, S extends number> = Tuple<M> extends [...Tuple<S>, ...infer Rest] ? Rest['length'] : never;
+/**
+ * SetDataSetter<{ name: string; foo: { bar: number } }> = {
+ *   name: string,
+ *   foo: { bar: number },
+ *   'foo.bar': number,
+ * }
+ * setDataSetter<{ list: number[], foo: { bar: number }[]}> = {
+ *   list: number[],
+ *   `list[${number}]`: number,
+ *   foo: { bar: number }[],
+ *   `foo[${number}]`: { bar: number }[],
+ *   `foo[${number}].bar`: number,
+ * }
+ */
+type SetDataSetter<T, Prefix extends string = never, Count extends number = 4> = Count extends 0 ? Record<SetDataStringPath<any, Prefix>, T> : IsAny<T> extends true ? Record<SetDataStringPath<any, Prefix>, T> : UnionToIntersection<T extends any[] ? {
+    [P in keyof T & number]: SetDataSetter<T[P], SetDataStringPath<P, Prefix>, Subtract<Count, 1>> & Record<SetDataStringPath<P, Prefix>, T[P]>;
+}[keyof T & number] : T extends Record<string | number, any> ? {
+    [P in keyof T & (string | number)]: SetDataSetter<T[P], SetDataStringPath<P, Prefix>, Subtract<Count, 1>> & Record<SetDataStringPath<P, Prefix>, T[P]>;
+}[keyof T & (string | number)] : never>;
+/**
+ * DeepReadonly<{ foo: { bar: number } }> = {
+ *   readonly foo: {
+ *     readonly bar: number
+ *   }
+ * }
+ */
+type DeepReadonly<T, Count extends number = 4> = Count extends 0 ? T : T extends Record<any, any> ? T extends (...args: any[]) => any ? T : {
+    readonly [P in keyof T]: DeepReadonly<T[P], Subtract<Count, 1>>;
+} : T;
+type PublicFields<T> = {
+    [K in keyof T as K extends `_$${any}` ? never : K]: T[K];
+};
+/**
+ * ObjectDataPathStrings<{ name: string; age: number }> = 'name' | 'age'
+ * ObjectDataPathStrings<{
+ *   refCount: number;
+ *   person: { name: string; age: number };
+ * }> = 'refCount' | 'person' | 'person.name' | 'person.age'
+ * ObjectDataPathStrings<{ books: [{ name: string; price: number }] }> =
+ *   'books' | `books[${number}]` | `books[${number}].name` | `books[${number}].price`
+ */
+type ObjectDataPathStrings<T, Prefix extends string = never, Count extends number = 4> = Count extends 0 ? SetDataStringPath<any, Prefix> : IsAny<T> extends true ? SetDataStringPath<any, Prefix> : T extends any[] ? {
+    [P in keyof T & number]: SetDataStringPath<P, Prefix> | ObjectDataPathStrings<T[P], SetDataStringPath<P, Prefix>, Subtract<Count, 1>>;
+}[keyof T & number] : T extends Record<string | number, any> ? {
+    [P in keyof T & (string | number)]: SetDataStringPath<P, Prefix> | ObjectDataPathStrings<T[P], SetDataStringPath<P, Prefix>, Subtract<Count, 1>>;
+}[keyof T & (string | number)] : Prefix;
+type ObserverDataPathStrings<T, S extends string = ObjectDataPathStrings<T>> = '**' | S | `${S}.**`;
+/**
+ * GetFromDataPathString<{ name: string; age: number }, 'name'> = string
+ * GetFromDataPathString<{ person: { name: string; age: number } }, 'person.name'> = string
+ * GetFromDataPathString<{ books: [{ name: string; price: number }] }, 'books[0].name'> = string
+ */
+type GetFromDataPathString<T, P extends string> = P extends keyof T ? T[P] : P extends '' ? T : P extends `[${infer K extends keyof T & number}].${infer R}` ? GetFromDataPathString<T[K], R> : P extends `[${infer K extends keyof T & number}]${infer R}` ? GetFromDataPathString<T[K], R> : P extends `${infer K extends keyof T & string}[${infer R}` ? GetFromDataPathString<T[K], `[${R}`> : P extends `${infer K extends keyof T & string}.${infer R}` ? GetFromDataPathString<T[K], R> : never;
+type GetFromObserverPathString<T, P extends string> = P extends '**' ? GetFromDataPathString<T, ''> : P extends `${infer K}.**` ? GetFromDataPathString<T, K> : GetFromDataPathString<T, P>;
+/**
+ * GetFromDataPath<{ foo: { bar: number } }, ['foo', 'bar']> = number
+ * GetFromDataPath<{ list: { bar: number }[] }, ['list', 0, 'bar']> = number
+ * GetFromDataPath<{ list: number }, ['nonExists']> = never
+ */
+type GetFromDataPath<T, K extends readonly (string | number)[]> = K extends [
+    infer F,
+    ...infer R extends (string | number)[]
+] ? F extends keyof T ? GetFromDataPath<T[F], R> : never : T;
+declare const TaggedSymbol: unique symbol;
+type Tagged = typeof TaggedSymbol;
+type IfNeverOrAny<T, Replacement> = [T] extends [never] ? Replacement : 1 extends T & 0 ? Replacement : T;
+type GetTags<B> = B extends {
+    readonly [Tag in Tagged]: infer Tags extends symbol[];
+} ? Tags : [];
+type GetTagsWithout<B, T extends symbol, Tags = GetTags<B>> = Tags extends [infer F, ...infer R] ? Equal<T, F> extends true ? GetTagsWithout<B, T, R> : [F, ...GetTagsWithout<B, T, R>] : [];
+type UnTagAll<B> = Tagged extends keyof IfNeverOrAny<B, unknown> ? B extends infer Origin & {
+    readonly [Tag in Tagged]: GetTags<B>;
+} ? Origin : B : B;
+type Tag<B, T extends symbol> = [IfNeverOrAny<B, unknown>] extends [null | undefined] ? B : UnTagAll<B> & {
+    readonly [Tag in Tagged]: [...GetTags<B>, T];
+};
+type UnTag<B, T extends symbol, Tags = GetTagsWithout<B, T>> = Tagged extends keyof IfNeverOrAny<B, unknown> ? Tags extends [] ? UnTagAll<B> : UnTagAll<B> & {
+    readonly [Tag in Tagged]: Tags;
+} : B;
+type HasTag<B, T extends symbol> = T extends GetTags<B>[number] ? true : false;
+type DataList = Record<string, unknown>;
+type PropertyList = Record<string, PropertyListItem<PropertyType, any>>;
+type PropertyType = null | StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | FunctionConstructor | NormalizedPropertyType;
+/**
+ * PropertyTypeToValueType<null> = any
+ * PropertyTypeToValueType<typeof String> = string
+ * PropertyTypeToValueType<typeof Number> = number
+ */
+type PropertyTypeToValueType<T extends PropertyType> = T extends null | NormalizedPropertyType.Any ? any : T extends StringConstructor | NormalizedPropertyType.String ? string : T extends NumberConstructor | NormalizedPropertyType.Number ? number : T extends BooleanConstructor | NormalizedPropertyType.Boolean ? boolean : T extends ArrayConstructor | NormalizedPropertyType.Array ? any[] : T extends ObjectConstructor | NormalizedPropertyType.Object ? Record<string, any> | null : T extends FunctionConstructor | NormalizedPropertyType.Function ? (...args: any[]) => any : never;
+type Satisfy<T, V> = V extends T ? V : T;
+/**
+ * PropertyTypeToSimpleValueType<typeof String, 'foo'> = 'foo'
+ * PropertyTypeToSimpleValueType<typeof String, 123> = string
+ */
+type PropertyTypeToSimpleValueType<T extends PropertyType, V> = T extends StringConstructor | NormalizedPropertyType.String ? Satisfy<string, V> : T extends NumberConstructor | NormalizedPropertyType.Number ? Satisfy<number, V> : T extends BooleanConstructor | NormalizedPropertyType.Boolean ? Satisfy<boolean, V> : T extends ArrayConstructor | NormalizedPropertyType.Array ? Satisfy<any[], V> : T extends ObjectConstructor | NormalizedPropertyType.Object ? Satisfy<Record<string, any> | null, V> : T extends FunctionConstructor | NormalizedPropertyType.Function ? Satisfy<(...args: any[]) => any, V> : never;
+/**
+ * PropertyValueType<null> = any
+ * PropertyValueType<typeof String> = string
+ * PropertyValueType<typeof String | typeof Number> = string | number
+ * PropertyValueType<{ type: typeof String }> = string
+ * PropertyValueType<{ type: typeof String, optionalTypes: [typeof Number] }> = string | number
+ * PropertyValueType<{ type: typeof String, value: 'foo' }> = 'foo'
+ * PropertyValueType<{ type: typeof String, value: 123 }> = never
+ * PropertyValueType<{ type: typeof String, optionalTypes: [typeof Number], value: 123 }> =
+ *  string | 123
+ */
+type PropertyValueType<P extends PropertyListItem<PropertyType, any>> = P extends PropertyListItem<infer T, infer V> ? unknown extends V ? PropertyTypeToValueType<T> : ((a: T) => void) extends (a: PropertyType) => void ? V : V extends PropertyTypeToValueType<T> ? PropertyTypeToSimpleValueType<T, V> : never : never;
+type PropertyOption<T extends PropertyType, V> = {
+    type?: T;
+    optionalTypes?: T[];
+    value?: V;
+    default?: () => V;
+    observer?: ((newValue: V, oldValue: V) => void) | string;
+    comparer?: (newValue: V, oldValue: V) => boolean;
+    reflectIdPrefix?: boolean;
+};
+type PropertyListItem<T extends PropertyType, V> = T | PropertyOption<T, V>;
+type PropertyValues<P extends PropertyList> = {
+    [key in keyof P]: PropertyValueType<P[key]>;
+};
+type DataWithPropertyValues<TData extends DataList, TProperty extends PropertyList> = TData & PropertyValues<TProperty>;
+type ComponentMethod = (...args: any[]) => any;
+type MethodList = Record<string, ComponentMethod>;
+declare const METHOD_TAG: unique symbol;
+type TaggedMethod<Fn extends ComponentMethod> = Tag<Fn, typeof METHOD_TAG>;
+type UnTaggedMethod<M extends TaggedMethod<any>> = UnTag<M, typeof METHOD_TAG>;
+type RelationParams = {
+    target?: string | ComponentDefinition<any, any, any> | GeneralBehavior | TraitBehavior<any>;
+    type: 'ancestor' | 'descendant' | 'parent' | 'child' | 'parent-common-node' | 'child-common-node';
+    linked?: (target: GeneralComponent) => void;
+    linkChanged?: (target: GeneralComponent) => void;
+    unlinked?: (target: GeneralComponent) => void;
+    linkFailed?: (target: GeneralComponent) => void;
+};
+type RelationParamsWithKey = {
+    [name: string]: RelationParams;
+};
+type TraitRelationParams<TOut extends {
+    [key: string]: any;
+}> = {
+    target: TraitBehavior<any, TOut>;
+    type: 'ancestor' | 'descendant' | 'parent' | 'child' | 'parent-common-node' | 'child-common-node';
+    linked?: (target: GeneralComponent) => void;
+    linkChanged?: (target: GeneralComponent) => void;
+    unlinked?: (target: GeneralComponent) => void;
+    linkFailed?: (target: GeneralComponent) => void;
+};
+type ChainingFilterFunc<TAddedFields extends {
+    [key: string]: any;
+}, TRemovedFields extends string = never> = (chain: GeneralBehaviorBuilder) => Omit<GeneralBehaviorBuilder, TRemovedFields> & TAddedFields;
+type ChainingFilterType = {
+    add: {
+        [key: string]: any;
+    };
+    remove: string;
+};
+type ComponentInstance<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> = Component<TData, TProperty, TMethod> & {
+    data: Merge<DataWithPropertyValues<TData, TProperty>>;
+    properties: Merge<DataWithPropertyValues<TData, TProperty>>;
+} & TMethod;
+type ComponentParams<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> = {
+    is?: string;
+    behaviors?: (string | GeneralBehavior)[];
+    using?: {
+        [name: string]: string | ComponentDefinition<any, any, any>;
+    };
+    generics?: {
+        [name: string]: {
+            default: string | ComponentDefinition<any, any, any>;
+        } | true;
+    };
+    placeholders?: {
+        [name: string]: string;
+    };
+    template?: {
+        [key: string]: any;
+    } | null;
+    externalClasses?: string[];
+    data?: TData | (() => TData);
+    properties?: TProperty;
+    methods?: TMethod;
+    listeners?: {
+        [name: string]: ComponentMethod | string;
+    };
+    relations?: RelationParamsWithKey;
+    lifetimes?: {
+        [name: string]: ComponentMethod;
+    };
+    created?: () => any;
+    attached?: ComponentMethod;
+    moved?: ComponentMethod;
+    detached?: ComponentMethod;
+    ready?: ComponentMethod;
+    pageLifetimes?: {
+        [name: string]: ComponentMethod;
+    };
+    observers?: {
+        fields?: string;
+        observer: ComponentMethod | string;
+    }[] | {
+        [fields: string]: ComponentMethod | string;
+    };
+    options?: ComponentOptions;
+};
+
+type component_params_ChainingFilterFunc<TAddedFields extends {
+    [key: string]: any;
+}, TRemovedFields extends string = never> = ChainingFilterFunc<TAddedFields, TRemovedFields>;
+type component_params_ChainingFilterType = ChainingFilterType;
+type component_params_ComponentInstance<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> = ComponentInstance<TData, TProperty, TMethod>;
+type component_params_ComponentMethod = ComponentMethod;
+type component_params_ComponentParams<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> = ComponentParams<TData, TProperty, TMethod>;
+type component_params_DataList = DataList;
+type component_params_DataWithPropertyValues<TData extends DataList, TProperty extends PropertyList> = DataWithPropertyValues<TData, TProperty>;
+type component_params_DeepReadonly<T, Count extends number = 4> = DeepReadonly<T, Count>;
+type component_params_Empty = Empty;
+type component_params_Equal<X, Y> = Equal<X, Y>;
+type component_params_GetFromDataPath<T, K extends readonly (string | number)[]> = GetFromDataPath<T, K>;
+type component_params_GetFromDataPathString<T, P extends string> = GetFromDataPathString<T, P>;
+type component_params_GetFromObserverPathString<T, P extends string> = GetFromObserverPathString<T, P>;
+type component_params_HasTag<B, T extends symbol> = HasTag<B, T>;
+type component_params_IsAny<T> = IsAny<T>;
+type component_params_IsEmpty<T> = IsEmpty<T>;
+type component_params_IsNever<T> = IsNever<T>;
+declare const component_params_METHOD_TAG: typeof METHOD_TAG;
+type component_params_Merge<U> = Merge<U>;
+type component_params_MethodList = MethodList;
+type component_params_NewField<TObject, TField extends string, TValueType> = NewField<TObject, TField, TValueType>;
+type component_params_NewFieldList<TObject, TNewObject> = NewFieldList<TObject, TNewObject>;
+type component_params_ObjectDataPathStrings<T, Prefix extends string = never, Count extends number = 4> = ObjectDataPathStrings<T, Prefix, Count>;
+type component_params_ObserverDataPathStrings<T, S extends string = ObjectDataPathStrings<T>> = ObserverDataPathStrings<T, S>;
+type component_params_PropertyList = PropertyList;
+type component_params_PropertyListItem<T extends PropertyType, V> = PropertyListItem<T, V>;
+type component_params_PropertyOption<T extends PropertyType, V> = PropertyOption<T, V>;
+type component_params_PropertyType = PropertyType;
+type component_params_PropertyTypeToValueType<T extends PropertyType> = PropertyTypeToValueType<T>;
+type component_params_PropertyValues<P extends PropertyList> = PropertyValues<P>;
+type component_params_PublicFields<T> = PublicFields<T>;
+type component_params_RelationParams = RelationParams;
+type component_params_RelationParamsWithKey = RelationParamsWithKey;
+type component_params_SetDataSetter<T, Prefix extends string = never, Count extends number = 4> = SetDataSetter<T, Prefix, Count>;
+type component_params_Tag<B, T extends symbol> = Tag<B, T>;
+type component_params_TaggedMethod<Fn extends ComponentMethod> = TaggedMethod<Fn>;
+type component_params_TraitRelationParams<TOut extends {
+    [key: string]: any;
+}> = TraitRelationParams<TOut>;
+type component_params_UnTag<B, T extends symbol, Tags = GetTagsWithout<B, T>> = UnTag<B, T, Tags>;
+type component_params_UnTaggedMethod<M extends TaggedMethod<any>> = UnTaggedMethod<M>;
+type component_params_UnionToIntersection<T> = UnionToIntersection<T>;
+declare namespace component_params {
+  export { type component_params_ChainingFilterFunc as ChainingFilterFunc, type component_params_ChainingFilterType as ChainingFilterType, type component_params_ComponentInstance as ComponentInstance, type component_params_ComponentMethod as ComponentMethod, type component_params_ComponentParams as ComponentParams, type component_params_DataList as DataList, type component_params_DataWithPropertyValues as DataWithPropertyValues, type component_params_DeepReadonly as DeepReadonly, type component_params_Empty as Empty, type component_params_Equal as Equal, type component_params_GetFromDataPath as GetFromDataPath, type component_params_GetFromDataPathString as GetFromDataPathString, type component_params_GetFromObserverPathString as GetFromObserverPathString, type component_params_HasTag as HasTag, type component_params_IsAny as IsAny, type component_params_IsEmpty as IsEmpty, type component_params_IsNever as IsNever, component_params_METHOD_TAG as METHOD_TAG, type component_params_Merge as Merge, type component_params_MethodList as MethodList, type component_params_NewField as NewField, type component_params_NewFieldList as NewFieldList, type component_params_ObjectDataPathStrings as ObjectDataPathStrings, type component_params_ObserverDataPathStrings as ObserverDataPathStrings, type component_params_PropertyList as PropertyList, type component_params_PropertyListItem as PropertyListItem, type component_params_PropertyOption as PropertyOption, type component_params_PropertyType as PropertyType, type component_params_PropertyTypeToValueType as PropertyTypeToValueType, type component_params_PropertyValues as PropertyValues, type component_params_PublicFields as PublicFields, type component_params_RelationParams as RelationParams, type component_params_RelationParamsWithKey as RelationParamsWithKey, type component_params_SetDataSetter as SetDataSetter, type component_params_Tag as Tag, type component_params_TaggedMethod as TaggedMethod, type component_params_TraitRelationParams as TraitRelationParams, type component_params_UnTag as UnTag, type component_params_UnTaggedMethod as UnTaggedMethod, type component_params_UnionToIntersection as UnionToIntersection };
+}
+
+declare const enum RelationType {
+    Ancestor = 0,
+    Descendant = 1,
+    ParentNonVirtualNode = 2,
+    ChildNonVirtualNode = 3,
+    ParentComponent = 4,
+    ChildComponent = 5
+}
+interface RelationHandler<TTarget, TOut> {
+    list(): TTarget[];
+    listAsTrait: TOut extends never ? undefined : () => TOut[];
+}
+type RelationListener = (target: unknown) => void;
+type RelationFailedListener = () => void;
+
+type NativeNodeDefinition = string;
+type ResolveBehaviorBuilder<B, TChainingFilter extends ChainingFilterType> = IsNever<TChainingFilter> extends false ? TChainingFilter extends ChainingFilterType ? Omit<B, TChainingFilter['remove']> & TChainingFilter['add'] : B : B;
+interface BuilderContext<TPrevData extends DataList, TProperty extends PropertyList, TMethodCaller> extends ThisType<TMethodCaller> {
+    self: TMethodCaller;
+    data: Merge<DataWithPropertyValues<TPrevData, TProperty>>;
+    setData: (newData: Partial<SetDataSetter<TPrevData>>) => void;
+    implement: <TIn extends {
+        [x: string]: any;
+    }>(traitBehavior: TraitBehavior<TIn, any>, impl: TIn) => void;
+    relation<TOut extends {
+        [key: string]: any;
+    }>(def: TraitRelationParams<TOut>): RelationHandler<any, TOut>;
+    relation(def: RelationParams): RelationHandler<any, never>;
+    observer<P extends ObserverDataPathStrings<DataWithPropertyValues<TPrevData, TProperty>>, V = Merge<GetFromObserverPathString<DataWithPropertyValues<TPrevData, TProperty>, P>>>(paths: P, func: (newValue: V) => void): void;
+    observer<P extends ObserverDataPathStrings<DataWithPropertyValues<TPrevData, TProperty>>[], V = {
+        [K in keyof P]: Merge<GetFromObserverPathString<DataWithPropertyValues<TPrevData, TProperty>, P[K]>>;
+    }>(paths: readonly [...P], func: (...newValues: V extends any[] ? V : never) => void): void;
+    lifetime: <L extends keyof Lifetimes>(name: L, func: Lifetimes[L]) => void;
+    pageLifetime: (name: string, func: (...args: any[]) => void) => void;
+    method: <Fn extends ComponentMethod>(func: Fn) => TaggedMethod<Fn>;
+    listener: <T>(func: EventListener<T>) => TaggedMethod<EventListener<T>>;
+}
+type GeneralBehaviorBuilder = BehaviorBuilder<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, never, never>;
+declare class BehaviorBuilder<TPrevData extends DataList = Empty, TData extends DataList = Empty, TProperty extends PropertyList = Empty, TMethod extends MethodList = Empty, TChainingFilter extends ChainingFilterType = never, TPendingChainingFilter extends ChainingFilterType = never> {
+    /**
+     * Set a front-most init function
+     *
+     * It should return the method caller (the `this` value for various callbacks)
+     * that will be used in future.
+     */
+    methodCallerInit(func: (this: ComponentInstance<TData, TProperty, TMethod>) => any): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add a behavior
+     *
+     * If the behavior contains a chaining filter, the chaining filter is called.
+     */
+    behavior<UData extends DataList, UProperty extends PropertyList, UMethod extends MethodList, UChainingFilter extends ChainingFilterType>(behavior: Behavior<UData, UProperty, UMethod, UChainingFilter>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData & UData, TProperty & UProperty, TMethod & UMethod, UChainingFilter, TPendingChainingFilter>, UChainingFilter>;
+    /**
+     * Set the chaining filter
+     *
+     * The chaining filter is the definition filter for chaining API.
+     * It SHOULD return another chainable object for further chaining.
+     */
+    chainingFilter<TAddedFields extends {
+        [key: string]: any;
+    }, TRemovedFields extends string = never>(func: ChainingFilterFunc<TAddedFields, TRemovedFields>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, {
+        add: TAddedFields;
+        remove: TRemovedFields;
+    }>, TChainingFilter>;
+    /**
+     * Set component options
+     *
+     * The options will be merged with previous settings.
+     */
+    options(options: ComponentOptions): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Implement a trait behavior
+     */
+    implement<TIn extends {
+        [key: string]: any;
+    }>(traitBehavior: TraitBehavior<TIn, any>, impl: TIn): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Set the compiled template object
+     */
+    template(template: {
+        [key: string]: unknown;
+    }): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add other components to the component using list
+     */
+    usingComponents<T extends Record<string, string | ComponentDefinition<any, any, any>>>(list: T): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add some placeholders
+     *
+     * The alias SHOULD be in the using list, otherwise it will be ignored.
+     */
+    placeholders(list: Record<string, string>): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add other generics
+     *
+     * The alias SHOULD NOT be in the using list, otherwise it will be ignored.
+     */
+    generics(list: Record<string, {
+        default?: string | GeneralComponentDefinition;
+    } | true>): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add external classes
+     */
+    externalClasses(list: string[]): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add some template data fields
+     *
+     * It does not support raw data, but a `gen` function which returns the new data fields.
+     * The `gen` function executes once during component creation.
+     */
+    data<T extends DataList>(gen: () => NewFieldList<DataWithPropertyValues<TData, TProperty>, T>): ResolveBehaviorBuilder<BehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter>, TChainingFilter>;
+    /**
+     * Set the static template data fields
+     *
+     * The data will be cloned once during component creation.
+     * If called multiple times, the static data will be overwritten but not merged!
+     * Usually, the `data()` method is preferred.
+     */
+    staticData<T extends DataList>(data: NewFieldList<DataWithPropertyValues<TData, TProperty>, T>): ResolveBehaviorBuilder<BehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter>, TChainingFilter>;
+    /**
+     * Add a single property
+     *
+     * The property name should be different from other properties.
+     */
+    property<N extends string, T extends PropertyType, V extends PropertyTypeToValueType<T>>(name: N, def: N extends keyof (TData & TProperty) ? never : PropertyListItem<T, V>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty & Record<N, unknown extends V ? T : PropertyOption<T, V>>, TMethod, TChainingFilter, TPendingChainingFilter>, TChainingFilter>;
+    /**
+     * Add a single public method
+     *
+     * The public method can be used as an event handler, and can be visited in component instance.
+     */
+    methods<T extends MethodList>(funcs: T & ThisType<ComponentInstance<TData, TProperty, TMethod & T>>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter>, TChainingFilter>;
+    /**
+     * Add a data observer
+     */
+    observer<P extends ObserverDataPathStrings<DataWithPropertyValues<TPrevData, TProperty>>, V = Merge<GetFromObserverPathString<DataWithPropertyValues<TPrevData, TProperty>, P>>>(paths: P, func: (this: ComponentInstance<TData, TProperty, TMethod>, newValue: V) => void, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    observer<P extends ObserverDataPathStrings<DataWithPropertyValues<TPrevData, TProperty>>[], V = {
+        [K in keyof P]: Merge<GetFromObserverPathString<DataWithPropertyValues<TPrevData, TProperty>, P[K]>>;
+    }>(paths: readonly [...P], func: (this: ComponentInstance<TData, TProperty, TMethod>, ...newValues: V extends any[] ? V : never) => void, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add a lifetime callback
+     */
+    lifetime<L extends keyof Lifetimes>(name: L, func: (this: ComponentInstance<TData, TProperty, TMethod>, ...args: Parameters<Lifetimes[L]>) => ReturnType<Lifetimes[L]>, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add a page-lifetime callback
+     */
+    pageLifetime(name: string, func: (this: ComponentInstance<TData, TProperty, TMethod>, ...args: any[]) => any, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add a relation
+     */
+    relation(name: string, rel: RelationParams & ThisType<ComponentInstance<TData, TProperty, TMethod>>): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Execute a function while component instance creation
+     *
+     * A `BuilderContext` is provided to tweak the component creation progress.
+     * The return value is used as the "export" value of the behavior,
+     * which can be imported by other behaviors.
+     */
+    init<TExport extends Record<string, TaggedMethod<(...args: any[]) => any>> | void>(func: (this: ComponentInstance<TData, TProperty, TMethod>, builderContext: BuilderContext<TPrevData, TProperty, ComponentInstance<TData, TProperty, TMethod>>) => TExport): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod & (TExport extends void ? Empty : {
+        [K in keyof TExport]: UnTaggedMethod<TExport[K]>;
+    }), TChainingFilter, TPendingChainingFilter>, TChainingFilter>;
+    /**
+     * Apply a classic-style definition
+     */
+    definition<TNewData extends DataList = Empty, TNewProperty extends PropertyList = Empty, TNewMethod extends MethodList = Empty>(def: ComponentParams<TNewData, TNewProperty, TNewMethod> & ThisType<ComponentInstance<TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod>>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter>, TChainingFilter>;
+    /**
+     * Finish build, generate a behavior, and register it in the component space
+     */
+    registerBehavior(): Behavior<TData, TProperty, TMethod, TPendingChainingFilter>;
+    /**
+     * Finish build, generate a component definition, and register it in the component space
+     */
+    registerComponent(): ComponentDefinition<TData, TProperty, TMethod>;
+}
+/**
+ * Common mixin-like behavior
+ *
+ * Each component definition contains a single *root* behavior.
+ * A behavior can mixin other behaviors.
+ */
+declare class Behavior<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList, TChainingFilter extends ChainingFilterType> {
+    is: string;
+    ownerSpace: ComponentSpace;
+    /**
+     * Create a behavior with classic-style definition
+     */
+    static create<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(def: ComponentParams<TData, TProperty, TMethod> & ThisType<ComponentInstance<TData, TProperty, TMethod>>, ownerSpace?: ComponentSpace): Behavior<Empty & TData, Empty & TProperty, Empty & TMethod, never>;
+    general(): GeneralBehavior;
+    /**
+     * List all component dependencies (recursively)
+     *
+     * This method will prepare the underlying behavior.
+     */
+    getComponentDependencies(genericTargets?: {
+        [name: string]: GeneralComponentDefinition | NativeNodeDefinition;
+    }): Set<GeneralComponentDefinition>;
+    /** Same as `prepare` method in the prototype (for backward compatibility) */
+    static prepare<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList, TChainingFilter extends ChainingFilterType = never>(behavior: Behavior<TData, TProperty, TMethod, TChainingFilter>): void;
+    /**
+     * Execute the prepare phase (an optimization phase) of this behavior
+     *
+     * Every behavior needs this phase for better future performance.
+     * However, this phase requires a little time for execution,
+     * and requires its all dependent behaviors created.
+     * If a dependent behavior is not prepared, then its prepare phase is also executed.
+     */
+    prepare(): void;
+    /**
+     * Get the template content
+     *
+     * This method is usually used by the template engine.
+     */
+    getTemplate(): {
+        [key: string]: unknown;
+    } | undefined;
+    _$updateTemplate(template: {
+        [key: string]: unknown;
+    }): void;
+    /** Check whether the `other` behavior is a dependent behavior of this behavior */
+    hasBehavior(other: string | GeneralBehavior): boolean;
+    /**
+     * Get the methods
+     *
+     * Only valid after `prepare` .
+     */
+    getMethods(): TMethod;
+}
+type GeneralBehavior = Behavior<Record<string, any>, Record<string, any>, Record<string, any>, any>;
+
+type Lifetimes = {
+    created: () => void;
+    attached: () => void;
+    moved: () => void;
+    detached: () => void;
+    ready: () => void;
+    listenerChange: (isAdd: boolean, name: string, func: EventListener<unknown>, options: EventListenerOptions | undefined) => void;
+    workletChange: (name: string, value: unknown) => void;
+};
+declare class ComponentDefinition<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> {
+    is: string;
+    behavior: Behavior<TData, TProperty, TMethod, any>;
+    general(): GeneralComponentDefinition;
+    /** Get the normalized component options */
+    getComponentOptions(): NormalizedComponentOptions;
+    /**
+     * List all component dependencies (recursively)
+     *
+     * This method will prepare the underlying behavior.
+     * The caller component is not included in the result.
+     */
+    getComponentDependencies(): Set<GeneralComponentDefinition>;
+    /**
+     * Update the template field
+     *
+     * This method throws error if the template engine does not support template update.
+     */
+    updateTemplate(template: {
+        [key: string]: unknown;
+    }): void;
+    isPrepared(): boolean;
+    prepare(): void;
+}
+/**
+ * A node that has a shadow tree attached to it
+ */
+declare class Component<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList> extends Element$4 {
+    [COMPONENT_SYMBOL]: true;
+    shadowRoot: ShadowRoot | ExternalShadowRoot;
+    tagName: string;
+    constructor();
+    general(): GeneralComponent;
+    static isComponent: (e: any) => e is GeneralComponent;
+    /**
+     * Cast a general component node to the instance of the specified component
+     *
+     * Returns `null` if the component node is not the instance of the specified component.
+     */
+    asInstanceOf<UData extends DataList, UProperty extends PropertyList, UMethod extends MethodList>(componentDefinition: ComponentDefinition<UData, UProperty, UMethod>): ComponentInstance<UData, UProperty, UMethod> | null;
+    static register<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(def: ComponentParams<TData, TProperty, TMethod> & ThisType<ComponentInstance<TData, TProperty, TMethod>>, space?: ComponentSpace): ComponentDefinition<TData, TProperty, TMethod>;
+    static createWithGenericsAndContext<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(tagName: string | ComponentDefinition<TData, TProperty, TMethod>, componentDefinition: ComponentDefinition<TData, TProperty, TMethod> | null, genericTargets: {
+        [name: string]: GeneralComponentDefinition;
+    } | null, backendContext: GeneralBackendContext | null, initPropValues?: (comp: ComponentInstance<TData, TProperty, TMethod>) => void): ComponentInstance<TData, TProperty, TMethod>;
+    static createWithGenerics<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(tagName: string | ComponentDefinition<TData, TProperty, TMethod>, componentDefinition: ComponentDefinition<TData, TProperty, TMethod> | null, genericImpls: {
+        [name: string]: GeneralComponentDefinition;
+    } | null, initPropValues?: (comp: ComponentInstance<TData, TProperty, TMethod>) => void): ComponentInstance<TData, TProperty, TMethod>;
+    static createWithContext<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(tagName: string | ComponentDefinition<TData, TProperty, TMethod>, componentDefinition: ComponentDefinition<TData, TProperty, TMethod> | null, backendContext: GeneralBackendContext | null, initPropValues?: (comp: ComponentInstance<TData, TProperty, TMethod>) => void): ComponentInstance<TData, TProperty, TMethod>;
+    static create<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(tagName: string | ComponentDefinition<TData, TProperty, TMethod>, componentDefinition: ComponentDefinition<TData, TProperty, TMethod> | null, initPropValues?: (comp: ComponentInstance<TData, TProperty, TMethod>) => void): ComponentInstance<TData, TProperty, TMethod>;
+    get is(): string;
+    get properties(): Merge<DataWithPropertyValues<TData, TProperty>>;
+    get data(): Merge<DataWithPropertyValues<TData, TProperty>>;
+    set data(newData: Partial<DataWithPropertyValues<TData, TProperty>>);
+    get $(): {
+        [id: string]: Element$4;
+    } | {
+        [id: string]: GeneralBackendElement;
+    };
+    /**
+     * Returns the shadow root element
+     *
+     * Returns `null` for external components.
+     */
+    getShadowRoot(): ShadowRoot | null;
+    /**
+     * Apply the template updates to this component instance
+     *
+     * This method throws error if the template engine does not support template update.
+     */
+    applyTemplateUpdates(): void;
+    /**
+     * Returns the owner component space of this component
+     */
+    getOwnerSpace(): ComponentSpace;
+    /** Get whether the component is external or not */
+    isExternal(): boolean;
+    static listProperties<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(comp: ComponentInstance<TData, TProperty, TMethod>): string[];
+    static hasProperty<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(comp: Component<TData, TProperty, TMethod>, propName: string): boolean;
+    /** List methods by the component definition (backward compatibility) */
+    static getMethodsFromDef<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(compDef: ComponentDefinition<TData, TProperty, TMethod>): {
+        [name: string]: GeneralFuncType;
+    };
+    /**
+     * Get a method
+     *
+     * If `useMethodCallerListeners` option is set for this component,
+     * this method will use the corresponding fields in the `methodCaller` .
+     */
+    static getMethod<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(comp: Component<TData, TProperty, TMethod>, methodName: string): GeneralFuncType | undefined;
+    /**
+     * Call a method
+     *
+     * If `useMethodCallerListeners` option is set for this component,
+     * this method will use the corresponding fields in the `methodCaller` .
+     * Returns `undefined` if there is no such method.
+     */
+    callMethod<T extends string>(methodName: T, ...args: Parameters<MethodList[T]>): ReturnType<MethodList[T]>;
+    /**
+     * Get the corresponding component definition
+     */
+    getComponentDefinition(): ComponentDefinition<TData, TProperty, TMethod>;
+    /**
+     * Get the options of the component
+     */
+    getComponentOptions(): NormalizedComponentOptions;
+    /**
+     * Check whether the `other` behavior is a dependent behavior or a implemented trait behavior
+     */
+    hasBehavior(other: string | GeneralBehavior | TraitBehavior<any, any>): boolean;
+    /** Get the root behavior of the component */
+    getRootBehavior(): Behavior<TData, TProperty, TMethod, any>;
+    /**
+     * Get the trait behavior implementation of the component
+     *
+     * Returns `undefined` if the specified trait behavior is not implemented.
+     */
+    traitBehavior<TOut extends {
+        [x: string]: any;
+    }>(traitBehavior: TraitBehavior<any, TOut>): TOut | undefined;
+    /**
+     * Set the caller (a.k.a. `this` ) of event callbacks and life-time callbacks
+     *
+     * By default, the caller is the component instance itself.
+     * Use this method to override this behavior.
+     */
+    setMethodCaller(caller: ComponentInstance<TData, TProperty, TMethod>): void;
+    /**
+     * Get the current caller set by `setMethodCaller`
+     */
+    getMethodCaller(): ComponentInstance<TData, TProperty, TMethod>;
+    /**
+     * Triggers a life-time callback on an element
+     *
+     * Normally external life-times should only be triggered by template engine.
+     * Most cases should take a common method instead.
+     */
+    triggerLifetime(name: string, args: Parameters<GeneralFuncType>): void;
+    /**
+     * Triggers a page-life-time callback on an element
+     */
+    triggerPageLifetime(name: string, args: Parameters<GeneralFuncType>): void;
+    /**
+     * Get the target elements of a relation
+     */
+    getRelationNodes(relationKey: string): GeneralComponent[];
+    /** Check the existence of an external class */
+    hasExternalClass(name: string): boolean;
+    /** Update an external class value */
+    setExternalClass(name: string, target: string | string[]): void;
+    /** Get all external classes */
+    getExternalClasses(): string[] | undefined;
+    /** Schedule an update for an external class value */
+    scheduleExternalClassChange(name: string, target: string | string[]): void;
+    /** Update multiple external class values */
+    applyExternalClassChanges(): void;
+    /** Triggers a worklet change lifetime */
+    triggerWorkletChangeLifetime(name: string, value: unknown): void;
+    /** Check a field is excluded by pureDataPattern or not */
+    isInnerDataExcluded(fieldName: string): boolean;
+    static getInnerData<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(comp: Component<TData, TProperty, TMethod>): {
+        [key: string]: DataValue;
+    } | null;
+    static getDataProxy<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(comp: Component<TData, TProperty, TMethod>): DataGroup<TData, TProperty, TMethod>;
+    static replaceWholeData<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(comp: Component<TData, TProperty, TMethod>, newData: DataWithPropertyValues<TData, TProperty>): void;
+    /**
+     * Schedule a data update on a single specified path
+     *
+     * The data update will not be applied until next `setData` or `applyDataUpdates` call.
+     * All data observers will not be triggered immediately before applied.
+     * Reads of the data will get the unchanged value before applied.
+     */
+    replaceDataOnPath<T extends DataPath>(path: readonly [...T], data: GetFromDataPath<DataWithPropertyValues<TData, TProperty>, T>): void;
+    /**
+     * Schedule an array update
+     *
+     * The behavior is like `Array.prototype.slice` .
+     * Break the array before the `index`-th item, delete `del` items, and insert some items here.
+     * If `index` is undefined, negative, or larger than the length of the array,
+     * no items will be deleted and new items will be appended to the end of the array.
+     * The data update will not be applied until next `setData` or `applyDataUpdates` call.
+     * All data observers will not be triggered immediately before applied.
+     * Reads of the data will get the unchanged value before applied.
+     */
+    spliceArrayDataOnPath<T extends DataPath>(path: readonly [...T], index: GetFromDataPath<DataWithPropertyValues<TData, TProperty>, T> extends any[] ? number | undefined : never, del: GetFromDataPath<DataWithPropertyValues<TData, TProperty>, T> extends any[] ? number | undefined : never, inserts: GetFromDataPath<DataWithPropertyValues<TData, TProperty>, T> extends (infer I)[] ? I[] : never): void;
+    /**
+     * Check whether there are pending changes or not
+     */
+    hasPendingChanges(): boolean;
+    /**
+     * Apply all scheduled updates immediately
+     *
+     * Inside observers, it is generally not .
+     */
+    applyDataUpdates(): void;
+    /**
+     * Pending all data updates in the callback, and apply updates after callback returns
+     *
+     * This function helps grouping several `replaceDataOnPath` or `spliceArrayDataOnPath` calls,
+     * and then apply them at the end of the callback.
+     * `setData` and `applyDataUpdates` calls inside the callback still apply updates immediately.
+     */
+    groupUpdates<T>(callback: () => T): T;
+    /**
+     * Schedule a classic data updates
+     *
+     * The data update will not be applied until next `setData` or `applyDataUpdates` call.
+     * When called inside observers, the data update will be applied when observer ends.
+     * All data observers will not be triggered immediately before applied.
+     * Reads of the data will get the unchanged value before applied.
+     */
+    updateData(newData?: Partial<SetDataSetter<DataWithPropertyValues<TData, TProperty>>>): void;
+    /**
+     * Do a classic data updates
+     *
+     * This method apply updates immediately, so there is no async callback.
+     * When called inside observers, the data update will not be applied to templates.
+     * Inside observers, it is recommended to use `updateData` instead.
+     */
+    setData(newData?: Partial<SetDataSetter<DataWithPropertyValues<TData, TProperty>>>): void;
+}
+type GeneralComponentDefinition = ComponentDefinition<Record<string, any>, Record<string, any>, Record<string, any>>;
+type GeneralComponent = Component<Record<string, any>, Record<string, any>, Record<string, any>>;
+type AnyComponent = Component<any, any, any>;
+
+declare const enum SegmentRelation {
+    Child = 0,
+    Descendant = 1,
+    CrossShadowDescendant = 2
+}
+type Segment = {
+    id: string;
+    classes: string[];
+    relation: SegmentRelation;
+};
+type Union = Segment[];
+/** A parsed selector that can be used in selector queries */
+declare class ParsedSelector {
+    unions: Union[];
+    private static _$parseSegment;
+    constructor(str: string);
+    /** Whether the selector is empty */
+    isEmpty(): boolean;
+    private static _$testSelectorSegment;
+    /**
+     * Test whether the specified node matches the selector
+     *
+     * If `root` is specified, than the selector is match inside this subtree;
+     * otherwise it match in the whole tree.
+     */
+    testSelector(root: Element$4 | null, node: Element$4): boolean;
+    /** Queries an element or elements that matches this selector */
+    query(root: Element$4, findOne: boolean): Element$4[] | Element$4 | null;
+}
+
+/**
+ * The "style" attribute and class list segments
+ *
+ * This allows different modules set the "style" attribute or the class list of an element
+ * without overriding each other.
+ * The final value is the concat of all segments.
+ * When calling `setNodeStyle` or `setNodeClass` on an element,
+ * a segment can be specified.
+ */
+declare const enum StyleSegmentIndex {
+    /** The main style segment, generally managed by the template engine (or manually set) */
+    MAIN = 0,
+    /** The template style segment, preserved for template engine */
+    TEMPLATE_EXTRA = 1,
+    /** The animation style segment, preserved for temporary transition */
+    ANIMATION_EXTRA = 2,
+    /** The temporary style segment, preserved for high priority styles */
+    TEMP_EXTRA = 3
+}
+/**
+ * A general element
+ *
+ * An element can be a `NativeNode` , a `Component` , or a `VirtualNode` .
+ */
+declare class Element$4 implements NodeCast {
+    [ELEMENT_SYMBOL]: true;
+    dataset: {
+        [name: string]: unknown;
+    };
+    /** The `ClassList` of the element (will never change and must not be modified!) */
+    classList: ClassList | null;
+    /** The parent element (must not be modified directly!) */
+    parentNode: Element$4 | null;
+    /** The child nodes (must not be modified directly!) */
+    childNodes: Node$1[];
+    /** The index in parentNode.childNodes (-1 if no parentNode) (must not be modified directly!) */
+    parentIndex: number;
+    /** The parent slot element in composed tree (must not be modified directly!) */
+    containingSlot: Element$4 | null | undefined;
+    /** The slot content nodes composed tree (must not be modified directly!) */
+    slotNodes: Node$1[] | undefined;
+    /** The index in containingSlot.slotNodes (must not be modified directly!) */
+    slotIndex: number | undefined;
+    /** The shadow-root which owns the element (will never change and must not be modified!) */
+    ownerShadowRoot: ShadowRoot | null;
+    constructor();
+    get $$(): GeneralBackendElement | null;
+    get id(): string;
+    set id(x: unknown);
+    get slot(): string;
+    set slot(x: string);
+    get attributes(): {
+        name: string;
+        value: unknown;
+    }[];
+    get class(): string;
+    set class(classNames: string);
+    get style(): string;
+    set style(styleText: string);
+    asTextNode(): null;
+    asElement(): Element$4;
+    asNativeNode(): NativeNode | null;
+    asVirtualNode(): VirtualNode | null;
+    static isElement: (e: any) => e is Element$4;
+    asInstanceOf<UData extends DataList, UProperty extends PropertyList, UMethod extends MethodList>(componentDefinition: ComponentDefinition<UData, UProperty, UMethod>): ComponentInstance<UData, UProperty, UMethod> | null;
+    /** Get the backend context */
+    getBackendContext(): GeneralBackendContext | null;
+    /** Get the backend mode */
+    getBackendMode(): BackendMode;
+    /** Get the backend element */
+    getBackendElement(): GeneralBackendElement | null;
+    /** Destroy the backend element */
+    destroyBackendElement(): void;
+    /** Destroy the backend element on next detach */
+    destroyBackendElementOnDetach(): void;
+    /** Cancel destroying backend element on detach */
+    cancelDestroyBackendElementOnDetach(): void;
+    /** Get whether the node is virtual or not */
+    isVirtual(): boolean;
+    /** Set the node class */
+    setNodeClass(classNames: string | string[], index?: StyleSegmentIndex): void;
+    /** Toggle the node class */
+    toggleNodeClass(classNames: string, force?: boolean, index?: StyleSegmentIndex): void;
+    /** Set the node style */
+    setNodeStyle(styleSegment: string, index?: StyleSegmentIndex): void;
+    private static checkAndCallAttached;
+    private static checkAndCallDetached;
+    private static checkAndCallMoved;
+    private static checkChildObservers;
+    /**
+     * Get whether a node has any subtree `MutationObserver` attached to it
+     *
+     * If there is, then tree update may have more performance impact.
+     */
+    static hasSubtreeMutationObservers(node: Element$4): boolean;
+    static insertChildReassign(shadowParent: Element$4, child: Node$1, oldSlot: Element$4 | null, newSlot: Element$4 | null, ideaPosIndex: number): void;
+    private static findNearestNonVirtual;
+    private static countNonVirtual;
+    /**
+     * Iterate elements with their slots (slots-inherited nodes included)
+     */
+    static forEachNodeInSlot(node: Node$1, f: (node: Node$1, slot: Element$4 | null | undefined) => boolean | void): boolean;
+    /**
+     * Iterate elements in specified slot (slots-inherited nodes included)
+     */
+    static forEachNodeInSpecificSlot(node: Node$1, slot: Element$4 | undefined | null, f: (node: Node$1) => boolean | void): boolean;
+    /**
+     * Iterate elements with their slots (slots-inherited nodes NOT included)
+     */
+    static forEachSlotContentInSlot(node: Node$1, f: (node: Node$1, slot: Element$4 | null | undefined) => boolean | void): boolean;
+    /**
+     * Iterate elements in specified slot (slots-inherited nodes NOT included)
+     */
+    static forEachSlotContentInSpecificSlot(node: Node$1, slot: Element$4 | undefined | null, f: (node: Node$1) => boolean | void): boolean;
+    private static insertChildComposed;
+    private static insertChildSingleOperation;
+    private static insertChildBatchRemoval;
+    private static insertChildBatchInsertion;
+    private static insertChildPlaceholderReplace;
+    appendChild(child: Node$1): void;
+    insertChildAt(child: Node$1, index: number): void;
+    insertBefore(child: Node$1, before?: Node$1): void;
+    removeChildAt(index: number): void;
+    removeChild(child: Node$1): void;
+    replaceChildAt(child: Node$1, index: number): void;
+    replaceChild(child: Node$1, relChild: Node$1): void;
+    insertChildren(children: Node$1[], index: number): void;
+    removeChildren(index: number, count: number): void;
+    selfReplaceWith(replaceWith: Element$4): void;
+    /** Trigger an event on the element */
+    triggerEvent(name: string, detail?: unknown, options?: EventOptions): void;
+    /** Trigger an event with specified event object on the element */
+    dispatchEvent(ev: Event<unknown>): void;
+    /** Add an event listener on the element */
+    addListener(name: string, func: EventListener<unknown>, options?: EventListenerOptions): void;
+    /** Remove an event listener on the element */
+    removeListener(name: string, func: EventListener<unknown>, options?: EventListenerOptions): void;
+    /** Get an attribute value ( `null` if not set or removed) */
+    getAttribute(name: string): unknown;
+    /** Update an attribute value */
+    updateAttribute(name: string, value: unknown): void;
+    /** Set an attribute value */
+    setAttribute(name: string, value: unknown): void;
+    /** Remove an attribute */
+    removeAttribute(name: string): void;
+    /** Set a dataset on the element */
+    setDataset(name: string, value: unknown): void;
+    /** Set a mark on the element */
+    setMark(name: string, value: unknown): void;
+    /**
+     * Collect the marks on the element
+     *
+     * The marks includes the marks on ancestors (in shadow tree) of the element.
+     * If multiple marks on different elements shares the same name,
+     * the mark value on the child-most element is accepted.
+     */
+    collectMarks(): {
+        [name: string]: unknown;
+    };
+    /**
+     * Attach the element into the backend, swapping out a placeholder element in the backend.
+     *
+     * The `element` must not be a child node of another element,
+     * must not be attached before,
+     * and must not have a `ownerShadowRoot` .
+     * The `element` `targetParent` and `targetNode` must be in the same backend context.
+     * The `element` replaces the `targetNode` in the `targetParent` .
+     */
+    static replaceDocumentElement(element: Element$4, targetParent: GeneralBackendElement, targetNode: GeneralBackendElement): void;
+    /**
+     * Make the element looks like attached.
+     *
+     * If the element will never be attached to backend or it has no backend element at all,
+     * this can be used to trigger `attached` life-time.
+     */
+    static pretendAttached(element: Element$4): void;
+    /**
+     * Make the element looks like detached.
+     *
+     * This can be used to trigger `detached` life-time without remove the element in the backend.
+     */
+    static pretendDetached(element: Element$4): void;
+    /** Check the element is attached or not */
+    static isAttached(element: Element$4): boolean;
+    /**
+     * Set the slot name of the element
+     *
+     * Once this method is called for an `element` ,
+     * it will be treated as a slot which can contain child nodes in composed tree.
+     * This method should not be used in components,
+     * otherwise the slot content will always be dangled.
+     */
+    static setSlotName(element: Element$4, name?: string): void;
+    /**
+     * Get the slot name of the element
+     */
+    static getSlotName(element: Element$4): string | undefined;
+    /**
+     * Set the virtual node to slot-inherit mode
+     *
+     * In slot-inherit mode of an element,
+     * the child nodes of the element will be treated as siblings and can have different target slot.
+     */
+    static setInheritSlots(element: Element$4): void;
+    /** Get whether the slot-inherit mode is set or not */
+    static getInheritSlots(element: Element$4): boolean;
+    /** Get whether the slot-inherit mode is set or not */
+    isInheritSlots(): boolean;
+    /**
+     * Set the binding slot of specific node
+     *
+     * Necessary if node belongs to a dynamic slot, which cannot be identified by slot name.
+     */
+    static setSlotElement(node: Node$1, slot: Element$4 | null): void;
+    static _$updateContainingSlot(node: Node$1, containingSlot: Element$4 | null | undefined): void;
+    static _$spliceSlotNodes(slot: Element$4, before: number, deleteCount: number, insertion: Node$1[] | undefined): void;
+    /** Get composed parent (including virtual nodes) */
+    getComposedParent(): Element$4 | null;
+    /**
+     * Get the composed children
+     *
+     * This method always returns a new array.
+     * It is convenient but less performant.
+     * For better performance, consider using `forEachComposedChild` .
+     */
+    getComposedChildren(): Node$1[];
+    /**
+     * Iterate composed child nodes (including virtual nodes)
+     *
+     * if `f` returns `false` then the iteration is interrupted.
+     * Returns `true` if that happens.
+     */
+    forEachComposedChild(f: (node: Node$1) => boolean | void): boolean;
+    /**
+     * Iterate non-virtual composed child nodes
+     *
+     * if `f` returns `false` then the iteration is interrupted.
+     * Returns `true` if that happens.
+     */
+    forEachNonVirtualComposedChild(f: (node: Node$1) => boolean | void): boolean;
+    /** Parse a selector string so that it can be used multiple queries */
+    static parseSelector(str: string): ParsedSelector;
+    /** Select the first descendant which matches the selector */
+    querySelector(selectorStr: string | ParsedSelector): Element$4 | null;
+    /** Select all descendants which matches the selector */
+    querySelectorAll(selectorStr: string | ParsedSelector): Element$4[];
+    /** Test whether the target matches the selector */
+    static matchSelector(selectorStr: string | ParsedSelector, target: Element$4): boolean;
+    /** Test whether the target in this subtree matches the selector */
+    matchSelector(selectorStr: string | ParsedSelector, target: Element$4): boolean;
+    /**
+     * Get the bounding client rect
+     *
+     * Return zero values when the backend element is invalid or it does not have layout information.
+     */
+    getBoundingClientRect(cb: (res: BoundingClientRect) => void): void;
+    /**
+     * Get the bounding client rect
+     *
+     * Return zero values when the backend element is invalid or it does not have layout information.
+     */
+    getScrollOffset(cb: (res: ScrollOffset) => void): void;
+    /**
+     * Create an intersection observer
+     *
+     * The `relativeElement` is the element to calculate intersection with ( `null` for the viewport).
+     * The `relativeElementMargin` is the margins of the `relativeElement` .
+     * The `thresholds` is a list of intersection ratios to trigger the `listener` .
+     * The listener always triggers once immediately after this call.
+     */
+    createIntersectionObserver(relativeElement: Element$4 | null, relativeElementMargin: string, thresholds: number[], listener: (res: IntersectionStatus) => void): Observer | null;
+    /**
+     * Get an interactive context
+     */
+    getContext(cb: (res: unknown) => void): void;
+}
+
+declare const BM: {
+    DYNAMIC: boolean;
+    SHADOW: boolean;
+    COMPOSED: boolean;
+    DOMLIKE: boolean;
+};
+declare const enum BackendMode {
+    Shadow = 1,
+    Composed = 2,
+    Domlike = 3
+}
+type BoundingClientRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+type ScrollOffset = {
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    scrollHeight: number;
+};
+type CSSProperty = {
+    name: string;
+    value: string;
+    disabled: boolean;
+    invalid: boolean;
+};
+type CSSRule = {
+    sheetIndex: number;
+    ruleIndex: number;
+    mediaQueries: string[];
+    selector: string;
+    properties: CSSProperty[];
+    weightHighBits: number;
+    weightLowBits: number;
+};
+type GetMatchedRulesResponses = {
+    inline: CSSProperty[];
+    rules: CSSRule[];
+};
+type GetAllComputedStylesResponses = {
+    properties: CSSProperty[];
+};
+interface Observer {
+    disconnect(): void;
+}
+type IntersectionStatus = {
+    intersectionRatio: number;
+    boundingClientRect: BoundingClientRect;
+    intersectionRect: BoundingClientRect;
+    relativeRect: BoundingClientRect;
+    time: number;
+};
+type MediaQueryStatus = {
+    minWidth?: number;
+    maxWidth?: number;
+    width?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    height?: number;
+    orientation?: string;
+};
+
+interface GetWrapper<T> {
+    get(): T;
+}
+type Element$3<E> = {
+    getAllComputedStyles(cb: (res: GetAllComputedStylesResponses) => void): void;
+    getBoundingClientRect(cb: (res: BoundingClientRect) => void): void;
+    createIntersectionObserver(relativeElement: E | null, relativeElementMargin: string, thresholds: number[], listener: (res: IntersectionStatus) => void): Observer;
+    getMatchedRules(cb: (res: GetMatchedRulesResponses) => void): void;
+    getScrollOffset(cb: (res: ScrollOffset) => void): void;
+    setScrollPosition(scrollLeft: number, scrollTop: number, duration: number): void;
+    getContext(cb: (res: unknown) => void): void;
+};
+type ElementForDomLike = {
+    getBoundingClientRect(): BoundingClientRect;
+    readonly scrollLeft: number;
+    readonly scrollTop: number;
+    readonly scrollWidth: number;
+    readonly scrollHeight: number;
+};
+interface Context$3<Ctx> {
+    createContext(options: unknown, cb: (ContextWrapper: GetWrapper<Partial<Context$3<Ctx> & Ctx>>) => void): void;
+    setFocusedNode(target: Node$1): void;
+    getFocusedNode(cb: (node: Node$1 | undefined) => void): void;
+    onWindowResize(cb: (res: {
+        width: number;
+        height: number;
+        devicePixelRatio: number;
+    }) => void): void;
+    onThemeChange(cb: (res: {
+        theme: string;
+    }) => void): void;
+    elementFromPoint(left: number, top: number, cb: (node: Node$1) => void): void;
+    createMediaQueryObserver(status: MediaQueryStatus, listener: (res: {
+        matches: boolean;
+    }) => void): Observer;
+    addStyleSheetRule(mediaQueryStr: string, selector: string, callback: (ruleIndex: number | null) => void): void;
+    getStyleSheetIndexForNewRules(callback: (sheetIndex: number) => void): void;
+    resetStyleSheetRule(sheetIndex: number, ruleIndex: number, callback: (ruleIndex: number | null) => void): void;
+    modifyStyleSheetRuleSelector(sheetIndex: number, ruleIndex: number, selector: string, callback: (ruleIndex: number | null) => void): void;
+    addStyleSheetProperty(sheetIndex: number, ruleIndex: number, inlineStyle: string, callback: (propertyIndex: number | null) => void): void;
+    replaceStyleSheetAllProperties(sheetIndex: number, ruleIndex: number, inlineStyle: string, callback: (propertyIndex: number | null) => void): void;
+    setStyleSheetPropertyDisabled(sheetIndex: number, ruleIndex: number, propertyIndex: number, disabled: boolean, callback: (propertyIndex: number | null) => void): void;
+    removeStyleSheetProperty(sheetIndex: number, ruleIndex: number, propertyIndex: number, callback: (propertyIndex: number | null) => void): void;
+    replaceStyleSheetProperty(sheetIndex: number, ruleIndex: number, propertyIndex: number, inlineStyle: string, callback: (propertyIndex: number | null) => void): void;
+    performanceTraceStart(): number;
+    performanceTraceEnd(id: number, cb: (stats: {
+        startTimestamp: number;
+        endTimestamp: number;
+    }) => void): void;
+}
+type UnshiftTarget<Fn, T> = Fn extends (...args: infer Args) => infer Ret ? (target: T, ...args: Args) => Ret : never;
+type UnshiftTargets<T, E> = {
+    [K in keyof T]: UnshiftTarget<T[K], E>;
+};
+type ContextForDomLike<Ctx> = Context$3<Ctx> & UnshiftTargets<Pick<Element$3<Ctx>, 'getAllComputedStyles' | 'createIntersectionObserver' | 'getMatchedRules' | 'setScrollPosition' | 'getContext'>, Ctx>;
+
+interface Context$2 extends Partial<Context$3<Context$2>> {
+    mode: BackendMode.Shadow;
+    destroy(): void;
+    getWindowWidth(): number;
+    getWindowHeight(): number;
+    getDevicePixelRatio(): number;
+    getTheme(): string;
+    registerStyleSheetContent(path: string, content: unknown): void;
+    appendStyleSheetPath(path: string, styleScope?: number): number;
+    disableStyleSheet(index: number): void;
+    render(cb: (err: Error | null) => void): void;
+    getRootNode(): ShadowRootContext;
+    createFragment(): Element$2;
+    onEvent(createEvent: (type: string, detail: unknown, options: EventOptions) => Event<unknown>, listener: (event: Event<unknown>, currentTarget: Element$4, mark: Record<string, unknown> | null, target: Element$4, isCapture: boolean) => EventBubbleStatus | void): void;
+}
+interface Element$2 extends Partial<Element$3<Element$2>> {
+    release(): void;
+    associateValue(v: Element$4): void;
+    getShadowRoot(): ShadowRootContext | undefined;
+    appendChild(child: Element$2): void;
+    removeChild(child: Element$2, index?: number): void;
+    insertBefore(child: Element$2, before: Element$2, index?: number): void;
+    replaceChild(child: Element$2, oldChild: Element$2, index?: number): void;
+    spliceBefore(before: Element$2, deleteCount: number, list: Element$2): void;
+    spliceAppend(list: Element$2): void;
+    spliceRemove(before: Element$2, deleteCount: number): void;
+    setId(id: string): void;
+    setSlotName(slot: string): void;
+    setContainingSlot(slot: Element$2 | undefined | null): void;
+    reassignContainingSlot(oldSlot: Element$2 | null, newSlot: Element$2 | null): void;
+    spliceBeforeSlotNodes(before: number, deleteCount: number, list: Element$2): void;
+    spliceAppendSlotNodes(list: Element$2): void;
+    spliceRemoveSlotNodes(before: number, deleteCount: number): void;
+    setInheritSlots(): void;
+    setStyle(styleText: string): void;
+    addClass(className: string): void;
+    removeClass(className: string): void;
+    clearClasses(): void;
+    setClassAlias(className: string, targets: string[]): void;
+    setAttribute(name: string, value: unknown): void;
+    removeAttribute(name: string): void;
+    setDataset(name: string, value: unknown): void;
+    setText(content: string): void;
+    setModelBindingStat(attributeName: string, listener: ((newValue: unknown) => void) | null): void;
+    setListenerStats(type: string, capture: boolean, mutLevel: MutLevel): void;
+}
+interface ShadowRootContext extends Element$2 {
+    createElement(logicalName: string, stylingName: string): Element$2;
+    createTextNode(content: string): Element$2;
+    createComponent(tagName: string, external: boolean, virtualHost: boolean, styleScope: number, extraStyleScope: number | null, externalClasses: string[] | undefined): Element$2;
+    createVirtualNode(virtualName: string): Element$2;
+}
+
+declare const backend_BM: typeof BM;
+type backend_BackendMode = BackendMode;
+declare const backend_BackendMode: typeof BackendMode;
+type backend_BoundingClientRect = BoundingClientRect;
+type backend_CSSProperty = CSSProperty;
+type backend_CSSRule = CSSRule;
+type backend_GetAllComputedStylesResponses = GetAllComputedStylesResponses;
+type backend_GetMatchedRulesResponses = GetMatchedRulesResponses;
+type backend_IntersectionStatus = IntersectionStatus;
+type backend_MediaQueryStatus = MediaQueryStatus;
+type backend_Observer = Observer;
+type backend_ScrollOffset = ScrollOffset;
+type backend_ShadowRootContext = ShadowRootContext;
+declare namespace backend {
+  export { backend_BM as BM, backend_BackendMode as BackendMode, type backend_BoundingClientRect as BoundingClientRect, type backend_CSSProperty as CSSProperty, type backend_CSSRule as CSSRule, type Context$2 as Context, type Element$2 as Element, type backend_GetAllComputedStylesResponses as GetAllComputedStylesResponses, type backend_GetMatchedRulesResponses as GetMatchedRulesResponses, type backend_IntersectionStatus as IntersectionStatus, type backend_MediaQueryStatus as MediaQueryStatus, type backend_Observer as Observer, type backend_ScrollOffset as ScrollOffset, type backend_ShadowRootContext as ShadowRootContext };
+}
+
+interface Context$1 extends Partial<Context$3<Context$1>> {
+    mode: BackendMode.Composed;
+    destroy(): void;
+    getWindowWidth(): number;
+    getWindowHeight(): number;
+    getDevicePixelRatio(): number;
+    getTheme(): string;
+    registerStyleSheetContent(path: string, content: unknown): void;
+    appendStyleSheetPath(path: string, styleScope?: number): number;
+    disableStyleSheet(index: number): void;
+    render(cb: (err: Error | null) => void): void;
+    getRootNode(): Element$1;
+    createElement(logicalName: string, stylingName: string): Element$1;
+    createTextNode(content: string): Element$1;
+    createFragment(): Element$1;
+    onEvent(listener: (target: Element$4, type: string, detail: unknown, options: EventOptions) => EventBubbleStatus | void): void;
+}
+interface Element$1 extends Partial<Element$3<Element$1>> {
+    release(): void;
+    associateValue(v: Element$4): void;
+    appendChild(child: Element$1): void;
+    removeChild(child: Element$1, index?: number): void;
+    insertBefore(child: Element$1, before: Element$1, index?: number): void;
+    replaceChild(child: Element$1, oldChild: Element$1, index?: number): void;
+    spliceBefore(before: Element$1, deleteCount: number, list: Element$1): void;
+    spliceAppend(list: Element$1): void;
+    spliceRemove(before: Element$1, deleteCount: number): void;
+    setId(id: string): void;
+    setStyleScope(styleScope: number, extraStyleScope?: number, hostStyleScope?: number): void;
+    setStyle(styleText: string): void;
+    addClass(elementClass: string, styleScope?: number): void;
+    removeClass(elementClass: string, styleScope?: number): void;
+    clearClasses(): void;
+    setAttribute(name: string, value: unknown): void;
+    removeAttribute(name: string): void;
+    setText(content: string): void;
+    setModelBindingStat(attributeName: string, listener: ((newValue: unknown) => void) | null): void;
+    setListenerStats(type: string, capture: boolean, mutLevel: MutLevel): void;
+}
+
+declare namespace composedBackend {
+  export type { Context$1 as Context, Element$1 as Element };
+}
+
+interface Context extends Partial<ContextForDomLike<Element>> {
+    mode: BackendMode.Domlike;
+    destroy(): void;
+    getWindowWidth(): number;
+    getWindowHeight(): number;
+    getDevicePixelRatio(): number;
+    getTheme(): string;
+    registerStyleSheetContent(path: string, content: unknown): void;
+    appendStyleSheetPath(path: string, styleScope?: number): number;
+    disableStyleSheet(index: number): void;
+    render(cb: (err: Error | null) => void): void;
+    getRootNode(): Element;
+    document: {
+        createElement(tagName: string): Element;
+        createTextNode(content: string): Element;
+        createDocumentFragment(): Element;
+    };
+    associateValue(element: Element, value: Element$4): void;
+    onEvent(listener: (target: Element$4, type: string, detail: unknown, options: EventOptions) => EventBubbleStatus | void): void;
+    setListenerStats(element: Element, type: string, capture: boolean, mutLevel: MutLevel): void;
+    setModelBindingStat(element: Element, attributeName: string, listener: ((newValue: unknown) => void) | null): void;
+}
+interface Element extends Partial<ElementForDomLike> {
+    _$wxArgs?: {
+        modelListeners: {
+            [name: string]: ((newValue: unknown) => void) | null;
+        };
+    };
+    __wxElement?: Element$4;
+    appendChild(child: Element): void;
+    removeChild(child: Element, index?: number): void;
+    insertBefore(child: Element, before?: Element, index?: number): void;
+    replaceChild(child: Element, oldChild?: Element, index?: number): void;
+    tagName: string;
+    id: string;
+    classList: {
+        add(elementClass: string): void;
+        remove(elementClass: string): void;
+    };
+    setAttribute(name: string, value: unknown): void;
+    removeAttribute(name: string): void;
+    textContent: string;
+    nextSibling: Element | undefined;
+    childNodes: Element[];
+    parentNode: Element | null;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+
+type domlikeBackend_Context = Context;
+type domlikeBackend_Element = Element;
+declare namespace domlikeBackend {
+  export type { domlikeBackend_Context as Context, domlikeBackend_Element as Element };
+}
+
+type GeneralBackendContext = Context$2 | Context$1 | Context;
+type GeneralBackendElement = Element$2 | Element$1 | Element;
+
+declare class CurrentWindowBackendContext implements Context {
+    mode: BackendMode.Domlike;
+    document: {
+        createElement(tagName: string): Element;
+        createTextNode(content: string): Element;
+        createDocumentFragment(): Element;
+    };
+    destroy(): void;
+    getWindowWidth(): number;
+    getWindowHeight(): number;
+    getDevicePixelRatio(): number;
+    getTheme(): string;
+    registerStyleSheetContent(path: string, content: unknown): void;
+    appendStyleSheetPath(path: string, styleScope?: number): number;
+    disableStyleSheet(index: number): void;
+    render(cb: (err: Error | null) => void): void;
+    getRootNode(): Element;
+    associateValue(element: Element, value: Element$4): void;
+    onEvent(listener: (target: Element$4, type: string, detail: any, options: EventOptions) => EventBubbleStatus | void): void;
+    setListenerStats(element: Element, type: string, capture: boolean, mutLevel: MutLevel): void;
+    setModelBindingStat(element: Element, attributeName: string, listener: ((newValue: unknown) => void) | null): void;
+    createIntersectionObserver(targetElement: Element, relativeElement: Element | null, relativeElementMargin: string, thresholds: number[], listener: (res: IntersectionStatus) => void): Observer;
+    createMediaQueryObserver(status: MediaQueryStatus, listener: (res: {
+        matches: boolean;
+    }) => void): Observer;
+    getContext(element: Element, cb: (res: unknown) => void): void;
+}
+
+declare const enum EmptyBackendElementType {
+    Fragment = 0,
+    Element = 1,
+    TextNode = 2,
+    Component = 3,
+    VirtualNode = 4
+}
+/** An empty backend implementation */
+declare class EmptyBackendContext implements Context$2 {
+    mode: BackendMode.Shadow;
+    destroy(): void;
+    getWindowWidth(): number;
+    getWindowHeight(): number;
+    getDevicePixelRatio(): number;
+    getTheme(): string;
+    registerStyleSheetContent(_path: string, _content: unknown): void;
+    appendStyleSheetPath(_path: string, _styleScope?: number): number;
+    disableStyleSheet(_index: number): void;
+    render(cb: (err: Error | null) => void): void;
+    getRootNode(): EmptyBackendShadowRootContext;
+    createFragment(): EmptyBackendElement;
+    onEvent(_createEvent: (type: string, detail: unknown, options: EventOptions) => Event<unknown>, _listener: (event: Event<unknown>, currentTarget: Element$4, mark: Record<string, unknown> | null, target: Element$4, isCapture: boolean) => EventBubbleStatus): void;
+}
+/** An element for empty backend implementation */
+declare class EmptyBackendElement implements Element$2 {
+    private _$shadowRoot;
+    constructor(type: EmptyBackendElementType);
+    release(): void;
+    associateValue(_v: Element$4): void;
+    getShadowRoot(): EmptyBackendShadowRootContext | undefined;
+    appendChild(_child: EmptyBackendElement): void;
+    removeChild(_child: EmptyBackendElement, _index: number): void;
+    insertBefore(_child: EmptyBackendElement, _before: EmptyBackendElement, _index: number): void;
+    replaceChild(_child: EmptyBackendElement, _oldChild: EmptyBackendElement, _index?: number): void;
+    spliceBefore(_before: EmptyBackendElement, _deleteCount: number, _list: EmptyBackendElement): void;
+    spliceAppend(_list: EmptyBackendElement): void;
+    spliceRemove(_before: EmptyBackendElement, _deleteCount: number): void;
+    setId(_id: string): void;
+    setSlotName(_name: string): void;
+    setContainingSlot(_slot: EmptyBackendElement | undefined | null): void;
+    reassignContainingSlot(_oldSlot: Element$2 | null, _newSlot: Element$2 | null): void;
+    spliceBeforeSlotNodes(_before: number, _deleteCount: number, _list: Element$2): void;
+    spliceRemoveSlotNodes(_before: number, _deleteCount: number): void;
+    spliceAppendSlotNodes(_list: Element$2): void;
+    setInheritSlots(): void;
+    setStyle(_styleText: string): void;
+    addClass(_className: string): void;
+    removeClass(_className: string): void;
+    clearClasses(): void;
+    setClassAlias(_className: string, _target: string[]): void;
+    setAttribute(_name: string, _value: unknown): void;
+    removeAttribute(_name: string): void;
+    setDataset(_name: string, _value: unknown): void;
+    setText(_content: string): void;
+    setListenerStats(_type: string, _capture: boolean, _mutLevel: MutLevel): void;
+    setModelBindingStat(_attributeName: string, _listener: ((newValue: unknown) => void) | null): void;
+}
+/** A shadow root for empty backend implementation */
+declare class EmptyBackendShadowRootContext extends EmptyBackendElement implements ShadowRootContext {
+    constructor();
+    createElement(_tagName: string, _stylingName: string): EmptyBackendElement;
+    createTextNode(_content: string): EmptyBackendElement;
+    createComponent(_tagName: string, _external: boolean, _virtualHost: boolean, _styleScope: number, _extraStyleScope: number | null, _externalClasses: string[] | undefined): EmptyBackendElement;
+    createVirtualNode(_virtualName: string): EmptyBackendElement;
+}
+
+/** An empty backend implementation */
+declare class EmptyComposedBackendContext implements Context$1 {
+    mode: BackendMode.Composed;
+    private _$styleSheetIdInc;
+    private _$renderCallbacks;
+    private _$rootNode;
+    destroy(): void;
+    getWindowWidth(): number;
+    getWindowHeight(): number;
+    getDevicePixelRatio(): number;
+    getTheme(): string;
+    registerStyleSheetContent(_path: string, _content: unknown): void;
+    appendStyleSheetPath(_path: string, _styleScope?: number): number;
+    disableStyleSheet(_index: number): void;
+    render(cb: (err: Error | null) => void): void;
+    getRootNode(): EmptyComposedBackendElement;
+    createElement(_tagName: string, _stylingName: string): EmptyComposedBackendElement;
+    createTextNode(_tagName: string): EmptyComposedBackendElement;
+    createFragment(): EmptyComposedBackendElement;
+    onEvent(_listener: (target: Element$4, type: string, detail: unknown, options: EventOptions) => EventBubbleStatus): void;
+    createMediaQueryObserver(_status: MediaQueryStatus, _listener: (res: {
+        matches: boolean;
+    }) => void): Observer;
+}
+/** An element for empty backend implementation */
+declare class EmptyComposedBackendElement implements Element$1 {
+    release(): void;
+    associateValue(_v: unknown): void;
+    appendChild(_child: EmptyComposedBackendElement): void;
+    removeChild(_child: EmptyComposedBackendElement, _index?: number): void;
+    insertBefore(_child: EmptyComposedBackendElement, _before: EmptyComposedBackendElement, _index?: number): void;
+    replaceChild(_child: EmptyComposedBackendElement, _oldChild: EmptyComposedBackendElement, _index?: number): void;
+    spliceBefore(_before: EmptyComposedBackendElement, _deleteCount: number, _list: EmptyComposedBackendElement): void;
+    spliceAppend(_list: EmptyComposedBackendElement): void;
+    spliceRemove(_before: EmptyComposedBackendElement, _deleteCount: number): void;
+    setId(_id: string): void;
+    setStyleScope(_styleScope: number, _extraStyleScope?: number, _hostStyleScope?: number): void;
+    setStyle(_styleText: string): void;
+    addClass(_elementClass: string, _styleScope?: number): void;
+    removeClass(_elementClass: string, _styleScope?: number): void;
+    clearClasses(): void;
+    setAttribute(_name: string, _value: unknown): void;
+    removeAttribute(_name: string): void;
+    setText(_content: string): void;
+    getBoundingClientRect(cb: (res: BoundingClientRect) => void): void;
+    getScrollOffset(cb: (res: ScrollOffset) => void): void;
+    setListenerStats(_type: string, _capture: boolean, _mutLevel: MutLevel): void;
+    setModelBindingStat(_attributeName: string, _listener: ((newValue: unknown) => void) | null): void;
+    createIntersectionObserver(_relativeElement: EmptyComposedBackendElement | null, _relativeElementMargin: string, _thresholds: number[], _listener: (res: IntersectionStatus) => void): Observer;
+    getContext(cb: (res: unknown) => void): void;
+}
+
+declare const simpleDeepCopy: <T>(src: T) => T;
+declare const deepCopy: <T>(src: T, withRecursion: boolean) => T;
+
+declare const data_utils_deepCopy: typeof deepCopy;
+declare const data_utils_simpleDeepCopy: typeof simpleDeepCopy;
+declare namespace data_utils {
+  export { data_utils_deepCopy as deepCopy, data_utils_simpleDeepCopy as simpleDeepCopy };
+}
+
+/** The iterator direction and order */
+declare const enum ElementIteratorType {
+    /** Iterate all ancestors in shadow tree */
+    ShadowAncestors = "shadow-ancestors",
+    /** Iterate all ancestors in composed tree */
+    ComposedAncestors = "composed-ancestors",
+    /** Iterate all descendants in shadow tree, returning parents before their children */
+    ShadowDescendantsRootFirst = "shadow-descendants-root-first",
+    /** Iterate all descendants in shadow tree, returning parents after their children */
+    ShadowDescendantsRootLast = "shadow-descendants-root-last",
+    /** Iterate all descendants in composed tree, returning parents before their children */
+    ComposedDescendantsRootFirst = "composed-descendants-root-first",
+    /** Iterate all descendants in composed tree, returning parents after their children */
+    ComposedDescendantsRootLast = "composed-descendants-root-last"
+}
+/**
+ * An iterator for node tree traversal
+ *
+ * This iterator is convenient but seems a little slower.
+ */
+declare class ElementIterator {
+    /**
+     * Create an iterator with type specified
+     *
+     * The `nodeTypeLimit` is used to limit which kind of nodes will be returned.
+     * It limits the returned result by an `instanceof` call.
+     * The default value is `Element` ,
+     * which means only elements will be returned (text nodes will not).
+     * Consider specifying `Node` if text nodes need to be returned as well as elements.
+     * Specify `Component` will only return components.
+     */
+    constructor(node: Node$1, type: ElementIteratorType, nodeTypeLimit?: unknown);
+    /** Same as constructor (for backward compatibility) */
+    static create(node: Node$1, type: ElementIteratorType, nodeTypeLimit?: unknown): ElementIterator;
+    forEach(f: (node: Node$1) => boolean): void;
+}
+
+/**
+ * What the observer will listen
+ */
+type MutationObserverOptions = {
+    /** Attribute changes, including property, id, slot, and class changes */
+    properties: boolean;
+    /** Child nodes changes */
+    childList: boolean;
+    /** Text content changes */
+    characterData: boolean;
+    /** Enable property, childList, and characterData changes in subtree */
+    subtree: boolean;
+    /** Attached status changes */
+    attachStatus: boolean;
+};
+type MutationObserverAttrEvent = {
+    type: 'properties';
+    target: Element$4;
+    propertyName?: string;
+    attributeName?: string;
+};
+type MutationObserverTextEvent = {
+    type: 'characterData';
+    target: TextNode;
+};
+type MutationObserverChildEvent = {
+    type: 'childList';
+    target: Node$1;
+    addedNodes?: Node$1[];
+    removedNodes?: Node$1[];
+};
+type MutationObserverAttachEvent = {
+    type: 'attachStatus';
+    target: Element$4;
+    status: 'attached' | 'detached';
+};
+type MutationObserverEvent = MutationObserverAttrEvent | MutationObserverTextEvent | MutationObserverChildEvent | MutationObserverAttachEvent;
+/**
+ * An observer that can observe shadow tree changes
+ *
+ * Like DOM MutationObserver,
+ * this observer can observe attributes, text content, and child nodes changes.
+ * It can optionally observe changes in a subtree.
+ * Further more, it can listen attached/detached events on an element.
+ */
+declare class MutationObserver {
+    private _$listener;
+    private _$normalizedListener;
+    private _$subtreeListenersCount;
+    private _$boundFuncArrs;
+    private _$boundTarget;
+    constructor(listener: (ev: MutationObserverEvent) => void);
+    static create(listener: (ev: MutationObserverEvent) => void): MutationObserver;
+    /** Start observation */
+    observe(targetElement: Element$4, options?: Partial<MutationObserverOptions>): void;
+    /** End observation */
+    disconnect(): void;
+}
+
+declare const triggerRender: (element: Element$4, callback?: ((err: Error | null) => void) | undefined) => void;
+
+type UpdatePathTreeNode = true | {
+    [key: string]: UpdatePathTreeNode;
+} | UpdatePathTreeNode[];
+type UpdatePathTreeRoot = UpdatePathTreeNode | undefined;
+type ChangePropListener = (this: unknown, newValue: unknown, oldValue: unknown, host: unknown, elem: unknown) => void;
+type ProcGen = (wrapper: ProcGenWrapper, isCreation: boolean, data: DataValue, dataUpdatePathTree: UpdatePathTreeRoot) => {
+    C: DefineChildren;
+    B?: {
+        [field: string]: BindingMapGen[];
+    };
+};
+type BindingMapGen = (data: DataValue, elementUpdated: (elem: Element$4) => void, updateText: (node: TextNode, content: string) => void) => void;
+type DefineChildren = (isCreation: boolean, defineTextNode: DefineTextNode, defineElement: DefineElement, defineIfGroup: DefineIfGroup, defineForLoop: DefineForLoop, defineSlot: DefineSlot, definePureVirtualNode: DefinePureVirtualNode, dynamicSlotValues: {
+    [name: string]: unknown;
+} | undefined, slotValueUpdatePathTrees: UpdatePathTreeNode | undefined) => void;
+type DefineTextNode = (text: string | undefined, textInit?: (elem: TextNode) => boolean) => void;
+type DefineElement = (tag: string, genericImpls: {
+    [key: string]: string;
+}, propertyInit: (elem: Element$4, isCreation: boolean) => void, children: DefineChildren, slot?: string, dynamicSlotValueNames?: string[]) => void;
+type DefineIfGroup = (branchKey: number | string, branchFunc: DefineChildren) => void;
+type DefineForLoop = (list: DataValue[], key: string | null, oriListUpdatePathTree: UpdatePathTreeRoot, lvaluePath: DataPath | null, itemCallback: (isCreation: boolean, item: DataValue, index: number | string, itemUpdatePathTree: UpdatePathTreeRoot, indexUpdatePathTree: UpdatePathTreeRoot, itemLvaluePath: DataPath | null, defineTextNode: DefineTextNode, defineElement: DefineElement, defineIfGroup: DefineIfGroup, defineForLoop: DefineForLoop, defineSlot: DefineSlot, definePureVirtualNode: DefinePureVirtualNode) => void) => void;
+type DefineSlot = (name: string | undefined, slotValueInit?: (elem: Element$4) => void, slot?: string) => void;
+type DefinePureVirtualNode = (children: DefineChildren, slot: string | undefined) => void;
+declare class ProcGenWrapper {
+    shadowRoot: ShadowRoot;
+    procGen: ProcGen;
+    fallbackListenerOnNativeNode: boolean;
+    bindingMapDisabled: boolean;
+    eventObjectFilter: (x: ShadowedEvent<unknown>) => ShadowedEvent<unknown>;
+    changePropFilter: <T>(x: T) => T;
+    eventListenerFilter: <T>(x: T) => T;
+    constructor(shadowRoot: ShadowRoot, procGen: ProcGen, fallbackListenerOnNativeNode: boolean, eventObjectFilter?: (x: ShadowedEvent<unknown>) => ShadowedEvent<unknown>);
+    create(data: DataValue): {
+        [field: string]: BindingMapGen[];
+    } | undefined;
+    update(data: DataValue, dataUpdatePathTree: UpdatePathTreeRoot): void;
+    bindingMapUpdate(field: string, data: DataValue, bindingMapGenList: {
+        [field: string]: BindingMapGen[];
+    }): boolean;
+    handleChildrenCreation(children: DefineChildren, slotElement: Element$4 | undefined, dynamicSlotName: string | undefined): Node$1[];
+    handleChildrenCreationAndInsert(children: DefineChildren, parentNode: Element$4, slotElement: Element$4 | undefined, dynamicSlotName: string | undefined): void;
+    handleChildrenUpdate(children: DefineChildren, parentNode: Element$4, slotElement: Element$4 | undefined, dynamicSlotName: string | undefined): void;
+    dynamicSlotUpdate(elem: GeneralComponent, dynamicSlotValueNames: string[] | undefined, children: DefineChildren): ShadowRoot | null;
+    createDynamicPlaceholder(slotElement: Element$4): Element$4;
+    createCommonElement(tagName: string, genericImpls: {
+        [key: string]: string;
+    }, propertyInit: (elem: Element$4, isCreation: boolean) => void, children: DefineChildren, dynamicSlotValueNames: string[] | undefined): Element$4;
+    s(elem: Element$4, v: string): void;
+    l(elem: Element$4, name: string, value: unknown): void;
+    i(elem: Element$4, v: string): void;
+    c(elem: Element$4, v: string | string[]): void;
+    y(elem: Element$4, v: string): void;
+    d(elem: Element$4, name: string, v: unknown): void;
+    m(elem: Element$4, name: string, v: unknown): void;
+    v(elem: Element$4, evName: string, v: string | ((ev: ShadowedEvent<unknown>) => void) | undefined, final: boolean, mutated: boolean, capture: boolean, isDynamic: boolean, _generalLvaluePath?: DataPath | null): void;
+    r: (elem: Element$4, name: string, v: unknown, modelLvaluePath?: DataPath | null, generalLvaluePath?: DataPath | null) => void;
+    wl(elem: Element$4, name: string, value: unknown): void;
+    p(elem: Element$4, name: string, v: ChangePropListener, _generalLvaluePath?: DataPath | null): void;
+    setFnFilter(changePropFilter: <T>(v: T) => T, eventListenerFilter: <T>(v: T) => T): void;
+}
+
+declare const DEFAULT_PROC_GEN_GROUP: (name: string) => ProcGen;
+type ProcGenGroup = (name: string) => ProcGen;
+type ProcGenGroupList = {
+    [path: string]: ProcGenGroup;
+};
+type ComponentTemplate = {
+    groupList?: ProcGenGroupList;
+    content: (name: string) => ProcGen;
+    updateMode?: string;
+    fallbackListenerOnNativeNode?: boolean;
+    eventObjectFilter?: (x: ShadowedEvent<unknown>) => ShadowedEvent<unknown>;
+    procGenWrapperType?: typeof ProcGenWrapper;
+};
+declare class GlassEaselTemplateEngine implements TemplateEngine {
+    create(behavior: GeneralBehavior, componentOptions: NormalizedComponentOptions): Template;
+}
+declare const getDefaultTemplateEngine: () => TemplateEngine;
+
+type index_ComponentTemplate = ComponentTemplate;
+declare const index_DEFAULT_PROC_GEN_GROUP: typeof DEFAULT_PROC_GEN_GROUP;
+type index_GlassEaselTemplateEngine = GlassEaselTemplateEngine;
+declare const index_GlassEaselTemplateEngine: typeof GlassEaselTemplateEngine;
+type index_ProcGenGroup = ProcGenGroup;
+type index_ProcGenGroupList = ProcGenGroupList;
+declare const index_getDefaultTemplateEngine: typeof getDefaultTemplateEngine;
+declare namespace index {
+  export { type index_ComponentTemplate as ComponentTemplate, index_DEFAULT_PROC_GEN_GROUP as DEFAULT_PROC_GEN_GROUP, index_GlassEaselTemplateEngine as GlassEaselTemplateEngine, type index_ProcGenGroup as ProcGenGroup, type index_ProcGenGroupList as ProcGenGroupList, index_getDefaultTemplateEngine as getDefaultTemplateEngine };
+}
+
+type ErrorListener = (error: unknown, method?: string, relatedComponent?: GeneralComponent | string, element?: Node$1) => boolean | void;
+type WarningListener = (message: string, relatedComponent: GeneralComponent | string, element?: Node$1) => boolean | void;
+declare function addGlobalErrorListener(func: ErrorListener): void;
+declare function removeGlobalErrorListener(func: ErrorListener): void;
+declare function addGlobalWarningListener(func: WarningListener): void;
+declare function removeGlobalWarningListener(func: WarningListener): void;
+
+declare const registerBehavior: <TData extends DataList = Empty, TProperty extends PropertyList = Empty, TMethod extends MethodList = Empty>(def: ComponentParams<TData, TProperty, TMethod> & ThisType<ComponentInstance<TData, TProperty, TMethod>>) => Behavior<TData, TProperty, TMethod, never>;
+declare const registerElement: <TData extends DataList = Empty, TProperty extends PropertyList = Empty, TMethod extends MethodList = Empty>(def: ComponentParams<TData, TProperty, TMethod> & ThisType<ComponentInstance<TData, TProperty, TMethod>>) => ComponentDefinition<TData, TProperty, TMethod>;
+declare function createElement(tagName: string, compDef?: GeneralComponentDefinition): GeneralComponent;
+declare function createElement<TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList>(tagName: string, compDef: ComponentDefinition<TData, TProperty, TMethod>): ComponentInstance<TData, TProperty, TMethod>;
+declare const triggerEvent: typeof Event.triggerEvent;
+declare const triggerExternalEvent: typeof Event.triggerExternalEvent;
+
+export { BackendMode, Behavior, BehaviorBuilder, type BuilderContext, ClassList, Component, ComponentDefinition, type ComponentOptions, ComponentSpace, CurrentWindowBackendContext, type DataChange, DataGroup, type DataObserver, type DataUpdateCallback, type DataValue, DeepCopyKind, Element$4 as Element, ElementIterator, ElementIteratorType, EmptyBackendContext, EmptyComposedBackendContext, type EnvironmentOptions, Event, EventBubbleStatus, type EventListener, type EventListenerOptions, MutLevel as EventMutLevel, type EventOptions, type ExternalShadowRoot, FuncArr, type GeneralBackendContext, type GeneralBackendElement, type GeneralBehavior, type GeneralBehaviorBuilder, type GeneralComponent, type GeneralComponentDefinition, type GeneralDataGroup, type GeneralFuncType, MutationObserver, NativeNode, type Node$1 as Node, type NodeCast, type NormalizedComponentOptions, NormalizedPropertyType, MutationObserver as Observer, ParsedSelector, type PropertyChange, type RelationFailedListener, type RelationListener, RelationType, ShadowRoot, type ShadowedEvent, type StyleScopeId, StyleScopeManager, StyleSegmentIndex, TextNode, TraitBehavior, VirtualNode, addGlobalErrorListener, addGlobalWarningListener, backend, composedBackend, createElement, data_path as dataPath, data_utils as dataUtils, domlikeBackend, dumpElement, dumpElementToString, dumpSingleElementToString, getDefaultComponentSpace, globalOptions, registerBehavior, registerElement, removeGlobalErrorListener, removeGlobalWarningListener, safeCallback, index as template, template_engine as templateEngine, triggerEvent, triggerExternalEvent, triggerRender, component_params as typeUtils };