@tachybase/client 0.23.8

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;
+}

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

@@ -0,0 +1,24 @@
+import { ButtonProps } from 'antd';
+import { Application } from '../Application';
+import { SchemaInitializer } from './SchemaInitializer';
+import { SchemaInitializerItemTypeWithoutName } from './types';
+interface ActionType {
+    type: 'add' | 'remove';
+    itemName: string;
+    data?: any;
+}
+export declare class SchemaInitializerManager {
+    protected _schemaInitializers: SchemaInitializer<any, any>[];
+    protected app: Application;
+    protected schemaInitializers: Record<string, SchemaInitializer<any, any>>;
+    protected actionList: Record<string, ActionType[]>;
+    constructor(_schemaInitializers: SchemaInitializer<any, any>[], app: Application);
+    add<P1 = any, P2 = any>(...schemaInitializerList: SchemaInitializer<P1, P2>[]): void;
+    addItem(schemaInitializerName: string, itemName: string, data: SchemaInitializerItemTypeWithoutName): void;
+    get<P1 = ButtonProps, P2 = {}>(name: string): SchemaInitializer<P1, P2> | undefined;
+    getAll(): Record<string, SchemaInitializer<any, any>>;
+    has(name: string): boolean;
+    remove(name: string): void;
+    removeItem(schemaInitializerName: string, itemName: string): void;
+}
+export {};

package/es/application/schema-initializer/components/SchemaInitializerActionModal.d.ts

@@ -0,0 +1,11 @@
+import React, { FC } from 'react';
+export interface SchemaInitializerActionModalProps {
+    title: string;
+    schema: any;
+    onCancel?: () => void;
+    onSubmit?: (values: any) => void;
+    buttonText?: any;
+    component?: any;
+}
+export declare const SchemaInitializerActionModal: FC<SchemaInitializerActionModalProps>;
+export declare const SchemaInitializerActionModalInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerButton.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+import { ButtonProps } from 'antd';
+import { SchemaInitializerOptions } from '../types';
+export interface SchemaInitializerButtonProps extends ButtonProps {
+    options: SchemaInitializerOptions;
+}
+export declare const SchemaInitializerButton: FC<SchemaInitializerButtonProps>;

package/es/application/schema-initializer/components/SchemaInitializerChildren.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { SchemaInitializerItemType } from '../types';
+export declare const SchemaInitializerChildren: FC<{
+    children: SchemaInitializerItemType[];
+}>;
+export declare const SchemaInitializerChild: FC<SchemaInitializerItemType>;

package/es/application/schema-initializer/components/SchemaInitializerDivider.d.ts

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

package/es/application/schema-initializer/components/SchemaInitializerItem.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from 'react';
+export interface SchemaInitializerItemProps {
+    style?: React.CSSProperties;
+    className?: string;
+    name?: string;
+    icon?: React.ReactNode;
+    title?: React.ReactNode;
+    items?: any[];
+    onClick?: (args?: any) => any;
+    applyMenuStyle?: boolean;
+    children?: ReactNode;
+}
+export declare const SchemaInitializerItem: React.MemoExoticComponent<React.ForwardRefExoticComponent<SchemaInitializerItemProps & React.RefAttributes<any>>>;
+export declare const SchemaInitializerItemInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerItemGroup.d.ts

@@ -0,0 +1,9 @@
+import React, { FC } from 'react';
+import { SchemaInitializerOptions } from '../types';
+export interface SchemaInitializerItemGroupProps {
+    title: string;
+    children?: SchemaInitializerOptions['items'];
+    divider?: boolean;
+}
+export declare const SchemaInitializerItemGroup: FC<SchemaInitializerItemGroupProps>;
+export declare const SchemaInitializerItemGroupInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerItems.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { ButtonProps } from 'antd';
+import { SchemaInitializerOptions } from '../types';
+export type SchemaInitializerItemsProps<P1 = ButtonProps, P2 = {}> = P2 & {
+    options?: SchemaInitializerOptions<P1, P2>;
+    items?: SchemaInitializerOptions['items'];
+};
+export declare const SchemaInitializerItems: FC<SchemaInitializerItemsProps>;

package/es/application/schema-initializer/components/SchemaInitializerSelect.d.ts

