@antsoo-lib/components 0.0.1

package/dist/src/vc-picker/utils/warnUtil.d.ts

@@ -0,0 +1,5 @@
+import { DisabledTimes, PickerMode } from '../interface';
+export interface WarningProps extends DisabledTimes {
+    picker?: PickerMode;
+}
+export declare function legacyPropsWarning(props: WarningProps): void;

package/dist/src/vc-progress/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Progress, Circle, Line, ProgressProps } from './src';
+export { Circle, Line };
+export type { ProgressProps };
+export default Progress;

package/dist/src/vc-progress/src/Circle.d.ts

@@ -0,0 +1,42 @@
+import { GapPositionType, StrokeColorType, StrokeLinecapType } from './types';
+import { DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: PropType<GapPositionType>;
+    };
+    percent: {
+        type: PropType<number | number[]>;
+    };
+    prefixCls: StringConstructor;
+    strokeColor: {
+        type: PropType<StrokeColorType>;
+    };
+    strokeLinecap: {
+        type: PropType<StrokeLinecapType>;
+    };
+    strokeWidth: NumberConstructor;
+    trailColor: StringConstructor;
+    trailWidth: NumberConstructor;
+    transition: StringConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: PropType<GapPositionType>;
+    };
+    percent: {
+        type: PropType<number | number[]>;
+    };
+    prefixCls: StringConstructor;
+    strokeColor: {
+        type: PropType<StrokeColorType>;
+    };
+    strokeLinecap: {
+        type: PropType<StrokeLinecapType>;
+    };
+    strokeWidth: NumberConstructor;
+    trailColor: StringConstructor;
+    trailWidth: NumberConstructor;
+    transition: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-progress/src/Line.d.ts

@@ -0,0 +1,42 @@
+import { DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { GapPositionType, StrokeColorType, StrokeLinecapType } from './types';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: PropType<GapPositionType>;
+    };
+    percent: {
+        type: PropType<number | number[]>;
+    };
+    prefixCls: StringConstructor;
+    strokeColor: {
+        type: PropType<StrokeColorType>;
+    };
+    strokeLinecap: {
+        type: PropType<StrokeLinecapType>;
+    };
+    strokeWidth: NumberConstructor;
+    trailColor: StringConstructor;
+    trailWidth: NumberConstructor;
+    transition: StringConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: PropType<GapPositionType>;
+    };
+    percent: {
+        type: PropType<number | number[]>;
+    };
+    prefixCls: StringConstructor;
+    strokeColor: {
+        type: PropType<StrokeColorType>;
+    };
+    strokeLinecap: {
+        type: PropType<StrokeLinecapType>;
+    };
+    strokeWidth: NumberConstructor;
+    trailColor: StringConstructor;
+    trailWidth: NumberConstructor;
+    transition: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-progress/src/common.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+import { RefsValue } from '../../_util/hooks/useRefs';
+import { ProgressProps } from './types';
+export declare const defaultProps: Partial<ProgressProps>;
+export declare const useTransitionDuration: (paths: Ref<RefsValue>) => Ref<RefsValue, RefsValue>;

package/dist/src/vc-progress/src/index.d.ts

