@unicom-cloud/ui 0.8.41

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

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

package/types/carousel/Arrow.d.ts

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

package/types/carousel/Indicator.d.ts

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

package/types/carousel/index.d.ts

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

package/types/carousel/interface.d.ts

@@ -0,0 +1,52 @@
+import { CSSProperties, MutableRefObject, ReactNode } from 'react';
+export type CarouselHandle = {
+    dom: HTMLElement;
+    goto: (options: {
+        index: number;
+        isNegative?: boolean;
+        isManual?: boolean;
+        resetAutoPlayInterval?: boolean;
+    }) => void;
+};
+export interface CarouselProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    currentIndex?: number;
+    autoPlay?: boolean | {
+        interval?: number;
+        hoverToPause?: boolean;
+    };
+    miniRender?: boolean;
+    autoPlaySpeed?: number;
+    moveSpeed?: number;
+    animation?: 'slide' | 'card' | 'fade';
+    trigger?: 'click' | 'hover';
+    direction?: 'horizontal' | 'vertical';
+    showArrow?: 'always' | 'hover' | 'never';
+    arrowClassName?: string | string[];
+    icons?: {
+        prev?: ReactNode;
+        next?: ReactNode;
+    };
+    indicatorType?: 'line' | 'dot' | 'slider' | 'never';
+    indicatorPosition?: 'bottom' | 'top' | 'left' | 'right' | 'outer';
+    indicatorClassName?: string | string[];
+    timingFunc?: string;
+    onChange?: (index: number, prevIndex: number, isManual: boolean) => void;
+    carousel?: MutableRefObject<CarouselHandle>;
+}
+export interface CarouselArrowProps extends Pick<CarouselProps, 'direction' | 'showArrow' | 'icons'> {
+    className?: string | string[];
+    prev?: (e: any) => any;
+    next?: (e: any) => any;
+}
+export interface CarouselIndicatorProps {
+    className?: string | string[];
+    count: number;
+    activeIndex?: number;
+    type?: CarouselProps['indicatorType'];
+    position?: CarouselProps['indicatorPosition'];
+    trigger?: CarouselProps['trigger'];
+    onSelectIndex?: (e: number) => void;
+}

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

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

package/types/cascader/Cascader.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { SelectViewHandle } from '../select-view';
+import type { CascaderProps } from './interface';
+export declare const DefaultFieldNames: {
+    label: string;
+    value: string;
+    isLeaf: string;
+    children: string;
+    disabled: string;
+};
+interface ForwardRefCascaderType extends React.ForwardRefExoticComponent<React.PropsWithoutRef<CascaderProps> & React.RefAttributes<SelectViewHandle>> {
+    <T = any>(props: React.PropsWithChildren<CascaderProps<T>> & {
+        ref?: React.Ref<SelectViewHandle>;
+    }): React.ReactElement;
+}
+declare const CascaderComponent: ForwardRefCascaderType;
+export default CascaderComponent;

package/types/cascader/base/node.d.ts

@@ -0,0 +1,48 @@
+import { OptionProps } from '../../cascader/interface';
+import { ConfigType } from './store';
+export interface NodeProps<T> extends OptionProps {
+    value: string;
+    label: string;
+    isLeaf?: boolean;
+    _checked: boolean;
+    _level?: number;
+    _halfChecked: boolean;
+    parent: NodeProps<T> | null;
+    pathValue: string[];
+    children?: NodeProps<T>[];
+    loading?: boolean;
+    loaded?: boolean;
+    pathLabel: string[];
+}
+declare class Node<T extends NodeProps<T>> {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    _level?: number;
+    _index?: number;
+    isLeaf?: boolean;
+    disableCheckbox?: boolean;
+    _checked: boolean;
+    _halfChecked: boolean;
+    parent: Node<T> | null;
+    pathValue: string[];
+    pathLabel: string[];
+    children?: Node<T>[];
+    loading?: boolean;
+    loaded?: boolean;
+    config: ConfigType<T>;
+    _data?: NodeProps<T>;
+    constructor(data: T, config?: ConfigType<T>, parent?: Node<T>);
+    private _initNode;
+    private _isHalfChecked;
+    private _setNodeChildrenChecked;
+    getSelfChildrenValue: () => never[];
+    updateHalfState: (checked: boolean) => void;
+    setCheckedProperty: (checked: boolean) => void;
+    setCheckedState: (checked: boolean) => void;
+    setCheckedStateIgnoreDisabled: (checked: boolean) => void;
+    getPathNodes: () => Node<T>[];
+    getChildren: () => Node<T>[];
+    setLoading: (loading?: boolean) => void;
+}
+export default Node;

