@tachybase/client 0.23.8-alpha.15

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;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import { GeneralField, Schema } from '@tachybase/schema';
+import { Designable } from '../../../schema-component';
+import { SchemaSettingsProps } from '../../../schema-settings';
+import { SchemaSettingOptions } from '../types';
+type UseSchemaSettingsRenderOptions<T = {}> = Omit<SchemaSettingOptions<T>, 'name' | 'items'> & Omit<SchemaSettingsProps, 'title' | 'children'> & {
+    fieldSchema?: Schema;
+    field?: GeneralField;
+    dn?: Designable;
+};
+export declare function useSchemaSettingsRender<T = {}>(name: string, options?: UseSchemaSettingsRenderOptions<T>): {
+    exists: boolean;
+    render: () => any;
+} | {
+    exists: boolean;
+    render: (options2?: UseSchemaSettingsRenderOptions) => React.FunctionComponentElement<any> | React.FunctionComponentElement<SchemaSettingOptions<any>>;
+};
+export {};

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

@@ -0,0 +1,6 @@
+export * from './SchemaSettings';
+export * from './SchemaSettingsManager';
+export * from './hooks';
+export * from './components';
+export * from './context';
+export * from './types';

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

@@ -0,0 +1,62 @@
+import { ComponentType } from 'react';
+import { SchemaSettingsCascaderItemProps, SchemaSettingsItemProps, SchemaSettingsModalItemProps, SchemaSettingsPopupProps, SchemaSettingsRemoveProps, SchemaSettingsSelectItemProps, SchemaSettingsSubMenuProps, SchemaSettingsSwitchItemProps } from '../../schema-settings';
+export interface SchemaSettingOptions<T = {}> {
+    name: string;
+    Component?: ComponentType<T>;
+    componentProps?: T;
+    items: SchemaSettingsItemType[];
+    style?: React.CSSProperties;
+}
+interface SchemaSettingsItemCommon<T = {}> {
+    name: string;
+    sort?: number;
+    useVisible?: () => boolean;
+    children?: SchemaSettingsItemType[];
+    useChildren?: () => SchemaSettingsItemType[];
+    /**
+     * @default true
+     */
+    hideIfNoChildren?: boolean;
+    componentProps?: Omit<T, 'children'>;
+    useComponentProps?: () => Omit<T, 'children'>;
+}
+export interface SchemaSettingItemItemType extends SchemaSettingsItemCommon<SchemaSettingsItemProps> {
+    type: 'item';
+}
+export interface SchemaSettingItemGroupType extends SchemaSettingsItemCommon<SchemaSettingsSubMenuProps> {
+    type: 'itemGroup';
+}
+export interface SchemaSettingItemDividerProps extends SchemaSettingsItemCommon {
+    type: 'divider';
+}
+export type SchemaSettingItemRemoveType = SchemaSettingsItemCommon<SchemaSettingsRemoveProps> & {
+    type: 'remove';
+};
+export type SchemaSettingItemSelectType = SchemaSettingsItemCommon<SchemaSettingsSelectItemProps> & {
+    type: 'select';
+};
+export type SchemaSettingItemCascaderType = SchemaSettingsItemCommon<SchemaSettingsCascaderItemProps> & {
+    type: 'cascader';
+};
+interface SchemaSettingItemSwitchType extends SchemaSettingsItemCommon<SchemaSettingsSwitchItemProps> {
+    type: 'switch';
+}
+export type SchemaSettingItemPopupType = SchemaSettingsItemCommon<SchemaSettingsPopupProps> & {
+    type: 'popup';
+};
+export type SchemaSettingItemModalType = SchemaSettingsItemCommon<SchemaSettingsModalItemProps> & {
+    type: 'modal';
+};
+export type SchemaSettingItemActionModalType = SchemaSettingsItemCommon<SchemaSettingsSelectItemProps> & {
+    type: 'actionModal';
+};
+export interface SchemaSettingItemSubMenuType extends SchemaSettingsItemCommon<SchemaSettingsSubMenuProps> {
+    type: 'subMenu';
+}
+export interface SchemaSettingItemComponentType<T = {}> extends SchemaSettingsItemCommon<T> {
+    Component: string | ComponentType<T>;
+}
+export type SchemaSettingItemAllBuiltType = SchemaSettingItemDividerProps | SchemaSettingItemRemoveType | SchemaSettingItemActionModalType | SchemaSettingItemSwitchType | SchemaSettingItemPopupType | SchemaSettingItemCascaderType | SchemaSettingItemModalType | SchemaSettingItemItemType | SchemaSettingItemSelectType | SchemaSettingItemSubMenuType | SchemaSettingItemGroupType;
+export type SchemaSettingsItemType = SchemaSettingItemComponentType | SchemaSettingItemAllBuiltType;
+export type SchemaSettingsItemTypeWithoutName = Omit<SchemaSettingItemComponentType, 'name'> | Omit<SchemaSettingItemAllBuiltType, 'name'>;
+export {};

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

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const SchemaToolbarContext: React.Context<any>;
+export declare const SchemaToolbarProvider: (props: any) => React.JSX.Element;
+export declare function useSchemaToolbar<T = any>(): T;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ISchema } from '@tachybase/schema';
+import { SchemaToolbarProps } from '../../../schema-settings/GeneralSchemaDesigner';
+export declare const useSchemaToolbarRender: (fieldSchema: ISchema) => {
+    render(props?: SchemaToolbarProps & {
+        [index: string]: any;
+    }): React.JSX.Element;
+    exists: boolean;
+};

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

