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[];
    context?: boolean;
};
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;
};
type ContextResult = {
    context: unknown;
};
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;
    context(cb?: (res: S extends true ? ContextResult : any[]) => 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 ResizeObserver {
    private _$comp;
    private _$observeAll;
    private _$mode;
    private _$observers;
    contentBox(): this;
    borderBox(): this;
    observe(targetSelector: string, listener: (status: glassEasel.backend.ResizeStatus) => 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 Empty$4 = typeUtils.Empty;
type PropertyValues<TProperty extends PropertyList$6> = typeUtils.PropertyValues<TProperty>;
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, UExtraThisFields extends DataList$6> = [UComponentExport] extends [never] ? Component<UData, UProperty, UMethod, UComponentExport, UExtraThisFields> : UComponentExport;
declare const determineComponentExports: (parent: GeneralBehavior[], selfExport: ((source: GeneralComponent | null) => any) | undefined) => ((source: GeneralComponent | null) => any) | undefined;
type GeneralComponent = Component<Record<string, any>, Record<string, any>, Record<string, any>, any, Record<string, any>>;
type Component<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport, TExtraThisFields extends DataList$6> = ComponentCaller<TData, TProperty, TMethod, TComponentExport> & {
    [k in keyof TMethod]: TMethod[k];
} & TExtraThisFields;
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 | undefined;
    /**
     * 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 a resize observer */
    createResizeObserver(options?: {
        observeAll?: boolean;
    }): ResizeObserver;
    /** 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, UExtraThisFields extends DataList$6>(selector: string, componentType: ComponentType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields>): ExportType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields> | 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, UExtraThisFields extends DataList$6>(selector: string, componentType: ComponentType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields>): ExportType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields>[];
    /**
     * 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, UExtraThisFields extends DataList$6>(componentType: ComponentType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields>): ExportType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields> | 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, UExtraThisFields extends DataList$6>(componentType: ComponentType<UData, UProperty, UMethod, UComponentExport, UExtraThisFields>): Component<UData, UProperty, UMethod, UComponentExport, UExtraThisFields> | null;
}
declare class ComponentProto<TData extends DataList$6, TProperty extends PropertyList$6, TMethod extends MethodList$5, TComponentExport, TExtraThisFields extends DataList$6> {
    private proto;
    constructor(methods: TMethod, parents: GeneralBehavior[], componentExport?: (source: GeneralComponent | null) => TComponentExport);
    derive(): Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>;
}

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, TExtraThisFields extends DataList$6> = Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>;
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, TExtraThisFields extends DataList$6> = ComponentProto<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>;
declare const component_ComponentProto: typeof ComponentProto;
type component_GeneralComponent = GeneralComponent;
type component_PropertyValues<TProperty extends PropertyList$6> = PropertyValues<TProperty>;
declare const component_determineComponentExports: typeof determineComponentExports;
declare namespace component {
  export { type component_AllData as AllData, type component_Component as Component, component_ComponentCaller as ComponentCaller, component_ComponentProto as ComponentProto, type Empty$4 as Empty, type component_GeneralComponent as GeneralComponent, type component_PropertyValues as PropertyValues, component_determineComponentExports as determineComponentExports };
}

type ResolveBehaviorBuilder<B, TChainingFilter extends ChainingFilterType$4> = typeUtils.IsNever<TChainingFilter> extends false ? TChainingFilter extends ChainingFilterType$4 ? Omit<B, TChainingFilter['remove']> & TChainingFilter['add'] : B : B;
type DataList$5 = typeUtils.DataList;
type PropertyList$5 = typeUtils.PropertyList;
type ChainingFilterType$4 = typeUtils.ChainingFilterType;
type ComponentMethod$4 = typeUtils.ComponentMethod;
type TaggedMethod$3<Fn extends ComponentMethod$4> = 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 | GeneralComponentType | 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$5, TProperty extends PropertyList$5, TMethodCaller> extends ThisType<TMethodCaller> {
    self: TMethodCaller;
    data: typeUtils.Merge<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>;
    setData: (this: void, newData: Partial<typeUtils.SetDataSetter<TPrevData>>, callback?: () => void) => void;
    implement: <TIn extends {
        [x: string]: any;
    }>(this: void, traitBehavior: TraitBehavior<TIn, any>, impl: TIn) => void;
    relation<TOut extends {
        [key: string]: any;
    }>(this: void, def: TraitRelationParams<TOut> & ThisType<TMethodCaller>): RelationHandler<any, TOut>;
    relation(this: void, def: RelationParams & ThisType<TMethodCaller>): RelationHandler<any, never>;
    observer<P extends typeUtils.ObserverDataPathStrings<typeUtils.DataWithPropertyValues<TPrevData, TProperty>>, V = typeUtils.GetFromObserverPathString<typeUtils.DataWithPropertyValues<TPrevData, TProperty>, P>>(this: void, 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]>;
    }>(this: void, paths: readonly [...P], func: (...newValues: V extends any[] ? V : never) => void): void;
    lifetime: <L extends keyof Lifetimes>(this: void, name: L, func: Lifetimes[L]) => void;
    pageLifetime: (this: void, name: string, func: (...args: any[]) => void) => void;
    method: <Fn extends ComponentMethod$4>(this: void, func: Fn) => TaggedMethod$3<Fn>;
    listener: <T>(this: void, func: glassEasel.EventListener<T>) => TaggedMethod$3<glassEasel.EventListener<T>>;
}

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;
    dynamicSlots?: boolean;
    pureDataPattern?: RegExp;
    virtualHost?: boolean;
    dataDeepCopy?: DeepCopyKind;
    propertyPassingDeepCopy?: DeepCopyKind;
    propertyEarlyInit?: boolean;
    propertyComparer?: (a: any, b: any) => boolean;
};
type ComponentMethod$3 = typeUtils.ComponentMethod;
type BehaviorDefinition<TData extends typeUtils.DataList, TProperty extends typeUtils.PropertyList, TMethod extends typeUtils.MethodList, TComponentExport> = {
    behaviors?: GeneralBehavior[];
    properties?: TProperty;
    data?: TData | (() => TData);
    observers?: {
        fields?: string;
        observer: ComponentMethod$3;
    }[] | {
        [fields: string]: ComponentMethod$3;
    };
    methods?: TMethod;
    created?: ComponentMethod$3;
    attached?: ComponentMethod$3;
    ready?: ComponentMethod$3;
    moved?: ComponentMethod$3;
    detached?: ComponentMethod$3;
    lifetimes?: {
        [name: string]: ComponentMethod$3;
    };
    pageLifetimes?: {
        [name: string]: ComponentMethod$3;
    };
    relations?: Record<string, RelationParams>;
    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$4 = typeUtils.DataList;
type PropertyList$4 = typeUtils.PropertyList;
type MethodList$4 = typeUtils.MethodList;
type ChainingFilterType$3 = 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, any, Record<string, any>>;
declare class Behavior<TData extends DataList$4, TProperty extends PropertyList$4, TMethod extends MethodList$4, TChainingFilter extends ChainingFilterType$3, TComponentExport, TExtraThisFields extends DataList$4> {
}
type ComponentFieldTypes<TData extends DataList$4, TProperty extends PropertyList$4, TMethod extends MethodList$4> = {
    propertyValues: PropertyValues<TProperty>;
    dataWithProperties: AllData<TData, TProperty>;
    methods: TMethod;
};
declare class ComponentType<TData extends DataList$4, TProperty extends PropertyList$4, TMethod extends MethodList$4, TComponentExport, TExtraThisFields extends DataList$4> {
    protected readonly _$fieldTypes: ComponentFieldTypes<TData, TProperty, TMethod>;
}
type GeneralComponentType = ComponentType<Record<string, any>, Record<string, any>, Record<string, any>, any, Record<string, any>>;
declare class TraitBehavior<TIn extends {
    [key: string]: any;
}, TOut extends {
    [key: string]: any;
} = TIn> {
    constructor(inner: glassEasel.TraitBehavior<TIn, TOut>);
}

type behavior_Behavior<TData extends DataList$4, TProperty extends PropertyList$4, TMethod extends MethodList$4, TChainingFilter extends ChainingFilterType$3, TComponentExport, TExtraThisFields extends DataList$4> = Behavior<TData, TProperty, TMethod, TChainingFilter, TComponentExport, TExtraThisFields>;
declare const behavior_Behavior: typeof Behavior;
type behavior_ComponentFieldTypes<TData extends DataList$4, TProperty extends PropertyList$4, TMethod extends MethodList$4> = ComponentFieldTypes<TData, TProperty, TMethod>;
type behavior_ComponentType<TData extends DataList$4, TProperty extends PropertyList$4, TMethod extends MethodList$4, TComponentExport, TExtraThisFields extends DataList$4> = ComponentType<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>;
declare const behavior_ComponentType: typeof ComponentType;
type behavior_DefinitionFilter = DefinitionFilter;
type behavior_GeneralBehavior = GeneralBehavior;
type behavior_GeneralComponentType = GeneralComponentType;
type behavior_TraitBehavior<TIn extends {
    [key: string]: any;
}, TOut extends {
    [key: string]: any;
} = TIn> = TraitBehavior<TIn, TOut>;
declare const behavior_TraitBehavior: typeof TraitBehavior;
declare namespace behavior {
  export { behavior_Behavior as Behavior, type behavior_ComponentFieldTypes as ComponentFieldTypes, behavior_ComponentType as ComponentType, type behavior_DefinitionFilter as DefinitionFilter, type behavior_GeneralBehavior as GeneralBehavior, type behavior_GeneralComponentType as GeneralComponentType, behavior_TraitBehavior as TraitBehavior };
}

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>;
type UnTaggedMethod$2<M extends TaggedMethod$2<any>> = typeUtils.UnTaggedMethod<M>;
declare class BaseBehaviorBuilder<TPrevData extends DataList$3, TData extends DataList$3, TProperty extends PropertyList$3, TMethod extends MethodList$3, TChainingFilter extends ChainingFilterType$2, TPendingChainingFilter extends ChainingFilterType$2, TComponentExport, TExtraThisFields extends DataList$3> {
    protected _$codeSpace: CodeSpace;
    protected _$: glassEasel.BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TExtraThisFields>;
    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;
    export<TNewComponentExport>(f: (this: GeneralComponent, source: GeneralComponent | null) => TNewComponentExport): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport, TExtraThisFields>, TChainingFilter>;
    /** Use another behavior */
    behavior<UData extends DataList$3, UProperty extends PropertyList$3, UMethod extends MethodList$3, UChainingFilter extends ChainingFilterType$2, UComponentExport, UExtraThisFields extends DataList$3>(behavior: Behavior<UData, UProperty, UMethod, UChainingFilter, UComponentExport, UExtraThisFields>): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData & UData, TProperty & UProperty, TMethod & UMethod, UChainingFilter, TPendingChainingFilter, UComponentExport, TExtraThisFields & UExtraThisFields>, UChainingFilter>;
    data<T extends DataList$3>(gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<BaseBehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, TChainingFilter>;
    staticData<T extends DataList$3>(data: typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<BaseBehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>, 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, TExtraThisFields>>): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>, 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, TExtraThisFields>, ...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, TExtraThisFields>, ...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, TExtraThisFields>, ...args: any[]) => any, once?: boolean): ResolveBehaviorBuilder<this, TChainingFilter>;
    /**
     * Add a relation
     */
    relation(name: string, rel: RelationParams & ThisType<Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>>): ResolveBehaviorBuilder<this, TChainingFilter>;
    init<TExport extends Record<string, TaggedMethod$2<(...args: any[]) => any>> | void>(func: (this: Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>, builderContext: BuilderContext<TPrevData, TProperty, Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>>) => TExport): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod & (TExport extends void ? Empty$3 : {
        [K in keyof TExport]: UnTaggedMethod$2<TExport[K]>;
    }), TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>>): ResolveBehaviorBuilder<BaseBehaviorBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport, TExtraThisFields>, 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 UnTaggedMethod$1<M extends TaggedMethod$1<any>> = typeUtils.UnTaggedMethod<M>;
type ChainingFilterFunc<TAddedFields extends {
    [key: string]: any;
}, TRemovedFields extends string = never> = typeUtils.ChainingFilterFunc<TAddedFields, TRemovedFields>;
type DefaultBehaviorBuilder = BehaviorBuilder<Empty$2, Empty$2, Empty$2, Empty$2, never, never, never, Empty$2>;
declare class BehaviorBuilder<TPrevData extends DataList$2, TData extends DataList$2, TProperty extends PropertyList$2, TMethod extends MethodList$2, TChainingFilter extends ChainingFilterType$1, TPendingChainingFilter extends ChainingFilterType$1, TComponentExport, TExtraThisFields extends DataList$2> extends BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields> {
    private _$definitionFilter;
    private _$chainingFilter?;
    /** 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, TExtraThisFields>, TChainingFilter>;
    /** Use another behavior */
    behavior<UData extends DataList$2, UProperty extends PropertyList$2, UMethod extends MethodList$2, UChainingFilter extends ChainingFilterType$1, UComponentExport, UExtraThisFields extends DataList$2>(behavior: Behavior<UData, UProperty, UMethod, UChainingFilter, UComponentExport, UExtraThisFields>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData & UData, TProperty & UProperty, TMethod & UMethod, UChainingFilter, TPendingChainingFilter, UComponentExport, TExtraThisFields & UExtraThisFields>, 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, TExtraThisFields>, 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 instance creation.
     */
    data<T extends DataList$2>(gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<BehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, TChainingFilter>;
    /**
     * Add some template data fields
     *
     * The data should be JSON-compatible, and will be cloned during component creation.
     */
    staticData<T extends DataList$2>(data: typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<BehaviorBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>, 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, TExtraThisFields>>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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.
     */
    init<TExport extends Record<string, TaggedMethod$1<(...args: any[]) => any>> | void>(func: (this: Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>, builderContext: BuilderContext<TPrevData, TProperty, Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>>) => TExport): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod & (TExport extends void ? Empty$2 : {
        [K in keyof TExport]: UnTaggedMethod$1<TExport[K]>;
    }), TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>>): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport, TExtraThisFields>, TChainingFilter>;
    /**
     * Finish the behavior definition process
     */
    register(): Behavior<TData, TProperty, TMethod, TPendingChainingFilter, TComponentExport, TExtraThisFields>;
    /**
     * Add extra this fields type
     */
    extraThisFieldsType<T extends DataList$2>(): ResolveBehaviorBuilder<BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields & T>, TChainingFilter>;
}

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>;
type UnTaggedMethod<M extends TaggedMethod<any>> = typeUtils.UnTaggedMethod<M>;
type DefaultComponentBuilder = ComponentBuilder<Empty$1, Empty$1, Empty$1, Empty$1, never, never, never, Empty$1>;
/**
 * A direct way to create a component
 */
declare class ComponentBuilder<TPrevData extends DataList$1, TData extends DataList$1, TProperty extends PropertyList$1, TMethod extends MethodList$1, TChainingFilter extends ChainingFilterType, TPendingChainingFilter extends ChainingFilterType, TComponentExport, TExtraThisFields extends DataList$1> extends BaseBehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields> {
    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, UExtraThisFields extends DataList$1>(behavior: Behavior<UData, UProperty, UMethod, UChainingFilter, UComponentExport, UExtraThisFields>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData & UData, TProperty & UProperty, TMethod & UMethod, UChainingFilter, TPendingChainingFilter, UComponentExport, TExtraThisFields & UExtraThisFields>, 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, TExtraThisFields>, 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 instance creation.
     */
    data<T extends DataList$1>(gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<ComponentBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, TChainingFilter>;
    /**
     * Add some template data fields
     *
     * The data should be JSON-compatible, and will be cloned during component creation.
     */
    staticData<T extends DataList$1>(data: typeUtils.NewFieldList<AllData<TData, TProperty>, T>): ResolveBehaviorBuilder<ComponentBuilder<T, TData & T, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>, 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, TExtraThisFields>>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty, TMethod & T, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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.
     */
    init<TExport extends Record<string, TaggedMethod<(...args: any[]) => any>> | void>(func: (this: Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>, builderContext: BuilderContext<TPrevData, TProperty, Component<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>>) => TExport): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty, TMethod & (TExport extends void ? Empty$1 : {
        [K in keyof TExport]: UnTaggedMethod<TExport[K]>;
    }), TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, 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, TExtraThisFields>>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData & TNewData, TProperty & TNewProperty, TMethod & TNewMethod, TChainingFilter, TPendingChainingFilter, TNewComponentExport, TExtraThisFields>, TChainingFilter>;
    pageDefinition<TNewData extends DataList$1, TNewExtraFields extends {
        [k: PropertyKey]: any;
    }>(def: PageDefinition<TNewData, TNewExtraFields> & ThisType<Component<TData & TNewData, TProperty, TMethod & TNewExtraFields, undefined, TExtraThisFields>>): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData & TNewData, TProperty, TMethod & TNewExtraFields, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>, TChainingFilter>;
    /**
     * Finish the component definition process
     */
    register(): ComponentType<TData, TProperty, TMethod, TComponentExport, TExtraThisFields>;
    /**
     * Add extra this fields type
     */
    extraThisFieldsType<T extends DataList$1>(): ResolveBehaviorBuilder<ComponentBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields & T>, TChainingFilter>;
}

type index_BehaviorBuilder<TPrevData extends DataList$2, TData extends DataList$2, TProperty extends PropertyList$2, TMethod extends MethodList$2, TChainingFilter extends ChainingFilterType$1, TPendingChainingFilter extends ChainingFilterType$1, TComponentExport, TExtraThisFields extends DataList$2> = BehaviorBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>;
declare const index_BehaviorBuilder: typeof BehaviorBuilder;
type index_BuilderContext<TPrevData extends DataList$5, TProperty extends PropertyList$5, TMethodCaller> = BuilderContext<TPrevData, TProperty, TMethodCaller>;
type index_ComponentBuilder<TPrevData extends DataList$1, TData extends DataList$1, TProperty extends PropertyList$1, TMethod extends MethodList$1, TChainingFilter extends ChainingFilterType, TPendingChainingFilter extends ChainingFilterType, TComponentExport, TExtraThisFields extends DataList$1> = ComponentBuilder<TPrevData, TData, TProperty, TMethod, TChainingFilter, TPendingChainingFilter, TComponentExport, TExtraThisFields>;
declare const index_ComponentBuilder: typeof ComponentBuilder;
type index_DefaultBehaviorBuilder = DefaultBehaviorBuilder;
type index_DefaultComponentBuilder = DefaultComponentBuilder;
declare namespace index {
  export { index_BehaviorBuilder as BehaviorBuilder, type index_BuilderContext as BuilderContext, index_ComponentBuilder as ComponentBuilder, type index_DefaultBehaviorBuilder as DefaultBehaviorBuilder, type index_DefaultComponentBuilder as DefaultComponentBuilder };
}

interface PageConstructor {
    <TData extends DataList, TNewExtraFields extends {
        [k: PropertyKey]: any;
    }>(definition: PageDefinition<TData, TNewExtraFields> & ThisType<Component<TData, Empty, TNewExtraFields, never, Empty>>): ComponentType<TData, Empty, TNewExtraFields, never, Empty>;
}
interface ComponentConstructor {
    (): DefaultComponentBuilder;
    <TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList, TComponentExport>(definition: ComponentDefinition<TData, TProperty, TMethod, TComponentExport> & ThisType<Component<TData, TProperty, TMethod, TComponentExport, Empty>>): ComponentType<TData, TProperty, TMethod, TComponentExport, Empty>;
}
interface BehaviorConstructor {
    (): DefaultBehaviorBuilder;
    <TData extends DataList, TProperty extends PropertyList, TMethod extends MethodList, TComponentExport>(definition: BehaviorDefinition<TData, TProperty, TMethod, TComponentExport> & ThisType<Component<TData, TProperty, TMethod, TComponentExport, Empty>>): Behavior<TData, TProperty, TMethod, never, TComponentExport, Empty>;
    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): DefaultComponentBuilder;
    /**
     * Build a behavior outside of a definition environment
     *
     * The method do not need a definition environment, so the global object pollution is avoided.
     */
    behavior(): DefaultBehaviorBuilder;
    /**
     * 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 root component
     */
    get(): ComponentCaller<any, any, any, any>;
    /**
     * Get the underlying component of the root 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, behavior, index as builder, component, types };