@unicom-cloud/ui 0.8.41

package/types/tree/interface.d.ts

@@ -0,0 +1,152 @@
+import { CSSProperties, DragEvent, PropsWithChildren, ReactElement, ReactNode } from 'react';
+import { TreeNodeProps } from '.';
+import { AvailableVirtualListProps } from '../virtual-list';
+import TreeNode from './Node';
+export type NodeInstance = ReactElement<PropsWithChildren<NodeProps>, typeof TreeNode>;
+export type FakeNodeInstance = {
+    key: string;
+    props: TreeNodeProps;
+};
+export type SHOW_ALL = 'all';
+export type SHOW_PARENT = 'parent';
+export type SHOW_CHILD = 'child';
+export type ActionOnClick = 'select' | 'check' | 'expand';
+export interface TreeState {
+    treeData?: TreeProps['treeData'];
+    nodeList?: NodeProps[];
+    shouldUpdate?: boolean;
+    selectedKeys?: string[];
+    checkedKeys?: string[];
+    expandedKeys?: string[];
+    loadedKeys?: string[];
+    loadingKeys?: string[];
+    halfCheckedKeys?: string[];
+    currentExpandKeys?: string[];
+}
+export type FieldNamesType = {
+    key?: string;
+    title?: string;
+    disabled?: string;
+    children?: string;
+    isLeaf?: string;
+    disableCheckbox?: string;
+    checkable?: string;
+};
+export type TreeDataType = NodeProps & {
+    key?: string;
+    _index?: number;
+    children?: TreeDataType[];
+    [key: string]: any;
+};
+export type AllowDrop = (options: {
+    dropNode: NodeInstance;
+    dragNode: NodeInstance | null;
+    dropPosition: number;
+}) => boolean;
+export interface TreeProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    height?: number;
+    size?: 'mini' | 'small' | 'default' | 'large';
+    blockNode?: boolean;
+    autoExpandParent?: boolean;
+    multiple?: boolean;
+    checkable?: boolean;
+    draggable?: boolean;
+    allowDrop?: AllowDrop;
+    selectable?: boolean;
+    checkStrictly?: boolean;
+    checkedStrategy?: SHOW_ALL | SHOW_PARENT | SHOW_CHILD;
+    defaultSelectedKeys?: string[];
+    selectedKeys?: string[];
+    defaultCheckedKeys?: string[];
+    checkedKeys?: string[];
+    halfCheckedKeys?: string[];
+    defaultExpandedKeys?: string[];
+    expandedKeys?: string[];
+    treeData?: TreeDataType[];
+    fieldNames?: FieldNamesType;
+    icons?: ((nodeProps: NodeProps) => {
+        dragIcon?: ReactNode;
+        switcherIcon?: ReactNode;
+        loadingIcon?: ReactNode;
+    }) | {
+        dragIcon?: ReactNode;
+        switcherIcon?: ReactNode;
+        loadingIcon?: ReactNode;
+    };
+    virtualListProps?: AvailableVirtualListProps;
+    renderExtra?: (props: NodeProps) => ReactNode;
+    renderTitle?: (props: NodeProps) => ReactNode;
+    showLine?: boolean;
+    actionOnClick?: ActionOnClick | ActionOnClick[];
+    loadMore?: (node: NodeInstance) => Promise<void>;
+    onSelect?: (selectedKeys: string[], extra: {
+        selected: boolean;
+        selectedNodes: NodeInstance[];
+        node: NodeInstance;
+        e: Event;
+    }) => void;
+    onSelect_?: (node: NodeProps) => void;
+    onCheck?: (checkedKeys: string[], extra: {
+        node: NodeInstance;
+        checkedNodes: NodeInstance[];
+        checked: boolean;
+        halfCheckedKeys: string[];
+        halfCheckedNodes: NodeInstance[];
+        e: Event;
+    }) => void;
+    onExpand?: (expandedKeys: string[], exra?: {
+        expanded: boolean;
+        node: NodeInstance;
+        expandedNodes: NodeInstance[];
+    }) => void;
+    onDragStart?: (e: DragEvent<HTMLSpanElement>, node: NodeInstance) => void;
+    onDragEnd?: (e: DragEvent<HTMLSpanElement>, node: NodeInstance) => void;
+    onDragOver?: (e: DragEvent<HTMLSpanElement>, node: NodeInstance) => void;
+    onDragLeave?: (e: DragEvent<HTMLSpanElement>, node: NodeInstance) => void;
+    onDrop?: (info: {
+        e: DragEvent<HTMLSpanElement>;
+        dragNode: NodeInstance | null;
+        dropNode: NodeInstance | null;
+        dropPosition: number;
+    }) => void;
+    filterNode?: (node: NodeProps) => boolean;
+    children?: ReactNode;
+    onMouseDown?: (e: any) => void;
+    __PqbAdapterMode__?: boolean;
+}
+export interface NodeProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    blockNode?: boolean;
+    title?: string | ReactNode;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: ReactNode;
+    checkable?: boolean;
+    isLeaf?: boolean;
+    icons?: TreeProps['icons'];
+    draggable?: boolean;
+    showLine?: boolean;
+    checked?: boolean;
+    selected?: boolean;
+    parentKey?: string;
+    pathParentKeys?: string[];
+    indeterminated?: boolean;
+    _key?: string;
+    _level?: number;
+    _lineless?: boolean[];
+    visible?: boolean;
+    selectedKeys?: string[];
+    checkedKeys?: string[];
+    expandedKeys?: string[];
+    loading?: boolean;
+    loaded?: boolean;
+    autoExpandParent?: boolean;
+    expanded?: boolean;
+    childrenData?: NodeProps[];
+    dataRef?: TreeDataType;
+    loadMore?: (node: NodeProps) => void;
+}

