@scenemesh/entity-engine/dist/index.d.ts

一个“元数据驱动 + 组件适配 + 动态关系 + 视图管线”式的实体引擎。以 **Model + View + FieldType + SuiteAdapter + DataSource** 为五大支点，统一 CRUD / 查询 / 引用管理 / 视图渲染 / 扩展注册，支持在运行期无侵入拼装出 **表单、网格、主从、看板、仪表盘、流程/树形视图** 等多形态界面。

import { ZodTypeAny } from 'zod';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { ReactNode, DependencyList, EffectCallback } from 'react';

type EntityEvent<T = any> = {
    name: string;
    modelName?: string;
    objectId?: string;
    parameter: T;
};
interface IEntityEventEmitter {
    emit(event: EntityEvent): void;
}
interface IEntityEventNextDispatcher {
    dispatch(): Promise<void>;
}
interface IEntityEventListener<T = any> {
    (event: EntityEvent<T>, next: IEntityEventNextDispatcher): Promise<void>;
}
interface IEntityEventRegistry {
    registerListener(eventName: string, listener: IEntityEventListener): void;
    unregisterListener(eventName: string, listener: IEntityEventListener): void;
    emit(event: EntityEvent): void;
    getListeners(eventName: string): IEntityEventListener[];
}

type EntityFieldType = 'string' | 'number' | 'boolean' | 'date' | 'enum' | 'array' | 'json' | 'binary' | 'one_to_one' | 'one_to_many' | 'many_to_many' | 'many_to_one';
type EntityViewDensity = 'small' | 'medium' | 'large';
type OptionPrimitive = string | number | boolean | undefined;
type OptionValue = OptionPrimitive | OptionPrimitive[] | Options | Options[];
interface Options extends Record<string, OptionValue> {
    [key: string]: OptionValue;
}
interface IEntityField {
    name: string;
    title: string;
    type: EntityFieldType;
    typeOptions?: Options;
    description?: string;
    defaultValue?: any;
    isRequired?: boolean;
    isPrimaryKey?: boolean;
    isUnique?: boolean;
    editable?: boolean;
    searchable?: boolean;
    refModel?: string;
    refField?: string;
    schema?: ZodTypeAny;
    order?: number;
}
interface IEntityModelExternalConfig {
    type: string;
    url: string;
    tableName: string;
    mappings: Array<{
        local: string;
        remote: string;
    }>;
    features: string[];
}
interface IEntityModel {
    name: string;
    title: string;
    description?: string;
    fields: IEntityField[];
    external?: boolean;
    externalConfig?: IEntityModelExternalConfig;
}
interface IEntityViewField {
    name: string;
    title?: string;
    description?: string;
    icon?: string;
    widget?: string;
    widgetOptions?: Options;
    width?: number;
    flex?: 1 | 0;
    spanCols?: number;
    order?: number;
    fields?: IEntityViewField[];
    hiddenWhen?: string;
    showWhen?: string;
    requiredWhen?: string;
    readOnlyWhen?: string;
    disabledWhen?: string;
}
interface IEntityGridViewHilite {
    when: string;
    color: string;
}
interface IEntityViewPanel extends IEntityViewField {
    fields: IEntityViewField[];
}
interface IEntityViewReference extends IEntityViewField {
    referenceView?: {
        modelName: string;
        viewType: string;
    };
    referenceComp?: {
        moudlePath: string;
        componentName: string;
    };
    fields?: IEntityViewField[];
}
interface IEntityView {
    name: string;
    title: string;
    description?: string;
    modelName: string;
    viewType: string;
    viewOptions?: Options;
    items: IEntityViewField[];
    hilites?: IEntityGridViewHilite[];
    canEdit?: boolean;
    canNew?: boolean;
    canDelete?: boolean;
    density?: EntityViewDensity;
}