package/types/cascader/base/store.d.ts

@@ -0,0 +1,26 @@
+import { CascaderProps, FieldNamesType } from '../../cascader/interface';
+import Node from './node';
+export type ConfigType<T> = {
+    changeOnSelect?: boolean;
+    lazyload?: boolean;
+    showEmptyChildren?: boolean;
+    filterOption?: CascaderProps<T>['filterOption'];
+    fieldNames?: FieldNamesType;
+    showParent?: boolean;
+};
+declare class Store<T> {
+    private nodes;
+    private flatNodes;
+    private config;
+    constructor(options: T[], value?: string[][], config?: ConfigType<T>);
+    private _calcNodes;
+    private _updateFlatNodes;
+    setNodeCheckedByValue: (initValues: string[][]) => void;
+    appendOptionChildren: (node: Node<T>, children: T[]) => void;
+    findNodeByValue: (value: string[]) => Node<T> | null;
+    searchNodeByLabel: (inputStr?: string) => Node<T>[];
+    getOptions: () => Node<T>[];
+    getCheckedNodes: () => Node<T>[];
+    getCheckedParentNodes: () => Node<T>[];
+}
+export default Store;

package/types/cascader/hook/useRefCurrent.d.ts

@@ -0,0 +1,3 @@
+import { DependencyList } from 'react';
+declare function useCurrentRef<T>(initFunc: () => T, deps: DependencyList): T;
+export default useCurrentRef;

package/types/cascader/index.d.ts

@@ -0,0 +1,5 @@
+import './style';
+import Cascader from './Cascader';
+export default Cascader;
+export type { NodeProps } from './base/node';
+export * from './interface';

package/types/cascader/interface.d.ts