package/types/tree/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../checkbox/style';
+import '../../style/index.less';
+import './index.less';

package/types/tree/util.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { key2nodePropsType } from '.';
+import type { TreeDataType } from './interface';
+export declare const getTreeDataFromTreeChildren: (treeChildren: ReactNode) => any;
+export declare function getChildNodeKeys(node: TreeDataType, key2nodeProps: key2nodePropsType): Set<string>;
+export declare function getCheckedKeysByInitKeys(checkedKeys: string[], key2nodeProps: any): {
+    checkedKeys: string[];
+    indeterminateKeys: string[];
+};
+export declare function getAllCheckedKeysByCheck(key: string, checked: boolean, checkedKeys: string[], key2nodeProps: key2nodePropsType, indeterminateKeys: string[]): {
+    checkedKeys: string[];
+    indeterminateKeys: string[];
+};

package/types/tree-select/List.d.ts

@@ -0,0 +1,11 @@
+import { TreeProps } from '../tree/interface';
+import type { LabelValue, TreeSelectProps } from './interface';
+interface TreeListProps extends TreeSelectProps {
+    value: LabelValue[];
+    multiple: boolean;
+    filterNode: TreeProps['filterNode'];
+    inputValue?: string;
+    prefixCls?: string;
+}
+declare const _default: import("react").ForwardRefExoticComponent<TreeListProps & import("react").RefAttributes<unknown>>;
+export default _default;

package/types/tree-select/Select.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import Tree from '../tree';
+import { RefTreeSelectType, TreeSelectProps } from './interface';
+declare const TreeSelectComponent: import("react").ForwardRefExoticComponent<TreeSelectProps & {
+    children?: ReactNode;
+} & import("react").RefAttributes<RefTreeSelectType>> & {
+    Node: typeof Tree.Node;
+    SHOW_ALL: typeof Tree.SHOW_ALL;
+    SHOW_PARENT: typeof Tree.SHOW_PARENT;
+    SHOW_CHILD: typeof Tree.SHOW_CHILD;
+};
+export default TreeSelectComponent;

package/types/tree-select/hook/useKeyCache.d.ts

@@ -0,0 +1,6 @@
+import { TreeSelectDataType } from '../../tree-select/interface';
+export type KeyCacheType = {
+    [key: string]: TreeSelectDataType;
+};
+declare const useKeyCache: (treeData: any, fieldNames: any) => KeyCacheType;
+export default useKeyCache;

package/types/tree-select/hook/useStateValue.d.ts