interface IEntityResult<T> {
    data: T | undefined;
    error?: string;
    isLoading: boolean;
    isSuccess: boolean;
    isError: boolean;
}
declare enum QueryOperator {
    NONE = "none",
    EQ = "eq",
    NE = "ne",
    GT = "gt",
    GTE = "gte",
    LT = "lt",
    LTE = "lte",
    CONTAINS = "contains",
    STARTS_WITH = "startsWith",
    ENDS_WITH = "endsWith",
    IN = "in",
    NOT_IN = "notIn",
    IS_NULL = "isNull",
    IS_NOT_NULL = "isNotNull",
    BETWEEN = "between"
}
interface ILeafCondition {
    field: string;
    operator: QueryOperator;
    value: any;
    value2?: any;
    and?: never;
    or?: never;
    not?: never;
}
interface ICompositeCondition {
    field?: never;
    operator?: never;
    value?: never;
    value2?: never;
    and?: IEntityQueryItem[];
    or?: IEntityQueryItem[];
    not?: IEntityQueryItem[];
}
type IEntityQueryItem = ILeafCondition | ICompositeCondition;
interface IEntityQuery {
    pageSize?: number;
    pageIndex?: number;
    sortBy?: {
        [key: string]: 'asc' | 'desc';
    };
    references?: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
    };
    filter?: IEntityQueryItem;
}
interface IEntityQueryItemMeta {
    field: IEntityField;
    operators: QueryOperator[];
    options?: {
        [key: string]: any;
    }[];
}
interface IEntityQueryMeta {
    queryItemMetas: IEntityQueryItemMeta[];
}
interface IEntityObject$1 {
    id: string;
    modelName: string;
    isDeleted?: boolean;
    createdAt?: Date;
    updatedAt?: Date;
    values: {
        [key: string]: any;
    };
}
interface IEntityObjectReference {
    id: number;
    fromModelName: string;
    fromFieldName: string;
    fromObjectId: string;
    toModelName: string;
    toObjectId: string;
    createdAt?: Date;
    updatedAt?: Date;
}
interface IEntityObjectReferenceProps {
    fromModelName: string;
    fromFieldName: string;
    fromObjectId: string;
}
interface EntityTreeNode {
    children: EntityTreeNode[];
    data: IEntityObject$1 | undefined | null;
    parentId: string | null | undefined;
}
interface IEntityDataSource {
    findPlainConfig(input: {
        modelName?: string;
        viewName?: string;
        configVersion?: string;
    }): Promise<{
        models: any[];
        views: any[];
    }>;
    findOne(input: {
        id: string;
        modelName?: string;
    }): Promise<IEntityObject$1 | undefined | null>;
    findMany(input: {
        modelName: string;
        query?: IEntityQuery;
        withAllReferences?: boolean;
    }): Promise<{
        data: IEntityObject$1[];
        count: number;
    }>;
    findTreeObjects(input: {
        modelName: string;
        fieldName: string;
        rootObjectId?: string;
    }): Promise<EntityTreeNode | EntityTreeNode[] | null>;
    findOneWithReferences(input: {
        modelName: string;
        id: string;
        includeFieldNames?: string[];
    }): Promise<IEntityObject$1 | undefined | null>;
    findManyWithReferences(input: {
        modelName: string;
        childrenFieldName: string;
        query?: IEntityQuery;
    }): Promise<{
        data: IEntityObject$1[];
        count: number;
    }>;
    findCount(input: {
        modelName: string;
        query?: IEntityQuery;
    }): Promise<number>;
    create(input: {
        modelName: string;
        data: Partial<IEntityObject$1>;
        reference?: IEntityObjectReferenceProps;
    }): Promise<IEntityObject$1 | null | undefined>;
    update(input: {
        id: string;
        data: Partial<IEntityObject$1>;
    }): Promise<boolean>;
    updateValues(input: {
        id: string;
        values: {
            [key: string]: any;
        };
    }): Promise<boolean>;
    delete(input: {
        id: string;
    }): Promise<boolean>;
    deleteMany(input: {
        ids: string[];
    }): Promise<boolean>;
    validate(input: {
        modelName: string;
        data: Partial<any>;
    }): Promise<boolean>;
    findReferences(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
    }): Promise<IEntityObjectReference[]>;
    findReferencesCount(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
    }): Promise<number>;
    createReference(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectId: string;
    }): Promise<IEntityObjectReference>;
    createReferences(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectIds: string[];
    }): Promise<number>;
    deleteReference(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectId: string;
    }): Promise<boolean>;
    deleteReferences(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectIds: string[];
    }): Promise<number>;
    findGroupedObjects(input: {
        modelName: string;
        groupBy: string | {
            field: string;
            format?: {
                type: 'time' | 'range';
                pattern: string;
            };
            withoutDetails?: boolean;
        };
        query?: IEntityQuery;
        aggregations?: {
            [fieldName: string]: 'count' | 'sum' | 'avg' | 'min' | 'max';
        };
        reference?: {
            fromModelName: string;
            fromFieldName: string;
            fromObjectId: string;
        };
        groupSortBy?: {
            [fieldName: string]: 'asc' | 'desc';
        };
        objectSortBy?: {
            [fieldName: string]: 'asc' | 'desc';
        };
    }): Promise<{
        groups: Array<{
            key: Record<string, any>;
            count: number;
            objects: IEntityObject$1[];
            aggregations?: Record<string, any>;
        }>;
        totalCount: number;
    }>;
}

interface IModelFieldTyper {
    get title(): string;
    get type(): string;
    get description(): string;
    getDefaultValue(field: IEntityFieldDelegate): any;
    getDefaultSchema(field: IEntityFieldDelegate): ZodTypeAny;
    getQueryItemMeta(field: IEntityFieldDelegate): IEntityQueryItemMeta | undefined;
    getDefaultWidgetType(viewType: string): string;
}

interface EntityCSSProperties extends React.CSSProperties {
    [key: string]: any;
}

interface IEntityFieldDelegate extends IEntityField {
}
interface IEntityModelDelegate extends IEntityModel {
    findPrimaryKeyFields(): IEntityField[];
    findUniqueFields(): IEntityField[];
    findFieldByName(name: string): IEntityField | undefined;
    findFieldByTitle(title: string): IEntityField | undefined;
    findSearchableFields(): IEntityField[];
    isSupportFeature(feature: string): boolean;
    get schema(): ZodTypeAny;
    toSupplementedValues(input: Record<string, any>): Record<string, any>;
    getQueryMeta(): IEntityQueryMeta;
}
interface IEntityViewFieldDelegate extends IEntityViewField {
}
interface IEntityViewDelegate extends IEntityView {
    toSupplementedView(viewOptions?: Record<string, any>): IEntityViewDelegate;
}
interface IEntityMetaRegistry {
    getModel(name: string): IEntityModelDelegate | undefined;
    findView(modelName: string, viewType: string, name?: string): IEntityViewDelegate | undefined;
    getView(name: string): IEntityViewDelegate | undefined;
    get models(): IEntityModelDelegate[];
    get views(): IEntityViewDelegate[];
    registerModel(model: IEntityModel): void;
    registerView(view: IEntityView): void;
    cleanup(): void;
    updateOrRegisterByPlainObject(config: {
        models: any[];
        views: any[];
    }): void;
    toJSONString(): string;
    toPlainModelObject(model: IEntityModelDelegate): Record<string, any>;
    toPlainViewObject(view: IEntityViewDelegate): Record<string, any>;
    fromJSONString(json: string): void;
}