@@ -0,0 +1,105 @@
+import { CSSProperties, ReactNode } from 'react';
+import { SelectViewCommonProps } from '../select-view';
+import { TriggerProps } from '../trigger';
+import { VirtualListProps } from '../virtual-list/VirtualList';
+import { NodeProps } from './base/node';
+import Store from './base/store';
+export interface CascaderProps<T = any> extends Omit<SelectViewCommonProps, 'showSearch'> {
+    defaultValue?: (string | string[])[];
+    inputValue?: string;
+    value?: (string | string[])[];
+    options?: T[];
+    trigger?: TriggerProps['trigger'];
+    expandTrigger?: 'click' | 'hover';
+    changeOnSelect?: boolean;
+    showEmptyChildren?: boolean;
+    unmountOnExit?: boolean;
+    mode?: 'multiple';
+    triggerProps?: Partial<TriggerProps>;
+    showSearch?: boolean | {
+        panelMode?: 'cascader' | 'select';
+        renderOption?: (inputValue: string, option: NodeProps<T>, options: extraOptions) => ReactNode;
+        retainInputValue?: boolean;
+        retainInputValueWhileSelect?: boolean;
+    };
+    notFoundContent?: ReactNode;
+    fieldNames?: FieldNamesType;
+    popupVisible?: boolean;
+    defaultPopupVisible?: boolean;
+    checkedStrategy?: 'parent' | 'child';
+    dropdownMenuClassName?: string | string[];
+    dropdownMenuColumnStyle?: CSSProperties;
+    virtualListProps?: Pick<VirtualListProps<any>, 'threshold' | 'isStaticItemHeight'>;
+    defaultActiveFirstOption?: boolean;
+    dropdownRender?: (menu: ReactNode) => ReactNode;
+    dropdownColumnRender?: (menu: ReactNode, level: number) => ReactNode;
+    filterOption?: (inputValue: string, option: NodeProps<T>) => boolean;
+    renderOption?: (option: NodeProps<T>, level: number) => ReactNode;
+    renderFooter?: (level: number, activeOption: NodeProps<T> | null) => ReactNode;
+    renderFormat?: (valueShow: any[]) => ReactNode;
+    onSearch?: (inputValue: string, reason: InputValueChangeReason) => void;
+    onChange?: (value: (string | string[])[], selectedOptions: any, extra: {
+        dropdownVisible?: boolean;
+    }) => void;
+    onInputValueChange?: (inputValue: string, reason: InputValueChangeReason) => void;
+    getPopupContainer?: (node: HTMLElement) => Element;
+    loadMore?: (pathValue: string[], level: number) => Promise<T[]>;
+    onVisibleChange?: (visible: boolean) => void;
+    onClear?: (visible: boolean) => void;
+    icons?: {
+        loading?: ReactNode;
+        checked?: ReactNode;
+        next?: ReactNode;
+    };
+}
+export interface OptionProps {
+    value?: string;
+    label?: string;
+    disabled?: boolean;
+    children?: OptionProps[];
+    isLeaf?: boolean;
+    disableCheckbox?: boolean;
+    [key: string]: any;
+}
+export type FieldNamesType = {
+    label?: string;
+    value?: string;
+    children?: string;
+    disabled?: string;
+    isLeaf?: string;
+};
+export type InputValueChangeReason = 'manual' | 'optionListHide' | 'optionChecked';
+export interface CascaderPanelProps<T> {
+    className?: string | string[];
+    style?: CSSProperties;
+    store: Store<T>;
+    multiple?: boolean;
+    defaultValue?: string[][];
+    value?: string[][];
+    changeOnSelect?: boolean;
+    popupVisible?: boolean;
+    expandTrigger?: 'click' | 'hover';
+    trigger?: 'click';
+    prefixCls?: string;
+    rtl?: boolean;
+    showEmptyChildren?: boolean;
+    virtualListProps?: CascaderProps<T>['virtualListProps'];
+    renderOption?: (option: NodeProps<T>, level: number) => ReactNode;
+    onChange?: (value: string[][]) => void;
+    loadMore?: (activeValue: any, level: number) => void;
+    renderEmpty?: (width?: CSSProperties['width']) => ReactNode;
+    renderFooter?: (level: number, activeOption: NodeProps<T> | null) => ReactNode;
+    onDoubleClickOption?: () => void;
+    onEsc?: () => void;
+    dropdownColumnRender?: CascaderProps<T>['dropdownColumnRender'];
+    dropdownMenuColumnStyle?: CascaderProps<T>['dropdownMenuColumnStyle'];
+    getTriggerElement: () => HTMLElement;
+    icons?: {
+        loading?: ReactNode;
+        checked?: ReactNode;
+        next?: ReactNode;
+    };
+}
+export interface extraOptions {
+    checked: boolean;
+}

package/types/cascader/panel/List.d.ts

@@ -0,0 +1,4 @@
+import { CascaderPanelProps, OptionProps } from '../../cascader/interface';
+export declare const getLegalIndex: (currentIndex: any, maxIndex: any) => any;
+declare const ListPanel: <T extends OptionProps>(props: CascaderPanelProps<T>) => import("react/jsx-dev-runtime").JSX.Element;
+export default ListPanel;

