glass-easel-miniprogram-adapter 0.2.0 → 0.3.0

package/dist/glass_easel_miniprogram_adapter.d.ts

@@ -1 +1,872 @@
-export * from "./types/src/index"
+import * as glassEasel from 'glass-easel';
+import { typeUtils, DeepCopyKind } from 'glass-easel';
+export { glassEasel };
+
+type SelectorQueryFields = {
+    id?: boolean;
+    dataset?: boolean;
+    mark?: boolean;
+    rect?: boolean;
+    size?: boolean;
+    scrollOffset?: boolean;
+    properties?: string[];
+};
+type SelectorQueryResult<T extends SelectorQueryFields> = {
+    id: T['id'] extends true ? string : undefined;
+    dataset: T['dataset'] extends true ? {
+        [k: string]: any;
+    } : undefined;
+    mark: T['mark'] extends true ? {
+        [k: string]: any;
+    } : undefined;
+    left: T['rect'] extends true ? number : undefined;
+    top: T['rect'] extends true ? number : undefined;
+    right: T['rect'] extends true ? number : undefined;
+    bottom: T['rect'] extends true ? number : undefined;
+    width: T['size'] extends true ? number : undefined;
+    height: T['size'] extends true ? number : undefined;
+    scrollLeft: T['scrollOffset'] extends true ? number : undefined;
+    scrollTop: T['scrollOffset'] extends true ? number : undefined;
+    scrollWidth: T['scrollOffset'] extends true ? number : undefined;
+    scrollHeight: T['scrollOffset'] extends true ? number : undefined;
+} & {
+    [K in T['properties'] extends (infer I extends string)[] ? I : never]: any;
+};
+type BoundingClientRect = {
+    id: string;
+    dataset: {
+        [k: string]: any;
+    };
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+type ScrollOffset = {
+    id: string;
+    dataset: {
+        [k: string]: any;
+    };
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    scrollHeight: number;
+};
+declare class NodesRef<S extends boolean> {
+    private _$sq;
+    private _$comp;
+    private _$sel;
+    private _$single;
+    constructor(selectorQuery: SelectorQuery, component: GeneralComponent, selector: string | null, selectSingle: S);
+    fields<T extends SelectorQueryFields>(fields: T, cb?: (res: S extends true ? SelectorQueryResult<T> : SelectorQueryResult<T>[]) => void): SelectorQuery;
+    boundingClientRect(cb?: (res: S extends true ? BoundingClientRect : BoundingClientRect[]) => void): SelectorQuery;
+    scrollOffset(cb?: (res: S extends true ? ScrollOffset : ScrollOffset[]) => void): SelectorQuery;
+}
+declare class SelectorQuery {
+    private _$comp;
+    /** Change where the node should be selected from */
+    in(component: GeneralComponent): this;
+    /** Select the first node that matches the selector */
+    select(selector: string): NodesRef<true>;
+    /** Select all nodes that match the selector */
+    selectAll(selector: string): NodesRef<false>;
+    /**
+     * Select the viewport of the component
+     *
+     * Only the size and the scroll position is meaningful when the viewport is selected.
+     */
+    selectViewport(): NodesRef<true>;
+    /**
+     * Execute all queries
+     *
+     * The `cb` is called after all queries done.
+     */
+    exec(cb?: (resList: any[]) => void): void;
+}
+
+type IntersectionObserverMargins = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+declare class IntersectionObserver {
+    private _$comp;
+    private _$thresholds;
+    private _$initialRatio;
+    private _$observeAll;
+    private _$selector;
+    private _$margins;
+    private _$observers;
+    relativeTo(selector: string, margins?: IntersectionObserverMargins): this;
+    relativeToViewport(margins?: IntersectionObserverMargins): this;
+    observe(targetSelector: string, listener: (status: glassEasel.backend.IntersectionStatus) => void): void;
+    disconnect(): void;
+}
+
+declare class MediaQueryObserver {
+    private _$comp;
+    private _$observer;
+    observe(descriptor: glassEasel.backend.MediaQueryStatus, listener: (status: {
+        matches: boolean;
+    }) => void): void;
+    disconnect(): void;
+}
+
+type DataList$6 = typeUtils.DataList;
+type PropertyList$6 = typeUtils.PropertyList;
+type MethodList$5 = typeUtils.MethodList;
+type AllData<TData extends DataList$6, TProperty extends PropertyList$6> = typeUtils.DataWithPropertyValues<TData, TProperty>;
+type ExportType<UData extends DataList$6, UProperty extends PropertyList$6, UMethod extends MethodList$5, UComponentExport> = [UComponentExport] extends [never] ? Component<UData, UProperty, UMethod, UComponentExport> : UComponentExport;
+type GeneralComponent = Component<any, any, any, any>;
+type Component<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport> = ComponentCaller<TData, TProperty, TMethod, TComponentExport> & {
+    [k in keyof TMethod]: TMethod[k];
+};
+declare class ComponentCaller<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport> {
+    /** The corresponding `Component` */
+    _$: glassEasel.Component<TData, TProperty, TMethod>;
+    /** The component path in the code space */
+    get is(): string;
+    set is(value: string);
+    /** The `id` field in the template */
+    get id(): string;
+    set id(value: string);
+    /** The `data-*` field in the template */
+    get dataset(): {
+        [key: string]: any;
+    } | null;
+    set dataset(value: {
+        [key: string]: any;
+    } | null);
+    /** The component data and property values */
+    get data(): typeUtils.Merge<AllData<TData, TProperty>>;
+    set data(value: AllData<TData, TProperty>);
+    /** The component data and property values (same as `data` ) */
+    get properties(): typeUtils.Merge<AllData<TData, TProperty>>;
+    set properties(value: AllData<TData, TProperty>);
+    /**
+     * Group several data update calls
+     *
+     * This method is designed for hinting the backend that some updates should be handled together.
+     * However, this is done automatically now,
+     * so this method is just for backward compatibilities.
+     */
+    groupSetData(callback: () => void): void;
+    /**
+     * Do a classic data update
+     *
+     * The `callback` is called after the update applies in the backend.
+     * In most cases, you SHOULD NOT wait the backend update (that might be very slow),
+     * and most calls, including read calls such as `selectComponent` , simply works immediately.
+     * However, when called inside observers,
+     * the data update will not be applied to templates immediately
+     * (it is recommanded to use `updateData` instead in observers).
+     */
+    setData(newData: Partial<typeUtils.SetDataSetter<typeUtils.DataWithPropertyValues<TData, TProperty>>>, callback?: () => void): void;
+    /**
+     * 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<typeUtils.SetDataSetter<typeUtils.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 (string | number)[]>(path: readonly [...T], data: typeUtils.GetFromDataPath<typeUtils.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 (string | number)[]>(path: readonly [...T], index: typeUtils.GetFromDataPath<typeUtils.DataWithPropertyValues<TData, TProperty>, T> extends any[] ? number | undefined : never, del: typeUtils.GetFromDataPath<typeUtils.DataWithPropertyValues<TData, TProperty>, T> extends any[] ? number | undefined : never, inserts: typeUtils.GetFromDataPath<typeUtils.DataWithPropertyValues<TData, TProperty>, T> extends (infer I)[] ? I[] : never): void;
+    /**
+     * 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;
+    /**
+     * Check whether the `other` behavior is a dependent behavior or a implemented trait behavior
+     */
+    hasBehavior(behavior: GeneralBehavior | TraitBehavior<any, any>): boolean;
+    /**
+     * Get the trait behavior implementation of the component
+     *
+     * Returns `undefined` if the specified trait behavior is not implemented.
+     */
+    traitBehavior<TOut extends {
+        [key: string]: any;
+    }>(traitBehavior: TraitBehavior<any, TOut>): TOut | undefined;
+    /** Trigger an event */
+    triggerEvent(name: string, detail: any, options: {
+        bubbles?: boolean;
+        composed?: boolean;
+        capturePhase?: boolean;
+    }): void;
+    /** Create a selector query for searching element inside the component */
+    createSelectorQuery(): SelectorQuery;
+    /** Create an intersection observer */
+    createIntersectionObserver(options?: {
+        thresholds?: number[];
+        initialRatio?: number;
+        observeAll?: boolean;
+    }): IntersectionObserver;
+    /** Create an media query observer */
+    createMediaQueryObserver(): MediaQueryObserver;
+    /**
+     * Query an element inside the component
+     *
+     * If `componentType` is provided, this method will check the selected component type.
+     * If the component type does not match, `null` is returned.
+     */
+    selectComponent(selector: string): any;
+    selectComponent<UData extends DataList$6, UProperty extends PropertyList$6, UMethod extends MethodList$5, UComponentExport>(selector: string, componentType: ComponentType<UData, UProperty, UMethod, UComponentExport>): ExportType<UData, UProperty, UMethod, UComponentExport> | null;
+    /**
+     * Query all elements inside the component
+     *
+     * If `componentType` is provided, this method will check the selected component type.
+     * If a component type does not match, it is not returned.
+     */
+    selectAllComponents(selector: string): GeneralComponent[];
+    selectAllComponents<UData extends DataList$6, UProperty extends PropertyList$6, UMethod extends MethodList$5, UComponentExport>(selector: string, componentType: ComponentType<UData, UProperty, UMethod, UComponentExport>): ExportType<UData, UProperty, UMethod, UComponentExport>[];
+    /**
+     * Get the owner component
+     *
+     * If `componentType` is provided, this method will check the selected component type.
+     * If a component type does not match, `null` is returned.
+     */
+    selectOwnerComponent(): any;
+    selectOwnerComponent<UData extends DataList$6, UProperty extends PropertyList$6, UMethod extends MethodList$5, UComponentExport>(componentType: ComponentType<UData, UProperty, UMethod, UComponentExport>): ExportType<UData, UProperty, UMethod, UComponentExport> | null;
+    getRelationNodes(relationKey: string): GeneralComponent[];
+    /** Cast the component into a general-typed one */
+    general(): GeneralComponent;
+    /**
+     * Cast the component into the specified type
+     *
+     * Returns `null` if the component node is not the instance of the specified component.
+     */
+    asInstanceOf<UData extends DataList$6, UProperty extends PropertyList$6, UMethod extends MethodList$5, UComponentExport>(componentType: ComponentType<UData, UProperty, UMethod, UComponentExport>): Component<UData, UProperty, UMethod, UComponentExport> | null;
+}
+declare class ComponentProto<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport> {
+    private proto;
+    constructor(methods: TMethod, componentExport?: (source: GeneralComponent | null) => TComponentExport);
+    derive(): Component<TData, TProperty, TMethod, TComponentExport>;
+}
+
+type component_AllData<TData extends DataList$6, TProperty extends PropertyList$6> = AllData<TData, TProperty>;
+type component_Component<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport> = Component<TData, TProperty, TMethod, TComponentExport>;
+type component_ComponentCaller<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport> = ComponentCaller<TData, TProperty, TMethod, TComponentExport>;
+declare const component_ComponentCaller: typeof ComponentCaller;
+type component_ComponentProto<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport> = ComponentProto<TData, TProperty, TMethod, TComponentExport>;
+declare const component_ComponentProto: typeof ComponentProto;
+type component_GeneralComponent = GeneralComponent;
+declare namespace component {
+  export { type component_AllData as AllData, type component_Component as Component, component_ComponentCaller as ComponentCaller, component_ComponentProto as ComponentProto, type component_GeneralComponent as GeneralComponent };
+}
+
+declare const enum StyleIsolation {
+    Isolated = "isolated",
+    ApplyShared = "apply-shared",
+    Shared = "shared",
+    PageIsolated = "page-isolated",
+    PageApplyShared = "page-apply-shared",
+    PageShared = "page-shared"
+}
+type ComponentStaticConfig = {
+    component?: boolean;
+    usingComponents?: {
+        [name: string]: string;
+    };
+    componentGenerics?: {
+        [name: string]: true | {
+            default?: string;
+        };
+    };
+    componentPlaceholder?: {
+        [name: string]: string;
+    };
+    styleIsolation?: StyleIsolation;
+    /** @obsolete */
+    addGlobalClass?: boolean;
+    pureDataPattern?: string;
+};
+type ComponentDefinitionOptions = {
+    multipleSlots?: boolean;
+    pureDataPattern?: RegExp;
+    virtualHost?: boolean;
+    dataDeepCopy?: DeepCopyKind;
+    propertyPassingDeepCopy?: DeepCopyKind;
+    propertyEarlyInit?: boolean;
+};
+type ComponentMethod$4 = typeUtils.ComponentMethod;
+type BehaviorDefinition<TData extends typeUtils.DataList, TProperty extends typeUtils.PropertyList, TMethod extends typeUtils.MethodList, TComponentExport> = {
+    behaviors?: Behavior<any, any, any, any, any>[];
+    properties?: TProperty;
+    data?: TData | (() => TData);
+    observers?: {
+        fields?: string;
+        observer: ComponentMethod$4;
+    }[] | {
+        [fields: string]: ComponentMethod$4;
+    };
+    methods?: TMethod;
+    created?: ComponentMethod$4;
+    attached?: ComponentMethod$4;
+    ready?: ComponentMethod$4;
+    moved?: ComponentMethod$4;
+    detached?: ComponentMethod$4;
+    lifetimes?: {
+        [name: string]: ComponentMethod$4;
+    };
+    pageLifetimes?: {
+        [name: string]: ComponentMethod$4;
+    };
+    relations?: typeUtils.RelationParamsWithKey;
+    externalClasses?: string[];
+    definitionFilter?: DefinitionFilter;
+    export?: (source: GeneralComponent | null) => TComponentExport;
+};
+type ComponentDefinition<TData extends typeUtils.DataList, TProperty extends typeUtils.PropertyList, TMethod extends typeUtils.MethodList, TComponentExport> = {
+    options?: ComponentDefinitionOptions;
+} & BehaviorDefinition<TData, TProperty, TMethod, TComponentExport>;
+type GeneralComponentDefinition = ComponentDefinition<any, any, any, any>;
+type PageDefinition<TData extends typeUtils.DataList, TExtraFields extends {
+    [k: PropertyKey]: any;
+}> = TExtraFields & {
+    options?: ComponentDefinitionOptions;
+    behaviors?: GeneralBehavior[];
+    data?: TData;
+};
+
+type types_BehaviorDefinition<TData extends typeUtils.DataList, TProperty extends typeUtils.PropertyList, TMethod extends typeUtils.MethodList, TComponentExport> = BehaviorDefinition<TData, TProperty, TMethod, TComponentExport>;
+type types_ComponentDefinition<TData extends typeUtils.DataList, TProperty extends typeUtils.PropertyList, TMethod extends typeUtils.MethodList, TComponentExport> = ComponentDefinition<TData, TProperty, TMethod, TComponentExport>;
+type types_ComponentDefinitionOptions = ComponentDefinitionOptions;
+type types_ComponentStaticConfig = ComponentStaticConfig;
+type types_GeneralComponentDefinition = GeneralComponentDefinition;
+type types_PageDefinition<TData extends typeUtils.DataList, TExtraFields extends {
+    [k: PropertyKey]: any;
+}> = PageDefinition<TData, TExtraFields>;
+type types_StyleIsolation = StyleIsolation;
+declare const types_StyleIsolation: typeof StyleIsolation;
+declare namespace types {
+  export { type types_BehaviorDefinition as BehaviorDefinition, type types_ComponentDefinition as ComponentDefinition, type types_ComponentDefinitionOptions as ComponentDefinitionOptions, type types_ComponentStaticConfig as ComponentStaticConfig, type types_GeneralComponentDefinition as GeneralComponentDefinition, type types_PageDefinition as PageDefinition, types_StyleIsolation as StyleIsolation, typeUtils as utils };
+}
+
+type DataList$5 = typeUtils.DataList;
+type PropertyList$5 = typeUtils.PropertyList;
+type MethodList$4 = typeUtils.MethodList;
+type ChainingFilterType$4 = typeUtils.ChainingFilterType;
+type DefinitionFilter = (target: GeneralComponentDefinition, childFilters: (((target: GeneralComponentDefinition) => void) | null)[]) => void;
+type GeneralBehavior = Behavior<Record<string, any>, Record<string, any>, Record<string, any>, any>;
+declare class Behavior<TData extends DataList$5, TProperty extends PropertyList$5, TMethod extends MethodList$4, TChainingFilter extends ChainingFilterType$4, TComponentExport = never> {
+}
+declare class ComponentType<TData extends DataList$5, TProperty extends PropertyList$5, TMethod extends MethodList$4, TComponentExport> {
+}
+declare class TraitBehavior<TIn extends {
+    [key: string]: any;
+}, TOut extends {
+    [key: string]: any;
+} = TIn> {
+    constructor(inner: glassEasel.TraitBehavior<TIn, TOut>);
+}
+
+type ResolveBehaviorBuilder<B, TChainingFilter extends ChainingFilterType$3> = typeUtils.IsNever<TChainingFilter> extends false ? TChainingFilter extends ChainingFilterType$3 ? Omit<B, TChainingFilter['remove']> & TChainingFilter['add'] : B : B;
+type DataList$4 = typeUtils.DataList;
+type PropertyList$4 = typeUtils.PropertyList;
+type ChainingFilterType$3 = typeUtils.ChainingFilterType;
+type ComponentMethod$3 = typeUtils.ComponentMethod;
+type TaggedMethod$3<Fn extends ComponentMethod$3> = typeUtils.TaggedMethod<Fn>;
+interface RelationHandler<TTarget, TOut> {
+    list(): TTarget[];
+    listAsTrait: TOut extends never ? undefined : () => TOut[];
+}
+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 RelationParams = {
+    target?: string | ComponentType<any, 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 Lifetimes = {
+    created: () => void;
+    attached: () => void;
+    moved: () => void;
+    detached: () => void;
+    ready: () => void;
+};
+interface BuilderContext<TPrevData extends DataList$4, TProperty extends PropertyList$4, TMethodCaller> extends ThisType<TMethodCaller> {
+    self: TMethodCaller;
+    data: typeUtils.Merge<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>;
+    setData: (newData: Partial<typeUtils.SetDataSetter<TPrevData>>, callback?: () => void) => void;
+    implement: <TIn extends {
+        [x: string]: any;
+    }>(traitBehavior: TraitBehavior<TIn, any>, impl: TIn) => void;
+    relation<TOut extends {
+        [key: string]: any;
+    }>(def: TraitRelationParams<TOut> & ThisType<TMethodCaller>): RelationHandler<any, TOut>;
+    relation(def: RelationParams & ThisType<TMethodCaller>): RelationHandler<any, never>;
+    observer<P extends typeUtils.ObserverDataPathStrings<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>, V = typeUtils.GetFromObserverPathString<typeUtils.DataWithPropertyValues<TPrevData, TProperty>, P>>(paths: P, func: (newValue: V) => void): void;
+    observer<P extends typeUtils.ObserverDataPathStrings<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>[], V = {
+        [K in keyof P]: typeUtils.GetFromObserverPathString<typeUtils.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$3>(func: Fn) => TaggedMethod$3<Fn>;
+    listener: <T>(func: glassEasel.EventListener<T>) => TaggedMethod$3<glassEasel.EventListener<T>>;
+}
+
+type Empty$3 = typeUtils.Empty;
+type DataList$3 = typeUtils.DataList;
+type PropertyList$3 = typeUtils.PropertyList;
+type PropertyType$2 = typeUtils.PropertyType;
+type PropertyTypeToValueType$2<T extends PropertyType$2> = typeUtils.PropertyTypeToValueType<T>;
+type MethodList$3 = typeUtils.MethodList;
+type ChainingFilterType$2 = typeUtils.ChainingFilterType;
+type ComponentMethod$2 = typeUtils.ComponentMethod;
+type TaggedMethod$2<Fn extends ComponentMethod$2> = typeUtils.TaggedMethod<Fn>;
+declare class BaseBehaviorBuilder<TPrevData extends DataList$3 = Empty$3, TData extends DataList$3 = Empty$3, TProperty extends PropertyList$3 = Empty$3, TMethod extends MethodList$3 = Empty$3, TChainingFilter extends ChainingFilterType$2 = never, TPendingChainingFilter extends ChainingFilterType$2 = never, TComponentExport = never> {
+    protected _$codeSpace: CodeSpace;
+    protected _$: glassEasel.BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter>;
+    protected _$parents: GeneralBehavior[];
+    protected _$export?: (source: GeneralComponent | null) => TComponentExport;
+    /** Implement a trait behavior */
+    implement<TIn extends {
+        [key: string]: any;
+    }>(traitBehavior: TraitBehavior<TIn, any>, impl: TIn): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /** Add external classes */
+    externalClasses(list: string[]): this;
+    /** Set the export value when the component is being selected */
+    export<TNewComponentExport>(f: (this: GeneralComponent, source: GeneralComponent | null) => TNewComponentExport): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport>, TChainingFilter>;
+    data<T extends DataList$3>(gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<BaseBehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    property<N extends string, T extends PropertyType$2, V extends PropertyTypeToValueType$2<T>>(name: N, def: N extends keyof (TData & TProperty) ? never : typeUtils.PropertyListItem<T, V>): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty & Record<N, unknown extends V ? T : typeUtils.PropertyOption<T, V>>, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /**
+     * Add some public methods
+     *
+     * The public method can be used as an event handler, and can be visited in component instance.
+     */
+    methods<T extends MethodList$3>(funcs: T & ThisType<Component<TData, TProperty, TMethod & T, any>>): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /**
+     * Add a data observer
+     */
+    observer<P extends typeUtils.ObserverDataPathStrings<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>, V = typeUtils.GetFromObserverPathString<typeUtils.DataWithPropertyValues<TPrevData, TProperty>, P>>(paths: P, func: (this: Component<TData, TProperty, TMethod, any>, newValue: V) => void, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    observer<P extends typeUtils.ObserverDataPathStrings<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>[], V = {
+        [K in keyof P]: typeUtils.GetFromObserverPathString<typeUtils.DataWithPropertyValues<TPrevData, TProperty>, P[K]>;
+    }>(paths: readonly [...P], func: (this: Component<TData, TProperty, TMethod, any>, ...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: Component<TData, TProperty, TMethod, any>, ...args: Parameters<Lifetimes[L]>) => ReturnType<Lifetimes[L]>, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add a page-lifetime callback
+     */
+    pageLifetime(name: string, func: (this: Component<TData, TProperty, TMethod, any>, ...args: any[]) => any, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /**
+     * Add a relation
+     */
+    relation(name: string, rel: RelationParams & ThisType<Component<TData, TProperty, TMethod, TComponentExport>>): ResolveBehaviorBuilder<this, TChainingFilter>;
+    init<TExport extends Record<string, TaggedMethod$2<(...args: any[]) => any>> | void>(func: (this: Component<TData, TProperty, TMethod, TComponentExport>, builderContext: BuilderContext<TPrevData, TProperty, Component<TData, TProperty, TMethod, TComponentExport>>) => TExport): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    definition<TNewData extends DataList$3 = Empty$3, TNewProperty extends PropertyList$3 = Empty$3, TNewMethod extends MethodList$3 = Empty$3, TNewComponentExport = never>(def: BehaviorDefinition<TNewData, TNewProperty, TNewMethod, TNewComponentExport> & ThisType<Component<TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TNewComponentExport>>): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport>, TChainingFilter>;
+}
+
+type Empty$2 = typeUtils.Empty;
+type DataList$2 = typeUtils.DataList;
+type PropertyList$2 = typeUtils.PropertyList;
+type PropertyType$1 = typeUtils.PropertyType;
+type PropertyTypeToValueType$1<T extends PropertyType$1> = typeUtils.PropertyTypeToValueType<T>;
+type MethodList$2 = typeUtils.MethodList;
+type ChainingFilterType$1 = typeUtils.ChainingFilterType;
+type ComponentMethod$1 = typeUtils.ComponentMethod;
+type TaggedMethod$1<Fn extends ComponentMethod$1> = typeUtils.TaggedMethod<Fn>;
+type ChainingFilterFunc<TAddedFields extends {
+    [key: string]: any;
+}, TRemovedFields extends string = never> = typeUtils.ChainingFilterFunc<TAddedFields, TRemovedFields>;
+declare class BehaviorBuilder<TPrevData extends DataList$2 = Empty$2, TData extends DataList$2 = Empty$2, TProperty extends PropertyList$2 = Empty$2, TMethod extends MethodList$2 = Empty$2, TChainingFilter extends ChainingFilterType$1 = never, TPendingChainingFilter extends ChainingFilterType$1 = never, TComponentExport = never> extends BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport> {
+    private _$definitionFilter;
+    /** Define a chaining filter */
+    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;
+    }, TComponentExport>, TChainingFilter>;
+    /** Use another behavior */
+    behavior<UData extends DataList$2, UProperty extends PropertyList$2, UMethod extends MethodList$2, UChainingFilter extends ChainingFilterType$1>(behavior: Behavior<UData, UProperty, UMethod, UChainingFilter>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData & UData, TProperty & UProperty, TMethod & UMethod, UChainingFilter, TPendingChainingFilter, TComponentExport>, UChainingFilter>;
+    /** Set the export value when the component is being selected */
+    export<TNewComponentExport>(f: (this: GeneralComponent, source: GeneralComponent | null) => TNewComponentExport): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport>, 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$2>(gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<BehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /**
+     * Add a single property
+     *
+     * The property name should be different from other properties.
+     */
+    property<N extends string, T extends PropertyType$1, V extends PropertyTypeToValueType$1<T>>(name: N, def: N extends keyof (TData & TProperty) ? never : typeUtils.PropertyListItem<T, V>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty & Record<N, unknown extends V ? T : typeUtils.PropertyOption<T, V>>, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /**
+     * Add some public methods
+     *
+     * The public method can be used as an event handler, and can be visited in component instance.
+     */
+    methods<T extends MethodList$2>(funcs: T & ThisType<Component<TData, TProperty, TMethod & T, any>>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter, TComponentExport>, 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$1<(...args: any[]) => any>> | void>(func: (this: Component<TData, TProperty, TMethod, TComponentExport>, builderContext: BuilderContext<TPrevData, TProperty, Component<TData, TProperty, TMethod, TComponentExport>>) => TExport): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /** Apply a classic definition object */
+    definition<TNewData extends DataList$2 = Empty$2, TNewProperty extends PropertyList$2 = Empty$2, TNewMethod extends MethodList$2 = Empty$2, TNewComponentExport = never>(def: BehaviorDefinition<TNewData, TNewProperty, TNewMethod, TNewComponentExport> & ThisType<Component<TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TNewComponentExport>>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport>, TChainingFilter>;
+    /**
+     * Finish the behavior definition process
+     */
+    register(): Behavior<TData, TProperty, TMethod, TPendingChainingFilter, TComponentExport>;
+}
+
+type Empty$1 = typeUtils.Empty;
+type DataList$1 = typeUtils.DataList;
+type PropertyList$1 = typeUtils.PropertyList;
+type PropertyType = typeUtils.PropertyType;
+type PropertyTypeToValueType<T extends PropertyType> = typeUtils.PropertyTypeToValueType<T>;
+type MethodList$1 = typeUtils.MethodList;
+type ChainingFilterType = typeUtils.ChainingFilterType;
+type ComponentMethod = typeUtils.ComponentMethod;
+type TaggedMethod<Fn extends ComponentMethod> = typeUtils.TaggedMethod<Fn>;
+/**
+ * A direct way to create a component
+ */
+declare class ComponentBuilder<TPrevData extends DataList$1 = Empty$1, TData extends DataList$1 = Empty$1, TProperty extends PropertyList$1 = Empty$1, TMethod extends MethodList$1 = Empty$1, TChainingFilter extends ChainingFilterType = never, TPendingChainingFilter extends ChainingFilterType = never, TComponentExport = never> extends BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport> {
+    private _$is;
+    private _$alias?;
+    private _$options?;
+    private _$proto?;
+    /**
+     * Set the component options
+     *
+     * If called multiple times, only the latest call is valid.
+     */
+    options(options: ComponentDefinitionOptions): ResolveBehaviorBuilder<this, TChainingFilter>;
+    /** Use another behavior */
+    behavior<UData extends DataList$1, UProperty extends PropertyList$1, UMethod extends MethodList$1, UChainingFilter extends ChainingFilterType, UComponentExport>(behavior: Behavior<UData, UProperty, UMethod, UChainingFilter, UComponentExport>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData & UData, TProperty & UProperty, TMethod & UMethod, UChainingFilter, TPendingChainingFilter, UComponentExport>, UChainingFilter>;
+    /** Set the export value when the component is being selected */
+    export<TNewComponentExport>(f: (this: GeneralComponent, source: GeneralComponent | null) => TNewComponentExport): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport>, 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$1>(gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<ComponentBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, 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 : typeUtils.PropertyListItem<T, V>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty & Record<N, unknown extends V ? T : typeUtils.PropertyOption<T, V>>, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /**
+     * Add some public methods
+     *
+     * The public method can be used as an event handler, and can be visited in component instance.
+     */
+    methods<T extends MethodList$1>(funcs: T & ThisType<Component<TData, TProperty, TMethod & T, any>>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter, TComponentExport>, 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: Component<TData, TProperty, TMethod, TComponentExport>, builderContext: BuilderContext<TPrevData, TProperty, Component<TData, TProperty, TMethod, TComponentExport>>) => TExport): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /** Apply a classic definition object */
+    definition<TNewData extends DataList$1 = Empty$1, TNewProperty extends PropertyList$1 = Empty$1, TNewMethod extends MethodList$1 = Empty$1, TNewComponentExport = never>(def: ComponentDefinition<TNewData, TNewProperty, TNewMethod, TNewComponentExport> & ThisType<Component<TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TNewComponentExport>>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport>, TChainingFilter>;
+    pageDefinition<TNewData extends DataList$1, TNewExtraFields extends {
+        [k: PropertyKey]: any;
+    }>(def: PageDefinition<TNewData, TNewExtraFields> & ThisType<Component<TData & TNewData, TProperty, TMethod & TNewExtraFields, undefined>>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData & TNewData, TProperty, TMethod & TNewExtraFields, TChainingFilter, TPendingChainingFilter, TComponentExport>, TChainingFilter>;
+    /**
+     * Finish the component definition process
+     */
+    register(): ComponentType<TData, TProperty, TMethod, TComponentExport>;
+}
+
+interface PageConstructor {
+    <TData extends DataList, TNewExtraFields extends {
+        [k: PropertyKey]: any;
+    }>(definition: PageDefinition<TData, TNewExtraFields> & ThisType<Component<TData, Empty, TNewExtraFields, undefined>>): void;
+}
+interface ComponentConstructor {
+    (): ComponentBuilder;
+    <TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList, TComponentExport>(definition: ComponentDefinition<TData, TProperty, TMethod, TComponentExport> & ThisType<Component<TData, TProperty, TMethod, TComponentExport>>): void;
+}
+interface BehaviorConstructor {
+    (): BehaviorBuilder;
+    <TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList, TComponentExport>(definition: BehaviorDefinition<TData, TProperty, TMethod, TComponentExport>): Behavior<TData, TProperty, TMethod, never>;
+    trait<TIn extends {
+        [key: string]: any;
+    }>(): TraitBehavior<TIn, TIn>;
+    trait<TIn extends {
+        [key: string]: any;
+    }, TOut extends {
+        [key: string]: any;
+    }>(trans: (impl: TIn) => TOut): TraitBehavior<TIn, TOut>;
+}
+interface ComponentEnv {
+    Page: PageConstructor;
+    Component: ComponentConstructor;
+    Behavior: BehaviorConstructor;
+}
+type Empty = typeUtils.Empty;
+type DataList = typeUtils.DataList;
+type PropertyList = typeUtils.PropertyList;
+type MethodList = typeUtils.MethodList;
+/**
+ * A component space with mini-program code manager
+ */
+declare class CodeSpace {
+    private _$isMainSpace;
+    private space;
+    private styleScopeManager;
+    private staticConfigMap;
+    private styleSheetMap;
+    private compiledTemplateMap;
+    private waitingAliasMap;
+    isMainSpace(): boolean;
+    /**
+     * Get the underlying component space
+     */
+    getComponentSpace(): glassEasel.ComponentSpace;
+    /**
+     * Add a behavior for all components
+     *
+     * Must be called before any component registration so that the component will use this behavior.
+     * Set to `null` to disable this behavior.
+     */
+    setOverallBehavior(behavior: glassEasel.GeneralBehavior): void;
+    /**
+     * Import another component space as a plugin (must be in the same environment)
+     *
+     * Components from the imported `codeSpace` can be used with URLs.
+     * If `domainAlias` is provided, the URL format is `plugin://DOMAIN_ALIAS/COMPONENT_SPACE_EXPORT_ALIAS` .
+     * If `privateImport` is enabled, another URL format is `plugin-private://DOMAIN/COMPONENT_IS` .
+     */
+    importCodeSpace(id: string, domainAlias?: string, privateImport?: boolean): void;
+    /**
+     * Add a style sheet URL with style scope name
+     *
+     * The URL should be recognized by the target backend.
+     * The `path` should not contain the `.wxss` suffix.
+     */
+    addStyleSheet(path: string, styleSheetUrl: string, styleScopeName?: string): void;
+    /**
+     * Get a style sheet URL
+     *
+     * The URL should be recognized by the target backend.
+     * The `path` should not contain the `.wxss` suffix.
+     */
+    getStyleSheet(path: string): string | undefined;
+    getStyleScopeName(path: string): string | undefined;
+    /**
+     * Add a compiled template
+     *
+     * The content is the execution result of the generated string of the template compiler.
+     * The `path` should not contain the `.wxml` suffix.
+     */
+    addCompiledTemplate(path: string, content: glassEasel.template.ComponentTemplate): void;
+    /**
+     * Get a compiled template
+     *
+     * The content is the execution result of the generated string of the template compiler.
+     * The `path` should not contain the `.wxml` suffix.
+     */
+    getCompiledTemplate(path: string): glassEasel.template.ComponentTemplate | undefined;
+    /**
+     * Add a static JSON config
+     *
+     * The `path` should not contain the `.json` suffix.
+     */
+    addComponentStaticConfig(path: string, content: ComponentStaticConfig): void;
+    /**
+     * Get a static JSON config
+     *
+     * The `path` should not contain the `.json` suffix.
+     */
+    getComponentStaticConfig(path: string): ComponentStaticConfig | undefined;
+    /**
+     * Create a component definition environment
+     *
+     * During the sync execution of `cb` , `Component` and `Behavior` global vars will be available.
+     * `globalObject` should be the JavaScript global object, a.k.a. `window` in DOM.
+     * Some global variables, a.k.a `Component` `Behavior` `Page` ,
+     * will be written into `globalObject` .
+     * `path` should be the component path (without ".js" extension).
+     */
+    globalComponentEnv<T>(globalObject: any, path: string, cb: () => T): T;
+    /**
+     * Create a component definition environment
+     *
+     * Like `globalComponentEnv` , but the global variables are given as callback arguments.
+     */
+    componentEnv<T>(path: string, cb: (env: ComponentEnv) => T): T;
+    /**
+     * Build a component outside of a definition environment
+     *
+     * The method do not need a definition environment, so the global object pollution is avoided.
+     * `path` should be the component path (without ".js" extension).
+     */
+    component(path: string): ComponentBuilder;
+    /**
+     * Build a behavior outside of a definition environment
+     *
+     * The method do not need a definition environment, so the global object pollution is avoided.
+     * `path` should be the component path (without ".js" extension).
+     */
+    behavior(): BehaviorBuilder;
+    /**
+     * Define a trait behavior
+     */
+    traitBehavior<TIn extends {
+        [key: string]: any;
+    }>(): TraitBehavior<TIn, TIn>;
+    traitBehavior<TIn extends {
+        [key: string]: any;
+    }, TOut extends {
+        [key: string]: any;
+    }>(trans: (impl: TIn) => TOut): TraitBehavior<TIn, TOut>;
+}
+
+/**
+ * A backend context that has been associated to an environment
+ */
+declare class AssociatedBackend {
+    private _$env;
+    /**
+     * Register a style sheet resource
+     *
+     * Some backend cannot load style sheet URL.
+     * In this cases, the content should be registered here.
+     */
+    registerStyleSheetContent(url: string, content: any): void;
+    /**
+     * Create a root component in specified backend
+     *
+     * The component is searched in the `codeSpace` with `url` .
+     * If `url` contains "?" params, it will be parsed and try to set to component properties.
+     */
+    createRoot(tagName: string, codeSpace: CodeSpace, url: string, genericTargets?: {
+        [key: string]: string;
+    }): Root;
+}
+/**
+ * A root component
+ */
+declare class Root {
+    private _$comp;
+    /**
+     * Get the underlying component
+     */
+    getComponent(): glassEasel.GeneralComponent;
+    /**
+     * Attach the root component to the backend
+     *
+     * This component, the `parent` and the `placeholder` MUST be in the same context.
+     * The `parent` MUST be a parent node of the `placeholder` .
+     * This also triggers `attached` lifetimes for components.
+     */
+    attach(parent: glassEasel.GeneralBackendElement, placeholder: glassEasel.GeneralBackendElement): void;
+    /**
+     * Release the root component
+     *
+     * Some backends require this explicit call to avoid memory leaks.
+     * This also triggers `detached` lifetimes for components.
+     */
+    release(): void;
+}
+
+/**
+ * A mini-program API environment
+ *
+ * Each environment manages multiple backend contexts.
+ * However, a backend context should be exclusively managed by a single environment
+ * (to avoid `StyleScopeId` confliction).
+ * It is able to create multiple `CodeSpace` within the environment.
+ */
+declare class MiniProgramEnv {
+    private codeSpaceMap;
+    private globalCodeSpace;
+    /**
+     * Create an empty mini-program API environment
+     */
+    constructor();
+    /**
+     * Get a global code space in which global components can be defined
+     *
+     * External glass-easel based components can be defined in this code space.
+     * All global components should be defined before any other `CodeSpace` created!
+     */
+    getGlobalCodeSpace(): CodeSpace;
+    /**
+     * Associate a backend context
+     *
+     * If `backendContext` is not given, the DOM-based backend is used
+     * (causes failure if running outside browsers).
+     * The backend context SHOULD NOT be associated by other environments!
+     */
+    associateBackend(backendContent?: glassEasel.GeneralBackendContext): AssociatedBackend;
+    /**
+     * Create a component space that can manage WXML, WXSS, JS and static JSON config files
+     *
+     * The space can be specified as a *main* space.
+     * This makes some features available:
+     * * the `app.wxss` will be used as a style sheet for all root components in the space;
+     * * the `StyleIsolation.Shared` is accepted for components in the space.
+     * Non-main spaces usually act as plugins.
+     * `publicComponents` is a map for specifying a map of aliases and component paths.
+     */
+    createCodeSpace(id: string, isMainSpace: boolean, publicComponents?: {
+        [alias: string]: string;
+    }): CodeSpace;
+    /**
+     * Get a component space by the `id` specified when created
+     */
+    getCodeSpace(id: string): CodeSpace | undefined;
+}
+
+export { AssociatedBackend, type BehaviorConstructor, CodeSpace, type ComponentConstructor, type ComponentEnv, MiniProgramEnv, type PageConstructor, Root, component, types };