interface IEntityServletRequest {
    req: Request;
    endpoint: string;
    engine: IEntityEnginePrimitive;
}
interface IEntityServletResponse {
    write(res: Response): void;
    read(): Response | undefined;
}
interface IEntityServlet {
    path: string;
    methods: ('GET' | 'POST' | 'PUT' | 'DELETE')[];
    handle: (req: IEntityServletRequest, res: IEntityServletResponse) => void;
}
interface IEntityServletRegistry {
    register: (servlet: IEntityServlet) => void;
    unregister: (path: string) => void;
    get: (path: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE') => IEntityServlet | undefined;
}

type EntityAction<T = any> = {
    name: string;
    modelName?: string;
    objectId?: string;
    parameter: T;
};
type EntityActionResultPayload<T = any> = {
    type: string;
    data?: T;
};
type EntityActionResult<T = any> = {
    success: boolean;
    message?: string;
    payload: EntityActionResultPayload<T>;
};
interface IEntityActionHandler<T = any, R = any> {
    actionNames: string[];
    handle: (action: EntityAction<T>, context: {
        engine: IEntityEnginePrimitive;
    }) => Promise<EntityActionResult<R>>;
}
interface IEntityRequestHandler {
    pathStartWith: string;
    handle: (req: Request) => Promise<Response>;
}
interface IEntityActionRegistry {
    registerActionHandler(handler: IEntityActionHandler): void;
    getActionHandler(actionName: string): IEntityActionHandler | undefined;
    registerRequestHandler(handler: IEntityRequestHandler): void;
    getRequestHandler(path: string): IEntityRequestHandler | undefined;
}

type EntityViewBehaviorMode = 'display' | 'edit';
type EntityViewBehaviorType = {
    mode?: EntityViewBehaviorMode;
    readonly?: boolean;
    disableEdit?: boolean;
    disableDelete?: boolean;
    disableNew?: boolean;
    toCreating?: boolean;
    toCreatingId?: string;
};
type EntityViewCallbacksType = {
    onObjectDeleted?: (obj: IEntityObject$1) => void;
    onObjectCreated?: (obj: IEntityObject$1) => void;
    onObjectUpdated?: (obj: IEntityObject$1) => void;
};
type EntityViewReferenceType = {
    fromModelName: string;
    fromFieldName: string;
    fromObjectId: string;
    toModelName: string;
};
type EntityViewProps = {
    model: IEntityModelDelegate;
    viewData: IEntityViewDelegate;
    baseObjectId?: string;
    reference?: EntityViewReferenceType;
    behavior: EntityViewBehaviorType;
    callbacks?: EntityViewCallbacksType;
};
interface IEntityViewMetaInfo {
    viewName: string;
    displayName: string;
    icon?: string;
    description?: string;
}
declare abstract class EntityView<P extends EntityViewProps = EntityViewProps> {
    abstract readonly info: IEntityViewMetaInfo;
    abstract readonly Component: React.FC<P>;
}
/**
 * 封装由表单控制库（如 react-hook-form）注入的属性
 * @template TValue - 字段值的类型
 */
type EntityWidgetFieldControlProps<TValue = any> = {
    name: string;
    value: TValue;
    onChange: (...event: any[]) => void;
    onBlur: () => void;
    ref: React.Ref<any>;
};
/**
 * 封装由表单控制库注入的字段状态
 */
type EntityWidgetFieldState = {
    invalid: boolean;
    isTouched: boolean;
    isDirty: boolean;
    error?: {
        type: string;
        message?: string;
    };
};
type EntityWidgetProps = {
    object?: IEntityObject$1;
    value: any;
    model: IEntityModelDelegate;
    view: IEntityViewDelegate;
    field: IEntityViewFieldDelegate;
    behavior: EntityViewBehaviorType;
    hasReference?: boolean;
    reference?: {
        referenceModel: IEntityModelDelegate;
        objectNum: number;
        object?: IEntityObject$1;
    };
    maintain?: EntityViewBehaviorType;
    options?: {
        [key: string]: any;
    };
    sx?: React.CSSProperties;
    fieldControl?: EntityWidgetFieldControlProps;
    fieldState?: EntityWidgetFieldState;
    style?: EntityCSSProperties;
    className?: string;
};
interface IEntityWidgetMetaInfo {
    widgetName: string;
    displayName: string;
    icon?: string;
    description?: string;
}
type EntityViewCapabilityDescriptor = {
    operators: Array<{
        name: string;
        category?: string;
        inputSchema?: ZodTypeAny;
        outputSchema?: ZodTypeAny;
        description?: string;
        flags?: string[];
    }>;
};
interface IEntityViewController {
    modelName: string;
    viewType: string;
    viewId: string;
    describe(): EntityViewCapabilityDescriptor;
    invoke<T = any, R = any>(operator: string, input?: T): Promise<R>;
}
declare abstract class EntityWidget<P extends EntityWidgetProps = EntityWidgetProps> {
    abstract readonly info: IEntityWidgetMetaInfo;
    abstract readonly Component: React.FC<P>;
}
interface IEntityComponentSuiteAdapter {
    suiteName: string;
    suiteVersion: string;
    getWidget(widgetName: string): EntityWidget | undefined;
    getWidgets(): EntityWidget[];
}
interface IEntityNamedRenderer {
    name: string;
    slotName?: string;
    disabled?: boolean;
    renderer: (props: any) => React.ReactNode;
}
interface IEntityComponentRegistry {
    registerView(view: EntityView): void;
    registerViewLoader(viewName: string, loader: () => EntityView): void;
    getView(viewName: string): EntityView | undefined;
    getViews(): EntityView[];
    registerAdapter(adapter: IEntityComponentSuiteAdapter): void;
    getAdapter(suiteName: string): IEntityComponentSuiteAdapter | undefined;
    getAdapters(): IEntityComponentSuiteAdapter[];
    registerRenderer(renderer: IEntityNamedRenderer): void;
    getRenderer(name: string): IEntityNamedRenderer | undefined;
    getRenderersBySlot(slotName: string): IEntityNamedRenderer[];
    registerViewController(controller: IEntityViewController): void;
    unregisterViewController(viewId: string): void;
    getViewController(modelName?: string, viewType?: string, viewId?: string): IEntityViewController | undefined;
    getAllViewControllers(): IEntityViewController[];
}

declare const EntityViewInspector: IEntityNamedRenderer;

declare class EntityComponentRegistry implements IEntityComponentRegistry {
    private _viewMap;
    private _viewFuncMap;
    private _suiteAdapters;
    private _renderers;
    private _viewControllers;
    constructor();
    getView(viewName: string): EntityView | undefined;
    getViews(): EntityView[];
    registerView(view: EntityView): void;
    registerViewLoader(viewName: string, loader: () => EntityView): void;
    registerAdapter(adapter: IEntityComponentSuiteAdapter): void;
    getAdapter(suiteName: string): IEntityComponentSuiteAdapter | undefined;
    getAdapters(): IEntityComponentSuiteAdapter[];
    registerRenderer(renderer: IEntityNamedRenderer): void;
    getRenderer(name: string): IEntityNamedRenderer | undefined;
    getRenderersBySlot(slotName: string): IEntityNamedRenderer[];
    registerViewController(controller: IEntityViewController): void;
    unregisterViewController(viewId: string): void;
    getViewController(modelName?: string, viewType?: string, viewId?: string): IEntityViewController | undefined;
    getAllViewControllers(): IEntityViewController[];
}

interface ImportReferenceData {
    fromFieldName: string;
    toObjectId: string;
}
interface ImportEntityData {
    id: string;
    modelName: string;
    values: Record<string, any>;
    references?: ImportReferenceData[];
}
type EntityModuleInfo = {
    name: string;
    description: string;
    provider: string;
    version: string;
    url?: string | undefined;
    dependencies?: string[] | undefined;
};
interface IEntityModule {
    readonly info: EntityModuleInfo;
    setupConfig(args: {
        models: IEntityModel[];
        views: IEntityView[];
        eventHandlers: {
            focusEventNames: string[];
            handler: IEntityEventListener<EntityEvent>;
        }[];
        actionHandlers: IEntityActionHandler[];
        servlets: IEntityServlet[];
    }): Promise<void>;
    setupComponents(args: {
        views: EntityView[];
        renderers: IEntityNamedRenderer[];
        widgets: EntityWidget[];
    }): Promise<void>;
    setupData(args: {
        entities: ImportEntityData[];
    }): Promise<void>;
}
interface IEntityModuleRegistry {
    registerModule(module: IEntityModule | string, clientSide?: boolean): Promise<IEntityModule[] | undefined>;
    getModule(name: string): IEntityModule | undefined;
    getAllModules(): IEntityModule[];
}

type EntitySessionData = {
    readonly email: string;
    readonly name: string;
    readonly avatar?: string;
    readonly roles?: string[];
    readonly id: string;
};
interface IEntitySession {
    isAuthenticated: () => boolean;
    update(): void;
    readonly sessionId?: string;
    readonly userInfo?: EntitySessionData;
    readonly updateTime?: number;
}
declare class EntitySession implements IEntitySession {
    readonly sessionId?: string | undefined;
    readonly userInfo?: EntitySessionData | undefined;
    readonly update: () => void;
    constructor(sessionId?: string | undefined, userInfo?: EntitySessionData | undefined, update?: () => void);
    isAuthenticated(): boolean;
}
interface IEntitySessionProvider {
    get providerType(): string;
    session(): Promise<IEntitySession>;
}
interface IEntitySessionManager {
    setProvider(provider: IEntitySessionProvider): void;
    getProvider(): IEntitySessionProvider | undefined;
    getSession(): Promise<IEntitySession>;
}

interface IModelFieldTyperRegistry {
    getFieldTyper(fieldType: string): IModelFieldTyper | undefined;
    registerFieldTyper(fieldType: IModelFieldTyper): void;
    getFieldTypers(): IModelFieldTyper[];
}

interface IEntityDataSourceFactory {
    getDataSource(): IEntityDataSource;
}

interface IEntityEngineInitializer {
    init(engine: IEntityEngine): Promise<void>;
}
interface IEntityEnginePrimitiveInitializer {
    init(engine: IEntityEnginePrimitive): Promise<void>;
}
interface IEntityEngineSettings {
    get baseUrl(): string;
    get endpoint(): string;
    setBaseUrl(baseUrl: string): void;
    setEndpoint(endpoint: string): void;
    getUrl(path: string): string;
    get authenticationEnabled(): boolean;
    set authenticationEnabled(value: boolean);
}
interface IEntityEnginePrimitive {
    get metaRegistry(): IEntityMetaRegistry;
    get fieldTyperRegistry(): IModelFieldTyperRegistry;
    get moduleRegistry(): IEntityModuleRegistry;
    get eventRegistry(): IEntityEventRegistry;
    get actionRegistry(): IEntityActionRegistry;
    get servletRegistry(): IEntityServletRegistry;
    get datasourceFactory(): IEntityDataSourceFactory;
    get sessionManager(): IEntitySessionManager;
    get settings(): IEntityEngineSettings;
    get createTime(): number;
    toString(): string;
    get version(): string;
    get isClientSide(): boolean;
}
interface IEntityEngine extends IEntityEnginePrimitive {
    get componentRegistry(): IEntityComponentRegistry;
}
interface IEntityEngineWatcher {
    onEntityEngineBeforeInit(args: {
        engine: IEntityEnginePrimitive | IEntityEngine;
        clientSide: boolean;
    }): Promise<void>;
    onEntityEngineAfterInit(args: {
        engine: IEntityEnginePrimitive | IEntityEngine;
        clientSide: boolean;
    }): Promise<void>;
}

interface IEntityEngineTheme {
    colors: {
        primary: string;
        secondary: string;
        success: string;
        warning: string;
        error: string;
        background: {
            main: string;
            secondary: string;
            accent: string;
        };
        text: {
            primary: string;
            secondary: string;
            muted: string;
        };
        border: {
            default: string;
            light: string;
            strong: string;
        };
    };
    spacing: {
        xs: string;
        sm: string;
        md: string;
        lg: string;
        xl: string;
    };
    typography: {
        fontFamily: {
            sans: string;
            mono: string;
        };
        fontSize: {
            xs: string;
            sm: string;
            base: string;
            lg: string;
            xl: string;
        };
    };
    borderRadius: {
        sm: string;
        md: string;
        lg: string;
    };
    shadows: {
        sm: string;
        md: string;
        lg: string;
    };
}

interface IEntityEngineRouter {
    navigate: (path: string, state?: any) => void;
}

type EntityPermissionActionType = {
    modelName: string;
    action: 'create' | 'read' | 'update' | 'delete';
    objectId?: string;
    object?: IEntityObject$1;
};
interface IEntityPermissionGuard {
    checkPermission: (action: EntityPermissionActionType) => Promise<boolean>;
}

declare const entityEngineDefaultTheme: IEntityEngineTheme;

declare class EntityEventRegistry implements IEntityEventRegistry {
    private listeners;
    constructor();
    registerListener(eventName: string, listener: IEntityEventListener): void;
    unregisterListener(eventName: string, listener: IEntityEventListener): void;
    emit(event: EntityEvent): void;
    getListeners(eventName: string): IEntityEventListener[];
}

declare class EntityEngine implements IEntityEngine {
    private _metaRegistry;
    private _fieldTyperRegistry;
    private _moduleRegistry;
    private _datasourceFactory;
    private _eventRegistry;
    private _actionRegistry;
    private _servletRegistry;
    private _sessionManager;
    private _componentRegistry;
    private _settings;
    private _createTime;
    constructor(metaRegistry: IEntityMetaRegistry, fieldTyperRegistry: IModelFieldTyperRegistry, moduleRegistry: IEntityModuleRegistry, datasourceFactory: IEntityDataSourceFactory, eventRegistry: IEntityEventRegistry, actionRegistry: IEntityActionRegistry, servletRegistry: IEntityServletRegistry, sessionManager: IEntitySessionManager, renderRegistry: IEntityComponentRegistry, settings: IEntityEngineSettings);
    get metaRegistry(): IEntityMetaRegistry;
    get fieldTyperRegistry(): IModelFieldTyperRegistry;
    get moduleRegistry(): IEntityModuleRegistry;
    get datasourceFactory(): IEntityDataSourceFactory;
    get eventRegistry(): IEntityEventRegistry;
    get actionRegistry(): IEntityActionRegistry;
    get servletRegistry(): IEntityServletRegistry;
    get sessionManager(): IEntitySessionManager;
    get componentRegistry(): IEntityComponentRegistry;
    get isClientSide(): boolean;
    get createTime(): number;
    toString(): string;
    get version(): string;
    get settings(): IEntityEngineSettings;
    private static instance;
    private static instancePromise;
    static getInstance(initializer?: IEntityEngineInitializer): Promise<IEntityEngine>;
}
declare const getEntityEngine: typeof EntityEngine.getInstance;

declare class EntityActionRegistry implements IEntityActionRegistry {
    #private;
    constructor();
    registerActionHandler(handler: IEntityActionHandler): void;
    getActionHandler<T = any, R = any>(actionName: string): IEntityActionHandler<T, R> | undefined;
    registerRequestHandler(handler: IEntityRequestHandler): void;
    getRequestHandler(path: string): IEntityRequestHandler | undefined;
}

declare class EntitySessionManager implements IEntitySessionManager {
    #private;
    constructor(settings: IEntityEngineSettings);
    setProvider(provider: IEntitySessionProvider): void;
    getProvider(): IEntitySessionProvider | undefined;
    getSession(): Promise<IEntitySession>;
}

declare class EntityFieldDelegate implements IEntityFieldDelegate {
    private _field;
    constructor(field: IEntityField);
    get name(): string;
    get title(): string;
    get type(): EntityFieldType;
    get typeOptions(): {
        [key: string]: any;
    } | undefined;
    get description(): string | undefined;
    get defaultValue(): any;
    get isRequired(): boolean;
    get isPrimaryKey(): boolean;
    get isUnique(): boolean;
    get editable(): boolean;
    get searchable(): boolean;
    get refModel(): string | undefined;
    get refField(): string | undefined;
    get schema(): ZodTypeAny | undefined;
    get order(): number | undefined;
}
declare class EntityModelDelegate implements IEntityModelDelegate {
    private _model;
    private _typeRegistry;
    constructor(model: IEntityModel, typeRegistry: IModelFieldTyperRegistry);
    get name(): string;
    get title(): string;
    get description(): string | undefined;
    get external(): boolean | undefined;
    get externalConfig(): IEntityModelExternalConfig | undefined;
    isSupportFeature(feature: string): boolean;
    findPrimaryKeyFields(): IEntityField[];
    findUniqueFields(): IEntityField[];
    findFieldByName(name: string): IEntityField | undefined;
    findFieldByTitle(title: string): IEntityField | undefined;
    findSearchableFields(): IEntityField[];
    get schema(): ZodTypeAny;
    private getFieldSchema;
    toSupplementedValues(input: Record<string, any>): Record<string, any>;
    private getFieldDefaultValue;
    getQueryMeta(): IEntityQueryMeta;
    private getFieldQueryItemMeta;
    get fields(): IEntityField[];
}
declare class EntityViewFieldDelegate implements IEntityViewFieldDelegate {
    private _field;
    constructor(field: IEntityViewField);
    get name(): string;
    get title(): string | undefined;
    get description(): string | undefined;
    get icon(): string | undefined;
    get widget(): string | undefined;
    get widgetOptions(): {
        [key: string]: any;
    } | undefined;
    get width(): number | undefined;
    get flex(): 1 | 0 | undefined;
    get spanCols(): number | undefined;
    get order(): number | undefined;
    get fields(): IEntityViewField[] | undefined;
    get hiddenWhen(): string | undefined;
    get showWhen(): string | undefined;
    get readOnlyWhen(): string | undefined;
    get disabledWhen(): string | undefined;
    get requiredWhen(): string | undefined;
}
declare class EntityViewDelegate implements IEntityViewDelegate {
    private _view;
    private _metaRegistry;
    private _typeRegistry;
    constructor(view: IEntityView, metaRegistry: IEntityMetaRegistry, typeRegistry: IModelFieldTyperRegistry);
    get name(): string;
    get title(): string;
    get description(): string | undefined;
    get modelName(): string;
    get viewType(): string;
    get density(): EntityViewDensity | undefined;
    get viewOptions(): {
        [key: string]: any;
    } | undefined;
    get items(): IEntityViewField[];
    get hilites(): IEntityGridViewHilite[] | undefined;
    get canEdit(): boolean | undefined;
    get canNew(): boolean | undefined;
    get canDelete(): boolean | undefined;
    toSupplementedView(viewOptions?: Record<string, any>): EntityViewDelegate;
    private supplementField;
    private getFieldWidget;
}

declare class EntityMetaRegistry implements IEntityMetaRegistry {
    private _typeRegistry;
    private _models;
    private _views;
    private _eventEmitter;
    constructor(typeRegistry: IModelFieldTyperRegistry, eventEmitter: IEntityEventEmitter);
    getModel(name: string): IEntityModelDelegate | undefined;
    get models(): IEntityModelDelegate[];
    get views(): IEntityViewDelegate[];
    getView(name: string): IEntityViewDelegate | undefined;
    cleanup(): void;
    findView(modelName: string, viewType: string, name?: string): IEntityViewDelegate | undefined;
    registerModel(model: IEntityModel): void;
    registerView(view: IEntityView): void;
    toPlainModelObject(model: IEntityModelDelegate): Record<string, any>;
    toPlainViewObject(view: IEntityViewDelegate): Record<string, any>;
    updateOrRegisterByPlainObject(config: {
        models: any[];
        views: any[];
    }): void;
    toJSONString(): string;
    fromJSONString(json: string): void;
}

declare class ModelFieldTyperRegistry implements IModelFieldTyperRegistry {
    private _fieldTypes;
    constructor();
    getFieldTyper(fieldType: string): IModelFieldTyper | undefined;
    registerFieldTyper(fieldType: IModelFieldTyper): void;
    getFieldTypers(): IModelFieldTyper[];
}

declare class TRPCEntityObjectDataSource implements IEntityDataSource {
    private _settings;
    private _vanillaTrpcClient?;
    private _serverUrl;
    constructor(settings: IEntityEngineSettings);
    private get __vanillaTrpcClient();
    findPlainConfig(input: {
        modelName?: string;
        viewName?: string;
        configVersion?: string;
    }): Promise<{
        models: any[];
        views: any[];
    }>;
    findGroupedObjects(input: {
        modelName: string;
        groupBy: string | {
            field: string;
            format?: {
                type: 'time' | 'range';
                pattern: string;
            };
            withoutDetails?: boolean;
        };
        query?: IEntityQuery;
        aggregations?: {
            [fieldName: string]: 'count' | 'sum' | 'avg' | 'min' | 'max';
        };
        reference?: {
            fromModelName: string;
            fromFieldName: string;
            fromObjectId: string;
        };
        groupSortBy?: {
            [fieldName: string]: 'asc' | 'desc';
        };
        objectSortBy?: {
            [fieldName: string]: 'asc' | 'desc';
        };
    }): Promise<{
        groups: Array<{
            key: Record<string, any>;
            count: number;
            objects: IEntityObject$1[];
            aggregations?: Record<string, any>;
        }>;
        totalCount: number;
    }>;
    findOne(input: {
        id: string;
        modelName?: string;
    }): Promise<IEntityObject$1 | undefined | null>;
    findMany(input: {
        modelName: string;
        query?: any;
        withAllReferences?: boolean;
    }): Promise<{
        data: IEntityObject$1[];
        count: number;
    }>;
    findTreeObjects(input: {
        modelName: string;
        fieldName: string;
        rootObjectId?: string;
    }): Promise<EntityTreeNode | EntityTreeNode[] | null>;
    findOneWithReferences(input: {
        modelName: string;
        id: string;
        includeFieldNames?: string[];
    }): Promise<IEntityObject$1 | undefined | null>;
    create(input: {
        modelName: string;
        data: Partial<IEntityObject$1>;
        reference?: IEntityObjectReferenceProps;
    }): Promise<IEntityObject$1 | null | undefined>;
    update(input: {
        id: string;
        data: Partial<IEntityObject$1>;
    }): Promise<boolean>;
    updateValues(input: {
        id: string;
        values: {
            [key: string]: any;
        };
    }): Promise<boolean>;
    delete(input: {
        id: string;
    }): Promise<boolean>;
    deleteMany(input: {
        ids: string[];
    }): Promise<boolean>;
    findCount(input: {
        modelName: string;
        query?: any;
    }): Promise<number>;
    findManyWithReferences(input: {
        modelName: string;
        childrenFieldName: string;
        query?: any;
    }): Promise<{
        data: IEntityObject$1[];
        count: number;
    }>;
    findReferences(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
    }): Promise<IEntityObjectReference[]>;
    validate(input: {
        modelName: string;
        data: Partial<any>;
    }): Promise<boolean>;
    findReferencesCount(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
    }): Promise<number>;
    createReference(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectId: string;
    }): Promise<IEntityObjectReference>;
    createReferences(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectIds: string[];
    }): Promise<number>;
    deleteReference(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectId: string;
    }): Promise<boolean>;
    deleteReferences(input: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
        toObjectIds: string[];
    }): Promise<number>;
}

