@tachybase/client 0.23.8-alpha.15

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

@@ -0,0 +1,15 @@
+import { APIClient as APIClientSDK } from '@tachybase/sdk';
+import { Result } from 'ahooks/es/useRequest/src/types';
+import { Application } from '../application';
+export declare class APIClient extends APIClientSDK {
+    services: Record<string, Result<any, any>>;
+    silence: boolean;
+    app: Application;
+    /** 该值会在 AntdAppProvider 中被重新赋值 */
+    notification: any;
+    service(uid: string): Result<any, any>;
+    getHeaders(): {};
+    interceptors(): void;
+    useNotificationMiddleware(): void;
+    silent(): this;
+}

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

@@ -0,0 +1,7 @@
+import React, { ReactNode } from 'react';
+import { APIClient } from './APIClient';
+export interface APIClientProviderProps {
+    apiClient: APIClient;
+    children?: ReactNode;
+}
+export declare const APIClientProvider: (props: APIClientProviderProps) => React.JSX.Element;

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

@@ -0,0 +1,2 @@
+import { APIClient } from './APIClient';
+export declare const APIClientContext: import("react").Context<APIClient>;

package/es/api-client/hooks/assign.d.ts

@@ -0,0 +1,9 @@
+type MergeStrategyType = 'merge' | 'deepMerge' | 'overwrite' | 'andMerge' | 'orMerge' | 'intersect' | 'union';
+type MergeStrategyFunc = (x: any, y: any) => any;
+export type MergeStrategy = MergeStrategyType | MergeStrategyFunc;
+export interface MergeStrategies {
+    [key: string]: MergeStrategy;
+}
+export declare const mergeStrategies: Map<MergeStrategyType, MergeStrategyFunc>;
+export declare function assign(target: any, source: any, strategies?: MergeStrategies): any;
+export {};

package/es/api-client/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useAPIClient';
+export * from './useRequest';
+export * from './useResource';

package/es/api-client/hooks/useAPIClient.d.ts

@@ -0,0 +1 @@
+export declare function useAPIClient(): import("..").APIClient;

package/es/api-client/hooks/useRequest.d.ts

@@ -0,0 +1,22 @@
+import { Options, Result } from 'ahooks/es/useRequest/src/types';
+import { SetState } from 'ahooks/lib/useSetState';
+import { AxiosRequestConfig } from 'axios';
+type FunctionService = (...args: any[]) => Promise<any>;
+export type ReturnTypeOfUseRequest<TData = any> = ReturnType<typeof useRequest<TData>>;
+export type ResourceActionOptions<P = any> = {
+    resource?: string;
+    resourceOf?: any;
+    action?: string;
+    params?: P;
+    url?: string;
+};
+export type UseRequestService<P> = AxiosRequestConfig<P> | ResourceActionOptions<P> | FunctionService;
+export type UseRequestOptions = Options<any, any> & {
+    uid?: string;
+};
+export interface UseRequestResult<P> extends Result<P, any> {
+    state: any;
+    setState: SetState<{}>;
+}
+export declare function useRequest<P>(service: UseRequestService<P>, options?: UseRequestOptions): UseRequestResult<P>;
+export {};

package/es/api-client/hooks/useResource.d.ts

@@ -0,0 +1 @@
+export declare function useResource(name: string, of?: string | number): import("packages/sdk/lib").IResource;

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

@@ -0,0 +1,4 @@
+export * from './hooks';
+export * from './APIClient';
+export * from './APIClientProvider';
+export * from './context';

package/es/application/AppSchemaComponentProvider.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ISchemaComponentProvider } from '../schema-component/types';
+export declare const AppSchemaComponentProvider: (props: ISchemaComponentProvider) => React.JSX.Element;

package/es/application/Application.d.ts

