kui-vue/dist/k-ui.d.ts

A lightweight desktop UI component library suitable for Vue.js 2.

/*!
 * kui-vue v3.6.2
 * Copyright 2017-present, kui-vue.
 * All rights reserved.
 * Author: Qiu / https://chuchur.com
 */

import Vue, { VueConstructor } from 'vue';

/** Affix component props */
interface AffixProps {
  /** default: 0 */
  offsetTop?: number;
  offsetBottom?: number;
  /** default: undefined */
  target?: (...args: any[]) => any;
}

/** Affix component instance */
interface Affix extends Vue {
  $props: AffixProps;
  $emit(event: string, ...args: any[]): void;
}

/** Affix Vue component type */
declare const Affix: VueConstructor<Affix>;

/** Badge component props */
interface BadgeProps {
  count?: string | number;
  dot?: boolean;
  color?: string;
  /** default: default */
  status?: string;
  text?: string;
  /** default: 99 */
  maxCount?: number;
}

/** Badge component instance */
interface Badge extends Vue {
  $props: BadgeProps;
  $emit(event: string, ...args: any[]): void;
}

/** Badge Vue component type */
declare const Badge: VueConstructor<Badge>;

/** BackTop component props */
interface BackTopProps {
  /** default: 100 */
  height?: number;
  right?: number;
  bottom?: number;
  /** default: undefined */
  target?: (...args: any[]) => any;
}

/** BackTop component instance */
interface BackTop extends Vue {
  $props: BackTopProps;
  $emit(event: string, ...args: any[]): void;
}

/** BackTop Vue component type */
declare const BackTop: VueConstructor<BackTop>;

/** Avatar component props */
interface AvatarProps {
  icon?: string | any[];
  shape?: string;
  /** default: default */
  size?: number | string;
  src?: string;
}

/** Avatar component instance */
interface Avatar extends Vue {
  $props: AvatarProps;
  $emit(event: string, ...args: any[]): void;
}

/** Avatar Vue component type */
declare const Avatar: VueConstructor<Avatar>;

/** Breadcrumb component props */
interface BreadcrumbProps {
  /** default: / */
  separator?: string | Record<string, any>;
}

/** Breadcrumb component instance */
interface Breadcrumb extends Vue {
  $props: BreadcrumbProps;
  $emit(event: string, ...args: any[]): void;
}

/** Breadcrumb Vue component type */
declare const Breadcrumb: VueConstructor<Breadcrumb>;

/** BreadcrumbItem component props */
interface BreadcrumbItemProps {
  href?: string;
  icon?: string | any[] | Record<string, any>;
}

/** BreadcrumbItem component instance */
interface BreadcrumbItem extends Vue {
  $props: BreadcrumbItemProps;
  $emit(event: string, ...args: any[]): void;
}

/** BreadcrumbItem Vue component type */
declare const BreadcrumbItem: VueConstructor<BreadcrumbItem>;

/** Alert component props */
interface AlertProps {
  /** default: warning */
  type?: string;
  closable?: boolean;
  showIcon?: boolean;
  icon?: string | Record<string, any> | any[];
  message?: string;
  description?: string;
}

/** Alert component instance */
interface Alert extends Vue {
  $props: AlertProps;
  $emit(event: string, ...args: any[]): void;
}

/** Alert Vue component type */
declare const Alert: VueConstructor<Alert>;

/** Button component props */
interface ButtonProps {
  /** default: button */
  htmlType?: any;
  icon?: string | any[];
  block?: boolean;
  size?: any;
  color?: any;
  loading?: boolean;
  /** default: default */
  type?: "outline" | "solid" | "light" | "dashed" | "card";
  /** default: false */
  disabled?: boolean;
  theme?: string;
  shape?: string;
  href?: string;
  target?: string;
}

/** Button component instance */
interface Button extends Vue {
  $props: ButtonProps;
  $emit(event: string, ...args: any[]): void;
}

/** Button Vue component type */
declare const Button: VueConstructor<Button>;

/** ButtonGroup component props */
interface ButtonGroupProps {
  size?: string;
  shape?: string;
}

/** ButtonGroup component instance */
interface ButtonGroup extends Vue {
  $props: ButtonGroupProps;
  $emit(event: string, ...args: any[]): void;
}

/** ButtonGroup Vue component type */
declare const ButtonGroup: VueConstructor<ButtonGroup>;

/** Card component props */
interface CardProps {
  /** default: true */
  bordered?: boolean;
  title?: string;
  icon?: string | any[];
}

/** Card component instance */
interface Card extends Vue {
  $props: CardProps;
  $emit(event: string, ...args: any[]): void;
}

/** Card Vue component type */
declare const Card: VueConstructor<Card>;

/** Carousel component props */
interface CarouselProps {
  /** default: 0 */
  value?: number;
  /** default: true */
  loop?: boolean;
  autoplay?: boolean;
  /** default: 3000 */
  delay?: number;
  vertical?: boolean;
  /** default: true */
  dots?: boolean;
}

/** Carousel component instance */
interface Carousel extends Vue {
  $props: CarouselProps;
  $emit(event: string, ...args: any[]): void;
}

/** Carousel Vue component type */
declare const Carousel: VueConstructor<Carousel>;