declare class EntityDataSourceFactory implements IEntityDataSourceFactory {
    private _dataSource;
    private _settings;
    constructor(settings: IEntityEngineSettings);
    getDataSource(): IEntityDataSource;
}

type EntityViewContainerProps = {
    modelName: string;
    viewType: string;
    viewName?: string;
    baseObjectId?: string;
    behavior?: EntityViewBehaviorType;
    callbacks?: EntityViewCallbacksType;
    reference?: {
        fromModelName: string;
        fromFieldName: string;
        fromObjectId: string;
        toModelName: string;
    };
    viewOptions?: {
        [key: string]: any;
    };
    containerName?: string;
    withoutProvider?: boolean;
};
declare function EntityViewContainer(props: EntityViewContainerProps): react_jsx_runtime.JSX.Element;

type EntityNamedRendererProps = {
    name?: string;
    slotName?: string;
    viewData?: IEntityViewDelegate;
    model?: IEntityModelDelegate;
    addationalProps?: any;
    children?: React__default.ReactNode;
    render?: (comp: React__default.ReactNode) => React__default.ReactNode;
};
declare function EntityNamedRenderer(props: EntityNamedRendererProps): React__default.ReactNode;

type EntityWidgetRendererProps = {
    widgetName: string;
    view: IEntityViewDelegate;
    model: IEntityModelDelegate;
    field: IEntityViewFieldDelegate;
    value?: any;
    object?: IEntityObject$1;
    behavior: EntityViewBehaviorType;
    showLabel?: boolean;
    fieldControl?: EntityWidgetFieldControlProps;
    fieldState?: EntityWidgetFieldState;
    style?: EntityCSSProperties;
    className?: string;
};
declare function EntityWidgetRenderer(props: EntityWidgetRendererProps): react_jsx_runtime.JSX.Element;

