@unicom-cloud/ui 0.8.41

package/types/radio/interface.d.ts

@@ -0,0 +1,39 @@
+import { CSSProperties, ChangeEvent, HTMLAttributes, ReactNode } from 'react';
+export interface RadioProps<T = any> extends Omit<HTMLAttributes<HTMLLabelElement>, 'children' | 'className' | 'onChange'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    value?: T;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean, event: ChangeEvent) => void;
+    children?: ReactNode | ((value: {
+        checked: boolean;
+    }) => ReactNode);
+}
+export interface RadioGroupProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    name?: string;
+    type?: 'radio' | 'button';
+    direction?: 'vertical' | 'horizontal';
+    size?: 'small' | 'default' | 'large' | 'mini';
+    mode?: 'outline' | 'fill';
+    onChange?: (value: any, event: ChangeEvent) => void;
+    defaultValue?: any;
+    value?: any;
+    options?: (string | number | {
+        label: ReactNode;
+        value: any;
+        disabled?: boolean;
+    })[];
+}
+export interface RadioGroupContextProps {
+    type: 'radio' | 'button';
+    value?: any;
+    disabled?: boolean;
+    group?: boolean;
+    name?: RadioGroupProps['name'];
+    onChangeValue?: (value: any, event: ChangeEvent) => void;
+}

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

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

package/types/rate/index.d.ts

@@ -0,0 +1,6 @@
+import './style';
+import React from 'react';
+import type { RateProps } from './interface';
+declare const RateComponent: React.ForwardRefExoticComponent<RateProps & React.RefAttributes<unknown>>;
+export default RateComponent;
+export type { RateProps };

package/types/rate/interface.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface RateProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    defaultValue?: number;
+    character?: ReactNode | ((index: number) => ReactNode);
+    count?: number;
+    value?: number;
+    tooltips?: string[];
+    allowHalf?: boolean;
+    allowClear?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    grading?: boolean;
+    onChange?: (value: number) => void;
+    onHoverChange?: (value: number) => void;
+}

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

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

package/types/resize-box/ResizeTrigger.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties, PropsWithChildren, ReactNode } from 'react';
+export interface ResizeTriggerProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    direction: string;
+    icon?: ReactNode;
+    onMouseDown?: (e: any) => void;
+    onResize?: (e: any) => void;
+    resizable?: boolean;
+    collapsible?: {
+        prev?: {
+            icon?: ReactNode;
+            onClick?: (e: any) => void;
+            collapsed?: boolean;
+        };
+        next?: {
+            icon?: ReactNode;
+            onClick?: (e: any) => void;
+            collapsed?: boolean;
+        };
+    };
+    renderChildren?: (prev: ReactNode, trigger: ReactNode, next: ReactNode) => ReactNode;
+}
+export default function ResizeTrigger(props: PropsWithChildren<ResizeTriggerProps>): import("react/jsx-dev-runtime").JSX.Element;

package/types/resize-box/Split.d.ts

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

package/types/resize-box/SplitGroup.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { SplitGroupProps } from './interface';
+declare const SplitGroupComponent: React.ForwardRefExoticComponent<SplitGroupProps & React.RefAttributes<unknown>>;
+export default SplitGroupComponent;

package/types/resize-box/index.d.ts

@@ -0,0 +1,13 @@
+import './style';
+import Split from './Split';
+import SplitGroup from './SplitGroup';
+import type { ResizeBoxProps } from './interface';
+export type DirectionType = 'left' | 'right' | 'top' | 'bottom';
+declare const ResizeBoxComponent: import("react").ForwardRefExoticComponent<ResizeBoxProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<unknown>> & {
+    Split: typeof Split;
+    SplitGroup: typeof SplitGroup;
+};
+export default ResizeBoxComponent;
+export type { ResizeBoxProps };

package/types/resize-box/interface.d.ts