/** CarouselItem component props */
interface CarouselItemProps {}

/** CarouselItem component instance */
interface CarouselItem extends Vue {
  $props: CarouselItemProps;
  $emit(event: string, ...args: any[]): void;
}

/** CarouselItem Vue component type */
declare const CarouselItem: VueConstructor<CarouselItem>;

/** Checkbox component props */
interface CheckboxProps {
  /** default: false */
  checked?: boolean | number;
  value?: string | number | boolean;
  label?: string | number;
  theme?: string;
  disabled?: boolean;
  indeterminate?: boolean;
  /** default: default */
  size?: any;
}

/** Checkbox component instance */
interface Checkbox extends Vue {
  $props: CheckboxProps;
  $emit(event: string, ...args: any[]): void;
}

/** Checkbox Vue component type */
declare const Checkbox: VueConstructor<Checkbox>;

/** CheckboxGroup component props */
interface CheckboxGroupProps {
  /** default: undefined */
  value?: any[];
  theme?: string;
  disabled?: boolean;
  options?: any[];
  /** default: horizontal */
  direction?: string;
  /** default: default */
  size?: any;
}

/** CheckboxGroup component instance */
interface CheckboxGroup extends Vue {
  $props: CheckboxGroupProps;
  $emit(event: string, ...args: any[]): void;
}

/** CheckboxGroup Vue component type */
declare const CheckboxGroup: VueConstructor<CheckboxGroup>;

/** Collapse component props */
interface CollapseProps {
  openKeys?: any[];
  accordion?: boolean;
  sample?: boolean;
}

/** Collapse component instance */
interface Collapse extends Vue {
  $props: CollapseProps;
  $emit(event: string, ...args: any[]): void;
}

/** Collapse Vue component type */
declare const Collapse: VueConstructor<Collapse>;

/** CollapsePanel component props */
interface CollapsePanelProps {
  title?: string;
  active?: boolean;
}

/** CollapsePanel component instance */
interface CollapsePanel extends Vue {
  $props: CollapsePanelProps;
  $emit(event: string, ...args: any[]): void;
}

/** CollapsePanel Vue component type */
declare const CollapsePanel: VueConstructor<CollapsePanel>;

/** ColorPicker component props */
interface ColorPickerProps {
  value?: string;
  /** default: true */
  transfer?: boolean;
  disabled?: boolean;
  disabledAlpha?: boolean;
  showText?: boolean;
  arrow?: boolean;
  /** default: bottom-left */
  placement?: any;
  /** default: click */
  trigger?: string;
  /** default: default */
  size?: any;
  /** default: hex */
  mode?: string;
  show?: boolean;
  presets?: any[];
}

/** ColorPicker component instance */
interface ColorPicker extends Vue {
  $props: ColorPickerProps;
  $emit(event: string, ...args: any[]): void;
}

/** ColorPicker Vue component type */
declare const ColorPicker: VueConstructor<ColorPicker>;

/** DatePicker component props */
interface DatePickerProps {
  /** default: undefined */
  value?: any | Record<string, any> | any[] | string | number;
  /** default: undefined */
  startDate?: any | Record<string, any> | string | number;
  /** default: undefined */
  endDate?: any | Record<string, any> | string | number;
  /** default: string */
  valueType?: string;
  /** default: date */
  mode?: string;
  presets?: any[];
  disabled?: boolean;
  /** default: true */
  clearable?: boolean;
  /** default: true */
  editable?: boolean;
  /** default:  */
  placeholder?: string | any[];
  /** default: undefined */
  format?: string | any[];
  /** default: undefined */
  disabledDate?: (...args: any[]) => any;
  /** default: undefined */
  disabledTime?: (...args: any[]) => any;
  /** default: default */
  size?: string;
  /** default: default */
  pickerSize?: string;
  dateIcon?: any[] | Record<string, any>;
  theme?: string;
  shape?: string;
  /** default: true */
  bordered?: boolean;
  /** default: bottom-left */
  placement?: any;
}

/** DatePicker component instance */
interface DatePicker extends Vue {
  $props: DatePickerProps;
  $emit(event: string, ...args: any[]): void;
}

/** DatePicker Vue component type */
declare const DatePicker: VueConstructor<DatePicker>;

/** Descriptions component props */
interface DescriptionsProps {
  bordered?: boolean;
  /** default: 3 */
  column?: number;
  /** default: horizontal */
  layout?: string;
  title?: string;
  extra?: string;
  /** default: default */
  size?: string;
}

/** Descriptions component instance */
interface Descriptions extends Vue {
  $props: DescriptionsProps;
  $emit(event: string, ...args: any[]): void;
}

/** Descriptions Vue component type */
declare const Descriptions: VueConstructor<Descriptions>;

/** DescriptionsItem component props */
interface DescriptionsItemProps {
  label?: string;
  /** default: 1 */
  span?: number;
  type?: string;
  bordered?: boolean;
  layout?: string;
}

/** DescriptionsItem component instance */
interface DescriptionsItem extends Vue {
  $props: DescriptionsItemProps;
  $emit(event: string, ...args: any[]): void;
}

/** DescriptionsItem Vue component type */
declare const DescriptionsItem: VueConstructor<DescriptionsItem>;