@@ -0,0 +1,11 @@
+import React, { FC } from 'react';
+import { SelectProps } from 'antd';
+import { SchemaInitializerItemProps } from './SchemaInitializerItem';
+export interface SchemaInitializerSelectItemProps extends SchemaInitializerItemProps {
+    options?: SelectProps['options'];
+    value?: SelectProps['defaultValue'];
+    onChange?: SelectProps['onChange'];
+    openOnHover?: boolean;
+}
+export declare const SchemaInitializerSelect: FC<SchemaInitializerSelectItemProps>;
+export declare const SchemaInitializerSelectInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerSubMenu.d.ts

@@ -0,0 +1,17 @@
+import React, { FC, ReactNode } from 'react';
+import { MenuProps } from 'antd';
+import { SchemaInitializerOptions } from '../types';
+export interface SchemaInitializerSubMenuProps {
+    name: string;
+    title?: string;
+    onClick?: (args: any) => void;
+    onOpenChange?: (openKeys: string[]) => void;
+    icon?: string | ReactNode;
+    children?: SchemaInitializerOptions['items'];
+}
+export declare const useSchemaInitializerSubMenuContext: () => {
+    isInMenu?: true;
+};
+export declare const SchemaInitializerMenu: (props: MenuProps) => React.JSX.Element;
+export declare const SchemaInitializerSubMenu: FC<SchemaInitializerSubMenuProps>;
+export declare const SchemaInitializerSubMenuInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/SchemaInitializerSwitch.d.ts

@@ -0,0 +1,8 @@
+import React, { FC } from 'react';
+import { SchemaInitializerItemProps } from './SchemaInitializerItem';
+export interface SchemaInitializerSwitchItemProps extends SchemaInitializerItemProps {
+    checked?: boolean;
+    disabled?: boolean;
+}
+export declare const SchemaInitializerSwitch: FC<SchemaInitializerSwitchItemProps>;
+export declare const SchemaInitializerSwitchInternal: () => React.JSX.Element;

package/es/application/schema-initializer/components/index.d.ts

@@ -0,0 +1,10 @@
+export * from './SchemaInitializerSubMenu';
+export * from './SchemaInitializerItem';
+export * from './SchemaInitializerSwitch';
+export * from './SchemaInitializerItemGroup';
+export * from './SchemaInitializerChildren';
+export * from './SchemaInitializerDivider';
+export * from './SchemaInitializerItems';
+export * from './SchemaInitializerActionModal';
+export * from './SchemaInitializerSelect';
+export * from './style';

package/es/application/schema-initializer/components/style.d.ts

@@ -0,0 +1 @@
+export declare const useSchemaInitializerStyles: (props?: any) => import("../../../schema-component/antd/__builtins__").UseComponentStyleResult;

package/es/application/schema-initializer/context/index.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { InsertType, SchemaInitializerItemType, SchemaInitializerOptions } from '../types';
+export declare const SchemaInitializerContext: React.Context<{
+    insert: InsertType;
+    options: SchemaInitializerOptions<any>;
+    visible: boolean;
+    setVisible: (v: boolean) => void;
+}>;
+export declare const useSchemaInitializer: () => {
+    insert: InsertType;
+    options: SchemaInitializerOptions<any>;
+    visible: boolean;
+    setVisible: (v: boolean) => void;
+};
+export declare const SchemaInitializerItemContext: React.Context<Omit<SchemaInitializerItemType, "type" | "Component" | "component" | "componentProps" | "sort" | "useVisible" | "useChildren" | "hideIfNoChildren">>;
+export declare const useSchemaInitializerItem: <T = any>() => T;

package/es/application/schema-initializer/hoc/index.d.ts

@@ -0,0 +1,3 @@
+import React, { ComponentType } from 'react';
+import { SchemaInitializerOptions } from '../types';
+export declare function withInitializer<T>(C: ComponentType<T>): React.MemoExoticComponent<import("@tachybase/schema").ReactFC<Omit<SchemaInitializerOptions<T, {}>, "ref">>>;

package/es/application/schema-initializer/hooks/index.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { ButtonProps } from 'antd';
+import { SchemaInitializerOptions } from '../types';
+export * from './useAriaAttributeOfMenuItem';
+/**
+ * @internal
+ */
+export declare function useSchemaInitializerMenuItems(items: any[], name?: string, onClick?: (args: any) => void): any;
+/**
+ * @internal
+ */
+export declare function useGetSchemaInitializerMenuItems(onClick?: (args: any) => void): (items: any[], parentKey: string) => any;
+export declare function useSchemaInitializerRender<P1 = ButtonProps, P2 = {}>(name: string, options?: Omit<SchemaInitializerOptions<P1, P2>, 'name'>): {
+    exists: boolean;
+    render: () => any;
+} | {
+    exists: boolean;
+    render: (props?: Omit<SchemaInitializerOptions<P1, P2>, "name">) => React.FunctionComponentElement<any> | React.FunctionComponentElement<SchemaInitializerOptions<any, any>>;
+};