@@ -0,0 +1,73 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface ResizeBoxProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    width?: number;
+    height?: number;
+    component?: string;
+    directions?: Array<'left' | 'right' | 'top' | 'bottom'>;
+    resizeIcons?: {
+        top?: ReactNode;
+        bottom?: ReactNode;
+        left?: ReactNode;
+        right?: ReactNode;
+    };
+    resizeTriggers?: {
+        top?: ReactNode;
+        bottom?: ReactNode;
+        left?: ReactNode;
+        right?: ReactNode;
+    };
+    onMovingStart?: () => void;
+    onMoving?: (e: MouseEvent, size: {
+        width: number;
+        height: number;
+    }) => void;
+    onMovingEnd?: () => void;
+}
+export interface SplitProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    component?: string;
+    direction?: 'horizontal' | 'vertical' | 'horizontal-reverse' | 'vertical-reverse';
+    icon?: ReactNode;
+    trigger?: ReactNode;
+    size?: number | string;
+    min?: number | string;
+    max?: number | string;
+    panes: ReactNode[];
+    disabled?: boolean;
+    onMovingStart?: () => void;
+    onMoving?: (e: MouseEvent, size: number | string) => void;
+    onMovingEnd?: () => void;
+    onPaneResize?: (paneContainers: HTMLElement[]) => void;
+}
+export interface SplitGroupProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    component?: string;
+    direction?: 'horizontal' | 'vertical';
+    icon?: ReactNode;
+    panes: SplitGroupPane[];
+    onMovingStart?: (activeIndex: number) => void;
+    onMoving?: (e: MouseEvent, size: string[], activeIndex: number) => void;
+    onMovingEnd?: (activeIndex: number) => void;
+    onPaneResize?: (paneContainers: HTMLElement[]) => void;
+}
+export interface CollapsedConfig {
+    icon?: ReactNode;
+    onClick?: (e: any, collapsed: any, activeIndex: any, direction: 'prev' | 'next') => void;
+}
+export interface SplitGroupPane {
+    content: ReactNode;
+    size?: number | string;
+    min?: number | string;
+    max?: number | string;
+    disabled?: boolean;
+    collapsible?: boolean | {
+        prev?: boolean | CollapsedConfig;
+        next?: boolean | CollapsedConfig;
+    };
+    resizable?: boolean;
+    trigger?: (prevNode: ReactNode, resizeNode: ReactNode, nextNode: ReactNode) => ReactNode;
+}

package/types/resize-box/style/index.d.ts

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

package/types/result/403.d.ts

@@ -0,0 +1 @@
+export default function Image403(): import("react/jsx-dev-runtime").JSX.Element;

package/types/result/404.d.ts

@@ -0,0 +1 @@
+export default function Image404(): import("react/jsx-dev-runtime").JSX.Element;

package/types/result/500.d.ts

@@ -0,0 +1 @@
+export default function Image500(): import("react/jsx-dev-runtime").JSX.Element;

package/types/result/index.d.ts

@@ -0,0 +1,7 @@
+import './style';
+import type { ResultProps } from './interface';
+declare const ResultRef: import("react").ForwardRefExoticComponent<ResultProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<unknown>>;
+export default ResultRef;
+export type { ResultProps };

package/types/result/interface.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties, ReactNode } from 'react';
+export type ResultStatus = null | 'success' | 'error' | 'info' | 'warning' | '404' | '403' | '500';
+export interface ResultProps {
+    className?: string | string[];
+    style?: CSSProperties;
+    title?: ReactNode;
+    subTitle?: ReactNode;
+    status?: 'success' | 'error' | 'info' | 'warning' | '404' | '403' | '500' | null;
+    icon?: ReactNode;
+    extra?: ReactNode;
+}

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

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

package/types/select/OptGroup.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { OptGroupProps } from './interface';
+declare const OptGroupComponent: React.ForwardRefExoticComponent<OptGroupProps & React.RefAttributes<unknown>> & {
+    __PQB_SELECT_OPTGROUP__?: boolean | undefined;
+};
+export default OptGroupComponent;

package/types/select/Option.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { OptionProps } from './interface';
+declare const OptionComponent: React.ForwardRefExoticComponent<OptionProps & React.RefAttributes<unknown>> & {
+    __PQB_SELECT_OPTION__?: boolean | undefined;
+};
+export default OptionComponent;

package/types/select/Select.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import OptGroup from './OptGroup';
+import Option from './Option';
+import type { SelectHandle, SelectProps } from './interface';
+declare const SelectComponent: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<SelectHandle>> & {
+    Option: typeof Option;
+    OptGroup: typeof OptGroup;
+};
+export type { SelectHandle };
+export default SelectComponent;

package/types/select/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import Select from './Select';
+export default Select;
+export type { OptGroupProps, OptionProps, SelectProps } from './interface';

package/types/select/interface.d.ts