declare function EmptySymbol(): null;

type IEntityObject = {
    id?: string;
    [k: string]: any;
};

type EntityViewPerfromActionType = {
    actionType: 'view' | 'comp' | 'reference-view' | string;
    payload: any;
    contextObject: any;
    target?: string | '__root__' | '__self__' | '__parent__';
};
interface MasterDetailViewContextType {
    performAction: (action: EntityViewPerfromActionType) => void;
    currentAction?: EntityViewPerfromActionType;
    broadcast: (actionType: string, payload: any) => void;
    broadcastData?: {
        actionType: string;
        payload: any;
        timestamp: number;
    };
    parentContext?: IEntityObject;
    containerName?: string;
    registerContainer: (name: string, handler: (action: EntityViewPerfromActionType) => void) => void;
    unregisterContainer: (name: string) => void;
}
declare function ViewContainerProvider({ children, parentContext, containerName, }: {
    children: React$1.ReactNode;
    parentContext?: IEntityObject;
    containerName?: string;
}): react_jsx_runtime.JSX.Element;
declare function useMasterDetailViewContainer(): MasterDetailViewContextType;
declare function useContainerRouter(): {
    containerName: string | undefined;
    pushView: (args: {
        modelName: string;
        viewType: string;
        viewName?: string;
        contextObject?: any;
        target?: string;
    }) => void;
    pushComponent: (comp: React$1.ComponentType, target?: string) => void;
    pushReferenceView: (args: {
        fromModelName?: string;
        fromFieldName: string;
        toModelName: string;
        viewType?: string;
        contextObject: {
            id: string;
        } | any;
        target?: string;
    }) => void;
};