@@ -0,0 +1,22 @@
+import { MutableRefObject } from 'react';
+import { LabelValue, TreeSelectProps } from '../../tree-select/interface';
+import { NodeProps } from '../../tree/interface';
+import { KeyCacheType } from './useKeyCache';
+type valueType = (string | LabelValue)[];
+export interface TreeSelectState {
+    value: valueType[];
+    popupVisible: boolean;
+    focused: boolean;
+    inputValue: string;
+    searchKeys: string[];
+}
+export declare const parseValue: (v: valueType, key2nodeProps: any, valueMap?: LabelValue[]) => LabelValue[];
+declare const useStateValue: (props: TreeSelectProps, key2nodeProps: KeyCacheType, indeterminateKeys: MutableRefObject<string[]>) => [
+    LabelValue[],
+    (v: LabelValue[], extra: {
+        trigger?: NodeProps;
+        checked?: boolean;
+        selected?: boolean;
+    }) => void
+];
+export default useStateValue;

package/types/tree-select/hook/useTreeData.d.ts

@@ -0,0 +1,3 @@
+import { TreeSelectProps } from '../../tree-select/interface';
+import { TreeProps } from '../../tree/interface';
+export default function useTreeData(props: TreeSelectProps): [TreeProps['treeData']];

package/types/tree-select/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import TreeSelect from './Select';
+export default TreeSelect;
+export type { RefTreeSelectType, TreeSelectProps } from './interface';

package/types/tree-select/interface.d.ts

@@ -0,0 +1,79 @@
+import { CSSProperties, ReactNode } from 'react';
+import { SelectViewCommonProps } from '../select-view';
+import { NodeProps, TreeDataType, TreeProps } from '../tree/interface';
+import { TriggerProps } from '../trigger';
+export type TreeSelectDataType = TreeDataType & {
+    value?: string;
+};
+export type LabelValue = {
+    label: ReactNode;
+    value: string;
+    disabled?: boolean;
+};
+export interface TreeSelectProps extends SelectViewCommonProps {
+    multiple?: boolean;
+    defaultValue?: string | string[] | {
+        label: ReactNode;
+        value: string;
+        disabled?: boolean;
+    } | {
+        label: ReactNode;
+        value: string;
+        disabled?: boolean;
+    }[];
+    value?: string | string[] | {
+        label: ReactNode;
+        value: string;
+        disabled?: boolean;
+    } | {
+        label: ReactNode;
+        value: string;
+        disabled?: boolean;
+    }[];
+    renderFormat?: (option: NodeProps | null, value: string | LabelValue) => ReactNode;
+    inputValue?: string;
+    fieldNames?: TreeProps['fieldNames'];
+    treeData?: TreeSelectDataType[];
+    labelInValue?: boolean;
+    unmountOnExit?: boolean;
+    treeCheckable?: boolean;
+    treeCheckStrictly?: boolean;
+    treeCheckedStrategy?: TreeProps['checkedStrategy'];
+    treeProps?: Partial<TreeProps>;
+    triggerProps?: Partial<TriggerProps>;
+    triggerElement?: ReactNode | ((params: {
+        value: any;
+    }) => ReactNode);
+    bordered?: boolean;
+    notFoundContent?: ReactNode;
+    popupVisible?: boolean;
+    dropdownMenuStyle?: CSSProperties;
+    dropdownRender?: (dom: ReactNode) => ReactNode;
+    onChange?: (value: any, extra: {
+        trigger?: NodeProps;
+        checked?: boolean;
+        selected?: boolean;
+    }) => void;
+    getPopupContainer?: (node: HTMLElement) => Element;
+    onVisibleChange?: (visible: boolean) => void;
+    filterTreeNode?: (inputText: any, treeNode: any) => boolean | void;
+    loadMore?: (treeNode: NodeProps, dataRef: any) => void;
+    onSearch?: (inputValue: string) => void;
+    onInputValueChange?: (value: string, reason: InputValueChangeReason) => void;
+    onClear?: (visible: boolean) => void;
+}
+export type RefTreeSelectType = {
+    focus: () => void;
+    blur: () => void;
+};
+export declare const DefaultFieldNames: {
+    key: string;
+    title: string;
+    children: string;
+    selectable: string;
+    disabled: string;
+    disableCheckbox: string;
+    checkable: string;
+    isLeaf: string;
+};
+export type InputValueChangeReason = 'manual' | 'optionChecked' | 'optionListHide';