/** Divider component props */
interface DividerProps {
  /** default: horizontal */
  type?: string;
  text?: string;
  dashed?: boolean;
  /** default: center */
  orientation?: string;
}

/** Divider component instance */
interface Divider extends Vue {
  $props: DividerProps;
  $emit(event: string, ...args: any[]): void;
}

/** Divider Vue component type */
declare const Divider: VueConstructor<Divider>;

/** Drawer component props */
interface DrawerProps {
  value?: boolean;
  /** default: Title */
  title?: string;
  /** default: 520 */
  width?: number | string;
  /** default: 256 */
  height?: number | string;
  okText?: string;
  cancelText?: string;
  /** default: right */
  placement?: string;
  /** default: true */
  closable?: boolean;
  /** default: true */
  footer?: boolean;
  /** default: true */
  maskClosable?: boolean;
  /** default: undefined */
  target?: (...args: any[]) => any;
  /** default: true */
  mask?: boolean;
  /** default: false */
  loading?: boolean;
  /** default: true */
  escKey?: boolean;
}

/** Drawer component instance */
interface Drawer extends Vue {
  $props: DrawerProps;
  $emit(event: string, ...args: any[]): void;
}

/** Drawer Vue component type */
declare const Drawer: VueConstructor<Drawer>;

/** Dropdown component props */
interface DropdownProps {
  dark?: boolean;
  /** default: hover */
  trigger?: string;
  /** default: true */
  transfer?: boolean;
  disabled?: boolean;
  /** default: false */
  arrow?: boolean;
  show?: boolean;
  /** default: bottom-left */
  placement?: any;
  target?: Record<string, any>;
}

/** Dropdown component instance */
interface Dropdown extends Vue {
  $props: DropdownProps;
  $emit(event: string, ...args: any[]): void;
}

/** Dropdown Vue component type */
declare const Dropdown: VueConstructor<Dropdown>;

/** DropdownButton component props */
interface DropdownButtonProps {
  size?: string;
  shape?: string;
  disabled?: boolean;
  icon?: string | any[] | Record<string, any>;
  theme?: string;
  dark?: boolean;
  arrow?: boolean;
  /** default: bottom-right */
  placement?: string;
}

/** DropdownButton component instance */
interface DropdownButton extends Vue {
  $props: DropdownButtonProps;
  $emit(event: string, ...args: any[]): void;
}

/** DropdownButton Vue component type */
declare const DropdownButton: VueConstructor<DropdownButton>;

/** Empty component props */
interface EmptyProps {
  description?: string;
  image?: string;
  imageStyle?: Record<string, any>;
}

/** Empty component instance */
interface Empty extends Vue {
  $props: EmptyProps;
  $emit(event: string, ...args: any[]): void;
}

/** Empty Vue component type */
declare const Empty: VueConstructor<Empty>;

/** Flex component props */
interface FlexProps {
  align?: string;
  justify?: string;
  vertical?: boolean;
  wrap?: boolean;
  size?: string | number | any[];
}

/** Flex component instance */
interface Flex extends Vue {
  $props: FlexProps;
  $emit(event: string, ...args: any[]): void;
}

/** Flex Vue component type */
declare const Flex: VueConstructor<Flex>;

/** Form component props */
interface FormProps {
  /** default: horizontal */
  layout?: string;
  model?: Record<string, any>;
  name?: string;
  labelCol?: Record<string, any>;
  wrapperCol?: Record<string, any>;
  /** default: undefined */
  rules?: Record<string, any>;
  /** default: default */
  size?: string;
  theme?: string;
  shape?: string;
  disabled?: boolean;
}

/** Form component instance */
interface Form extends Vue {
  $props: FormProps;
  $emit(event: string, ...args: any[]): void;
}

/** Form Vue component type */
declare const Form: VueConstructor<Form>;

/** formitem component props */
interface formitemProps {
  label?: string;
  prop?: string;
  labelCol?: Record<string, any>;
  wrapperCol?: Record<string, any>;
  rules?: any[] | Record<string, any>;
}

/** formitem component instance */
interface formitem extends Vue {
  $props: formitemProps;
  $emit(event: string, ...args: any[]): void;
}

/** formitem Vue component type */
declare const formitem: VueConstructor<formitem>;

/** Row component props */
interface RowProps {
  gutter?: number | any[];
  /** default: flex */
  type?: string;
  justify?: string;
  align?: string;
}

/** Row component instance */
interface Row extends Vue {
  $props: RowProps;
  $emit(event: string, ...args: any[]): void;
}

/** Row Vue component type */
declare const Row: VueConstructor<Row>;

/** Col component props */
interface ColProps {
  span?: number;
  offset?: number;
  flex?: string | number;
}

/** Col component instance */
interface Col extends Vue {
  $props: ColProps;
  $emit(event: string, ...args: any[]): void;
}

/** Col Vue component type */
declare const Col: VueConstructor<Col>;

/** Icon component props */
interface IconProps {
  type?: string | any[];
  size?: string | number;
  color?: string;
  spin?: boolean;
  strokeWidth?: string | number;
}

/** Icon component instance */
interface Icon extends Vue {
  $props: IconProps;
  $emit(event: string, ...args: any[]): void;
}