type EntityEngineProviderProps = {
    initializer: IEntityEngineInitializer;
    children: React$1.ReactNode;
    loading?: React$1.ReactNode;
    router?: IEntityEngineRouter;
    permissionGuard?: IEntityPermissionGuard;
};
declare const EntityEngineProvider: (props: EntityEngineProviderProps) => string | number | bigint | true | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element;
declare const useEntityEngine: () => IEntityEngine;
declare const useEntitySession: () => {
    sessionLoading: boolean;
    sessionError: Error | null;
    session: IEntitySession | null;
    sessionRefresh: () => Promise<void>;
};
declare const useEntityEngineRouter: () => IEntityEngineRouter;
declare const useEntityPermissionGuard: () => IEntityPermissionGuard;
type EntityPermissionGuardProps = {
    action: EntityPermissionActionType;
    children: React$1.ReactNode;
    noPermissionComponent?: React$1.ComponentType;
};
declare function EntityPermissionGuard(props: EntityPermissionGuardProps): react_jsx_runtime.JSX.Element;

type AdapterType = {
    suiteName: string;
    suiteVersion: string;
};
declare const EntitySuiteAdapterProvider: React$1.FC<{
    adapter: AdapterType;
    children: React$1.ReactNode;
}>;
declare const useEntitySuiteAdapter: () => AdapterType;