package/types/cascader/panel/Option.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import Node from '../../cascader/base/node';
+import { OptionProps } from '../../cascader/interface';
+export interface CascaderOptionProps<T> {
+    prefixCls?: string;
+    rtl?: boolean;
+    multiple?: boolean;
+    selected?: boolean;
+    isLeaf?: boolean;
+    option: Node<T>;
+    icons?: {
+        loading?: ReactNode;
+        checked?: ReactNode;
+        next?: ReactNode;
+    };
+    renderOption?: () => ReactNode;
+    onClickOption?: () => void;
+    onDoubleClickOption?: () => void;
+    onMouseEnter?: () => void;
+    onMultipleChecked?: (checked: boolean) => void;
+}
+declare const Option: <T extends OptionProps>(props: CascaderOptionProps<T>) => import("react/jsx-dev-runtime").JSX.Element;
+export default Option;

package/types/cascader/panel/Search.d.ts

@@ -0,0 +1,28 @@
+import { CSSProperties, ReactNode } from 'react';
+import { NodeProps } from '../../cascader/base/node';
+import Store from '../../cascader/base/store';
+import { CascaderProps, OptionProps, extraOptions } from '../interface';
+export declare const getLegalIndex: (currentIndex: any, maxIndex: any) => any;
+export type SearchPanelProps<T> = {
+    store?: Store<T>;
+    style?: CSSProperties;
+    prefixCls?: string;
+    rtl?: boolean;
+    multiple?: boolean;
+    value: string[][];
+    inputValue?: string;
+    onEsc?: () => void;
+    onChange?: (value: string[][]) => void;
+    renderEmpty?: () => ReactNode;
+    virtualListProps?: CascaderProps<T>['virtualListProps'];
+    defaultActiveFirstOption: boolean;
+    renderOption?: (inputValue: string, node: NodeProps<T>, options: extraOptions) => ReactNode;
+    getTriggerElement: () => HTMLElement;
+    icons?: {
+        loading?: ReactNode;
+        checked?: ReactNode;
+        next?: ReactNode;
+    };
+};
+declare const SearchPanel: <T extends OptionProps>(props: SearchPanelProps<T>) => import("react/jsx-dev-runtime").JSX.Element;
+export default SearchPanel;

package/types/cascader/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/cascader/util.d.ts

@@ -0,0 +1,23 @@
+import Store from './base/store';
+import type { CascaderProps } from './interface';
+export declare const ValueSeparator = "__pqb_cascader__";
+export declare const SHOW_PARENT = "parent";
+export declare const SHOW_CHILD = "child";
+export declare const PANEL_MODE: {
+    cascader: string;
+    select: string;
+};
+export declare function getConfig(props: CascaderProps): {
+    showEmptyChildren: boolean | undefined;
+    changeOnSelect: boolean | undefined;
+    lazyload: boolean;
+    fieldNames: import("./interface").FieldNamesType | undefined;
+    filterOption: ((inputValue: string, option: import(".").NodeProps<any>) => boolean) | undefined;
+    showParent: boolean;
+};
+export declare function getStore(props: any, value: any): Store<any>;
+export declare const transformValuesToSet: (values: string[][]) => Set<unknown>;
+export declare const valueInSet: (set: any, value: string[]) => any;
+export declare const removeValueFromSet: (set: any, value: string[]) => any;
+export declare const formatValue: (value: any, isMultiple: any, store?: any) => string[][] | undefined;
+export declare const getMultipleCheckValue: (propsValue: any, store: Store<any>, option: any, _checked: any) => any;

package/types/checkbox/Checkbox.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import Group from './Group';
+import type { CheckboxProps } from './interface';
+import useCheckbox from './useCheckbox';
+interface ForwardRefCheckboxType extends React.ForwardRefExoticComponent<React.PropsWithoutRef<CheckboxProps> & React.RefAttributes<unknown>> {
+    <T extends React.ReactText = any>(props: React.PropsWithChildren<CheckboxProps<T>> & {
+        ref?: React.Ref<unknown>;
+    }): React.ReactElement;
+    Group: typeof Group;
+    useCheckbox: typeof useCheckbox;
+}
+declare const CheckboxComponent: ForwardRefCheckboxType;
+export default CheckboxComponent;
+export type { CheckboxProps };