/** Icon Vue component type */
declare const Icon: VueConstructor<Icon>;

/** KImage component props */
interface KImageProps {
  alt?: string;
  src?: string;
  type?: string;
  origin?: string;
  height?: string | number;
  width?: string | number;
  placeholder?: string;
  data?: any[];
  imgStyle?: Record<string, any>;
  showPanel?: boolean;
}

/** KImage component instance */
interface KImage extends Vue {
  $props: KImageProps;
  $emit(event: string, ...args: any[]): void;
}

/** KImage Vue component type */
declare const KImage: VueConstructor<KImage>;

/** ImageGroup component props */
interface ImageGroupProps {
  data?: any[];
}

/** ImageGroup component instance */
interface ImageGroup extends Vue {
  $props: ImageGroupProps;
  $emit(event: string, ...args: any[]): void;
}

/** ImageGroup Vue component type */
declare const ImageGroup: VueConstructor<ImageGroup>;

/** Input component props */
interface InputProps {
  /** default: true */
  clearable?: boolean;
  /** default: true */
  visiblePasswordIcon?: boolean;
  size?: string;
  value?: string | number | any[] | Record<string, any>;
  disabled?: boolean;
  /** default: text */
  type?: any;
  icon?: string | any[];
  suffix?: string;
  prefix?: string;
  theme?: string;
  shape?: string;
  formatter?: (...args: any[]) => any;
  parser?: (...args: any[]) => any;
  /** default: input */
  inputType?: string;
}

/** Input component instance */
interface Input extends Vue {
  $props: InputProps;
  $emit(event: string, ...args: any[]): void;
}

/** Input Vue component type */
declare const Input: VueConstructor<Input>;

/** TextArea component props */
interface TextAreaProps {
  value?: string | number | Record<string, any> | any[];
  theme?: string;
  size?: string;
  disabled?: boolean;
}

/** TextArea component instance */
interface TextArea extends Vue {
  $props: TextAreaProps;
  $emit(event: string, ...args: any[]): void;
}

/** TextArea Vue component type */
declare const TextArea: VueConstructor<TextArea>;

/** InputGroup component props */
interface InputGroupProps {
  block?: boolean;
  /** default: true */
  compact?: boolean;
  size?: string;
}

/** InputGroup component instance */
interface InputGroup extends Vue {
  $props: InputGroupProps;
  $emit(event: string, ...args: any[]): void;
}

/** InputGroup Vue component type */
declare const InputGroup: VueConstructor<InputGroup>;

/** InputNumber component props */
interface InputNumberProps {
  value?: any[] | number | string;
  /** default: undefined */
  min?: number;
  /** default: undefined */
  max?: number;
  disabled?: boolean;
  clearable?: boolean;
  readonly?: boolean;
  formatter?: (...args: any[]) => any;
  parser?: (...args: any[]) => any;
  size?: string;
  precision?: number;
  suffix?: string;
  prefix?: string;
  /** default: true */
  controls?: boolean;
  /** default: true */
  keyboard?: boolean;
  /** default: 1 */
  step?: number;
  theme?: string;
  icon?: string | any[];
  id?: string;
}

/** InputNumber component instance */
interface InputNumber extends Vue {
  $props: InputNumberProps;
  $emit(event: string, ...args: any[]): void;
}

/** InputNumber Vue component type */
declare const InputNumber: VueConstructor<InputNumber>;

/** loading component props */
interface loadingProps {}

/** loading component instance */
interface loading extends Vue {
  $props: loadingProps;
  $emit(event: string, ...args: any[]): void;
}

/** loading Vue component type */
declare const loading: VueConstructor<loading>;

/** Menu component props */
interface MenuProps {
  theme?: string;
  /** default: vertical */
  mode?: string;
  /** default: undefined */
  value?: any[];
  accordion?: boolean;
  inlineCollapsed?: boolean;
  /** default: undefined */
  openKeys?: any[];
}

/** Menu component instance */
interface Menu extends Vue {
  $props: MenuProps;
  $emit(event: string, ...args: any[]): void;
}

/** Menu Vue component type */
declare const Menu: VueConstructor<Menu>;

/** MenuGroup component props */
interface MenuGroupProps {
  title?: string;
}

/** MenuGroup component instance */
interface MenuGroup extends Vue {
  $props: MenuGroupProps;
  $emit(event: string, ...args: any[]): void;
}

/** MenuGroup Vue component type */
declare const MenuGroup: VueConstructor<MenuGroup>;

/** MenuItem component props */
interface MenuItemProps {
  icon?: string | any[];
  title?: string;
  label?: string;
  disabled?: boolean;
  isPopup?: boolean;
}

/** MenuItem component instance */
interface MenuItem extends Vue {
  $props: MenuItemProps;
  $emit(event: string, ...args: any[]): void;
}

/** MenuItem Vue component type */
declare const MenuItem: VueConstructor<MenuItem>;

/** SubMenu component props */
interface SubMenuProps {
  disabled?: boolean;
  title?: string;
  isPopup?: boolean;
  icon?: string | any[];
}

/** SubMenu component instance */
interface SubMenu extends Vue {
  $props: SubMenuProps;
  $emit(event: string, ...args: any[]): void;
}