package/es/application/schema-initializer/hooks/useAriaAttributeOfMenuItem.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+export declare const useAriaAttributeOfMenuItem: () => {
+    attribute: {
+        role: string;
+    } | {
+        role?: undefined;
+    };
+};

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

@@ -0,0 +1,7 @@
+export * from './hoc';
+export * from './hooks';
+export * from './types';
+export * from './context';
+export * from './components';
+export * from './SchemaInitializer';
+export * from './SchemaInitializerManager';

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

@@ -0,0 +1,80 @@
+import { ComponentType, ReactNode } from 'react';
+import { ISchema } from '@tachybase/schema';
+import { ButtonProps, PopoverProps } from 'antd';
+import type { SchemaInitializerActionModalProps, SchemaInitializerItemGroupProps, SchemaInitializerItemProps, SchemaInitializerSelectItemProps, SchemaInitializerSubMenuProps, SchemaInitializerSwitchItemProps } from './components';
+export type InsertType = (s: ISchema) => void;
+type SchemaInitializerItemBuiltInType<T = {}> = T & {
+    name: string;
+    sort?: number;
+    componentProps?: Omit<T, 'children'>;
+    useComponentProps?: () => Omit<T, 'children'>;
+    useVisible?: () => boolean;
+    [index: string]: any;
+};
+export interface SchemaInitializerItemComponentType<T = {}> {
+    name: string;
+    Component?: ComponentType<T> | string;
+    sort?: number;
+    componentProps?: Omit<T, 'children'>;
+    useComponentProps?: () => Omit<T, 'children'>;
+    useVisible?: () => boolean;
+    children?: SchemaInitializerItemType[];
+    hideIfNoChildren?: boolean;
+    useChildren?: () => SchemaInitializerItemType[];
+    [index: string]: any;
+}
+export interface SchemaInitializerItemDividerType extends SchemaInitializerItemBuiltInType {
+    type: 'divider';
+}
+export type SchemaInitializerItemItemType = {
+    type: 'item';
+} & SchemaInitializerItemBuiltInType<SchemaInitializerItemProps>;
+export type SchemaInitializerItemSwitchType = {
+    type: 'switch';
+} & SchemaInitializerItemBuiltInType<SchemaInitializerSwitchItemProps>;
+export type SchemaInitializerItemSelectType = {
+    type: 'select';
+} & SchemaInitializerItemBuiltInType<SchemaInitializerSelectItemProps>;
+export type SchemaInitializerItemActionModalType = {
+    type: 'actionModal';
+} & SchemaInitializerItemBuiltInType<SchemaInitializerActionModalProps>;
+export type SchemaInitializerItemGroupType = {
+    type: 'itemGroup';
+    children?: SchemaInitializerItemType[];
+    hideIfNoChildren?: boolean;
+    useChildren?: () => SchemaInitializerItemType[];
+} & SchemaInitializerItemBuiltInType<SchemaInitializerItemGroupProps>;
+export type SchemaInitializerSubMenuType = {
+    type: 'subMenu';
+    children?: SchemaInitializerItemType[];
+    hideIfNoChildren?: boolean;
+    useChildren?: () => SchemaInitializerItemType[];
+} & SchemaInitializerItemBuiltInType<SchemaInitializerSubMenuProps>;
+export type SchemaInitializerAllBuiltItemType = SchemaInitializerItemDividerType | SchemaInitializerItemItemType | SchemaInitializerItemSwitchType | SchemaInitializerItemSelectType | SchemaInitializerItemGroupType | SchemaInitializerSubMenuType | SchemaInitializerItemActionModalType;
+export type SchemaInitializerItemType<T = any> = SchemaInitializerAllBuiltItemType | SchemaInitializerItemComponentType<T>;
+export type SchemaInitializerItemTypeWithoutName<T = any> = Omit<SchemaInitializerAllBuiltItemType, 'name'> | Omit<SchemaInitializerItemComponentType<T>, 'name'>;
+export interface SchemaInitializerOptions<P1 = ButtonProps, P2 = {}> {
+    name: string;
+    Component?: ComponentType<P1>;
+    componentProps?: P1;
+    style?: React.CSSProperties;
+    title?: string;
+    icon?: ReactNode;
+    items?: SchemaInitializerItemType[];
+    ItemsComponent?: ComponentType<P2>;
+    itemsComponentProps?: P2;
+    itemsComponentStyle?: React.CSSProperties;
+    insertPosition?: 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd';
+    designable?: boolean;
+    wrap?: (s: ISchema, options?: any) => ISchema;
+    onSuccess?: (data: any) => void;
+    insert?: InsertType;
+    useInsert?: () => InsertType;
+    /**
+     * @default true
+     */
+    popover?: boolean;
+    popoverProps?: PopoverProps;
+    [index: string]: any;
+}
+export {};