@@ -0,0 +1,87 @@
+import { default as Circle } from './Circle';
+import { default as Line } from './Line';
+import { ProgressProps, GapPositionType, StrokeColorType, StrokeLinecapType } from './types';
+import { DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export { Circle, Line };
+export type { ProgressProps };
+declare const _default: {
+    Line: DefineComponent<ExtractPropTypes<{
+        gapDegree: NumberConstructor;
+        gapPosition: {
+            type: PropType<GapPositionType>;
+        };
+        percent: {
+            type: PropType<number | number[]>;
+        };
+        prefixCls: StringConstructor;
+        strokeColor: {
+            type: PropType<StrokeColorType>;
+        };
+        strokeLinecap: {
+            type: PropType<StrokeLinecapType>;
+        };
+        strokeWidth: NumberConstructor;
+        trailColor: StringConstructor;
+        trailWidth: NumberConstructor;
+        transition: StringConstructor;
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+        gapDegree: NumberConstructor;
+        gapPosition: {
+            type: PropType<GapPositionType>;
+        };
+        percent: {
+            type: PropType<number | number[]>;
+        };
+        prefixCls: StringConstructor;
+        strokeColor: {
+            type: PropType<StrokeColorType>;
+        };
+        strokeLinecap: {
+            type: PropType<StrokeLinecapType>;
+        };
+        strokeWidth: NumberConstructor;
+        trailColor: StringConstructor;
+        trailWidth: NumberConstructor;
+        transition: StringConstructor;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+    Circle: DefineComponent<ExtractPropTypes<{
+        gapDegree: NumberConstructor;
+        gapPosition: {
+            type: PropType<GapPositionType>;
+        };
+        percent: {
+            type: PropType<number | number[]>;
+        };
+        prefixCls: StringConstructor;
+        strokeColor: {
+            type: PropType<StrokeColorType>;
+        };
+        strokeLinecap: {
+            type: PropType<StrokeLinecapType>;
+        };
+        strokeWidth: NumberConstructor;
+        trailColor: StringConstructor;
+        trailWidth: NumberConstructor;
+        transition: StringConstructor;
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+        gapDegree: NumberConstructor;
+        gapPosition: {
+            type: PropType<GapPositionType>;
+        };
+        percent: {
+            type: PropType<number | number[]>;
+        };
+        prefixCls: StringConstructor;
+        strokeColor: {
+            type: PropType<StrokeColorType>;
+        };
+        strokeLinecap: {
+            type: PropType<StrokeLinecapType>;
+        };
+        strokeWidth: NumberConstructor;
+        trailColor: StringConstructor;
+        trailWidth: NumberConstructor;
+        transition: StringConstructor;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+};
+export default _default;

package/dist/src/vc-progress/src/types.d.ts

@@ -0,0 +1,25 @@
+import { ExtractPropTypes, PropType } from 'vue';
+export type StrokeColorType = string | string[] | object;
+export type GapPositionType = 'top' | 'right' | 'bottom' | 'left';
+export type StrokeLinecapType = 'round' | 'butt' | 'square';
+export declare const propTypes: {
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: PropType<GapPositionType>;
+    };
+    percent: {
+        type: PropType<number | number[]>;
+    };
+    prefixCls: StringConstructor;
+    strokeColor: {
+        type: PropType<StrokeColorType>;
+    };
+    strokeLinecap: {
+        type: PropType<StrokeLinecapType>;
+    };
+    strokeWidth: NumberConstructor;
+    trailColor: StringConstructor;
+    trailWidth: NumberConstructor;
+    transition: StringConstructor;
+};
+export type ProgressProps = Partial<ExtractPropTypes<typeof propTypes>>;

package/dist/src/vc-resize-observer/index.d.ts

@@ -0,0 +1,25 @@
+import { PropType, DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    onResize: PropType<(size: {
+        width: number;
+        height: number;
+        offsetWidth: number;
+        offsetHeight: number;
+    }, element: HTMLElement) => void>;
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}> | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "resize"[], "resize", PublicProps, Readonly< ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    onResize: PropType<(size: {
+        width: number;
+        height: number;
+        offsetWidth: number;
+        offsetHeight: number;
+    }, element: HTMLElement) => void>;
+}>> & Readonly<{
+    onResize?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-select/OptGroup.d.ts

@@ -0,0 +1,9 @@
+import { FunctionalComponent } from 'vue';
+import { DefaultOptionType } from './Select';
+export type OptGroupProps = Omit<DefaultOptionType, 'options'>;
+export interface OptionGroupFC extends FunctionalComponent<OptGroupProps> {
+    /** Legacy for check if is a Option Group */
+    isSelectOptGroup: boolean;
+}
+declare const OptGroup: OptionGroupFC;
+export default OptGroup;

package/dist/src/vc-select/Option.d.ts

@@ -0,0 +1,12 @@
+import { FunctionalComponent } from 'vue';
+import { DefaultOptionType } from './Select';
+export interface OptionProps extends Omit<DefaultOptionType, 'label'> {
+    /** Save for customize data */
+    [prop: string]: any;
+}
+export interface OptionFC extends FunctionalComponent<OptionProps> {
+    /** Legacy for check if is a Option Group */
+    isSelectOption: boolean;
+}
+declare const Option: OptionFC;
+export default Option;

package/dist/src/vc-select/OptionList.d.ts

@@ -0,0 +1,14 @@
+import { ScrollConfig } from '../vc-virtual-list/List';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface RefOptionListProps {
+    onKeydown: (e?: KeyboardEvent) => void;
+    onKeyup: (e?: KeyboardEvent) => void;
+    scrollTo?: (index: number | ScrollConfig) => void;
+}
+export type OptionListProps = Record<string, never>;
+/**
+ * Using virtual list of option display.
+ * Will fallback to dom if use customize render.
+ */
+declare const OptionList: DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default OptionList;

package/dist/src/vc-select/SelectContext.d.ts

@@ -0,0 +1,19 @@
+import { RawValueType, RenderNode } from './BaseSelect';
+import { BaseOptionType, FieldNames, OnActiveValue, OnInternalSelect } from './Select';
+import { FlattenOptionData } from './interface';
+export interface SelectContextProps {
+    options: BaseOptionType[];
+    flattenOptions: FlattenOptionData<BaseOptionType>[];
+    onActiveValue: OnActiveValue;
+    defaultActiveFirstOption?: boolean;
+    onSelect: OnInternalSelect;
+    menuItemSelectedIcon?: RenderNode;
+    rawValues: Set<RawValueType>;
+    fieldNames?: FieldNames;
+    virtual?: boolean;
+    listHeight?: number;
+    listItemHeight?: number;
+    childrenAsData?: boolean;
+}
+export declare function useProvideSelectProps(props: SelectContextProps): void;
+export default function useSelectProps(): SelectContextProps;

package/dist/src/vc-select/SelectTrigger.d.ts

@@ -0,0 +1,34 @@
+import { CSSProperties, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueNode } from '../_util/type';
+import { AlignType } from '../vc-trigger/interface';
+import { DropdownRender, Placement, RenderDOMFunc } from './BaseSelect';
+export interface RefTriggerProps {
+    getPopupElement: () => HTMLDivElement;
+}
+export interface SelectTriggerProps {
+    prefixCls: string;
+    disabled: boolean;
+    visible: boolean;
+    popupElement: VueNode;
+    animation?: string;
+    transitionName?: string;
+    containerWidth: number;
+    placement?: Placement;
+    dropdownStyle: CSSProperties;
+    dropdownClassName: string;
+    direction: string;
+    dropdownMatchSelectWidth?: boolean | number;
+    dropdownRender?: DropdownRender;
+    getPopupContainer?: RenderDOMFunc;
+    dropdownAlign: AlignType;
+    empty: boolean;
+    getTriggerDOMNode: () => any;
+    onPopupVisibleChange?: (visible: boolean) => void;
+    onPopupMouseEnter: () => void;
+    onPopupFocusin: () => void;
+    onPopupFocusout: () => void;
+}
+declare const SelectTrigger: DefineComponent<SelectTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectTriggerProps> & Readonly<{}>, {
+    popupRef: any;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default SelectTrigger;

package/dist/src/vc-select/Selector/MultipleSelector.d.ts

@@ -0,0 +1,18 @@
+import { VueNode } from '../../_util/type';
+import { CustomTagProps, DisplayValueType, RenderNode } from '../BaseSelect';
+import { InnerSelectorProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type SelectorProps = InnerSelectorProps & {
+    removeIcon?: RenderNode;
+    maxTagCount?: number | 'responsive';
+    maxTagTextLength?: number;
+    maxTagPlaceholder?: VueNode | ((omittedValues: DisplayValueType[]) => VueNode);
+    tokenSeparators?: string[];
+    tagRender?: (props: CustomTagProps) => VueNode;
+    onToggleOpen: any;
+    compositionStatus: boolean;
+    choiceTransitionName?: string;
+    onRemove: (value: DisplayValueType) => void;
+};
+declare const SelectSelector: DefineComponent<SelectorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectorProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default SelectSelector;

package/dist/src/vc-select/Selector/SingleSelector.d.ts

@@ -0,0 +1,11 @@
+import { VueNode } from '../../_util/type';
+import { InnerSelectorProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface SelectorProps extends InnerSelectorProps {
+    inputElement: VueNode;
+    activeValue: string;
+    optionLabelRender: Function;
+    compositionStatus: boolean;
+}
+declare const SingleSelector: DefineComponent<SelectorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectorProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default SingleSelector;

package/dist/src/vc-select/Selector/index.d.ts

@@ -0,0 +1,48 @@
+import { VueNode } from '../../_util/type';
+import { ScrollTo } from '../../vc-virtual-list/List';
+import { CustomTagProps, DisplayValueType, Mode, RenderNode } from '../BaseSelect';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface SelectorProps {
+    id: string;
+    prefixCls: string;
+    showSearch?: boolean;
+    open: boolean;
+    values: DisplayValueType[];
+    multiple?: boolean;
+    mode: Mode;
+    searchValue: string;
+    activeValue: string;
+    inputElement: VueNode;
+    autofocus?: boolean;
+    activeDescendantId?: string;
+    tabindex?: number | string;
+    disabled?: boolean;
+    placeholder?: VueNode;
+    removeIcon?: RenderNode;
+    maxTagCount?: number | 'responsive';
+    maxTagTextLength?: number;
+    maxTagPlaceholder?: VueNode | ((omittedValues: DisplayValueType[]) => VueNode);
+    tagRender?: (props: CustomTagProps) => VueNode;
+    optionLabelRender?: (props: Record<string, any>) => VueNode;
+    /** Check if `tokenSeparators` contains `\n` or `\r\n` */
+    tokenWithEnter?: boolean;
+    choiceTransitionName?: string;
+    onToggleOpen: (open?: boolean) => void | any;
+    /** `onSearch` returns go next step boolean to check if need do toggle open */
+    onSearch: (searchText: string, fromTyping: boolean, isCompositing: boolean) => boolean;
+    onSearchSubmit: (searchText: string) => void;
+    onRemove: (value: DisplayValueType) => void;
+    onInputKeyDown?: (e: KeyboardEvent) => void;
+    /**
+     * @private
+     * This may be removed after React provides replacement of `findDOMNode`
+     */
+    domRef: () => HTMLDivElement;
+}
+export interface RefSelectorProps {
+    focus: () => void;
+    blur: () => void;
+    scrollTo?: ScrollTo;
+}
+declare const Selector: DefineComponent<SelectorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectorProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default Selector;

package/dist/src/vc-select/Selector/interface.d.ts

@@ -0,0 +1,26 @@
+import { EventHandler } from '../../_util/EventInterface';
+import { RefObject } from '../../_util/createRef';
+import { VueNode } from '../../_util/type';
+import { DisplayValueType, Mode } from '../BaseSelect';
+export interface InnerSelectorProps {
+    prefixCls: string;
+    id: string;
+    mode: Mode;
+    inputRef: RefObject;
+    placeholder?: VueNode;
+    disabled?: boolean;
+    autofocus?: boolean;
+    autocomplete?: string;
+    values: DisplayValueType[];
+    showSearch?: boolean;
+    searchValue: string;
+    activeDescendantId: string;
+    open: boolean;
+    tabindex?: number | string;
+    onInputKeyDown: EventHandler;
+    onInputMouseDown: EventHandler;
+    onInputChange: EventHandler;
+    onInputPaste: EventHandler;
+    onInputCompositionStart: EventHandler;
+    onInputCompositionEnd: EventHandler;
+}

package/dist/src/vc-select/TransBtn.d.ts

@@ -0,0 +1,14 @@
+import { FunctionalComponent } from 'vue';
+import { RenderNode } from './BaseSelect';
+export interface TransBtnProps {
+    class: string;
+    customizeIcon: RenderNode;
+    customizeIconProps?: any;
+    onMousedown?: (payload: MouseEvent) => void;
+    onClick?: (payload: MouseEvent) => void;
+}
+export interface TransBtnType extends FunctionalComponent<TransBtnProps> {
+    displayName: string;
+}
+declare const TransBtn: TransBtnType;
+export default TransBtn;

package/dist/src/vc-select/hooks/useBaseProps.d.ts

@@ -0,0 +1,8 @@
+import { BaseSelectProps } from '../BaseSelect';
+export interface BaseSelectContextProps extends BaseSelectProps {
+    triggerOpen: boolean;
+    multiple: boolean;
+    toggleOpen: (open?: boolean) => void;
+}
+export declare function useProvideBaseSelectProps(props: BaseSelectContextProps): void;
+export default function useBaseProps(): BaseSelectContextProps;

package/dist/src/vc-select/hooks/useCache.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { RawValueType } from '../BaseSelect';
+import { DefaultOptionType, LabelInValueType } from '../Select';
+/**
+ * Cache `value` related LabeledValue & options.
+ */
+declare const _default: (labeledValues: Ref<LabelInValueType[]>, valueOptions: Ref<Map<RawValueType, DefaultOptionType>>) => [Ref<LabelInValueType[]>, (val: RawValueType) => DefaultOptionType];
+export default _default;

package/dist/src/vc-select/hooks/useDelayReset.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+/**
+ * Similar with `useLock`, but this hook will always execute last value.
+ * When set to `true`, it will keep `true` for a short time even if `false` is set.
+ */
+export default function useDelayReset(timeout?: number): [Ref<boolean>, (val: boolean, callback?: () => void) => void, () => void];

package/dist/src/vc-select/hooks/useFilterOptions.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ShallowRef, ComputedRef } from 'vue';
+import { DefaultOptionType, FieldNames, SelectProps } from '../Select';
+declare const _default: (options: ShallowRef<DefaultOptionType[]>, fieldNames: Ref<FieldNames>, searchValue?: Ref<string>, filterOption?: Ref<SelectProps["filterOption"]>, optionFilterProp?: Ref<string>) => ComputedRef<DefaultOptionType[]>;
+export default _default;

package/dist/src/vc-select/hooks/useId.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+/** Is client side and not jsdom */
+export declare const isBrowserClient: boolean;
+/** Get unique id for accessibility usage */
+export declare function getUUID(): number | string;
+export default function useId(id?: Ref<string, string>): string;

package/dist/src/vc-select/hooks/useLock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Locker return cached mark.
+ * If set to `true`, will return `true` in a short time even if set `false`.
+ * If set to `false` and then set to `true`, will change to `true`.
+ * And after time duration, it will back to `null` automatically.
+ */
+export default function useLock(duration?: number): [() => boolean | null, (lock: boolean) => void];

package/dist/src/vc-select/hooks/useOptions.d.ts

@@ -0,0 +1,11 @@
+import { Ref, ShallowRef } from 'vue';
+import { FieldNames } from '../Select';
+/**
+ * Parse `children` to `options` if `options` is not provided.
+ * Then flatten the `options`.
+ */
+export default function useOptions<OptionType>(options: Ref<OptionType[]>, children: Ref<any>, fieldNames: Ref<FieldNames>): {
+    options: ShallowRef<any, any>;
+    valueOptions: ShallowRef<any, any>;
+    labelOptions: ShallowRef<any, any>;
+};

package/dist/src/vc-select/hooks/useSelectTriggerControl.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useSelectTriggerControl(refs: Ref[], open: Ref<boolean>, triggerOpen: (open: boolean) => void): void;

package/dist/src/vc-select/index.d.ts

@@ -0,0 +1,8 @@
+import { default as BaseSelect, BaseSelectProps, BaseSelectPropsWithoutPrivate, BaseSelectRef } from './BaseSelect';
+import { default as OptGroup } from './OptGroup';
+import { default as Option } from './Option';
+import { SelectProps, default as Select, selectProps } from './Select';
+import { default as useBaseProps } from './hooks/useBaseProps';
+export { BaseSelect, OptGroup, Option, selectProps, useBaseProps };
+export type { BaseSelectProps, BaseSelectPropsWithoutPrivate, BaseSelectRef, SelectProps };
+export default Select;

package/dist/src/vc-select/interface.d.ts

@@ -0,0 +1,10 @@
+import { Key } from '../_util/type';
+import { RawValueType } from './BaseSelect';
+export interface FlattenOptionData<OptionType> {
+    label?: any;
+    data: OptionType;
+    key: Key;
+    value?: RawValueType;
+    groupOption?: boolean;
+    group?: boolean;
+}

package/dist/src/vc-select/utils/commonUtil.d.ts

@@ -0,0 +1,4 @@
+export declare function toArray<T>(value: T | T[]): T[];
+export declare const isClient: false | HTMLElement;
+/** Is client side and not jsdom */
+export declare const isBrowserClient: false | HTMLElement;

package/dist/src/vc-select/utils/keyUtil.d.ts

@@ -0,0 +1,2 @@
+/** keyCode Judgment function */
+export declare function isValidateOpenKey(currentKeyCode: number): boolean;

package/dist/src/vc-select/utils/legacyUtil.d.ts

@@ -0,0 +1,3 @@
+import { VueNode } from '../../_util/type';
+import { BaseOptionType, DefaultOptionType } from '../Select';
+export declare function convertChildrenToData<OptionType extends BaseOptionType = DefaultOptionType>(nodes: VueNode[], optionOnly?: boolean): OptionType[];

package/dist/src/vc-select/utils/platformUtil.d.ts

@@ -0,0 +1 @@
+export declare function isPlatformMac(): boolean;

package/dist/src/vc-select/utils/valueUtil.d.ts

@@ -0,0 +1,21 @@
+import { BaseOptionType, DefaultOptionType, FieldNames } from '../Select';
+import { FlattenOptionData } from '../interface';
+export declare function fillFieldNames(fieldNames: FieldNames | undefined, childrenAsData: boolean): {
+    label: string;
+    value: string;
+    options: string;
+};
+/**
+ * Flat options into flatten list.
+ * We use `optionOnly` here is aim to avoid user use nested option group.
+ * Here is simply set `key` to the index if not provided.
+ */
+export declare function flattenOptions<OptionType extends BaseOptionType = DefaultOptionType>(options: OptionType[], { fieldNames, childrenAsData }?: {
+    fieldNames?: FieldNames;
+    childrenAsData?: boolean;
+}): FlattenOptionData<OptionType>[];
+/**
+ * Inject `props` into `option` for legacy usage
+ */
+export declare function injectPropsWithOption<T extends object>(option: T): T;
+export declare function getSeparatedContent(text: string, tokens: string[]): string[];

package/dist/src/vc-select/utils/warningPropsUtil.d.ts

@@ -0,0 +1,3 @@
+import { SelectProps } from '../Select';
+declare function warningProps(props: SelectProps): void;
+export default warningProps;

package/dist/src/vc-slider/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Slider } from './src/';
+export default Slider;