interface ThemeContextValue {
    theme: IEntityEngineTheme;
}
interface ThemeProviderProps {
    theme?: Partial<IEntityEngineTheme>;
    children: ReactNode;
}
declare function EntityEngineThemeProvider({ theme: customTheme, children, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
declare function useEntityEngineTheme(): ThemeContextValue;

type EntityEngineInitConfig = {
    config?: {
        models: IEntityModel[];
        views: IEntityView[];
    };
    suiteAdapters?: IEntityComponentSuiteAdapter[];
    theme?: Partial<IEntityEngineTheme>;
    suiteAdapter?: AdapterType;
    loading?: ReactNode;
    router?: IEntityEngineRouter;
    permissionGuard?: IEntityPermissionGuard;
    renderers?: IEntityNamedRenderer[];
    fieldTypers?: IModelFieldTyper[];
    modules?: (IEntityModule | string)[];
    settings?: {
        baseUrl?: string;
        endpoint?: string;
        authenticationEnabled?: boolean;
    };
};
/**
 * 工厂函数：
 * 接收开发者的配置，然后返回一个已经完全配置好的 Provider 组件。
 */
declare function createEntityEngineProvider(config: EntityEngineInitConfig): {
    ({ children }: {
        children: ReactNode;
    }): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type EntityObjectsConsumerProps = {
    modelName: string;
    query?: IEntityQuery;
    withReference?: boolean;
    objectsRenderer: (count: number, objs: IEntityObject$1[]) => React__default.ReactNode;
    onError?: (error: Error) => React__default.ReactNode;
    loading?: React__default.ReactNode;
};
declare function EntityObjectsConsumer(props: EntityObjectsConsumerProps): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
type EntityObjectConsumerProps = {
    modelName: string;
    objectId: string;
    withReference?: boolean;
    objectRenderer: (obj: IEntityObject$1) => React__default.ReactNode;
    onError?: (error: Error) => React__default.ReactNode;
    loading?: React__default.ReactNode;
};
declare function EntityObjectConsumer(props: EntityObjectConsumerProps): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;

declare class BuildinModule implements IEntityModule {
    readonly info: {
        name: string;
        version: string;
        description: string;
        provider: string;
        dependencies: never[];
        url: string;
    };
    setupConfig(args: {
        models: IEntityModel[];
        views: IEntityView[];
        servlets: IEntityServlet[];
    }): Promise<void>;
    setupComponents(args: {
        views: EntityView[];
        renderers: IEntityNamedRenderer[];
        widgets: EntityWidget[];
    }): Promise<void>;
    setupData(args: {
        entities: ImportEntityData[];
    }): Promise<void>;
}

declare function useAsync<T>(func: () => Promise<T>, deps?: DependencyList): {
    state: 'loading' | 'hasData' | 'hasError';
    data?: T;
    error?: any;
};
declare function useAsyncWithCache<T>(func: () => Promise<T>, deps?: DependencyList): {
    state: 'loading' | 'hasData' | 'hasError';
    data?: T;
    error?: any;
};

type AsyncEffectCallbackResult = ReturnType<EffectCallback>;
type AsyncEffectCallback = (signal: AbortSignal) => Promise<AsyncEffectCallbackResult>;
declare function useAsyncEffect(effect: AsyncEffectCallback, deps?: DependencyList): void;

type AsyncFunction = (...args: any[]) => Promise<any>;
interface IUseDataSourceHookReturn<T> {
    data: T | undefined;
    loading: boolean;
    error: any;
    refetch: () => void;
    isFetching: boolean;
    isPreviousData: boolean;
}
type DataSourceHook<T extends AsyncFunction> = (input: Parameters<T>[0], options?: {
    enabled?: boolean;
    select?: (data: Awaited<ReturnType<T>>) => any;
    keepPreviousData?: boolean;
}) => IUseDataSourceHookReturn<Awaited<ReturnType<T>>>;
type DataSourceHooks<T> = {
    [K in keyof T as T[K] extends AsyncFunction ? `use${Capitalize<string & K>}` : never]: T[K] extends AsyncFunction ? DataSourceHook<T[K]> : never;
};
/**
 * 将 IEntityDataSource 实例转换为一组 React Hooks。
 * @param dataSource - IEntityDataSource 的实例。
 * @returns 返回一个包含所有对应 Hooks 的对象。
 */
declare function toDataSourceHook<T extends IEntityDataSource>(dataSource: T): DataSourceHooks<T>;

export { type AdapterType, BuildinModule, EmptySymbol, type EntityAction, EntityActionRegistry, type EntityActionResult, type EntityActionResultPayload, type EntityCSSProperties, EntityComponentRegistry, EntityDataSourceFactory, EntityEngine, EntityEngineProvider, type EntityEngineProviderProps, EntityEngineThemeProvider, type EntityEvent, EntityEventRegistry, EntityFieldDelegate, type EntityFieldType, EntityMetaRegistry, EntityModelDelegate, type EntityModuleInfo, EntityNamedRenderer, EntityObjectConsumer, EntityObjectsConsumer, type EntityPermissionActionType, EntityPermissionGuard, type EntityPermissionGuardProps, EntitySession, type EntitySessionData, EntitySessionManager, EntitySuiteAdapterProvider, type EntityTreeNode, EntityView, type EntityViewBehaviorMode, type EntityViewBehaviorType, type EntityViewCallbacksType, type EntityViewCapabilityDescriptor, EntityViewContainer, type EntityViewContainerProps, EntityViewDelegate, type EntityViewDensity, EntityViewFieldDelegate, EntityViewInspector, type EntityViewPerfromActionType, type EntityViewProps, type EntityViewReferenceType, EntityWidget, type EntityWidgetFieldControlProps, type EntityWidgetFieldState, type EntityWidgetProps, EntityWidgetRenderer, type EntityWidgetRendererProps, type ICompositeCondition, type IEntityActionHandler, type IEntityActionRegistry, type IEntityComponentRegistry, type IEntityComponentSuiteAdapter, type IEntityDataSource, type IEntityDataSourceFactory, type IEntityEngine, type IEntityEngineInitializer, type IEntityEnginePrimitive, type IEntityEnginePrimitiveInitializer, type IEntityEngineRouter, type IEntityEngineSettings, type IEntityEngineTheme, type IEntityEngineWatcher, type IEntityEventEmitter, type IEntityEventListener, type IEntityEventNextDispatcher, type IEntityEventRegistry, type IEntityField, type IEntityFieldDelegate, type IEntityGridViewHilite, type IEntityMetaRegistry, type IEntityModel, type IEntityModelDelegate, type IEntityModelExternalConfig, type IEntityModule, type IEntityModuleRegistry, type IEntityNamedRenderer, type IEntityObject$1 as IEntityObject, type IEntityObjectReference, type IEntityObjectReferenceProps, type IEntityPermissionGuard, type IEntityQuery, type IEntityQueryItem, type IEntityQueryItemMeta, type IEntityQueryMeta, type IEntityRequestHandler, type IEntityResult, type IEntityServlet, type IEntityServletRegistry, type IEntityServletRequest, type IEntityServletResponse, type IEntitySession, type IEntitySessionManager, type IEntitySessionProvider, type IEntityView, type IEntityViewController, type IEntityViewDelegate, type IEntityViewField, type IEntityViewFieldDelegate, type IEntityViewMetaInfo, type IEntityViewPanel, type IEntityViewReference, type IEntityWidgetMetaInfo, type ILeafCondition, type IModelFieldTyper, type IModelFieldTyperRegistry, type ImportEntityData, type ImportReferenceData, ModelFieldTyperRegistry, type OptionValue, type Options, QueryOperator, TRPCEntityObjectDataSource, ViewContainerProvider, createEntityEngineProvider, entityEngineDefaultTheme, getEntityEngine, toDataSourceHook, useAsync, useAsyncEffect, useAsyncWithCache, useContainerRouter, useEntityEngine, useEntityEngineRouter, useEntityEngineTheme, useEntityPermissionGuard, useEntitySession, useEntitySuiteAdapter, useMasterDetailViewContainer };