package/es/application/schema-settings/SchemaSettings.d.ts

@@ -0,0 +1,10 @@
+import { SchemaSettingOptions, SchemaSettingsItemType, SchemaSettingsItemTypeWithoutName } from './types';
+export declare class SchemaSettings<T = {}> {
+    options: SchemaSettingOptions<T>;
+    name: string;
+    get items(): SchemaSettingsItemType[];
+    constructor(options: SchemaSettingOptions<T>);
+    add(name: string, item: SchemaSettingsItemTypeWithoutName): void;
+    get(nestedName: string): SchemaSettingsItemType | undefined;
+    remove(nestedName: string): void;
+}

package/es/application/schema-settings/SchemaSettingsDefaults.d.ts

@@ -0,0 +1,2 @@
+import { SchemaSettingsItemType } from './types';
+export declare const defaultSettingItems: SchemaSettingsItemType[];

package/es/application/schema-settings/SchemaSettingsManager.d.ts

@@ -0,0 +1,23 @@
+import { Application } from '../Application';
+import { SchemaSettings } from './SchemaSettings';
+import { SchemaSettingsItemTypeWithoutName } from './types';
+interface ActionType {
+    type: 'add' | 'remove';
+    itemName: string;
+    data?: any;
+}
+export declare class SchemaSettingsManager {
+    protected _schemaSettings: SchemaSettings<any>[];
+    protected app: Application;
+    protected schemaSettings: Record<string, SchemaSettings<any>>;
+    protected actionList: Record<string, ActionType[]>;
+    constructor(_schemaSettings: SchemaSettings<any>[], app: Application);
+    add<T = any>(...schemaSettingList: SchemaSettings<T>[]): void;
+    addItem(schemaSettingName: string, itemName: string, data: SchemaSettingsItemTypeWithoutName): void;
+    get<T>(name: string): SchemaSettings<T> | undefined;
+    getAll(): Record<string, SchemaSettings<any>>;
+    has(name: string): boolean;
+    remove(name: string): void;
+    removeItem(schemaSettingName: string, itemName: string): void;
+}
+export {};

package/es/application/schema-settings/components/SchemaSettingsChildren.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+import { SchemaSettingsItemType } from '../types';
+export interface SchemaSettingsChildrenProps {
+    children: SchemaSettingsItemType[];
+}
+export declare const SchemaSettingsChildren: FC<SchemaSettingsChildrenProps>;
+export declare const SchemaSettingsChild: FC<SchemaSettingsItemType>;

package/es/application/schema-settings/components/SchemaSettingsIcon.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { SchemaSettingOptions } from '../types';
+export interface SchemaSettingsIconProps {
+    options: SchemaSettingOptions;
+}
+export declare const SchemaSettingsIcon: FC<SchemaSettingOptions>;

package/es/application/schema-settings/components/SchemaSettingsWrapper.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { SchemaSettingOptions } from '../types';
+/**
+ * @internal
+ */
+export declare const SchemaSettingsWrapper: FC<SchemaSettingOptions<any>>;

package/es/application/schema-settings/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SchemaSettingsWrapper';
+export * from './SchemaSettingsChildren';

package/es/application/schema-settings/context/index.d.ts

@@ -0,0 +1,3 @@
+import { SchemaSettingsItemType } from '../types';
+export declare const SchemaSettingItemContext: import("react").Context<SchemaSettingsItemType>;
+export declare function useSchemaSettingsItem(): SchemaSettingsItemType;