package/types/tree-select/style/index.d.ts

@@ -0,0 +1,5 @@
+import '../../empty/style';
+import '../../style/index.less';
+import '../../tree/style';
+import '../../trigger/style';
+import './index.less';

package/types/tree-select/util.d.ts

@@ -0,0 +1 @@
+export declare const normalizeValueToArray: (val: any) => string[];

package/types/trigger/Portal.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export interface PortalProps {
+    getContainer: () => HTMLElement;
+    children?: React.ReactNode;
+}
+declare const Portal: (props: PortalProps) => React.ReactPortal | null;
+export default Portal;

package/types/trigger/getPopupStyle.d.ts

@@ -0,0 +1,20 @@
+import { CSSProperties } from 'react';
+import { MouseLocationType, TriggerProps } from './interface';
+export declare const getBoundingClientRect: (dom: any, options: {
+    boundaryDistance?: TriggerProps['boundaryDistance'];
+    position: TriggerProps['position'];
+}) => {
+    width: any;
+    height: any;
+    left: any;
+    right: any;
+    top: any;
+    bottom: any;
+};
+type ReturnType = {
+    style?: CSSProperties;
+    arrowStyle?: CSSProperties;
+    realPosition?: TriggerProps['position'];
+};
+declare const _default: (props: TriggerProps, content: HTMLElement, child: HTMLElement, mountContainer: Element, mouseLocation: MouseLocationType) => ReturnType;
+export default _default;

package/types/trigger/index.d.ts