/** SubMenu Vue component type */
declare const SubMenu: VueConstructor<SubMenu>;

/** MenuDivider component props */
interface MenuDividerProps {}

/** MenuDivider component instance */
interface MenuDivider extends Vue {
  $props: MenuDividerProps;
  $emit(event: string, ...args: any[]): void;
}

/** MenuDivider Vue component type */
declare const MenuDivider: VueConstructor<MenuDivider>;

/** sider component props */
interface siderProps {
  suffixCls?: string;
}

/** sider component instance */
interface sider extends Vue {
  $props: siderProps;
  $emit(event: string, ...args: any[]): void;
}

/** sider Vue component type */
declare const sider: VueConstructor<sider>;

/** Page component props */
interface PageProps {
  disabled?: boolean;
  showSizer?: boolean;
  /** default: true */
  showTotal?: boolean;
  showElevator?: boolean;
  theme?: string;
  /** default: undefined */
  sizeData?: any[];
  /** default: default */
  size?: any;
  /** default: 0 */
  total?: number;
  /** default: 10 */
  pageSize?: number;
  /** default: 1 */
  current?: number;
}

/** Page component instance */
interface Page extends Vue {
  $props: PageProps;
  $emit(event: string, ...args: any[]): void;
}

/** Page Vue component type */
declare const Page: VueConstructor<Page>;

/** Popconfirm component props */
interface PopconfirmProps {
  dark?: boolean;
  show?: boolean;
  title?: string | number | Record<string, any> | any[];
  size?: string;
  width?: number | string;
  okText?: string;
  cancelText?: string;
  /** default: top */
  placement?: any;
}

/** Popconfirm component instance */
interface Popconfirm extends Vue {
  $props: PopconfirmProps;
  $emit(event: string, ...args: any[]): void;
}

/** Popconfirm Vue component type */
declare const Popconfirm: VueConstructor<Popconfirm>;

/** Poptip component props */
interface PoptipProps {
  dark?: boolean;
  show?: boolean;
  title?: string | number | Record<string, any> | any[];
  size?: string;
  width?: number | string;
  /** default: hover */
  trigger?: any;
  /** default: top */
  placement?: any;
}

/** Poptip component instance */
interface Poptip extends Vue {
  $props: PoptipProps;
  $emit(event: string, ...args: any[]): void;
}

/** Poptip Vue component type */
declare const Poptip: VueConstructor<Poptip>;

/** Modal component props */
interface ModalProps {
  value?: boolean;
  title?: string;
  okText?: string;
  cancelText?: string;
  top?: number;
  width?: number;
  /** default: true */
  mask?: boolean;
  /** default: false */
  maskClosable?: boolean;
  maximized?: boolean;
  centered?: boolean;
  draggable?: boolean;
  /** default: true */
  showClose?: boolean;
  loading?: boolean;
  footer?: string;
  /** default: true */
  transfer?: boolean;
  /** default: true */
  escKey?: boolean;
}

/** Modal component instance */
interface Modal extends Vue {
  $props: ModalProps;
  $emit(event: string, ...args: any[]): void;
}

/** Modal Vue component type */
declare const Modal: VueConstructor<Modal>;

/** Progress component props */
interface ProgressProps {
  /** default: 0 */
  percent?: number;
  /** default: 6 */
  strokeWidth?: number;
  color?: string;
  format?: (...args: any[]) => any;
  width?: number;
  strokeHeight?: number;
  /** default: 75 */
  gapDegree?: number;
  strokeColor?: Record<string, any>;
  /** default: round */
  strokeLinecap?: string;
  /** default: default */
  size?: string;
  /** default: normal */
  status?: string;
  /** default: line */
  type?: string;
  /** default: true */
  showInfo?: boolean;
}

/** Progress component instance */
interface Progress extends Vue {
  $props: ProgressProps;
  $emit(event: string, ...args: any[]): void;
}

/** Progress Vue component type */
declare const Progress: VueConstructor<Progress>;

/** Radio component props */
interface RadioProps {
  /** default: false */
  checked?: boolean | number;
  value?: string | number | boolean;
  label?: string | number;
  disabled?: boolean;
  theme?: string;
  /** default: default */
  size?: any;
}

/** Radio component instance */
interface Radio extends Vue {
  $props: RadioProps;
  $emit(event: string, ...args: any[]): void;
}

/** Radio Vue component type */
declare const Radio: VueConstructor<Radio>;

/** RadioGroup component props */
interface RadioGroupProps {
  /** default:  */
  value?: string | number | boolean;
  disabled?: boolean;
  /** default: horizontal */
  direction?: string;
  size?: any;
  theme?: string;
  shape?: string;
  options?: any[];
  type?: string;
}

/** RadioGroup component instance */
interface RadioGroup extends Vue {
  $props: RadioGroupProps;
  $emit(event: string, ...args: any[]): void;
}

/** RadioGroup Vue component type */
declare const RadioGroup: VueConstructor<RadioGroup>;

/** RadioButton component props */
interface RadioButtonProps {
  /** default: false */
  checked?: boolean | number;
  value?: string | number | boolean;
  label?: string | number;
  theme?: string;
  disabled?: boolean;
  /** default: default */
  size?: any;
}