@@ -0,0 +1,2 @@
+export * from './context';
+export * from './hooks';

package/es/application/utils/globalDeps.d.ts

@@ -0,0 +1,5 @@
+import type { RequireJS } from '@tachybase/requirejs';
+/**
+ * @internal
+ */
+export declare function defineGlobalDeps(requirejs: RequireJS): void;

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

@@ -0,0 +1,3 @@
+import { ComponentType, FC } from 'react';
+export declare function normalizeContainer(container: Element | ShadowRoot | string): Element | null;
+export declare const compose: (...components: [ComponentType, any][]) => (LastChild?: ComponentType) => FC;

package/es/application/utils/remotePlugins.d.ts

@@ -0,0 +1,36 @@
+import type { RequireJS } from '@tachybase/requirejs';
+import type { DevDynamicImport } from '../Application';
+import type { Plugin } from '../Plugin';
+import type { PluginData } from '../PluginManager';
+/**
+ * @internal
+ */
+export declare function defineDevPlugins(plugins: Record<string, unknown>): void;
+/**
+ * @internal
+ */
+export declare function definePluginClient(packageName: string): void;
+/**
+ * @internal
+ */
+export declare function configRequirejs(requirejs: any, pluginData: PluginData[]): void;
+/**
+ * @internal
+ */
+export declare function processRemotePlugins(pluginData: PluginData[], resolve: (plugins: [string, typeof Plugin][]) => void): (...pluginModules: (typeof Plugin & {
+    default?: typeof Plugin;
+})[]) => void;
+/**
+ * @internal
+ */
+export declare function getRemotePlugins(requirejs: any, pluginData?: PluginData[]): Promise<Array<[string, typeof Plugin]>>;
+interface GetPluginsOption {
+    requirejs: RequireJS;
+    pluginData: PluginData[];
+    devDynamicImport?: DevDynamicImport;
+}
+/**
+ * @internal
+ */
+export declare function getPlugins(options: GetPluginsOption): Promise<Array<[string, typeof Plugin]>>;
+export {};

package/es/async-data-provider/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Result } from 'ahooks/es/useRequest/src/types';
+export declare const AsyncDataContext: React.Context<Result<any, any> & {
+    state?: any;
+    setState?: any;
+}>;
+export interface AsyncDataProviderProps {
+    value?: any;
+    request?: any;
+    uid?: string;
+    onSuccess?: (data: any, params: any) => void;
+    children: React.ReactNode;
+}
+export declare const AsyncDataProvider: (props: AsyncDataProviderProps) => React.JSX.Element;
+export declare const useAsyncData: () => Result<any, any> & {
+    state?: any;
+    setState?: any;
+};

package/es/block-provider/BlockProvider.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import { GeneralField } from '@tachybase/schema';
+/**
+ * @deprecated
+ */
+export declare const BlockResourceContext: React.Context<any>;
+export declare const BlockAssociationContext: React.Context<any>;
+/**
+ * @deprecated
+ */
+export declare const BlockRequestContext_deprecated: React.Context<{
+    block?: string;
+    props?: any;
+    field?: GeneralField;
+    service?: any;
+    resource?: any;
+    allowedActions?: any;
+    __parent?: any;
+    updateAssociationValues?: any[];
+}>;
+export declare const useBlockResource: () => any;
+export declare const MaybeCollectionProvider: (props: any) => any;
+/**
+ * @deprecated
+ * @param props
+ * @returns
+ */
+export declare const BlockRequestProvider_deprecated: (props: any) => React.JSX.Element;
+/**
+ * @deprecated
+ */
+export declare const useBlockRequestContext: () => {
+    block?: string;
+    props?: any;
+    field?: GeneralField;
+    service?: any;
+    resource?: any;
+    allowedActions?: any;
+    __parent?: any;
+    updateAssociationValues?: any[];
+};
+export declare const RenderChildrenWithAssociationFilter: React.FC<any>;
+export declare const useBlockContext: () => {
+    /** 用以区分卡片的标识 */
+    name: string;
+};
+/**
+ * @deprecated use `DataBlockProvider` instead
+ */
+export declare const BlockProvider: (props: {
+    name: string;
+    resource: any;
+    collection?: any;
+    association?: any;
+    dataSource?: string;
+    params?: any;
+    children?: any;
+    parentRecord?: any;
+    /** @deprecated */
+    useSourceId?: any;
+    /** @deprecated */
+    useParams?: any;
+}) => React.JSX.Element;
+export declare const useBlockAssociationContext: () => any;
+export declare const useFilterByTk: () => any;
+/**
+ * @deprecated
+ * 已弃用，应使用 useSourceIdFromParentRecord
+ * @returns
+ */
+export declare const useSourceIdFromRecord: () => any;
+export declare const useSourceIdFromParentRecord: () => any;
+export declare const useParamsFromRecord: () => {
+    filterByTk: any;
+};
+export declare const RecordLink: (props: any) => React.JSX.Element;

package/es/block-provider/DetailsBlockProvider.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export declare const DetailsBlockContext: React.Context<any>;
+export declare const DetailsBlockProvider: React.FunctionComponent<any>;
+/**
+ * @deprecated
+ */
+export declare const useDetailsBlockContext: () => any;
+/**
+ * @deprecated
+ * 即将废弃，请用 useDetailsWithPaginationProps 或者 useDetailsProps
+ * @returns
+ */
+export declare const useDetailsBlockProps: () => {
+    form: any;
+};