@@ -0,0 +1,108 @@
+import React, { ComponentType, ReactElement } from 'react';
+import { type RequireJS } from '@tachybase/requirejs';
+import { APIClientOptions } from '@tachybase/sdk';
+import { i18n as i18next } from 'i18next';
+import { APIClient } from '../api-client';
+import { DataSourceManager, type DataSourceManagerOptions } from '../data-source/data-source/DataSourceManager';
+import { AttachmentPreviewManager, PluginAttachmentItemsOptions } from './AttachmentPreviewManager';
+import { NoticeManager } from './NoticesManager';
+import type { Plugin } from './Plugin';
+import { PluginContextMenu, PluginItemsOptions } from './PluginContextMenu';
+import { PluginManager, PluginType } from './PluginManager';
+import { ComponentTypeAndString, RouterManager, RouterOptions } from './RouterManager';
+import { SchemaInitializer, SchemaInitializerManager } from './schema-initializer';
+import { SchemaSettings, SchemaSettingsManager } from './schema-settings';
+import { PluginSettingOptions, SystemSettingsManager } from './SystemSettingsManager';
+import { UserSettingOptions, UserSettingsManager } from './UserSettingsManager';
+import { WebSocketClient, WebSocketClientOptions } from './WebSocketClient';
+declare global {
+    interface Window {
+        define: RequireJS['define'];
+        require: RequireJS['require'];
+        Sentry?: any;
+    }
+}
+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>;
+    userSettings?: Record<string, UserSettingOptions>;
+    schemaSettings?: SchemaSettings[];
+    schemaInitializers?: SchemaInitializer[];
+    designable?: boolean;
+    loadRemotePlugins?: boolean;
+    devDynamicImport?: DevDynamicImport;
+    dataSourceManager?: DataSourceManagerOptions;
+    pluginMenuItems?: Record<string, PluginItemsOptions>;
+    attachmentItem?: Record<string, PluginAttachmentItemsOptions>;
+}
+export declare class Application {
+    protected options: ApplicationOptions;
+    providers: ComponentAndProps[];
+    router: RouterManager;
+    scopes: Record<string, any>;
+    i18n: i18next;
+    ws: WebSocketClient;
+    apiClient: APIClient;
+    components: Record<string, ComponentType<any> | any>;
+    pluginManager: PluginManager;
+    systemSettingsManager: SystemSettingsManager;
+    userSettingsManager: UserSettingsManager;
+    devDynamicImport: DevDynamicImport;
+    requirejs: RequireJS;
+    notification: any;
+    schemaInitializerManager: SchemaInitializerManager;
+    schemaSettingsManager: SchemaSettingsManager;
+    dataSourceManager: DataSourceManager;
+    noticeManager: NoticeManager;
+    pluginContextMenu: PluginContextMenu;
+    AttachmentPreviewManager: AttachmentPreviewManager;
+    name: string;
+    loading: boolean;
+    maintained: boolean;
+    maintaining: boolean;
+    error: any;
+    get pm(): PluginManager;
+    get adminUrl(): string;
+    constructor(options?: ApplicationOptions);
+    private initRequireJs;
+    private addDefaultProviders;
+    private addReactRouterComponents;
+    private addRoutes;
+    getOptions(): ApplicationOptions;
+    getPublicPath(): string;
+    getName(): string;
+    getApiUrl(pathname?: string): string;
+    getRouteUrl(pathname: string): string;
+    getCollectionManager(dataSource?: string): import("..").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>;
+    getComponent<T = any>(Component: ComponentTypeAndString<T>, isShowError?: boolean): ComponentType<T> | undefined;
+    renderComponent<T extends {}>(Component: ComponentTypeAndString, props?: T): 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.JSX.Element;
+    mount(containerOrSelector: Element | ShadowRoot | string): import("react-dom/client").Root;
+}

package/es/application/AttachmentPreviewManager.d.ts

@@ -0,0 +1,15 @@
+import type { Application } from './Application';
+export interface PluginAttachmentItemsOptions {
+    key: string;
+    type: string;
+    viewComponet: (any: any) => JSX.Element;
+    checkedComponent: (any: any) => JSX.Element;
+}
+export declare class AttachmentPreviewManager {
+    protected attachmentItem: Record<string, PluginAttachmentItemsOptions>;
+    app: Application;
+    constructor(_pluginAttachmentItems: Record<string, PluginAttachmentItemsOptions>, app: Application);
+    get(): Record<string, PluginAttachmentItemsOptions>;
+    getTypeItem(key: any): PluginAttachmentItemsOptions;
+    add(options: PluginAttachmentItemsOptions): void;
+}

package/es/application/NoticesManager.d.ts