/** RadioButton component instance */
interface RadioButton extends Vue {
  $props: RadioButtonProps;
  $emit(event: string, ...args: any[]): void;
}

/** RadioButton Vue component type */
declare const RadioButton: VueConstructor<RadioButton>;

/** Rate component props */
interface RateProps {
  /** default: 0 */
  value?: number;
  /** default: true */
  allowClear?: boolean;
  allowHalf?: boolean;
  character?: string | ((...args: any[]) => any);
  icon?: string | any[] | ((...args: any[]) => any);
  /** default: 5 */
  count?: number;
  disabled?: boolean;
  tooltips?: any[];
  showScore?: boolean;
  size?: number;
  color?: string;
}

/** Rate component instance */
interface Rate extends Vue {
  $props: RateProps;
  $emit(event: string, ...args: any[]): void;
}

/** Rate Vue component type */
declare const Rate: VueConstructor<Rate>;

/** Select component props */
interface SelectProps {
  placeholder?: string;
  /** default: default */
  size?: any;
  /** default: bottom-left */
  placement?: any;
  width?: number;
  maxTagCount?: number;
  value?: string | number | any[];
  /** default: true */
  clearable?: boolean;
  filterable?: boolean;
  block?: boolean;
  disabled?: boolean;
  multiple?: boolean;
  loading?: boolean;
  /** default: true */
  bordered?: boolean;
  /** default: true */
  showArrow?: boolean;
  options?: any[];
  theme?: string;
  emptyText?: string;
  loadingText?: string;
  icon?: string | any[];
  shape?: string;
  arrowIcon?: string | any[];
}

/** Select component instance */
interface Select extends Vue {
  $props: SelectProps;
  $emit(event: string, ...args: any[]): void;
}

/** Select Vue component type */
declare const Select: VueConstructor<Select>;

/** Option component props */
interface OptionProps {
  value?: string | number;
  label?: string | number;
  disabled?: boolean;
  checked?: boolean;
  active?: boolean;
  multiple?: boolean;
}

/** Option component instance */
interface Option extends Vue {
  $props: OptionProps;
  $emit(event: string, ...args: any[]): void;
}

/** Option Vue component type */
declare const Option: VueConstructor<Option>;

/** Skeleton component props */
interface SkeletonProps {
  animated?: boolean;
  avatar?: boolean | Record<string, any>;
  loading?: boolean;
  /** default: 35 */
  title?: number;
  /** default: 500 */
  delay?: number;
  /** default: 3 */
  rows?: number;
}

/** Skeleton component instance */
interface Skeleton extends Vue {
  $props: SkeletonProps;
  $emit(event: string, ...args: any[]): void;
}

/** Skeleton Vue component type */
declare const Skeleton: VueConstructor<Skeleton>;

/** SkeletonAvatar component props */
interface SkeletonAvatarProps {
  animated?: boolean;
  radius?: number;
  loading?: boolean;
  /** default: 500 */
  delay?: number;
  shape?: string;
  size?: number | string;
}

/** SkeletonAvatar component instance */
interface SkeletonAvatar extends Vue {
  $props: SkeletonAvatarProps;
  $emit(event: string, ...args: any[]): void;
}

/** SkeletonAvatar Vue component type */
declare const SkeletonAvatar: VueConstructor<SkeletonAvatar>;

/** SkeletonButton component props */
interface SkeletonButtonProps {
  animated?: boolean;
  block?: boolean;
  loading?: boolean;
  /** default: 500 */
  delay?: number;
  shape?: string;
  size?: string;
  width?: number;
}

/** SkeletonButton component instance */
interface SkeletonButton extends Vue {
  $props: SkeletonButtonProps;
  $emit(event: string, ...args: any[]): void;
}

/** SkeletonButton Vue component type */
declare const SkeletonButton: VueConstructor<SkeletonButton>;

/** SkeletonImage component props */
interface SkeletonImageProps {
  animated?: boolean;
  loading?: boolean;
  /** default: 500 */
  delay?: number;
  radius?: number;
  size?: number | any[];
}

/** SkeletonImage component instance */
interface SkeletonImage extends Vue {
  $props: SkeletonImageProps;
  $emit(event: string, ...args: any[]): void;
}

/** SkeletonImage Vue component type */
declare const SkeletonImage: VueConstructor<SkeletonImage>;

/** SkeletonText component props */
interface SkeletonTextProps {
  animated?: boolean;
  loading?: boolean;
  /** default: 500 */
  delay?: number;
  size?: string;
  width?: number;
}

/** SkeletonText component instance */
interface SkeletonText extends Vue {
  $props: SkeletonTextProps;
  $emit(event: string, ...args: any[]): void;
}

/** SkeletonText Vue component type */
declare const SkeletonText: VueConstructor<SkeletonText>;

/** Slider component props */
interface SliderProps {
  value?: any[] | number | string;
  /** default: 0 */
  min?: number;
  /** default: 100 */
  max?: number;
  disabled?: boolean;
  /** default: 1 */
  step?: number;
  size?: string;
  vertical?: boolean;
  range?: boolean;
  reverse?: boolean;
  marks?: Record<string, any>;
  /** default: true */
  included?: boolean;
  tipFormatter?: ((...args: any[]) => any) | Record<string, any>;
  tooltipVisible?: boolean;
}