@@ -0,0 +1,125 @@
+import './style';
+import React, { CSSProperties, PropsWithChildren, PureComponent } from 'react';
+import { ConfigContext } from '../config-provider';
+import type { MouseLocationType, TriggerProps } from './interface';
+export type { TriggerProps };
+declare function getDOMPos(dom: HTMLElement, options: {
+    boundaryDistance: TriggerProps['boundaryDistance'];
+    position: TriggerProps['position'];
+}): {
+    width?: undefined;
+    height?: undefined;
+    left?: undefined;
+    right?: undefined;
+} | {
+    width: any;
+    height: any;
+    left: any;
+    right: any;
+};
+export interface TriggerState {
+    popupVisible: boolean;
+    popupStyle: object;
+}
+export declare const EventsByTriggerNeed: string[];
+export type EventsByTriggerNeedType = 'onClick' | 'onMouseEnter' | 'onMouseLeave' | 'onMouseMove' | 'onFocus' | 'onBlur' | 'onContextMenu' | 'onKeyDown';
+declare class Trigger extends PureComponent<TriggerProps, TriggerState> {
+    static displayName: string;
+    static contextType: React.Context<import("../config-provider").ConfigProviderProps>;
+    context: React.ContextType<typeof ConfigContext>;
+    static getDerivedStateFromProps(nextProps: any, state: any): {
+        popupVisible: any;
+    } | null;
+    popupContainer: any;
+    refTrigger: HTMLSpanElement | null;
+    delayTimer: any;
+    updatePositionTimer: any;
+    realPosition: string;
+    arrowStyle: CSSProperties;
+    popupOpen: boolean;
+    mousedownToHide: boolean;
+    mouseDownTimeout: any;
+    hasPopupMouseDown: boolean;
+    handleClickOutside: boolean;
+    handleWindowResize: boolean;
+    unmount: boolean;
+    isDidMount: boolean;
+    mouseLocation: MouseLocationType;
+    observerContainer: null;
+    scrollElements: (HTMLElement | Window)[];
+    resizeObserver: ResizeObserver;
+    resizeObserver2: ResizeObserver | null;
+    resizeObserver2Observe(): void;
+    resizeObserver2Disconnect(): void;
+    resizeObserver3: ResizeObserver | null;
+    resizeObserver3Observe(): void;
+    resizeObserver3Disconnect(): void;
+    childrenDom: null;
+    childrenDomSize: ReturnType<typeof getDOMPos>;
+    getMergedProps: (basePropsOrKeys?: any) => PropsWithChildren<TriggerProps>;
+    constructor(props: any, context: any);
+    getRootElement: () => HTMLElement;
+    componentDidMount(): void;
+    componentDidUpdate(_prevProps: any): void;
+    componentWillUnmount(): void;
+    offScrollListeners: () => void;
+    offWindowResize: () => void;
+    offContainerResize: () => void;
+    handleScroll: () => void;
+    onContainersScroll: (props: TriggerProps) => void;
+    onContainerResize: () => void;
+    handleUpdatePosition: {
+        (...args: any[]): void;
+        cancel(): void;
+    };
+    isClickTrigger: () => boolean;
+    isFocusTrigger: () => boolean;
+    isHoverTrigger: () => boolean;
+    isContextMenuTrigger: () => boolean;
+    isMouseLeaveToClose: () => boolean | undefined;
+    isPopupHoverHide: () => boolean;
+    isClickToHide: () => boolean | undefined;
+    isBlurToHide: () => boolean | undefined;
+    clearTimer: () => void;
+    offClickOutside: () => void;
+    getTransformOrigin: (position: any) => {
+        transformOrigin?: undefined;
+    } | {
+        transformOrigin: any;
+    };
+    getTransformTranslate: () => "" | "scaleY(0.9) translateY(-4px)" | "scaleY(0.9) translateY(4px)";
+    getPopupStyle: () => any;
+    showPopup: (callback?: () => void) => void;
+    update: {
+        (...args: any[]): void;
+        cancel(): void;
+    };
+    updatePopupPosition: (delay?: number, callback?: () => void) => void;
+    setPopupVisible: (visible: boolean, delay?: number, callback?: () => void) => void;
+    delayToDo: (delay: number, callback: () => void) => void;
+    clearDelayTimer(): void;
+    onClickOutside: (e: any) => void;
+    onKeyDown: (e: any) => void;
+    onPressEsc: (e: any) => void;
+    onMouseEnter: (e: any) => void;
+    onMouseMove: (e: any) => void;
+    onMouseLeave: (e: any) => void;
+    onPopupMouseEnter: () => void;
+    onPopupMouseLeave: (e: any) => void;
+    setMouseLocation: (e: any) => void;
+    onContextMenu: (e: any) => void;
+    clickToHidePopup: (e: any) => void;
+    onClick: (e: any) => void;
+    onFocus: (e: any) => void;
+    onBlur: (e: any) => void;
+    onResize: () => void;
+    onPopupMouseDown: () => void;
+    getChild: () => string | number | true | Iterable<React.ReactNode> | import("react/jsx-dev-runtime").JSX.Element;
+    rafId: number;
+    appendToContainer: (node: HTMLDivElement) => void;
+    getContainer: () => HTMLDivElement;
+    triggerPropsEvent: (eventName: EventsByTriggerNeedType, e: any) => void;
+    triggerOriginEvent: (eventName: EventsByTriggerNeedType) => any;
+    render(): import("react/jsx-dev-runtime").JSX.Element | null;
+}
+export default Trigger;

package/types/trigger/interface.d.ts