package/types/checkbox/Group.d.ts

@@ -0,0 +1,17 @@
+import React, { PropsWithChildren, ReactText } from 'react';
+import type { CheckboxGroupProps } from './interface';
+export declare const CheckboxGroupContext: React.Context<{
+    disabled?: boolean | undefined;
+    isCheckboxGroup: boolean;
+    onGroupChange: (_optionValue, _checked: boolean, e: Event) => void;
+    checkboxGroupValue: ReactText[];
+    registerValue: (value: ReactText) => void;
+    unRegisterValue: (value: ReactText) => void;
+}>;
+export declare const ClearCheckboxGroupContext: ({ children, }: PropsWithChildren<{}>) => import("react/jsx-dev-runtime").JSX.Element;
+declare function Group<T extends React.ReactText>(props: PropsWithChildren<CheckboxGroupProps<T>>): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Group {
+    var displayName: string;
+}
+export default Group;
+export type { CheckboxGroupProps };

package/types/checkbox/index.d.ts

@@ -0,0 +1,5 @@
+import './style';
+import Checkbox from './Checkbox';
+export default Checkbox;
+export type { ClearCheckboxGroupContext } from './Group';
+export type { CheckboxProps } from './interface';

package/types/checkbox/interface.d.ts

@@ -0,0 +1,36 @@
+import { CSSProperties, HTMLAttributes, ReactNode, ReactText } from 'react';
+export interface CheckboxProps<T extends ReactText = any> extends Omit<HTMLAttributes<HTMLLabelElement>, 'children' | 'className' | 'onChange'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    error?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    onChange?: (checked: boolean, e: Event) => void;
+    value?: T;
+    icon?: ReactNode;
+    checkboxGroupValue?: T[];
+    onGroupChange?: (value: T, checked: boolean) => void;
+    isCheckboxGroup?: boolean;
+    children?: ReactNode | ((value: {
+        checked: boolean;
+        indeterminate: boolean;
+    }) => ReactNode);
+}
+export interface CheckboxGroupProps<T extends ReactText> {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    direction?: 'horizontal' | 'vertical';
+    error?: boolean;
+    defaultValue?: T[];
+    options?: (T | {
+        label: ReactNode;
+        value: T;
+        disabled?: boolean;
+        icon?: ReactNode;
+    })[];
+    value?: T[];
+    onChange?: (value: T[], e: Event) => void;
+}

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

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

package/types/checkbox/useCheckbox.d.ts

@@ -0,0 +1,13 @@
+export type ResultType<T> = {
+    selected: T[];
+    setSelected: (value: T[]) => void;
+    setValueSelected: (value: T | T[], selected?: boolean) => void;
+    selectAll: () => void;
+    unSelectAll: () => void;
+    isSelected: (value: T) => boolean;
+    toggle: (value?: T | T[]) => void;
+    isAllSelected: () => boolean;
+    isPartialSelected: () => boolean;
+};
+declare const useCheckbox: <T>(values: T[], defaultSelected?: T[]) => ResultType<T>;
+export default useCheckbox;

package/types/collapse/Collapse.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { CollapseProps } from './interface';
+import CollapseItem from './Item';
+export declare const CollapseContext: React.Context<Pick<CollapseProps, "lazyload" | "destroyOnHide" | "expandIcon" | "triggerRegion" | "expandIconPosition"> & {
+    activeKeys: string[];
+    onToggle?: ((_key: string, _e: any) => void) | undefined;
+}>;
+declare const CollapseComponent: React.ForwardRefExoticComponent<CollapseProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<unknown>> & {
+    Item: typeof CollapseItem;
+};
+export default CollapseComponent;
+export type { CollapseProps };

package/types/collapse/Item.d.ts

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

package/types/collapse/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import Collapse from './Collapse';
+export default Collapse;
+export type { CollapseItemProps, CollapseProps } from './interface';