@@ -0,0 +1,102 @@
+import { Options as ScrollIntoViewOptions } from '@unicom-cloud/scroll-into-view-if-needed';
+import { CSSProperties, HTMLAttributes, PropsWithChildren, ReactElement, ReactNode } from 'react';
+import { SelectViewCommonProps } from '../select-view';
+import { TriggerProps } from '../trigger';
+import { AvailableVirtualListProps } from '../virtual-list';
+export type OptionsType = SelectProps['options'];
+export type InputValueChangeReason = 'manual' | 'optionChecked' | 'optionListHide' | 'tokenSeparator';
+export interface OptionInfo extends PropsWithChildren<OptionProps> {
+    child?: ReactElement;
+    _valid: boolean;
+    _index: number;
+    _origin: 'children' | 'options' | 'userCreatedOptions' | 'userCreatingOption';
+}
+export type LabeledValue = {
+    value: string | number;
+    label: ReactNode;
+};
+export type SelectInnerStateValue = string | number | string[] | number[];
+export interface SelectProps extends SelectViewCommonProps {
+    defaultValue?: string | string[] | number | number[] | LabeledValue | LabeledValue[];
+    value?: string | string[] | number | number[] | LabeledValue | LabeledValue[];
+    inputValue?: string;
+    mode?: 'multiple' | 'tags';
+    options?: (string | number | {
+        label: ReactNode | string;
+        value: string | number;
+        disabled?: boolean;
+        extra?: any;
+    })[];
+    labelInValue?: boolean;
+    filterOption?: boolean | ((inputValue: string, option: ReactElement) => boolean);
+    renderFormat?: (option: OptionInfo | null, value: string | number | LabeledValue) => ReactNode;
+    defaultActiveFirstOption?: boolean;
+    allowCreate?: boolean | {
+        formatter: (inputValue: string, creating: boolean) => SelectProps['options'][number];
+    };
+    unmountOnExit?: boolean;
+    defaultPopupVisible?: boolean;
+    popupVisible?: boolean;
+    notFoundContent?: ReactNode;
+    tokenSeparators?: string[];
+    getPopupContainer?: (node: HTMLElement) => Element;
+    trigger?: TriggerProps['trigger'];
+    triggerElement?: ReactNode | ((params: {
+        value: any;
+        option: OptionInfo | OptionInfo[];
+    }) => ReactNode);
+    triggerProps?: Partial<TriggerProps>;
+    dropdownRender?: (menu: ReactNode) => ReactNode;
+    dropdownMenuStyle?: CSSProperties;
+    dropdownMenuClassName?: string | string[];
+    virtualListProps?: AvailableVirtualListProps;
+    onChange?: (value: any, option: OptionInfo | OptionInfo[]) => void;
+    onSelect?: (value: string | number | LabeledValue, option: OptionInfo) => void;
+    onDeselect?: (value: string | number | LabeledValue, option: OptionInfo) => void;
+    onClear?: (visible: boolean) => void;
+    onSearch?: (value: string, reason: InputValueChangeReason) => void;
+    onFocus?: (e: any) => void;
+    onBlur?: (e: any) => void;
+    onPopupScroll?: (elem: any) => void;
+    onVisibleChange?: (visible: boolean) => void;
+    onInputValueChange?: (value: string, reason: InputValueChangeReason) => void;
+    onPaste?: (e: any) => void;
+}
+export interface OptionProps extends Omit<HTMLAttributes<HTMLLIElement>, 'className'> {
+    _key?: any;
+    style?: CSSProperties;
+    children?: ReactNode;
+    prefixCls?: string;
+    rtl?: boolean;
+    className?: string | string[];
+    wrapperClassName?: string | string[];
+    disabled?: boolean;
+    value: string | number;
+    extra?: any;
+    isSelectOption?: boolean;
+    _isMultipleMode?: boolean;
+    _isUserCreatedOption?: boolean;
+    _isUserCreatingOption?: boolean;
+    _valueActive?: OptionProps['value'];
+    _valueSelect?: SelectInnerStateValue;
+    _onClick?: (value: OptionProps['value'], disabled: boolean) => void;
+    _onMouseEnter?: (value: OptionProps['value']) => void;
+    _onMouseLeave?: () => void;
+}
+export interface OptGroupProps extends HTMLAttributes<HTMLLIElement> {
+    _key?: any;
+    children?: ReactNode;
+    prefixCls?: string;
+    label?: ReactNode;
+    isSelectOptGroup?: boolean;
+}
+export type SelectHandle = {
+    dom: HTMLDivElement;
+    focus: () => void;
+    blur: () => void;
+    hotkeyHandler: (event: KeyboardEvent) => void;
+    activeOptionValue: OptionProps['value'];
+    getOptionInfoList: () => OptionInfo[];
+    getOptionInfoByValue: (value: OptionProps['value']) => OptionInfo;
+    scrollIntoView: (value: OptionProps['value'], options?: ScrollIntoViewOptions) => void;
+};

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

