@nocobase/client 2.1.0-beta.21 → 2.1.0-beta.23

package/es/ai/index.d.ts

@@ -6,7 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export * from './ai-manager';
-export * from './tools-manager';
-export * from './skills-manager';
-export * from './utils';
+export { AIManager, DefaultToolsManager, toToolsMap } from '@nocobase/client-v2';
+export type { ToolsManager, ToolsRegistration, ToolsOptions, ToolCall, FrontendTools, BackendTools, ToolsEntry, ToolsUIProperties, DecisionActions, ToolsFilter, Scope, Permission, From, SkillsScope, SkillsEntry, SkillsFilter, } from '@nocobase/client-v2';

package/es/api-client/APIClient.d.ts

@@ -13,8 +13,7 @@ export declare class APIClient extends APIClientSDK {
     services: Record<string, Result<any, any>>;
     silence: boolean;
     app: Application;
-    /** 该值会在 AntdAppProvider 中被重新赋值 */
-    notification: any;
+    get notification(): import("antd/es/notification/interface").NotificationInstance;
     cloneInstance(): APIClient;
     getHostname(): string;
     getHeaders(): {};

package/es/application/Application.d.ts

@@ -6,205 +6,135 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+import { BaseApplication, type BaseApplicationOptions, type ComponentAndProps, type WebSocketClientOptions } from '@nocobase/client-v2';
 import { APIClientOptions } from '@nocobase/sdk';
 import { i18n as i18next } from 'i18next';
-import React, { ComponentType, ReactElement, ReactNode } from 'react';
+import type { ComponentType } from 'react';
 import { APIClient } from '../api-client';
-import { PluginManager, PluginType } from './PluginManager';
+import type { CollectionFieldInterfaceFactory } from '../data-source';
+import { CollectionFieldInterfaceComponentOption } from '../data-source/collection-field-interface/CollectionFieldInterface';
+import { DataSourceManager, type DataSourceManagerOptions } from '../data-source/data-source/DataSourceManager';
+import { PluginManager, type PluginType } from './PluginManager';
+import type { PluginClass } from './PluginManager';
 import { PluginSettingOptions, PluginSettingsManager } from './PluginSettingsManager';
-import { ComponentTypeAndString, RouterManager, RouterOptions } from './RouterManager';
-import { WebSocketClient, WebSocketClientOptions } from './WebSocketClient';
+import { RouterManager, type RouterOptions } from './RouterManager';
 import { SchemaInitializer, SchemaInitializerManager } from './schema-initializer';
 import { SchemaSettings, SchemaSettingsItemType, SchemaSettingsManager } from './schema-settings';
-import { CollectionFieldInterfaceComponentOption } from '../data-source/collection-field-interface/CollectionFieldInterface';
-import { DataSourceManager, type DataSourceManagerOptions } from '../data-source/data-source/DataSourceManager';
-import { FlowEngine, FlowEngineContext, FlowModel } from '@nocobase/flow-engine';
-import type { CollectionFieldInterfaceFactory } from '../data-source';
-import type { Plugin } from './Plugin';
-import type { RequireJS } from './utils/requirejs';
-import { AIManager } from '../ai';
 type JsonLogic = {
     addOperation: (name: string, fn?: any) => void;
     rmOperation: (name: string) => void;
 };
-declare global {
-    interface Window {
-        define: RequireJS['define'];
-    }
-}
-export type DevDynamicImport = (packageName: string) => Promise<{
-    default: typeof Plugin;
-}>;
-export type ComponentAndProps<T = any> = [ComponentType, T];
-export interface ApplicationOptions {
-    name?: string;
-    publicPath?: string;
-    apiClient?: APIClientOptions | APIClient;
-    ws?: WebSocketClientOptions | boolean;
-    i18n?: i18next;
-    providers?: (ComponentType | ComponentAndProps)[];
-    plugins?: PluginType[];
-    components?: Record<string, ComponentType>;
-    scopes?: Record<string, any>;
-    router?: RouterOptions;
-    pluginSettings?: Record<string, PluginSettingOptions>;
-    schemaSettings?: SchemaSettings[];
-    schemaInitializers?: SchemaInitializer[];
-    designable?: boolean;
-    loadRemotePlugins?: boolean;
-    devDynamicImport?: DevDynamicImport;
-    dataSourceManager?: DataSourceManagerOptions;
-    disableAcl?: boolean;
-}
 /**
  * Reference: https://ant.design/components/cascader-cn#option
  */
 interface VariableOption {
-    /** Unique identifier of the variable */
     value: string | number;
-    /** Variable name displayed in UI */
     label?: React.ReactNode;
     disabled?: boolean;
     children?: VariableOption[];
 }
 interface Variable {
-    /** Unique identifier of the variable */
     name: string;
-    /** Variable configuration options */
     useOption: () => {
         option: VariableOption;
         visible?: boolean;
     };
-    /** Variable context */
     useCtx: () => any | ((param: {
         variableName: string;
     }) => Promise<any>);
 }
-export declare class Application {
-    protected options: ApplicationOptions;
-    eventBus: EventTarget;
-    aiManager: AIManager;
-    providers: ComponentAndProps[];
-    router: RouterManager;
-    scopes: Record<string, any>;
-    i18n: i18next;
-    ws: WebSocketClient;
-    apiClient: APIClient;
-    components: Record<string, ComponentType<any> | any>;
-    pluginManager: PluginManager;
-    pluginSettingsManager: PluginSettingsManager;
-    devDynamicImport: DevDynamicImport;
-    requirejs: RequireJS;
-    notification: any;
+export type { ComponentAndProps };
+export type DevDynamicImport = (packageName: string) => Promise<{
+    default: PluginClass;
+}>;
+export interface ApplicationOptions extends BaseApplicationOptions<PluginType> {
+    apiClient?: APIClientOptions | APIClient;
+    ws?: WebSocketClientOptions | boolean;
+    i18n?: i18next;
+    providers?: (ComponentType | ComponentAndProps)[];
+    plugins?: PluginType[];
+    components?: Record<string, ComponentType>;
+    scopes?: Record<string, any>;
+    router?: RouterOptions;
+    pluginSettings?: Record<string, PluginSettingOptions>;
+    schemaSettings?: SchemaSettings[];
+    schemaInitializers?: SchemaInitializer[];
+    dataSourceManager?: DataSourceManagerOptions;
+}
+export declare class Application extends BaseApplication<ApplicationOptions, PluginManager, RouterManager, APIClient, PluginSettingsManager> {
+    devDynamicImport?: DevDynamicImport;
     schemaInitializerManager: SchemaInitializerManager;
     schemaSettingsManager: SchemaSettingsManager;
     dataSourceManager: DataSourceManager;
-    name: string;
-    favicon: string;
     globalVars: Record<string, any>;
     globalVarCtxs: Record<string, any>;
     jsonLogic: JsonLogic;
-    flowEngine: FlowEngine;
-    model: ApplicationModel;
-    context: FlowEngineContext & {
-        pluginSettingsRouter: PluginSettingsManager;
-        pluginManager: PluginManager;
-    };
     loading: boolean;
-    maintained: boolean;
-    maintaining: boolean;
-    error: any;
     hasLoadError: boolean;
     locales: any;
-    private wsAuthorized;
     private readonly variables;
-    apps: {
-        Component?: ComponentType;
+    protected initRequireJs(): void;
+    protected defineObservableState(): void;
+    protected createApiClient(options: ApplicationOptions): APIClient;
+    protected createI18n(options: ApplicationOptions): i18next;
+    protected createRouterManager(options: ApplicationOptions): RouterManager;
+    protected createPluginManager(options: ApplicationOptions): PluginManager;
+    protected createPluginSettingsManager(options: ApplicationOptions): PluginSettingsManager;
+    protected getDefaultComponents(): {
+        DataBlockProvider: import("react").FC<Partial<import("../data-source").AllDataBlockProps>>;
+        SchemaInitializerActionModal: import("react").FC<import("./schema-initializer").SchemaInitializerActionModalProps>;
+        SchemaInitializerActionModalInternal: () => import("react").JSX.Element;
+        SchemaInitializerChildren: import("react").FC<{
+            children: import("./schema-initializer").SchemaInitializerItemType[];
+        }>;
+        SchemaInitializerChild: import("react").FC<import("./schema-initializer").SchemaInitializerItemType>;
+        SchemaInitializerDivider: () => import("react").JSX.Element;
+        SchemaInitializerItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./schema-initializer").SchemaInitializerItemProps & import("react").RefAttributes<any>>>;
+        SchemaInitializerItemGroup: import("react").FC<import("./schema-initializer").SchemaInitializerItemGroupProps>;
+        SchemaInitializerItemGroupInternal: () => import("react").JSX.Element;
+        SchemaInitializerItemInternal: () => import("react").JSX.Element;
+        SchemaInitializerItems: import("react").FC<{
+            options?: import("./schema-initializer").SchemaInitializerOptions<import("antd").ButtonProps, {}>;
+            items?: import("./schema-initializer").SchemaInitializerItemType<any>[];
+        }>;
+        SchemaInitializerSelect: import("react").FC<import("./schema-initializer").SchemaInitializerSelectItemProps>;
+        SchemaInitializerSelectInternal: () => import("react").JSX.Element;
+        SchemaInitializerSubMenu: import("react").FC<import("./schema-initializer").SchemaInitializerSubMenuProps>;
+        SchemaInitializerSubMenuInternal: () => import("react").JSX.Element;
+        SchemaInitializerSwitch: import("react").FC<import("./schema-initializer").SchemaInitializerSwitchItemProps>;
+        SchemaInitializerSwitchInternal: () => import("react").JSX.Element;
+        CollectionField: import("react").ForwardRefExoticComponent<Omit<Partial<any>, "ref"> & import("react").RefAttributes<unknown>>;
     };
-    get pm(): PluginManager;
-    get disableAcl(): boolean;
-    get isWsAuthorized(): boolean;
-    updateFavicon(favicon?: string): void;
-    setWsAuthorized(authorized: boolean): void;
-    constructor(options?: ApplicationOptions);
-    private initListeners;
-    protected setTokenInWebSocket(options: {
-        token: string;
-        authenticator: string;
-    }): void;
-    setMaintaining(maintaining: boolean): void;
-    private initRequireJs;
-    private addDefaultProviders;
-    private addReactRouterComponents;
-    private addRoutes;
-    getOptions(): ApplicationOptions;
-    getName(): string;
-    getPublicPath(): string;
-    getApiUrl(pathname?: string): string;
-    getRouteUrl(pathname: string): string;
-    getHref(pathname: string): string;
+    protected initializeExtendedState(): void;
+    protected afterManagersInitialized(): void;
+    protected addCustomProviders(): void;
+    protected getRootFallback(): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
     getCollectionManager(dataSource?: string): import("../data-source").CollectionManager;
-    /**
-     * @internal
-     */
-    getComposeProviders(): React.FC;
-    use<T = any>(component: ComponentType, props?: T): number;
-    addProvider<T = any>(component: ComponentType, props?: T): number;
-    addProviders(providers: (ComponentType | [ComponentType, any])[]): void;
     load(): Promise<void>;
     loadWebSocket(): Promise<void>;
-    getComponent<T = any>(Component: ComponentTypeAndString<T>, isShowError?: boolean): ComponentType<T> | undefined;
-    renderComponent<T extends {}>(Component: ComponentTypeAndString, props?: T, children?: ReactNode): ReactElement;
-    /**
-     * @internal use addComponents({ SomeComponent }) instead
-     */
-    protected addComponent(component: ComponentType, name?: string): void;
-    addComponents(components: Record<string, ComponentType>): void;
     addScopes(scopes: Record<string, any>): void;
-    getRootComponent(): React.FC<{
-        children?: React.ReactNode;
-    }>;
-    mount(containerOrSelector: Element | ShadowRoot | string): import("react-dom/client").Root;
     addFieldInterfaces(fieldInterfaceClasses?: CollectionFieldInterfaceFactory[]): void;
+    addFieldInterfaceGroups(groups: Record<string, {
+        label: string;
+        order?: number;
+    }>): void;
     addFieldInterfaceComponentOption(fieldName: string, componentOption: CollectionFieldInterfaceComponentOption): void;
     /**
      * 为指定的字段接口添加操作符选项
      *
      * @param name 字段接口的名称
      * @param operatorOption 要添加的操作符选项
-     *
-     * @example
-     * // 为"单行文本"类型字段添加"等于任意一个"操作符
-     * app.addFieldInterfaceOperator('input', {
-     *   label: '{{t("equals any of")}}',
-     *   value: '$in',
-     * });
      */
     addFieldInterfaceOperator(name: string, operatorOption: any): void;
     addGlobalVar(key: string, value: any, varCtx?: any): void;
-    getGlobalVar(key: any): any;
-    getGlobalVarCtx(key: any): any;
+    getGlobalVar(key: string): any;
+    getGlobalVarCtx(key: string): any;
     addUserCenterSettingsItem(item: SchemaSettingsItemType & {
         aclSnippet?: string;
     }): void;
-    /**
-     * Register a variable for use in the frontend
-     *
-     * Note: It is not recommended to register variables in components as it may cause rendering errors
-     * @param variable
-     * @returns
-     */
     registerVariable(variable: Variable): void;
-    /**
-     * Get all registered variables
-     * @returns
-     */
     getVariables(): Variable[];
     setAppsComponent({ Component }: {
         Component: ComponentType;
     }): void;
 }
-declare class ApplicationModel extends FlowModel {
-    render(): React.JSX.Element;
-}
-export {};

package/es/application/Plugin.d.ts

@@ -6,29 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { TFuncKey, TOptions } from 'i18next';
 import type { Application } from './Application';
-export declare class Plugin<T = any> {
-    options: T;
-    protected app: Application;
-    constructor(options: T, app: Application);
-    get pluginManager(): import("./PluginManager").PluginManager;
-    get context(): import("@nocobase/flow-engine").FlowEngineContext & {
-        pluginSettingsRouter: import("./PluginSettingsManager").PluginSettingsManager;
-        pluginManager: import("./PluginManager").PluginManager;
-    };
-    get flowEngine(): import("@nocobase/flow-engine").FlowEngine;
-    get engine(): import("@nocobase/flow-engine").FlowEngine;
-    get ai(): import("..").AIManager;
-    get pm(): import("./PluginManager").PluginManager;
-    get router(): import("./RouterManager").RouterManager;
-    get pluginSettingsManager(): import("./PluginSettingsManager").PluginSettingsManager;
-    get pluginSettingsRouter(): import("./PluginSettingsManager").PluginSettingsManager;
-    get schemaInitializerManager(): import("./schema-initializer").SchemaInitializerManager;
-    get schemaSettingsManager(): import("./schema-settings").SchemaSettingsManager;
-    get dataSourceManager(): import("..").DataSourceManager;
-    afterAdd(): Promise<void>;
-    beforeLoad(): Promise<void>;
-    load(): Promise<void>;
-    t(text: TFuncKey | TFuncKey[], options?: TOptions): import("i18next").TFunctionDetailedResult<object>;
+import { Plugin as BasePlugin, PluginOptions } from '@nocobase/client-v2';
+export declare class Plugin<T extends PluginOptions = PluginOptions> extends BasePlugin<T, Application> {
 }

package/es/application/PluginManager.d.ts

@@ -6,41 +6,12 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+import { PluginManager as BasePluginManager, type PluginClass as BasePluginClass, type PluginType as BasePluginType } from '@nocobase/client-v2';
 import type { Application } from './Application';
-import type { Plugin } from './Plugin';
-export type PluginOptions<T = any> = {
-    name?: string;
-    packageName?: string;
-    config?: T;
-};
-export type PluginType<Opts = any> = typeof Plugin | [typeof Plugin<Opts>, PluginOptions<Opts>];
-export type PluginData = {
-    name: string;
-    packageName: string;
-    version: string;
-    url: string;
-    type: 'local' | 'upload' | 'npm';
-};
-export declare class PluginManager {
-    protected _plugins: PluginType[];
-    protected loadRemotePlugins: boolean;
-    protected app: Application;
-    protected pluginInstances: Map<typeof Plugin, Plugin>;
-    protected pluginsAliases: Record<string, Plugin>;
-    private initPlugins;
-    constructor(_plugins: PluginType[], loadRemotePlugins: boolean, app: Application);
-    /**
-     * @internal
-     */
-    init(_plugins: PluginType[]): Promise<void>;
-    private initStaticPlugins;
-    private initRemotePlugins;
-    add<T = any>(plugin: typeof Plugin, opts?: PluginOptions<T>): Promise<void>;
-    get<T extends typeof Plugin>(PluginClass: T): InstanceType<T>;
-    get<T extends {}>(name: string): T;
-    private getInstance;
-    /**
-     * @internal
-     */
-    load(): Promise<void>;
+export type { PluginData, PluginOptions } from '@nocobase/client-v2';
+export type PluginClass<Opts = any> = BasePluginClass<Opts, Application>;
+export type PluginType<Opts = any> = BasePluginType<Opts, Application>;
+export declare class PluginManager extends BasePluginManager<Application> {
+    protected getRemotePluginsRequestUrl(): string;
+    protected initRemotePlugins(): Promise<void>;
 }

package/es/application/PluginSettingsManager.d.ts

@@ -6,7 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import React from 'react';
+import { type ReactNode } from 'react';
 import type { Application } from './Application';
 import type { RouteType } from './RouterManager';
 export declare const ADMIN_SETTINGS_KEY = "admin.settings.";
@@ -18,7 +18,8 @@ export interface PluginSettingOptions {
      * @default Outlet
      */
     Component?: RouteType['Component'];
-    icon?: string;
+    componentLoader?: RouteType['componentLoader'];
+    icon?: string | ReactNode;
     /**
      * sort, the smaller the number, the higher the priority
      * @default 0
@@ -31,11 +32,11 @@ export interface PluginSettingOptions {
     [index: string]: any;
 }
 export interface PluginSettingsPageType {
-    label?: string | React.ReactElement;
-    title: string | React.ReactElement;
+    label?: string | ReactNode;
+    title: string | ReactNode;
     link?: string;
     key: string;
-    icon: any;
+    icon: ReactNode;
     path: string;
     sort?: number;
     name?: string;
@@ -45,23 +46,118 @@ export interface PluginSettingsPageType {
     children?: PluginSettingsPageType[];
     [index: string]: any;
 }
+/**
+ * client-v1 兼容版插件设置管理器。
+ *
+ * 继续保留旧的 dotted-key 注册协议，与 client-v2 的新两层实现完全脱钩。
+ *
+ * @example
+ * ```typescript
+ * app.pluginSettingsManager.add('system.test', { title: 'Test', Component: DemoPage });
+ * ```
+ */
 export declare class PluginSettingsManager {
     protected settings: Record<string, PluginSettingOptions>;
     protected aclSnippets: string[];
     app: Application;
     private cachedList;
-    constructor(_pluginSettings: Record<string, PluginSettingOptions>, app: Application);
+    constructor(_pluginSettings: Record<string, PluginSettingOptions> | undefined, app: Application);
+    /**
+     * 渲染图标字符串为 Icon 组件。
+     *
+     * @param {PluginSettingOptions['icon']} icon 图标定义
+     * @returns {ReactNode} 图标节点
+     */
+    protected renderIcon(icon: PluginSettingOptions['icon']): ReactNode;
+    /**
+     * 清理缓存。
+     *
+     * @returns {void}
+     */
     clearCache(): void;
+    /**
+     * 设置 ACL snippets。
+     *
+     * @param {string[]} aclSnippets snippets 列表
+     * @returns {void}
+     */
     setAclSnippets(aclSnippets: string[]): void;
+    /**
+     * 获取 ACL snippet。
+     *
+     * @param {string} name settings 名称
+     * @returns {string | null} snippet
+     */
     getAclSnippet(name: string): string;
+    /**
+     * 获取 route name。
+     *
+     * @param {string} name settings 名称
+     * @returns {string} route name
+     */
     getRouteName(name: string): string;
+    /**
+     * 获取 route path。
+     *
+     * @param {string} name settings 名称
+     * @returns {string} route path
+     */
     getRoutePath(name: string): string;
+    /**
+     * 追加 settings 配置。
+     *
+     * @param {string} name dotted settings key
+     * @param {PluginSettingOptions} options 配置项
+     * @returns {void}
+     */
     add(name: string, options: PluginSettingOptions): void;
+    /**
+     * 删除 settings 配置。
+     *
+     * @param {string} name settings 名称
+     * @returns {void}
+     */
     remove(name: string): void;
+    /**
+     * 判断 ACL 是否允许。
+     *
+     * @param {string} name settings 名称
+     * @returns {boolean} 是否允许
+     */
     hasAuth(name: string): boolean;
+    /**
+     * 获取内部原始设置。
+     *
+     * @param {string} name settings 名称
+     * @returns {PluginSettingOptions | undefined} 原始设置
+     */
     getSetting(name: string): PluginSettingOptions;
+    /**
+     * 判断配置是否存在且可访问。
+     *
+     * @param {string} name settings 名称
+     * @returns {boolean} 是否存在
+     */
     has(name: string): boolean;
-    get(name: string, filterAuth?: boolean): PluginSettingsPageType;
+    /**
+     * 获取 settings 快照。
+     *
+     * @param {string} name settings 名称
+     * @param {boolean} [filterAuth=true] 是否过滤 ACL
+     * @returns {PluginSettingsPageType | null} settings 快照
+     */
+    get(name: string, filterAuth?: boolean): PluginSettingsPageType | null;
+    /**
+     * 获取顶级 settings 列表。
+     *
+     * @param {boolean} [filterAuth=true] 是否过滤 ACL
+     * @returns {PluginSettingsPageType[]} 顶级列表
+     */
     getList(filterAuth?: boolean): PluginSettingsPageType[];
+    /**
+     * 获取所有 ACL snippets。
+     *
+     * @returns {(string | null)[]} snippet 列表
+     */
     getAclSnippets(): string[];
 }

package/es/application/RouteRepository.d.ts

@@ -6,18 +6,4 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-type RouteOptions = {
-    id: string;
-    schemaUid: string;
-    children?: RouteOptions[];
-};
-export declare class RouteRepository {
-    protected ctx: any;
-    routes: Array<RouteOptions>;
-    constructor(ctx: any);
-    setRoutes(routes: Array<any>): void;
-    listAccessible(): RouteOptions[];
-    getRouteBySchemaUid(schemaUid: string): RouteOptions | undefined;
-    private findRoute;
-}
-export {};
+export { RouteRepository } from '@nocobase/client-v2';

package/es/application/RouterManager.d.ts

@@ -6,56 +6,16 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import React, { ComponentType } from 'react';
-import { BrowserRouterProps, HashRouterProps, MemoryRouterProps, RouteObject } from 'react-router-dom';
+import { RouterManager as BaseRouterManager, type RouterOptions } from '@nocobase/client-v2';
+import React, { type ComponentType } from 'react';
 import { Application } from './Application';
-export interface BrowserRouterOptions extends Omit<BrowserRouterProps, 'children'> {
-    type?: 'browser';
-}
-export interface HashRouterOptions extends Omit<HashRouterProps, 'children'> {
-    type?: 'hash';
-}
-export interface MemoryRouterOptions extends Omit<MemoryRouterProps, 'children'> {
-    type?: 'memory';
-}
-export type RouterOptions = (HashRouterOptions | BrowserRouterOptions | MemoryRouterOptions) & {
-    renderComponent?: RenderComponentType;
-    routes?: Record<string, RouteType>;
-};
-export type ComponentTypeAndString<T = any> = ComponentType<T> | string;
-export interface RouteType extends Omit<RouteObject, 'children' | 'Component'> {
-    Component?: ComponentTypeAndString;
-    skipAuthCheck?: boolean;
-}
-export type RenderComponentType = (Component: ComponentTypeAndString, props?: any) => React.ReactNode;
-export declare class RouterManager {
-    protected routes: Record<string, RouteType>;
-    protected options: RouterOptions;
-    app: Application;
-    router: any;
-    get basename(): any;
-    get state(): any;
-    get navigate(): any;
-    constructor(options: RouterOptions, app: Application);
-    /**
-     * @internal
-     */
-    getRoutesTree(): RouteObject[];
-    getRoutes(): Record<string, RouteType>;
-    setType(type: RouterOptions['type']): void;
-    getBasename(): string;
-    setBasename(basename: string): void;
-    matchRoutes(pathname: string): import("@remix-run/router").AgnosticRouteMatch<string, RouteType>[];
-    isSkippedAuthCheckRoute(pathname: string): boolean;
+export type { BrowserRouterOptions, HashRouterOptions, MemoryRouterOptions, RouterOptions, ComponentTypeAndString, ComponentLoaderResult, ComponentLoader, RouteType, RenderComponentType, } from '@nocobase/client-v2';
+export declare class RouterManager extends BaseRouterManager<Application> {
     /**
      * @internal
      */
     getRouterComponent(children?: React.ReactNode): React.FC<{
         BaseLayout?: ComponentType;
     }>;
-    add(name: string, route: RouteType): void;
-    get(name: string): RouteType;
-    has(name: string): boolean;
-    remove(name: string): void;
 }
 export declare function createRouterManager(options?: RouterOptions, app?: Application): RouterManager;

package/es/application/WebSocketClient.d.ts

@@ -6,39 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { Application } from './Application';
-export type WebSocketClientOptions = {
-    reconnectInterval?: number;
-    reconnectAttempts?: number;
-    pingInterval?: number;
-    url?: string;
-    basename?: string;
-    protocols?: string | string[];
-    onServerDown?: any;
-};
-export declare class WebSocketClient {
-    protected _ws: WebSocket;
-    protected _reconnectTimes: number;
-    protected events: any[];
-    protected options: WebSocketClientOptions;
-    app: Application;
-    enabled: boolean;
-    connected: boolean;
-    serverDown: boolean;
-    lastMessage: {};
-    constructor(options: WebSocketClientOptions | boolean);
-    getSubAppName: (app: Application) => string;
-    getURL(): string;
-    get reconnectAttempts(): number;
-    get reconnectInterval(): number;
-    get pingInterval(): number;
-    get readyState(): number;
-    connect(): void;
-    reconnect(): void;
-    close(): void;
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-    on(type: string, listener: any, options?: boolean | AddEventListenerOptions): void;
-    emit(type: string, args: any): void;
-    off(type: string, listener: any, options?: boolean | EventListenerOptions): void;
-    removeAllListeners(): void;
-}
+export { WebSocketClient } from '@nocobase/client-v2';
+export type { WebSocketClientOptions } from '@nocobase/client-v2';

package/es/application/components/index.d.ts

@@ -6,7 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export * from './AppComponent';
 export * from './BlankComponent';
-export * from './defaultComponents';
 export * from './RouterContextCleaner';