@@ -0,0 +1,71 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+export interface TriggerProps {
+    className?: string | string[];
+    style?: CSSProperties;
+    popupStyle?: CSSProperties;
+    alignPoint?: boolean;
+    autoAlignPopupWidth?: boolean;
+    autoAlignPopupMinWidth?: boolean;
+    classNames?: string;
+    duration?: number | {
+        exit?: number;
+        enter?: number;
+        appear?: number;
+    };
+    childrenPrefix?: string;
+    disabled?: boolean;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    focusDelay?: number;
+    getDocument?: () => Element;
+    getPopupContainer?: (node: HTMLElement) => Element;
+    unmountOnExit?: boolean;
+    trigger?: 'hover' | 'click' | 'focus' | 'contextMenu' | Array<'hover' | 'click' | 'focus' | 'contextMenu'>;
+    position?: 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br' | 'left' | 'lt' | 'lb' | 'right' | 'rt' | 'rb';
+    popup?: () => ReactNode;
+    autoFitPosition?: boolean;
+    boundaryDistance?: {
+        left?: number;
+        bottom?: number;
+    } | {
+        left?: number;
+        top?: number;
+    } | {
+        right?: number;
+        bottom?: number;
+    } | {
+        right?: number;
+        top?: number;
+    };
+    popupHoverStay?: boolean;
+    blurToHide?: boolean;
+    mouseLeaveToClose?: boolean;
+    clickToClose?: boolean;
+    clickOutsideToClose?: boolean | {
+        capture: boolean;
+    };
+    escToClose?: boolean;
+    containerScrollToClose?: boolean;
+    onClick?: (e: any) => void;
+    onClickOutside?: Function;
+    popupAlign?: {
+        left?: number | [number, number];
+        right?: number | [number, number];
+        top?: number | [number, number];
+        bottom?: number | [number, number];
+    };
+    defaultPopupVisible?: boolean;
+    popupVisible?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+    autoFixPosition?: boolean;
+    showArrow?: boolean;
+    arrowProps?: HTMLAttributes<HTMLDivElement>;
+    updateOnScroll?: boolean;
+    children?: ReactNode;
+    __onExit?: (event: any) => void;
+    __onExited?: (event: any) => void;
+}
+export type MouseLocationType = {
+    clientX: number;
+    clientY: number;
+};

package/types/trigger/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/typography/Base.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+import type { TypographyParagraphProps, TypographyTextProps, TypographyTitleProps } from './interface';
+type BaseProps = PropsWithChildren<TypographyParagraphProps & TypographyTitleProps & TypographyTextProps> & {
+    componentType: 'Title' | 'Paragraph' | 'Text';
+};
+declare function Base(props: BaseProps): import("react/jsx-dev-runtime").JSX.Element;
+export default Base;

package/types/typography/EditContent.d.ts

@@ -0,0 +1,2 @@
+import type { EditContentProps } from './interface';
+export default function EditContent(props: EditContentProps): import("react/jsx-dev-runtime").JSX.Element;

package/types/typography/Ellipsis.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { TypographyEllipsisProps } from './interface';
+declare const Ellipsis: React.ForwardRefExoticComponent<TypographyEllipsisProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<unknown>>;
+export default Ellipsis;

package/types/typography/Operations.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from 'react';
+import type { OperationsProps } from './interface';
+export default function Operations(props: PropsWithChildren<OperationsProps>): import("react/jsx-dev-runtime").JSX.Element;

package/types/typography/Paragraph.d.ts

@@ -0,0 +1,6 @@
+import type { TypographyParagraphProps } from './interface';
+declare function Paragraph(props: TypographyParagraphProps): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Paragraph {
+    var displayName: string;
+}
+export default Paragraph;

package/types/typography/Text.d.ts

@@ -0,0 +1,6 @@
+import type { TypographyTextProps } from './interface';
+declare function Text(props: TypographyTextProps): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Text {
+    var displayName: string;
+}
+export default Text;

package/types/typography/Title.d.ts

@@ -0,0 +1,6 @@
+import type { TypographyTitleProps } from './interface';
+declare function Title(props: TypographyTitleProps): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Title {
+    var displayName: string;
+}
+export default Title;

package/types/typography/Typography.d.ts

@@ -0,0 +1,3 @@
+import type { TypographyProps } from './interface';
+declare const TypographyComponent: import("react").ForwardRefExoticComponent<TypographyProps & import("react").RefAttributes<unknown>>;
+export default TypographyComponent;

package/types/typography/index.d.ts

@@ -0,0 +1,12 @@
+import Ellipsis from './Ellipsis';
+import Paragraph from './Paragraph';
+import Text from './Text';
+import Title from './Title';
+declare const Typography: import("react").ForwardRefExoticComponent<import("./interface").TypographyProps & import("react").RefAttributes<unknown>> & {
+    Title: typeof Title;
+    Text: typeof Text;
+    Paragraph: typeof Paragraph;
+    Ellipsis: typeof Ellipsis;
+};
+export default Typography;
+export type { EllipsisConfig, TypographyEllipsisProps, TypographyParagraphProps, TypographyProps, TypographyTextProps, TypographyTitleProps, } from './interface';