package/types/collapse/interface.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface CollapseProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    activeKey?: string | string[];
+    defaultActiveKey?: string | string[];
+    accordion?: boolean;
+    expandIcon?: ReactNode;
+    expandIconPosition?: 'left' | 'right';
+    bordered?: boolean;
+    lazyload?: boolean;
+    destroyOnHide?: boolean;
+    triggerRegion?: 'header' | 'icon';
+    onChange?: (key: string, keys: string[], e: any) => void;
+}
+export interface CollapseItemProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    contentStyle?: CSSProperties;
+    header?: ReactNode;
+    name: string;
+    disabled?: boolean;
+    expandIcon?: ReactNode;
+    showExpandIcon?: boolean;
+    extra?: ReactNode;
+    destroyOnHide?: boolean;
+}

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

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

package/types/color-picker/ControlBar.d.ts

@@ -0,0 +1,11 @@
+import React, { CSSProperties } from 'react';
+import { Color } from './interface';
+interface ControlBarProps {
+    x: number;
+    type?: 'hue' | 'alpha';
+    color?: Color;
+    onChange: (x: number) => void;
+    style?: CSSProperties;
+}
+export declare const ControlBar: React.FC<ControlBarProps>;
+export {};

package/types/color-picker/InputAlpha.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface InputAlphaProps {
+    value: number;
+    onChange: (value: number) => void;
+}
+export declare const InputAlpha: React.FC<InputAlphaProps>;
+export {};

package/types/color-picker/InputHex.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Color, HSV } from './interface';
+interface InputHexProps {
+    color: Color;
+    alpha: number;
+    onHsvChange: (value: HSV) => void;
+    onAlphaChange: (value: number) => void;
+    disabledAlpha?: boolean;
+}
+export declare const InputHex: React.FC<InputHexProps>;
+export {};

package/types/color-picker/InputRgb.d.ts

@@ -0,0 +1,10 @@
+import { Color, HSV } from './interface';
+interface InputRgbProps {
+    color: Color;
+    alpha: number;
+    onHsvChange: (value: HSV) => void;
+    onAlphaChange: (value: number) => void;
+    disabledAlpha?: boolean;
+}
+export declare const InputRgb: ({ color, alpha, onHsvChange, onAlphaChange, disabledAlpha, }: InputRgbProps) => import("react/jsx-dev-runtime").JSX.Element;
+export {};

package/types/color-picker/Palette.d.ts

@@ -0,0 +1,7 @@
+import { Color } from './interface';
+interface PaletteProps {
+    color: Color;
+    onChange: (s: number, v: number) => void;
+}
+export declare const Palette: ({ color, onChange }: PaletteProps) => import("react/jsx-dev-runtime").JSX.Element;
+export {};

package/types/color-picker/Panel.d.ts

@@ -0,0 +1,20 @@
+import React, { ReactNode } from 'react';
+import { Color, HSV } from './interface';
+interface PanelProps {
+    color: Color;
+    alpha: number;
+    disabledAlpha: boolean;
+    colorString: string;
+    showHistory?: boolean;
+    historyColors?: string[];
+    showPreset?: boolean;
+    presetColors?: string[];
+    renderHistory?: () => ReactNode;
+    renderPreset?: () => ReactNode;
+    renderPickSection?: () => ReactNode;
+    renderFooter?: () => ReactNode;
+    onHsvChange: (value: HSV) => void;
+    onAlphaChange: (value: number) => void;
+}
+export declare const Panel: React.FC<PanelProps>;
+export {};

package/types/color-picker/colors.d.ts

@@ -0,0 +1,2 @@
+export declare const colors: FlatArray<boolean | string[], 0 | 2 | 1 | 4 | 3 | -1 | 13 | 8 | 9 | 16 | 10 | 5 | 6 | 7 | 11 | 12 | 14 | 15 | 17 | 18 | 19 | 20>[];
+export default colors;