@@ -0,0 +1,6 @@
+import '../../checkbox/style';
+import '../../empty/style';
+import '../../input-tag/style';
+import '../../style/index.less';
+import '../../trigger/style';
+import './index.less';

package/types/select/util.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { OptionInfo, OptionProps, SelectInnerStateValue, SelectProps } from './interface';
+export type OptionInfoMap = Map<OptionProps['value'], OptionInfo>;
+declare function preventDefaultEvent(e: any): void;
+declare function isEmpty(value: any, isMultiple: boolean): boolean;
+declare function getValidValue(value: any, isMultiple: boolean, labelInValue: boolean): SelectInnerStateValue;
+declare function isSelectOption(child: any): boolean;
+declare function isSelectOptGroup(child: any): boolean;
+declare function flatChildren({ children, options, filterOption, }: Pick<SelectProps, 'children' | 'options' | 'filterOption'>, { inputValue, userCreatedOptions, userCreatingOption, prefixCls, }: {
+    inputValue: string;
+    userCreatedOptions?: SelectProps['options'];
+    userCreatingOption?: SelectProps['options'][number];
+    prefixCls: string;
+}, { optionInfoMap, optionValueList, customNodeCount, }?: {
+    optionInfoMap?: OptionInfoMap;
+    optionValueList?: Array<OptionProps['value']>;
+    customNodeCount?: number;
+}): {
+    childrenList: React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+    optionInfoMap: OptionInfoMap;
+    optionValueList: (string | number)[];
+    optionIndexListForArrowKey: number[];
+    hasOptGroup: boolean;
+    hasComplexLabelInOptions: boolean;
+};
+export { flatChildren, getValidValue, isEmpty, isSelectOptGroup, isSelectOption, preventDefaultEvent, };

package/types/select-view/Core.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { SelectViewProps } from './interface';
+export type SelectViewHandle = {
+    dom: HTMLDivElement;
+    focus: () => void;
+    blur: () => void;
+    getWidth: () => number;
+};
+declare const _default: React.ForwardRefExoticComponent<SelectViewProps & {
+    htmlDataAttributes: Record<string, string>;
+} & React.RefAttributes<unknown>>;
+export default _default;

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

@@ -0,0 +1,12 @@
+import './style';
+import React from 'react';
+import type { SelectViewProps } from './interface';
+export type { SelectViewCommonProps, SelectViewProps } from './interface';
+export type SelectViewHandle = {
+    dom: HTMLDivElement;
+    focus: () => void;
+    blur: () => void;
+    getWidth: () => number;
+};
+declare const SelectViewComponent: React.ForwardRefExoticComponent<SelectViewProps & React.RefAttributes<SelectViewHandle>>;
+export default SelectViewComponent;

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

@@ -0,0 +1,60 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { InputTagProps } from '../input-tag';
+import { InputComponentProps } from '../input/interface';
+export interface SelectViewCommonProps extends Pick<InputTagProps<unknown>, 'animation' | 'renderTag' | 'dragToSort'> {
+    id?: string;
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    inputValue?: string;
+    placeholder?: string;
+    bordered?: boolean;
+    showSearch?: boolean | {
+        retainInputValue?: boolean;
+        retainInputValueWhileSelect?: boolean;
+    };
+    size?: 'mini' | 'small' | 'default' | 'large';
+    disabled?: boolean;
+    error?: boolean;
+    status?: 'error' | 'warning';
+    loading?: boolean;
+    allowClear?: boolean;
+    maxTagCount?: number | 'responsive' | {
+        count: number | 'responsive';
+        render?: (invisibleTagCount: number) => ReactNode;
+    };
+    prefix?: ReactNode;
+    suffixIcon?: ReactNode;
+    arrowIcon?: ReactNode | null;
+    removeIcon?: ReactNode | null;
+    clearIcon?: ReactNode;
+    autoWidth?: boolean | {
+        minWidth?: CSSProperties['minWidth'];
+        maxWidth?: CSSProperties['maxWidth'];
+    };
+    addBefore?: ReactNode;
+    onClick?: (e: any) => void;
+    onKeyDown?: (e: any) => void;
+}
+export interface SelectViewProps extends SelectViewCommonProps {
+    value?: any;
+    popupVisible?: boolean;
+    allowCreate?: boolean;
+    isEmptyValue: boolean;
+    isMultiple?: boolean;
+    prefixCls: string;
+    rtl?: boolean;
+    ariaControls?: string;
+    renderText: (value: any) => {
+        text: any;
+        disabled: any;
+    };
+    renderView?: (eleView: ReactElement) => ReactElement;
+    onSort?: (value: any) => void;
+    onRemoveCheckedItem?: (item: any, index: number, e: any) => void;
+    onChangeInputValue?: InputComponentProps['onChange'];
+    onPaste?: (e: any) => void;
+    onClear?: (e: any) => void;
+    onFocus?: (e: any) => void;
+    onBlur?: (e: any) => void;
+}

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

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