/** Slider component instance */
interface Slider extends Vue {
  $props: SliderProps;
  $emit(event: string, ...args: any[]): void;
}

/** Slider Vue component type */
declare const Slider: VueConstructor<Slider>;

/** Space component props */
interface SpaceProps {
  align?: string;
  vertical?: boolean;
  /** default: false */
  wrap?: boolean;
  block?: boolean;
  compact?: boolean;
  size?: string | number | any[];
}

/** Space component instance */
interface Space extends Vue {
  $props: SpaceProps;
  $emit(event: string, ...args: any[]): void;
}

/** Space Vue component type */
declare const Space: VueConstructor<Space>;

/** Spin component props */
interface SpinProps {
  /** default: true */
  value?: boolean;
  /** default: 500 */
  delay?: number;
  /** default: default */
  size?: string;
  /** default: rotate */
  mode?: string;
}

/** Spin component instance */
interface Spin extends Vue {
  $props: SpinProps;
  $emit(event: string, ...args: any[]): void;
}

/** Spin Vue component type */
declare const Spin: VueConstructor<Spin>;

/** Switch component props */
interface SwitchProps {
  /** default: false */
  checked?: boolean | number;
  type?: string;
  disabled?: boolean;
  loading?: boolean;
  /** default: default */
  size?: any;
  trueText?: string;
  falseText?: string;
}

/** Switch component instance */
interface Switch extends Vue {
  $props: SwitchProps;
  $emit(event: string, ...args: any[]): void;
}

/** Switch Vue component type */
declare const Switch: VueConstructor<Switch>;

/** Table component props */
interface TableProps {
  /** default: undefined */
  data?: any[];
  /** default: undefined */
  columns?: any[];
  /** default: undefined */
  selectedKeys?: any[];
  /** default: undefined */
  disabledKeys?: any[];
  /** default: key */
  rowKey?: string;
  /** default: undefined */
  scroll?: Record<string, any>;
  /** default: default */
  size?: any;
  bordered?: boolean;
  checkable?: boolean;
  loading?: boolean;
  emptyText?: string;
}

/** Table component instance */
interface Table extends Vue {
  $props: TableProps;
  $emit(event: string, ...args: any[]): void;
}

/** Table Vue component type */
declare const Table: VueConstructor<Table>;

/** Tabs component props */
interface TabsProps {
  value?: string | number;
  card?: boolean;
  sample?: boolean;
  centered?: boolean;
  /** default: true */
  animated?: boolean;
}

/** Tabs component instance */
interface Tabs extends Vue {
  $props: TabsProps;
  $emit(event: string, ...args: any[]): void;
}

/** Tabs Vue component type */
declare const Tabs: VueConstructor<Tabs>;

/** TabPanel component props */
interface TabPanelProps {
  title?: string;
  icon?: string | any[];
  disabled?: boolean;
  closable?: boolean;
  activeKey?: string | number;
}

/** TabPanel component instance */
interface TabPanel extends Vue {
  $props: TabPanelProps;
  $emit(event: string, ...args: any[]): void;
}

/** TabPanel Vue component type */
declare const TabPanel: VueConstructor<TabPanel>;

/** Tag component props */
interface TagProps {
  closeable?: boolean;
  color?: string;
  shape?: string;
  icon?: string | any[];
  /** default: small */
  size?: any;
  theme?: string;
}

/** Tag component instance */
interface Tag extends Vue {
  $props: TagProps;
  $emit(event: string, ...args: any[]): void;
}

/** Tag Vue component type */
declare const Tag: VueConstructor<Tag>;

/** TimeLine component props */
interface TimeLineProps {
  /** default: left */
  mode?: string;
}

/** TimeLine component instance */
interface TimeLine extends Vue {
  $props: TimeLineProps;
  $emit(event: string, ...args: any[]): void;
}

/** TimeLine Vue component type */
declare const TimeLine: VueConstructor<TimeLine>;

/** TimeLineItem component props */
interface TimeLineItemProps {
  color?: string;
  icon?: string | any[];
  time?: string;
  extra?: string;
}

/** TimeLineItem component instance */
interface TimeLineItem extends Vue {
  $props: TimeLineItemProps;
  $emit(event: string, ...args: any[]): void;
}

/** TimeLineItem Vue component type */
declare const TimeLineItem: VueConstructor<TimeLineItem>;

/** Tooltip component props */
interface TooltipProps {
  show?: boolean;
  dark?: boolean;
  title?: string | number | Record<string, any> | any[];
  color?: string;
  disabled?: boolean;
  size?: string;
  width?: number | string;
  /** default: top */
  placement?: any;
  show?: boolean;
}

/** Tooltip component instance */
interface Tooltip extends Vue {
  $props: TooltipProps;
  $emit(event: string, ...args: any[]): void;
}

/** Tooltip Vue component type */
declare const Tooltip: VueConstructor<Tooltip>;

