ngx-axis-appforge 0.0.2 → 0.0.3

package/core/index.d.ts

@@ -0,0 +1,773 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, AfterViewInit, Injector, Type, ComponentRef, PipeTransform, ChangeDetectorRef, InjectionToken, AfterContentInit, ViewContainerRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, BehaviorSubject, Subject } from 'rxjs';
+import { AbstractControl, ControlValueAccessor, FormBuilder, UntypedFormGroup, NgModel, Validators, ValidationErrors, ValidatorFn, FormGroup, FormArray } from '@angular/forms';
+import { NzDropdownMenuComponent } from 'ng-zorro-antd/dropdown';
+import * as ngx_axis_appforge_core from 'ngx-axis-appforge/core';
+import { NzMessageService } from 'ng-zorro-antd/message';
+import { NzCheckboxOption } from 'ng-zorro-antd/checkbox';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+import { NzTreeNodeOptions, NzTreeComponent, NzFormatEmitEvent, NzFormatBeforeDropEvent, NzTreeNode } from 'ng-zorro-antd/tree';
+import { NzFilterOptionType } from 'ng-zorro-antd/select';
+
+interface EventHandlerOptions<T> {
+    name: string;
+    disabled?: boolean;
+    target: "service" | "component" | "scope";
+    data?: T;
+    id?: string;
+    triggeEvents?: TriggeEventsOptions;
+    tempDataSource?: any;
+    ref?: Base<BaseOptions>;
+}
+
+type TriggeEventsOptions = {
+    [trigger: string]: EventHandlerOptions<any>[];
+};
+
+declare class BaseOptions {
+    component: string;
+    id: string;
+    inuse: _angular_core.WritableSignal<boolean>;
+    requiredPermissions: string[];
+    triggeEvents: _angular_core.WritableSignal<TriggeEventsOptions | undefined>;
+    style: _angular_core.WritableSignal<any>;
+}
+
+interface ApiOptions {
+    url: string;
+    method?: "get" | "post" | "put" | "delete";
+    body?: any;
+}
+
+interface DataSourceOptions {
+    name: string;
+    skipOnExists?: boolean;
+    type: "api" | "local" | "inject" | "cache";
+    api?: ApiOptions;
+    data?: any;
+    injectField?: string;
+    cacheKey?: string;
+}
+
+interface Initobs {
+    init?: any;
+    obs?: Observable<any>;
+    firstDefinedFields?: string[];
+    definedFields?: string[];
+}
+
+declare class ScopeDirective implements OnInit, OnDestroy {
+    constructor();
+    private oriDataSources?;
+    private readonly http;
+    readonly axisScope: _angular_core.InputSignal<string>;
+    readonly scopeName: _angular_core.InputSignal<string>;
+    readonly isRoot: _angular_core.InputSignal<boolean>;
+    private readonly _parentScope;
+    readonly scripts: {
+        [name: string]: string;
+    } | null;
+    readonly injectData: any;
+    readonly injectFuncs: {
+        [name: string]: Function;
+    } | null;
+    readonly dataSources: _angular_core.InputSignal<DataSourceOptions[] | undefined>;
+    private readonly designBuilder;
+    private readonly ds;
+    private readonly updateDs;
+    private dynamicOptionsSubs;
+    private rootSubs;
+    private injectDataSub?;
+    private readonly instanceMap;
+    private readonly changeSubject;
+    private readonly latestUpdateOptions;
+    private get parentScope();
+    host: ElementRef<any>;
+    ngOnInit(): void;
+    private initDs;
+    private updateDataSource;
+    get(name: string, init?: boolean): Observable<any> | undefined;
+    snapshot(name: string): any;
+    snapshotAll(): any;
+    getSnapshoptAllWithScopeId(scopeId: string): any;
+    getAllWithScopeId(scopeId: string): Observable<any>;
+    dynamicField(obj: any, field: string, deep?: boolean, tempDataSource?: any): Initobs;
+    snapshotField(obj: any, field: string, tempDataSource?: any): any;
+    bindOptions(optionsConfig: any, options: any, tempDataSource?: any): Subscription[];
+    dynamicOptions(optionsConfig: any, deep?: boolean, tempDataSource?: any): Initobs;
+    snapshotOptions(optionsConfig: any, tempDataSource?: any): any;
+    registInstance(id: string, instance: Base<BaseOptions>): void;
+    unRegistInstance(id: string): void;
+    findInstance(id: string): Base<BaseOptions> | undefined;
+    findScope(scopeId: string): ScopeDirective | undefined;
+    ngOnDestroy(): void;
+    onEvents(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+    private setDataSourceEventHandler;
+    private refreshDataSourceEventHandler;
+    preloadImports(obj: any): Promise<void>;
+    runFnWithImports(fnstr: any, args: any, imports: string[]): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScopeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScopeDirective, "[axisScope]", never, { "axisScope": { "alias": "axisScope"; "required": true; "isSignal": true; }; "scopeName": { "alias": "scopeName"; "required": true; "isSignal": true; }; "isRoot": { "alias": "isRoot"; "required": false; "isSignal": true; }; "dataSources": { "alias": "dataSources"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class Base<T extends BaseOptions> implements OnDestroy, AfterViewInit {
+    onAfterViewInit?: Function;
+    injector: Injector;
+    isDesign: boolean;
+    protected options: T;
+    private eventsService;
+    private scope;
+    private _sub;
+    get style(): any;
+    ngAfterViewInit(): void;
+    preloadImports(optionsConfig: any): Promise<void>;
+    bindWithConfig(optionsConfig: any, config?: {
+        options?: any;
+        snapshot?: boolean;
+        tag?: string;
+        tempDataSource?: any;
+    }): void;
+    unsubscribeAll(): void;
+    unsubscribe(tags: string[]): void;
+    addSubscribe(sub: Subscription, tag?: string): void;
+    addAllSubscribe(subs: Subscription[], tag?: string): void;
+    onEvents?(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+    hasEventHandler(trigger: string, triggeEvents?: TriggeEventsOptions): boolean;
+    triggeEvents(trigger: string, tempDataSource?: any, triggeEvents?: TriggeEventsOptions, scope?: ScopeDirective): Observable<boolean>;
+    triggeEvent(e: EventHandlerOptions<unknown>, scope?: ScopeDirective): Observable<boolean>;
+    getScope(): ScopeDirective | null;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Base<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Base<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class ValueAccessOptions extends BaseOptions {
+    initValue: _angular_core.WritableSignal<any>;
+    emitInitEvent: _angular_core.WritableSignal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    readonly: _angular_core.WritableSignal<boolean>;
+}
+
+interface RegisteValueAccessOptions {
+    initValue?: any;
+    validFn?: (control: AbstractControl) => boolean;
+}
+interface RegisteFormControlOptions {
+    name: string;
+    control?: AbstractControl;
+    initValue?: any;
+}
+
+declare abstract class ValueAccess<T extends ValueAccessOptions> extends Base<T> implements ControlValueAccessor {
+    constructor();
+    protected readonly value: _angular_core.ModelSignal<any>;
+    private readonly registe;
+    setInitValue(value: any): void;
+    onChange?: (value: any) => void;
+    onTouched?: (value: any) => {};
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    onEvents(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+    protected registValueAccess(opt: RegisteValueAccessOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueAccess<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ValueAccess<any>, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+interface FunFieldOptions {
+    [field: string]: {
+        defaultValue?: any;
+        child?: FunFieldOptions;
+    };
+}
+
+declare abstract class FunFieldBase {
+    private orivalue;
+    protected readonly fb: FormBuilder;
+    abstract fg: UntypedFormGroup;
+    protected funFields: FunFieldOptions;
+    reset(value?: any): void;
+    getValue(): any;
+    valid(): boolean;
+    buildFunField(obj: any, funFields?: FunFieldOptions): any;
+    recoverFunField(obj: any, funFields?: FunFieldOptions, oriObj?: any): any;
+}
+
+declare abstract class FunFieldValueBase extends FunFieldBase implements OnInit, OnDestroy, ControlValueAccessor {
+    onChange: any;
+    protected readonly value: _angular_core.ModelSignal<any>;
+    protected readonly formValue: _angular_core.ModelSignal<any>;
+    private sub;
+    protected sendInitValue: boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    reset(value?: any): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunFieldValueBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FunFieldValueBase, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "formValue": { "alias": "formValue"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "formValue": "formValueChange"; }, never, never, true, never>;
+}
+
+declare class OptionsNode {
+    protected config: OptionsNodeConfig;
+    constructor(config: OptionsNodeConfig);
+    get id(): string;
+    get parentId(): string | undefined;
+    get scopeId(): string | undefined;
+    get name(): string | undefined;
+    get dragType(): string | undefined;
+    get dropType(): string | undefined;
+    get canSetting(): boolean;
+    get canDrag(): boolean;
+    get childDirection(): "horizontal" | "vertical";
+    get canDrop(): boolean;
+    get dropObj(): any;
+    get parentObj(): any;
+    get indexOfParentObj(): number | string | undefined;
+    get options(): any;
+    get defaultDropIndex(): number | string | undefined;
+    get isRoot(): boolean;
+    get icon(): string | undefined;
+    get children(): OptionsNode[] | undefined;
+    get settingType(): Type<FunFieldValueBase> | undefined;
+    get contextMenu(): Type<BaseMenu> | undefined;
+    toElementNode(elements: {
+        element?: HTMLElement;
+        dropElement?: HTMLElement;
+    }): ElementNode;
+    updateOptions(options: any): void;
+    copyWith(config: OptionsNodeConfig): OptionsNode;
+    refresh(): void;
+}
+declare class ElementNode {
+    id: string;
+    constructor(id: string, elements: {
+        element?: HTMLElement;
+        dropElement?: HTMLElement;
+    });
+    element?: HTMLElement;
+    dropElement?: HTMLElement;
+}
+interface OptionsNodeConfig {
+    id?: string;
+    updateId?: (newOptions: any) => string;
+    parentId?: string;
+    scopeId?: string;
+    name?: string;
+    canSetting?: boolean;
+    canDrag?: boolean;
+    canDrop?: boolean;
+    childDirection?: "horizontal" | "vertical";
+    dragType?: string;
+    dropType?: string;
+    parentObj?: any;
+    dropObj?: any;
+    indexOfParentObj?: number | string;
+    rootOptions?: any;
+    defaultDropIndex?: number | string;
+    settingType?: Type<FunFieldValueBase>;
+    icon?: string;
+    children?: OptionsNode[];
+    contextMenu?: Type<BaseMenu>;
+}
+
+declare abstract class BaseMenu {
+    private readonly contextMenuService;
+    readonly optionsNodes: {
+        current: OptionsNode;
+        parent?: OptionsNode;
+    };
+    menu: NzDropdownMenuComponent;
+    onChange: any;
+    contextMenu(e: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseMenu, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseMenu, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class DesignBuilder {
+    buildElement: (ref: ComponentRef<any>, options: any) => void;
+    buildScope: (scope: ScopeDirective) => void;
+    constructor(buildElement: (ref: ComponentRef<any>, options: any) => void, buildScope: (scope: ScopeDirective) => void);
+}
+
+declare class DynamicDirective implements ControlValueAccessor, OnDestroy {
+    readonly axisDynamic: _angular_core.InputSignal<any>;
+    readonly standalone: _angular_core.InputSignal<boolean>;
+    readonly isDesign: _angular_core.InputSignal<boolean>;
+    private component?;
+    private sub?;
+    private id?;
+    private readonly injector;
+    private _designBuilder;
+    private loader;
+    readonly currentUserPermissions: string[] | null;
+    private container;
+    private _scope;
+    private ref?;
+    private get scope();
+    private get designBuilder();
+    private get valueInstance();
+    onChange?: (value: any) => {};
+    onTouched?: (value: any) => {};
+    triggeEvent?: (e: EventHandlerOptions<any>) => Observable<boolean>;
+    onEvents?: (e: EventHandlerOptions<any>) => Observable<boolean> | undefined;
+    value: any;
+    constructor();
+    private hasPermission;
+    private render;
+    private buildInjector;
+    forceRender(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    destoryInstance(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DynamicDirective, "[axisDynamic]", ["axisDynamic"], { "axisDynamic": { "alias": "axisDynamic"; "required": true; "isSignal": true; }; "standalone": { "alias": "standalone"; "required": false; "isSignal": true; }; "isDesign": { "alias": "isDesign"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HowLongPipe implements PipeTransform {
+    private cdr;
+    constructor(cdr: ChangeDetectorRef);
+    timer?: any;
+    lastValue: string;
+    date?: Date;
+    ngOnDestroy(): void;
+    transform(date?: Date): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HowLongPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HowLongPipe, "axisHowLong", true>;
+}
+
+interface DesignBuildResult {
+    treeNode: OptionsNode;
+    next?: NextInfo[];
+    newScopes?: ScopeInfo[];
+}
+interface DesignBindElementsResult {
+    [id: string]: {
+        element?: HTMLElement;
+        dropElement?: HTMLElement;
+    };
+}
+interface NextInfo {
+    currentObject?: any;
+    parentObject?: any;
+    indexOfParent?: string | number;
+    parentId?: string;
+    scopeId?: string;
+}
+interface ScopeInfo {
+    scopeId: string;
+    scopeName: string;
+    parentScopeId?: string;
+    ds?: any;
+}
+
+interface EventDesc {
+    name: string;
+    title: string;
+    noListen?: boolean;
+    ds?: any;
+}
+interface EventHandlerDesc {
+    name: string;
+    title: string;
+    icon?: string;
+    target: "service" | "component" | "scope";
+    targetComponent?: string;
+    dataComponent?: Type<FunFieldValueBase>;
+    events?: EventDesc[];
+    formStyle?: {
+        width?: string;
+        labelSpan?: number;
+    };
+}
+interface EventHandlerDescGroup {
+    groupName: string;
+    handlerDescs: EventHandlerDesc[];
+}
+
+interface DesignConfig {
+    componentName: string;
+    eventHandlerDescs?: {
+        [name: string]: EventHandlerDesc;
+    };
+    buildOptionsNodes?(nextInfo: NextInfo): DesignBuildResult;
+    bindElementsOptionsNode?(element: HTMLElement, options: any): DesignBindElementsResult;
+}
+
+interface FlatNode {
+    expandable: boolean;
+    id: string;
+    title: string;
+    icon?: string;
+    level: number;
+}
+declare class FilteredTreeResult {
+    treeData: OptionsNode[];
+    needsToExpanded: string[];
+    constructor(treeData: OptionsNode[], needsToExpanded?: string[]);
+}
+
+declare class DataOptions extends BaseOptions {
+    data: _angular_core.WritableSignal<any>;
+}
+
+interface ExampleGroup {
+    groupName: string;
+    children: ExampleDesc[];
+}
+interface ExampleDesc {
+    component: string;
+    coverImg: string;
+    span: number;
+    height: number;
+    tags?: string[];
+    example: Example;
+    moreExamples?: Example[];
+}
+interface Example {
+    name?: string;
+    builder: ExampleBuilder;
+}
+type ExampleBuilder = (componentIdBuilder?: (component: string, offset?: number) => string) => any;
+
+interface Cmplib {
+    name: string;
+    cmpMap: {
+        [component: string]: () => Promise<any>;
+    };
+    examples: ExampleGroup[];
+}
+
+interface EventsHandler {
+    onEvents(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+}
+
+declare class ComponentsLoader {
+    private readonly components;
+    private readonly loadedMap;
+    private readonly loadingMap;
+    loadComponent(component: string): Promise<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentsLoader, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ComponentsLoader>;
+}
+
+declare const AXIS_DESIGN_OPTIONS_NODE_FOR_MENU: InjectionToken<{
+    current: OptionsNode;
+    parent?: OptionsNode;
+}>;
+declare const AXIS_DESIGN_SCOPE_INFOS_GETTER_TOKEN: InjectionToken<(scopeId?: string) => BehaviorSubject<ScopeInfo[]>>;
+declare const AXIS_DESIGN_COMPONENT_INFO_FOR_SETTING_TOKEN: InjectionToken<{
+    component: string;
+    componentName: string;
+    nodes: OptionsNode[];
+    eventHandlerDescs: {
+        [event: string]: EventHandlerDesc;
+    };
+}[]>;
+declare const AXIS_DESIGN_ALL_PERMISSIONS_TOKEN: InjectionToken<{
+    [permission: string]: string;
+}>;
+declare const AXIS_DESIGN_CHOOSE_COMPONENT_FUNC_TOKEN: InjectionToken<(...tags: string[]) => Observable<{
+    options?: any;
+    config?: DesignConfig;
+}>>;
+declare const AXIS_DESIGN_CMPLIBS_TOKEN: InjectionToken<{
+    libName: string;
+    lib: ExampleGroup[];
+}[]>;
+declare const AXIS_COMPONENTS_TOKEN: InjectionToken<{
+    [module: string]: () => Promise<any>;
+}>;
+declare const AXIS_COMPONENTS_LOADER_TOKEN: InjectionToken<ComponentsLoader>;
+declare const AXIS_SCRIPTS_TOKEN: InjectionToken<{
+    [name: string]: string;
+}>;
+declare const AXIS_EVENT_HANDLERS_TOKEN: InjectionToken<EventsHandler[]>;
+declare const AXIS_EVENT_HANDLER_DESCS_TOKEN: InjectionToken<EventHandlerDescGroup[]>;
+declare const AXIS_INJECT_DATA_TOKEN: InjectionToken<any>;
+declare const AXIS_INJECT_FUNC_TOKEN: InjectionToken<{
+    [name: string]: Function;
+}>;
+declare const AXIS_CURRENT_USER_PERMISSIONS_TOKEN: InjectionToken<string[]>;
+declare const AXIS_FORM_REGISTE_CONTROL_TOKEN: InjectionToken<(opt: RegisteFormControlOptions) => void>;
+declare const AXIS_FORMITEM_REGISTE_VALUE_ACCESS_TOKEN: InjectionToken<(opt: RegisteValueAccessOptions) => void>;
+
+declare class CommonMenu {
+    readonly baseMenu: _angular_core.InputSignal<BaseMenu>;
+    readonly chooseComponentFunc: (...tags: string[]) => rxjs.Observable<{
+        options?: any;
+        config?: ngx_axis_appforge_core.DesignConfig;
+    }>;
+    get canAddParent(): boolean;
+    get canAddChild(): boolean;
+    get canRemove(): boolean;
+    addParent(): void;
+    addChild(): void;
+    remove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommonMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommonMenu, "axis-common-menu", never, { "baseMenu": { "alias": "baseMenu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FunField implements ControlValueAccessor, OnDestroy, AfterContentInit {
+    private msg;
+    constructor(msg: NzMessageService);
+    readonly scopes: _angular_core.InputSignal<ScopeInfo[] | undefined>;
+    readonly exclude: _angular_core.InputSignal<string[] | undefined>;
+    readonly scopeId: _angular_core.InputSignal<string | undefined>;
+    readonly onlyFun: _angular_core.InputSignal<boolean>;
+    readonly noListen: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly getScopeInfos: (scopeId?: string) => rxjs.BehaviorSubject<ScopeInfo[]>;
+    readonly scopeInfos: _angular_core.Signal<ScopeInfo[] | undefined>;
+    readonly scripts: {
+        [name: string]: string;
+    } | null;
+    readonly funcs: {
+        [name: string]: Function;
+    } | null;
+    readonly funcsNames: string[];
+    readonly scopeds: _angular_core.Signal<ScopeInfo[]>;
+    readonly ds: _angular_core.Signal<any>;
+    readonly argsName: _angular_core.Signal<string>;
+    readonly importsList: _angular_core.Signal<NzCheckboxOption[]>;
+    readonly importDeclarations: _angular_core.WritableSignal<any[]>;
+    readonly showDataSource: _angular_core.WritableSignal<any>;
+    readonly editValue: _angular_core.WritableSignal<any>;
+    readonly editFn: _angular_core.WritableSignal<any>;
+    readonly editTip: _angular_core.InputSignal<string | undefined>;
+    funEditor?: DynamicDirective;
+    monaco?: any;
+    contentModel?: NgModel;
+    execFnSubject: Subject<void>;
+    successResult: any;
+    computeResult: _angular_core.WritableSignal<any>;
+    resultResultEditorMode: string;
+    isShowSuccessResult: boolean;
+    _sub: Subscription[];
+    ngOnDestroy(): void;
+    onChange: any;
+    value: _angular_core.ModelSignal<any>;
+    writeValue(v: FunFieldValue | undefined): void;
+    private updateContentValue;
+    registerOnChange(fn: any): void;
+    registerOnTouched(_: any): void;
+    _templateDataSource?: any[];
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly success: _angular_core.WritableSignal<string>;
+    readonly error: _angular_core.WritableSignal<string>;
+    readonly warn: _angular_core.WritableSignal<string>;
+    showCreateListenModal: _angular_core.ModelSignal<boolean>;
+    showAddImportModal: boolean;
+    createListenDataSourceName: _angular_core.ModelSignal<string>;
+    ngAfterContentInit(): void;
+    private buildScopeDs;
+    getDsNames(scope: ScopeInfo): string[];
+    private buildDs;
+    openFunModal(): void;
+    private buildArgsName;
+    private buildImportsList;
+    changeLinstenMode(name: string, mode: string): void;
+    changeImports(imports: string[]): void;
+    onCancel(): void;
+    onOk(): void;
+    toogleMode(): void;
+    changeValue(): void;
+    doShowDataSource(name: string): void;
+    copySuccess(): void;
+    addListen(): void;
+    removeListen(name: string): void;
+    buildImportDeclarations(): Promise<void>;
+    layoutEditor(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FunField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FunField, "axis-fun-field", never, { "scopes": { "alias": "scopes"; "required": false; "isSignal": true; }; "exclude": { "alias": "exclude"; "required": false; "isSignal": true; }; "scopeId": { "alias": "scopeId"; "required": false; "isSignal": true; }; "onlyFun": { "alias": "onlyFun"; "required": false; "isSignal": true; }; "noListen": { "alias": "noListen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "editTip": { "alias": "editTip"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "showCreateListenModal": { "alias": "showCreateListenModal"; "required": false; "isSignal": true; }; "createListenDataSourceName": { "alias": "createListenDataSourceName"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; "showCreateListenModal": "showCreateListenModalChange"; "createListenDataSourceName": "createListenDataSourceNameChange"; }, ["contentModel"], ["*"], true, never>;
+}
+interface FunFieldValue {
+    funMode: boolean;
+    originValue: any;
+    fnValue: any;
+}
+
+type MyErrorsOptions = {
+    'zh-cn': string;
+} & Record<string, NzSafeAny>;
+type MyValidationErrors = Record<string, MyErrorsOptions>;
+declare class FormValidators extends Validators {
+    static required(control: AbstractControl): ValidationErrors | null;
+    static requiredFun(control: AbstractControl): ValidationErrors | null;
+    static equal(comparedValue: string | (() => string | null)): (control: AbstractControl) => ValidationErrors | null;
+    static minLength(minLength: number): ValidatorFn;
+    static maxLength(maxLength: number): ValidatorFn;
+    static min(minvalue: number): ValidatorFn;
+    static max(maxvalue: number): ValidatorFn;
+    static pattern(pattern: string | RegExp): ValidatorFn;
+}
+
+declare class BaseDesignSetting implements AfterViewInit {
+    private element;
+    constructor(element: ElementRef);
+    readonly showLine: _angular_core.WritableSignal<boolean>;
+    readonly scopeId: _angular_core.InputSignal<string | undefined>;
+    readonly exclude: _angular_core.InputSignal<string[]>;
+    readonly allPermissions: [string, string][];
+    fg: _angular_core.InputSignal<UntypedFormGroup>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseDesignSetting, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseDesignSetting, "axis-base-design-setting", never, { "scopeId": { "alias": "scopeId"; "required": false; "isSignal": true; }; "exclude": { "alias": "exclude"; "required": false; "isSignal": true; }; "fg": { "alias": "fg"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare const baseFbConfig: {
+    id: ((typeof FormValidators.required)[] | undefined)[];
+    inuse: ((typeof FormValidators.requiredFun)[] | undefined)[];
+    requiredPermissions: never[];
+    style: never[];
+    triggeEvents: never[];
+};
+declare const baseFunField: FunFieldOptions;
+
+declare class InputTrigger extends FunFieldBase implements AfterViewInit {
+    private element;
+    constructor(element: ElementRef);
+    fg: UntypedFormGroup;
+    protected funFields: FunFieldOptions;
+    onChange: any;
+    readonly noListen: _angular_core.WritableSignal<boolean>;
+    readonly internalTriggers: _angular_core.InputSignal<"valueChange"[] | undefined>;
+    readonly getScopeInfos: (scopeId?: string) => BehaviorSubject<ScopeInfo[]>;
+    readonly componentsInfo: {
+        component: string;
+        componentName: string;
+        nodes: OptionsNode[];
+        eventHandlerDescs: {
+            [event: string]: EventHandlerDesc;
+        };
+    }[];
+    readonly canChooseComponentsInfo: _angular_core.WritableSignal<{
+        component: string;
+        componentName: string;
+        nodes: OptionsNode[];
+        eventHandlerDescs: {
+            [event: string]: EventHandlerDesc;
+        };
+    }[]>;
+    readonly value: _angular_core.ModelSignal<TriggeEventsOptions | undefined>;
+    readonly nodes: _angular_core.Signal<NzTreeNodeOptions[]>;
+    readonly eventDesc: _angular_core.InputSignal<EventDesc[] | undefined>;
+    readonly allEventDesc: _angular_core.Signal<EventDesc[]>;
+    readonly allEventHanderDescGroups: _angular_core.Signal<EventHandlerDescGroup[]>;
+    readonly allEventHanderDescs: _angular_core.Signal<{
+        [name: string]: EventHandlerDesc;
+    }>;
+    readonly showLine: _angular_core.WritableSignal<boolean>;
+    readonly isVisibleHandlerModal: _angular_core.ModelSignal<boolean>;
+    readonly handlerFunFieldScopes: _angular_core.WritableSignal<ScopeInfo[]>;
+    readonly editEventHandler: _angular_core.ModelSignal<EventHandlerOptions<any> | undefined>;
+    readonly treeExpandedKeys: _angular_core.WritableSignal<string[]>;
+    readonly selectedHandlerDesc: _angular_core.WritableSignal<EventHandlerDesc | undefined>;
+    readonly otherHandlerDescs: EventHandlerDescGroup[] | null;
+    tree: NzTreeComponent;
+    dataContainer?: ViewContainerRef;
+    readonly scopeInfoSubject: _angular_core.Signal<BehaviorSubject<ScopeInfo[]>>;
+    editInfo?: {
+        key: string;
+        event: string;
+        isAdd: boolean;
+        value?: EventHandlerOptions<any>;
+        parentValue?: EventHandlerOptions<any>;
+    };
+    filterOption: NzFilterOptionType;
+    writeValue(v: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    ngAfterViewInit(): void;
+    onDragStart(e: NzFormatEmitEvent): void;
+    beforeDrop: (e: NzFormatBeforeDropEvent) => Observable<boolean>;
+    private buildAllEventHandlerDescGroups;
+    private buildAllEventHandlerDescs;
+    private buildAllEventDesc;
+    private makeTreeNode;
+    deleteHandler(e: NzTreeNode): void;
+    private onValueChange;
+    startAddHandler(node: NzTreeNode): void;
+    startSetHandler(node: NzTreeNode): void;
+    private buildHandlerFunFieldScopes;
+    private buildScopeInfoSubject;
+    onHandlerChange(name: string | undefined): void;
+    onSetHandlerOk(): void;
+    resetSetHandler(): void;
+    hasExpanded(node: NzTreeNode): boolean;
+    expand(node: NzTreeNode, expanded: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputTrigger, "axis-input-trigger", never, { "internalTriggers": { "alias": "internalTriggers"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "eventDesc": { "alias": "eventDesc"; "required": false; "isSignal": true; }; "isVisibleHandlerModal": { "alias": "isVisibleHandlerModal"; "required": false; "isSignal": true; }; "editEventHandler": { "alias": "editEventHandler"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "isVisibleHandlerModal": "isVisibleHandlerModalChange"; "editEventHandler": "editEventHandlerChange"; }, never, never, true, never>;
+}
+
+declare class ValueDesignSetting implements AfterViewInit {
+    private element;
+    constructor(element: ElementRef);
+    readonly showLine: _angular_core.WritableSignal<boolean>;
+    readonly scopeId: _angular_core.InputSignal<string | undefined>;
+    readonly exclude: _angular_core.InputSignal<string[]>;
+    fg: _angular_core.InputSignal<UntypedFormGroup>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueDesignSetting, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueDesignSetting, "axis-value-design-setting", never, { "scopeId": { "alias": "scopeId"; "required": false; "isSignal": true; }; "exclude": { "alias": "exclude"; "required": false; "isSignal": true; }; "fg": { "alias": "fg"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare const valueFbConfig: {
+    initValue: never[];
+    emitInitEvent: (boolean | typeof FormValidators.required)[];
+    disabled: ((typeof FormValidators.requiredFun)[] | undefined)[];
+    readonly: ((typeof FormValidators.requiredFun)[] | undefined)[];
+};
+declare const valueFunField: FunFieldOptions;
+
+declare class DataHandler extends FunFieldValueBase {
+    readonly noListen: _angular_core.WritableSignal<boolean>;
+    fg: UntypedFormGroup;
+    protected funFields: FunFieldOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataHandler, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataHandler, "axis-data-handler", never, {}, {}, never, never, true, never>;
+}
+
+declare class SimpleMenu extends BaseMenu {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SimpleMenu, "axis-design-simple-menu", never, {}, {}, never, never, true, never>;
+}
+
+declare function listSort(list: Array<any>, compareField: string, reverse?: boolean): void;
+declare function trackByFn(trackByField: string): (index: number, item: any) => any;
+declare function copy(obj: any, deepCopy?: boolean): any;
+declare function deepMerge(...objs: any[]): any;
+declare function obj2Arr(obj: any): any[];
+declare function recursionArray(arr: any[], options: {
+    childrenField?: string;
+    before?: (node: any, level: number, parent?: any) => boolean | void;
+    after?: (node: any, level: number, parent?: any) => boolean | void;
+}, offsetLevel?: number, parent?: any): boolean | void;
+declare function recursionObject(obj: any, handler: (keys: string[], value: any, parent: any) => void, keys?: string[], parent?: any): void;
+declare function rebuildObject(targetObj: any, sourceObj: any): any;
+declare function assignDefaultField(targetObj: any, sourceObj: any): any;
+declare function isEquals(objA: any, objB: any): boolean;
+declare function objDiff(last: {
+    [k: string]: any;
+} | undefined | null, current: {
+    [k: string]: any;
+} | undefined | null): Set<string>;
+
+declare function updateAndValidAll(form: FormGroup | FormArray | AbstractControl, options?: {
+    markAsDirty?: boolean;
+}): boolean;
+
+declare function codeName(code?: string, name?: string): string;
+declare function nameCode(name?: string, code?: string): string;
+
+interface DynamicFnOptions {
+    fnBody?: string;
+    args?: any[] | object;
+}
+declare function fn(fnBody: string, argsObj: any, ignoreUndefined?: boolean, printError?: boolean): any;
+
+export { AXIS_COMPONENTS_LOADER_TOKEN, AXIS_COMPONENTS_TOKEN, AXIS_CURRENT_USER_PERMISSIONS_TOKEN, AXIS_DESIGN_ALL_PERMISSIONS_TOKEN, AXIS_DESIGN_CHOOSE_COMPONENT_FUNC_TOKEN, AXIS_DESIGN_CMPLIBS_TOKEN, AXIS_DESIGN_COMPONENT_INFO_FOR_SETTING_TOKEN, AXIS_DESIGN_OPTIONS_NODE_FOR_MENU, AXIS_DESIGN_SCOPE_INFOS_GETTER_TOKEN, AXIS_EVENT_HANDLERS_TOKEN, AXIS_EVENT_HANDLER_DESCS_TOKEN, AXIS_FORMITEM_REGISTE_VALUE_ACCESS_TOKEN, AXIS_FORM_REGISTE_CONTROL_TOKEN, AXIS_INJECT_DATA_TOKEN, AXIS_INJECT_FUNC_TOKEN, AXIS_SCRIPTS_TOKEN, Base, BaseDesignSetting, BaseMenu, BaseOptions, CommonMenu, ComponentsLoader, DataHandler, DataOptions, DesignBuilder, DynamicDirective, ElementNode, FilteredTreeResult, FormValidators, FunField, FunFieldBase, FunFieldValueBase, HowLongPipe, InputTrigger, OptionsNode, ScopeDirective, SimpleMenu, ValueAccess, ValueAccessOptions, ValueDesignSetting, assignDefaultField, baseFbConfig, baseFunField, codeName, copy, deepMerge, fn, isEquals, listSort, nameCode, obj2Arr, objDiff, rebuildObject, recursionArray, recursionObject, trackByFn, updateAndValidAll, valueFbConfig, valueFunField };
+export type { Cmplib, DataSourceOptions, DesignBindElementsResult, DesignBuildResult, DesignConfig, DynamicFnOptions, EventDesc, EventHandlerDesc, EventHandlerDescGroup, EventHandlerOptions, EventsHandler, Example, ExampleBuilder, ExampleDesc, ExampleGroup, FlatNode, FunFieldOptions, FunFieldValue, MyErrorsOptions, MyValidationErrors, NextInfo, RegisteFormControlOptions, RegisteValueAccessOptions, ScopeInfo, TriggeEventsOptions };