package/types/skeleton/Image.d.ts

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

package/types/skeleton/Text.d.ts

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

package/types/skeleton/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import React from 'react';
+import type { SkeletonProps } from './interface';
+declare const SkeletonComponent: React.ForwardRefExoticComponent<SkeletonProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<unknown>>;
+export default SkeletonComponent;
+export type { SkeletonProps };

package/types/skeleton/interface.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties } from 'react';
+export interface SkeletonProps {
+    style?: CSSProperties;
+    className?: string;
+    animation?: boolean;
+    loading?: boolean;
+    image?: SkeletonImageProps | boolean;
+    text?: SkeletonTextProps | boolean;
+}
+export interface SkeletonImageProps {
+    style?: CSSProperties;
+    className?: string;
+    shape?: 'circle' | 'square';
+    size?: 'small' | 'default' | 'large';
+    position?: 'left' | 'right';
+    prefixCls?: string;
+}
+export interface SkeletonTextProps {
+    style?: CSSProperties;
+    className?: string;
+    rows?: number;
+    width?: number | string | (string | number)[];
+    prefixCls?: string;
+}

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

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

package/types/slider/Button.d.ts

@@ -0,0 +1,21 @@
+import React, { CSSProperties, ReactNode } from 'react';
+import type { TooltipPosition } from './interface';
+interface SliderButtonProps {
+    style?: CSSProperties;
+    disabled?: boolean;
+    prefixCls: string;
+    value: number;
+    maxValue?: number;
+    minValue?: number;
+    vertical?: boolean;
+    tooltipVisible?: boolean;
+    tooltipPosition?: TooltipPosition;
+    formatTooltip?: (value: number) => string | ReactNode;
+    getTooltipContainer?: () => Element;
+    onMoving?: (x: number, y: number) => void;
+    onMoveEnd?: () => void;
+    onMoveBegin?: () => void;
+    onArrowEvent?: (type: 'addition' | 'subtraction') => void;
+}
+declare const _default: React.MemoExoticComponent<(props: SliderButtonProps) => import("react/jsx-dev-runtime").JSX.Element>;
+export default _default;

package/types/slider/Dot.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { IntervalConfig } from './hook/useInterval';
+type MaskType = {
+    key: number | string;
+    content: any;
+};
+interface MaskProps {
+    data: MaskType[];
+    valueRange?: [number, number];
+    vertical?: boolean;
+    prefixCls?: string;
+    reverse?: boolean;
+    onMouseDown?: (val: number) => void;
+    intervalConfigs?: IntervalConfig[];
+}
+declare const _default: React.NamedExoticComponent<MaskProps>;
+export default _default;

package/types/slider/Input.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { InputNumberProps } from '../input-number';
+interface InputProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    value: number[];
+    range?: boolean;
+    disabled?: boolean;
+    prefixCls?: string;
+    onChange?: (val: number[]) => void;
+    extra?: InputNumberProps[];
+}
+declare const _default: React.MemoExoticComponent<(props: InputProps) => import("react/jsx-dev-runtime").JSX.Element>;
+export default _default;

package/types/slider/Mark.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { IntervalConfig } from './hook/useInterval';
+type MaskType = {
+    key: number | string;
+    content: any;
+};
+interface MaskProps {
+    data: MaskType[];
+    vertical?: boolean;
+    prefixCls?: string;
+    onMouseDown?: (val: number) => void;
+    reverse?: boolean;
+    intervalConfigs?: IntervalConfig[];
+}
+declare const _default: React.NamedExoticComponent<MaskProps>;
+export default _default;

package/types/slider/Tick.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { IntervalConfig } from './hook/useInterval';
+interface TicksProps {
+    min: number;
+    max: number;
+    valueRange: [number, number];
+    prefixCls: string;
+    vertical: boolean;
+    reverse?: boolean;
+    intervalConfigs?: IntervalConfig[];
+}
+declare function Ticks(props: TicksProps): import("react/jsx-dev-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Ticks>;
+export default _default;