/** TreeSelect component props */
interface TreeSelectProps {
  placeholder?: string;
  /** default: default */
  size?: any;
  /** default: bottom-left */
  placement?: any;
  width?: number;
  maxTagCount?: number;
  value?: string | number | any[];
  /** default: true */
  clearable?: boolean;
  filterable?: boolean;
  block?: boolean;
  disabled?: boolean;
  multiple?: boolean;
  loading?: boolean;
  /** default: true */
  bordered?: boolean;
  /** default: true */
  showArrow?: boolean;
  options?: any[];
  theme?: string;
  emptyText?: string;
  icon?: string | any[];
  shape?: string;
  arrowIcon?: string | any[];
  treeData?: any[];
  treeCheckable?: boolean;
  treeShowLine?: boolean;
  /** default: true */
  treeShowIcon?: boolean;
  treeCheckStrictly?: boolean;
  treeExpandedKeys?: any[];
  treeSelectedKeys?: any[];
  treeExpandedAll?: boolean;
}

/** TreeSelect component instance */
interface TreeSelect extends Vue {
  $props: TreeSelectProps;
  $emit(event: string, ...args: any[]): void;
}

/** TreeSelect Vue component type */
declare const TreeSelect: VueConstructor<TreeSelect>;

/** Tree component props */
interface TreeProps {
  data?: any[];
  selectedKeys?: any[];
  expandedKeys?: any[];
  checkedKeys?: any[];
  directory?: boolean;
  expandAll?: boolean;
  checkable?: boolean;
  draggable?: boolean;
  showLine?: boolean;
  /** default: true */
  showIcon?: boolean;
  /** default: false */
  showExtra?: boolean;
  /** default: false */
  multiple?: boolean;
  checkStrictly?: boolean;
  selectAsCheck?: boolean;
  queryKey?: string;
}

/** Tree component instance */
interface Tree extends Vue {
  $props: TreeProps;
  $emit(event: string, ...args: any[]): void;
}

/** Tree Vue component type */
declare const Tree: VueConstructor<Tree>;

/** Upload component props */
interface UploadProps {
  /** default: post */
  method?: string;
  /** default: file */
  name?: string;
  action?: string;
  /** default: list */
  type?: string;
  /** default: undefined */
  data?: Record<string, any>;
  disabled?: boolean;
  directory?: boolean;
  multiple?: boolean;
  accept?: string;
  headers?: Record<string, any>;
  /** default: true */
  showUploadList?: boolean;
  transformFile?: (...args: any[]) => any;
  fileList?: any[];
  /** default: true */
  autoTrigger?: boolean;
  limit?: number;
  minSize?: number;
  maxSize?: number;
  uploadText?: string;
  uploadSubText?: string;
  uploadIcon?: string | Record<string, any> | any[];
  draggable?: boolean;
}

/** Upload component instance */
interface Upload extends Vue {
  $props: UploadProps;
  $emit(event: string, ...args: any[]): void;
}

/** Upload Vue component type */
declare const Upload: VueConstructor<Upload>;

export { Affix, Alert, Avatar, BackTop, Badge, Breadcrumb, BreadcrumbItem, Button, ButtonGroup, Card, Carousel, CarouselItem, Checkbox, CheckboxGroup, Col, Collapse, CollapsePanel, ColorPicker, DatePicker, Descriptions, DescriptionsItem, Divider, Drawer, Dropdown, DropdownButton, Empty, Flex, Form, Icon, ImageGroup, Input, InputGroup, InputNumber, KImage, Menu, MenuDivider, MenuGroup, MenuItem, Modal, Option, Page, Popconfirm, Poptip, Progress, Radio, RadioButton, RadioGroup, Rate, Row, Select, Skeleton, SkeletonAvatar, SkeletonButton, SkeletonImage, SkeletonText, Slider, Space, Spin, SubMenu, Switch, TabPanel, Table, Tabs, Tag, TextArea, TimeLine, TimeLineItem, Tooltip, Tree, TreeSelect, Upload, formitem, loading, sider };
export type { AffixProps, AlertProps, AvatarProps, BackTopProps, BadgeProps, BreadcrumbItemProps, BreadcrumbProps, ButtonGroupProps, ButtonProps, CardProps, CarouselItemProps, CarouselProps, CheckboxGroupProps, CheckboxProps, ColProps, CollapsePanelProps, CollapseProps, ColorPickerProps, DatePickerProps, DescriptionsItemProps, DescriptionsProps, DividerProps, DrawerProps, DropdownButtonProps, DropdownProps, EmptyProps, FlexProps, FormProps, IconProps, ImageGroupProps, InputGroupProps, InputNumberProps, InputProps, KImageProps, MenuDividerProps, MenuGroupProps, MenuItemProps, MenuProps, ModalProps, OptionProps, PageProps, PopconfirmProps, PoptipProps, ProgressProps, RadioButtonProps, RadioGroupProps, RadioProps, RateProps, RowProps, SelectProps, SkeletonAvatarProps, SkeletonButtonProps, SkeletonImageProps, SkeletonProps, SkeletonTextProps, SliderProps, SpaceProps, SpinProps, SubMenuProps, SwitchProps, TabPanelProps, TableProps, TabsProps, TagProps, TextAreaProps, TimeLineItemProps, TimeLineProps, TooltipProps, TreeProps, TreeSelectProps, UploadProps, formitemProps, loadingProps, siderProps };