@@ -0,0 +1,46 @@
+import React, { ReactNode } from 'react';
+import { Emitter, EventType } from 'mitt';
+import { Application } from './Application';
+export declare enum NoticeLevel {
+    INFO = "info",
+    WARNING = "warning",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export declare enum NoticeType {
+    STATUS = "status",
+    TOAST = "toast",
+    NOTIFICATION = "notification",
+    CUSTOM = "custom"
+}
+export declare enum NoticeDuration {
+    Short = "SHORT"
+}
+export interface NoticeManagerContextProps {
+    manager: NoticeManager;
+}
+export declare const NoticeManagerContext: React.Context<NoticeManagerContextProps>;
+export declare const NoticeManagerProvider: ({ children }: {
+    children: ReactNode;
+}) => React.JSX.Element;
+export declare const useNoticeManager: () => NoticeManagerContextProps;
+export declare const useNoticeSub: (name: string, handler: (...args: any) => void) => void;
+export declare class NoticeManager {
+    private app;
+    private ws;
+    emitter: Emitter<Record<EventType, unknown>>;
+    constructor(app: Application);
+    currentStatus: string;
+    currentStatusUpdatedAt: number;
+    on(data: {
+        type: NoticeType;
+        title?: string;
+        content: string;
+        level: NoticeLevel;
+        eventType?: string;
+        event?: any;
+    }): void;
+    status(content: string, level: NoticeLevel, duration?: NoticeDuration): void;
+    toast(content: string, level: NoticeLevel): void;
+    notification(title: string, content: string, level: NoticeLevel): void;
+}

package/es/application/Plugin.d.ts

@@ -0,0 +1,21 @@
+import { ParseKeys, TOptions } from 'i18next';
+import type { Application } from './Application';
+export declare class Plugin<T = any> {
+    protected options: T;
+    protected app: Application;
+    constructor(options: T, app: Application);
+    get pluginManager(): import("./PluginManager").PluginManager;
+    get pm(): import("./PluginManager").PluginManager;
+    get router(): import("./RouterManager").RouterManager;
+    get systemSettingsManager(): import("./SystemSettingsManager").SystemSettingsManager;
+    get userSettingsManager(): import("./UserSettingsManager").UserSettingsManager;
+    get schemaInitializerManager(): import("./schema-initializer").SchemaInitializerManager;
+    get schemaSettingsManager(): import("./schema-settings").SchemaSettingsManager;
+    get dataSourceManager(): import("..").DataSourceManager;
+    get AttachmentPreviewManager(): import("./AttachmentPreviewManager").AttachmentPreviewManager;
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    afterLoad(): Promise<void>;
+    t(text: ParseKeys | ParseKeys[], options?: TOptions): string;
+}

package/es/application/PluginContextMenu.d.ts

@@ -0,0 +1,17 @@
+export interface PluginItemsOptions {
+    name?: string;
+    sort?: number;
+    useLoadMethod?: (any: any) => methodOptionsType;
+}
+export interface methodOptionsType {
+    title: any;
+    actionProps: any;
+    icon?: React.ReactNode;
+    children?: any;
+}
+export declare class PluginContextMenu {
+    protected menuItems: Record<string, PluginItemsOptions>;
+    constructor(_pluginMenuItems: Record<string, PluginItemsOptions>);
+    get(): Record<string, PluginItemsOptions>;
+    add(name: string, options: PluginItemsOptions): void;
+}

package/es/application/PluginManager.d.ts

@@ -0,0 +1,38 @@
+import type { Application } from './Application';
+import { Plugin } from './Plugin';
+export type PluginOptions<T = any> = {
+    name?: string;
+    packageName?: string;
+    config?: T;
+};
+export type PluginType<Opts = any> = typeof Plugin | [typeof Plugin, 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>;
+}

package/es/application/RouterManager.d.ts

@@ -0,0 +1,46 @@
+import React, { ComponentType } from 'react';
+import { BrowserRouterProps, HashRouterProps, MemoryRouterProps, RouteObject } from 'react-router-dom';
+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;
+};
+export type ComponentTypeAndString<T = any> = ComponentType<T> | string;
+export interface RouteType extends Omit<RouteObject, 'children' | 'Component'> {
+    Component?: ComponentTypeAndString;
+}
+export type RenderComponentType = (Component: ComponentTypeAndString, props?: any) => React.ReactNode;
+export declare class RouterManager {
+    protected routes: Record<string, RouteType>;
+    protected options: RouterOptions;
+    app: Application;
+    constructor(options: RouterOptions, app: Application);
+    /**
+     * @internal
+     */
+    getRoutesTree(): RouteObject[];
+    getRoutes(): Record<string, RouteType>;
+    setType(type: RouterOptions['type']): void;
+    getBasename(): string;
+    setBasename(basename: string): void;
+    /**
+     * @internal
+     */
+    getRouterComponent(): ({ BaseLayout, }: {
+        BaseLayout?: ComponentType<any>;
+        children?: React.ReactNode;
+    }) => React.JSX.Element;
+    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/SystemSettingsManager.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+import type { Application } from './Application';
+import type { RouteType } from './RouterManager';
+export declare const ADMIN_SETTINGS_KEY = "admin-settings.";
+export declare const ADMIN_SETTINGS_PATH = "/_admin/";
+export declare const SNIPPET_PREFIX = "pm.";
+export interface PluginSettingOptions {
+    title: any;
+    /**
+     * @default Outlet
+     */
+    Component?: RouteType['Component'];
+    icon?: string;
+    /**
+     * sort, the smaller the number, the higher the priority
+     * @default 0
+     */
+    sort?: number;
+    aclSnippet?: string;
+    [index: string]: any;
+}
+export interface PluginSettingsPageType {
+    label?: string | React.ReactElement;
+    title: string | React.ReactElement;
+    key: string;
+    icon: any;
+    path: string;
+    sort?: number;
+    name?: string;
+    isAllow?: boolean;
+    topLevelName?: string;
+    aclSnippet: string;
+    children?: PluginSettingsPageType[];
+    [index: string]: any;
+}
+export declare class SystemSettingsManager {
+    protected settings: Record<string, PluginSettingOptions>;
+    protected aclSnippets: string[];
+    app: Application;
+    private cachedList;
+    constructor(_pluginSettings: Record<string, PluginSettingOptions>, app: Application);
+    setAclSnippets(aclSnippets: string[]): void;
+    getAclSnippet(name: string): string;
+    getRouteName(name: string): string;
+    getRoutePath(name: string): string;
+    add(name: string, options: PluginSettingOptions): void;
+    remove(name: string): void;
+    hasAuth(name: string): boolean;
+    getSetting(name: string): PluginSettingOptions;
+    has(name: string): boolean;
+    get(name: string, filterAuth?: boolean): PluginSettingsPageType;
+    getList(filterAuth?: boolean): PluginSettingsPageType[];
+    getAclSnippets(): string[];
+}

package/es/application/UserSettingsManager.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+import type { Application } from './Application';
+import type { RouteType } from './RouterManager';
+export declare const USER_SETTINGS_KEY = "profilers.";
+export declare const USER_SETTINGS_PATH = "/profilers/";
+export declare const SNIPPET_PREFIX = "pm.";
+export interface UserSettingOptions {
+    title: any;
+    /**
+     * @default Outlet
+     */
+    Component?: RouteType['Component'];
+    icon?: string;
+    /**
+     * sort, the smaller the number, the higher the priority
+     * @default 0
+     */
+    sort?: number;
+    aclSnippet?: string;
+    [index: string]: any;
+}
+export interface UserSettingsPageType {
+    label?: string | React.ReactElement;
+    title: string | React.ReactElement;
+    key: string;
+    icon: any;
+    path: string;
+    sort?: number;
+    name?: string;
+    isAllow?: boolean;
+    topLevelName?: string;
+    aclSnippet: string;
+    children?: UserSettingsPageType[];
+    [index: string]: any;
+}
+export declare class UserSettingsManager {
+    protected settings: Record<string, UserSettingOptions>;
+    protected aclSnippets: string[];
+    app: Application;
+    private cachedList;
+    constructor(_userSettings: Record<string, UserSettingOptions>, app: Application);
+    setAclSnippets(aclSnippets: string[]): void;
+    getAclSnippet(name: string): string;
+    getRouteName(name: string): string;
+    getRoutePath(name: string): string;
+    add(name: string, options: UserSettingOptions): void;
+    remove(name: string): void;
+    hasAuth(name: string): boolean;
+    getSetting(name: string): UserSettingOptions;
+    has(name: string): boolean;
+    get(name: string, filterAuth?: boolean): UserSettingsPageType;
+    getList(filterAuth?: boolean): UserSettingsPageType[];
+    getAclSnippets(): string[];
+}

package/es/application/WebSocketClient.d.ts

@@ -0,0 +1,35 @@
+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 {
+    private app;
+    protected _ws: WebSocket;
+    protected _reconnectTimes: number;
+    protected events: any[];
+    protected options: WebSocketClientOptions;
+    enabled: boolean;
+    connected: boolean;
+    serverDown: boolean;
+    lastMessage: {};
+    constructor(options: WebSocketClientOptions | boolean, app: Application);
+    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;
+}

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { Application } from '../Application';
+export interface AppComponentProps {
+    app: Application;
+}
+export declare const AppComponent: React.MemoExoticComponent<import("@tachybase/schema").ReactFC<AppComponentProps>>;

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

@@ -0,0 +1,4 @@
+import React, { ReactNode } from 'react';
+export declare const BlankComponent: ({ children }: {
+    children?: ReactNode;
+}) => React.JSX.Element;

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const MainComponent: React.MemoExoticComponent<() => React.JSX.Element>;

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

@@ -0,0 +1,4 @@
+import React, { ReactNode } from 'react';
+export declare const RouterContextCleaner: React.MemoExoticComponent<(props: {
+    children?: ReactNode;
+}) => React.JSX.Element>;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare const defaultAppComponents: {
+    AppMain: React.MemoExoticComponent<() => React.JSX.Element>;
+    AppSpin: () => React.JSX.Element;
+    AppError: ({ error }: {
+        error: Error;
+    }) => React.JSX.Element;
+    AppNotFound: () => React.JSX.Element;
+};

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

@@ -0,0 +1,4 @@
+export * from './AppComponent';
+export * from './BlankComponent';
+export * from './defaultComponents';
+export * from './RouterContextCleaner';

package/es/application/context.d.ts

@@ -0,0 +1,2 @@
+import { Application } from './Application';
+export declare const ApplicationContext: import("react").Context<Application>;

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

@@ -0,0 +1 @@
+export * from './withDynamicSchemaProps';

package/es/application/hoc/withDynamicSchemaProps.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface WithSchemaHookOptions {
+    displayName?: string;
+}
+export declare function withDynamicSchemaProps<T = any>(Component: any, options?: WithSchemaHookOptions): React.FunctionComponent<T>;
+export declare function DynamicSchemaProps(options?: WithSchemaHookOptions): <T = any>(Component: any, _context: any) => React.FunctionComponent<T>;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './useApp';
+export * from './usePlugin';
+export * from './useRouter';

package/es/application/hooks/useApp.d.ts

@@ -0,0 +1,2 @@
+import type { Application } from '../Application';
+export declare const useApp: () => Application;

package/es/application/hooks/usePlugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '../Plugin';
+export declare function usePlugin<T extends typeof Plugin>(plugin: T): InstanceType<T>;
+export declare function usePlugin<T extends {}>(name: string): T;

package/es/application/hooks/useRouter.d.ts

@@ -0,0 +1 @@
+export declare const useRouter: () => import("..").RouterManager;

package/es/application/index.d.ts

@@ -0,0 +1,15 @@
+export * from './Application';
+export * from './hooks';
+export * from './Plugin';
+export * from './RouterManager';
+export * from './utils';
+export * from './components';
+export * from './schema-initializer';
+export * from './schema-settings';
+export * from './schema-toolbar';
+export * from './SystemSettingsManager';
+export * from './NoticesManager';
+export * from './hoc';
+export { ApplicationContext } from './context';
+export * from './PluginContextMenu';
+export * from './AttachmentPreviewManager';

package/es/application/schema-initializer/SchemaInitializer.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonProps } from 'antd';
+import { SchemaInitializerItemType, SchemaInitializerItemTypeWithoutName, SchemaInitializerOptions } from './types';
+export declare class SchemaInitializer<P1 = ButtonProps, P2 = {}> {
+    options: SchemaInitializerOptions<P1, P2>;
+    name: string;
+    waitlist: [string, SchemaInitializerItemTypeWithoutName][];
+    get items(): SchemaInitializerItemType<any>[];
+    constructor(options: SchemaInitializerOptions<P1, P2>);
+    add(name: string, item: SchemaInitializerItemTypeWithoutName): void;
+    get(nestedName: string): SchemaInitializerItemType | undefined;
+    remove(nestedName: string): void;
+}