adtec-hnyzfc-core-package 1.0.0

package/dist/src/types/vxe-pc-ui/components/radio-group.d.ts

@@ -0,0 +1,153 @@
+import { RenderFunction, SetupContext, Ref, ComputedRef } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, ValueOf, VxeComponentStatusType } from '@vxe-ui/core'
+import { VxeRadioPropTypes } from './radio'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeRadioGroup: DefineVxeComponentApp<VxeRadioGroupProps, VxeRadioGroupEventProps, VxeRadioGroupSlots, VxeRadioGroupMethods>
+export type VxeRadioGroupComponent = DefineVxeComponentOptions<VxeRadioGroupProps, VxeRadioGroupEventProps>
+
+export type VxeRadioGroupInstance = DefineVxeComponentInstance<VxeRadioGroupProps, VxeRadioGroupConstructor>
+
+export interface VxeRadioGroupConstructor extends VxeComponentBaseOptions, VxeRadioGroupMethods {
+  name: string
+  props: VxeRadioGroupProps
+  context: SetupContext<VxeRadioGroupEmits>
+  reactData: RadioGroupReactData
+  getRefMaps(): RadioGroupPrivateRef
+  getComputeMaps(): RadioGroupPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface RadioGroupPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeRadioGroupPrivateRef extends RadioGroupPrivateRef { }
+
+export namespace VxeRadioGroupPropTypes {
+  export type Size = VxeComponentSizeType
+  export type Type = 'button' | 'default' | '' | null
+  export type Options = {
+    value?: VxeRadioPropTypes.CheckedValue
+    label?: VxeRadioPropTypes.Content
+    icon?: string
+    title?: string
+
+    [key: string]: any
+  }[]
+  export type OptionProps = {
+    value?: string
+    label?: string
+    icon?: string
+    title?: string
+    disabled?: string
+  }
+  export type ModelValue = any
+  export type Status = VxeComponentStatusType
+  export type Strict = boolean
+  export type Disabled = boolean
+  export type Readonly = boolean
+  export interface DefaultConfig {
+    /**
+     * 默认选择模式，默认选中行为只会在初始化时触发一次
+     */
+    selectMode?: 'first' | 'last'
+  }
+}
+
+export interface VxeRadioGroupProps {
+  size?: VxeRadioGroupPropTypes.Size
+  type?: VxeRadioGroupPropTypes.Type
+  options?: VxeRadioGroupPropTypes.Options
+  optionProps?: VxeRadioGroupPropTypes.OptionProps
+  status?: VxeRadioGroupPropTypes.Status
+  /**
+   * 严格模式，不允许取消
+   */
+  strict?: VxeRadioGroupPropTypes.Strict
+  modelValue?: VxeRadioGroupPropTypes.ModelValue
+  disabled?: VxeRadioGroupPropTypes.Disabled
+  readonly?: VxeRadioGroupPropTypes.Readonly
+  defaultConfig?: VxeRadioGroupPropTypes.DefaultConfig
+}
+
+export interface RadioGroupPrivateComputed {
+  computeIsDisabled: ComputedRef<boolean | undefined>
+  computeIsReadonly: ComputedRef<boolean | undefined>
+}
+export interface VxeRadioGroupPrivateComputed extends RadioGroupPrivateComputed { }
+
+export interface RadioGroupReactData {
+}
+export interface RadioGroupInternalData {
+  isLoaded?: boolean
+}
+
+export interface RadioGroupMethods {
+  dispatchEvent(type: ValueOf<VxeRadioGroupEmits>, params: Record<string, any>, evnt: Event | null): void
+}
+export interface VxeRadioGroupMethods extends RadioGroupMethods { }
+
+export interface RadioGroupPrivateMethods {
+  handleChecked(params: {
+    checkedValue: VxeRadioPropTypes.CheckedValue
+    checkedLabel: VxeRadioPropTypes.Content | undefined
+
+    /**
+     * @deprecated
+     */
+    label: any
+   }, evnt: Event): void
+}
+export interface VxeRadioGroupPrivateMethods extends RadioGroupPrivateMethods { }
+
+export type VxeRadioGroupEmits = [
+  'update:modelValue',
+  'change',
+  'default-change'
+]
+
+export namespace VxeRadioGroupDefines {
+  interface RadioGroupEventParams extends VxeComponentEventParams {
+    $radioGroup: VxeRadioGroupConstructor
+  }
+
+  export interface ChangeParams {
+    value: any
+    label: any
+  }
+  export interface ChangeEventParams extends RadioGroupEventParams, ChangeParams { }
+
+  export interface DefaultChangeEventParams {
+    value: any
+  }
+}
+
+export type VxeRadioGroupEventProps = {
+  'onUpdate:modelValue'?: VxeRadioGroupEvents.UpdateModelValue
+  onChange?: VxeRadioGroupEvents.Change
+  onDefaultChange?: VxeRadioGroupEvents.DefaultChange
+}
+
+export interface VxeRadioGroupListeners {
+  'update:modelValue'?: VxeRadioGroupEvents.UpdateModelValue
+  change?: VxeRadioGroupEvents.Change
+  defaultChange?: VxeRadioGroupEvents.DefaultChange
+}
+
+export namespace VxeRadioGroupEvents {
+  export type UpdateModelValue = (modelValue: VxeRadioGroupPropTypes.ModelValue) => void
+  export type Change = (params: VxeRadioGroupDefines.ChangeEventParams) => void
+  export type DefaultChange = (params: VxeRadioGroupDefines.DefaultChangeEventParams) => void
+}
+
+export namespace VxeRadioGroupSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeRadioGroupSlots {
+  default?: (params: VxeRadioGroupSlotTypes.DefaultSlotParams) => any
+}
+
+export const RadioGroup: typeof VxeRadioGroup
+export default VxeRadioGroup

package/dist/src/types/vxe-pc-ui/components/radio.d.ts

@@ -0,0 +1,134 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, ValueOf } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeRadio: DefineVxeComponentApp<VxeRadioProps, VxeRadioEventProps, VxeRadioSlots, VxeRadioMethods>
+export type VxeRadioComponent = DefineVxeComponentOptions<VxeRadioProps, VxeRadioEventProps>
+
+export type VxeRadioInstance = DefineVxeComponentInstance<VxeRadioProps, VxeRadioConstructor>
+
+export interface VxeRadioConstructor extends VxeComponentBaseOptions, VxeRadioMethods {
+  props: VxeRadioProps
+  context: SetupContext<VxeRadioEmits>
+  reactData: RadioReactData
+  getRefMaps(): RadioPrivateRef
+  getComputeMaps(): RadioPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface RadioPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeRadioPrivateRef extends RadioPrivateRef { }
+
+export namespace VxeRadioPropTypes {
+  export type Size = VxeComponentSizeType
+  export type Strict = boolean
+  export type ModelValue = any
+  /**
+   * 已废弃，被 CheckedValue 替换
+   * @deprecated
+   */
+  export type Label = any
+  export type CheckedValue = any
+  export type Title = string | number
+  export type Content = string | number
+  export type Disabled = boolean
+  export type Name = string
+}
+
+export interface VxeRadioProps {
+  size?: VxeRadioPropTypes.Size
+  /**
+   * 严格模式，不允许取消
+   */
+  strict?: VxeRadioPropTypes.Strict
+  /**
+   * 绑定值
+   */
+  modelValue?: VxeRadioPropTypes.ModelValue
+  /**
+   * 值
+   */
+  checkedValue?: VxeRadioPropTypes.CheckedValue
+  /**
+   * 原生 title 属性
+   */
+  title?: VxeRadioPropTypes.Title
+  /**
+   * 内容
+   */
+  content?: VxeRadioPropTypes.Content
+  /**
+   * 是否禁用
+   */
+  disabled?: VxeRadioPropTypes.Disabled
+  /**
+   * 原生 title 属性
+   */
+  name?: VxeRadioPropTypes.Name
+
+  /**
+   * 已废弃，被 checked-value 替换
+   * @deprecated
+   */
+  label?: VxeRadioPropTypes.Label
+}
+
+export interface RadioPrivateComputed {
+}
+export interface VxeRadioPrivateComputed extends RadioPrivateComputed { }
+
+export interface RadioReactData {
+}
+
+export interface RadioMethods {
+  dispatchEvent(type: ValueOf<VxeRadioEmits>, params: Record<string, any>, evnt: Event | null): void
+}
+export interface VxeRadioMethods extends RadioMethods { }
+
+export interface RadioPrivateMethods { }
+export interface VxeRadioPrivateMethods extends RadioPrivateMethods { }
+
+export type VxeRadioEmits = [
+  'update:modelValue',
+  'change'
+]
+
+export namespace VxeRadioDefines {
+  interface RadioEventParams extends VxeComponentEventParams {
+    $radio: VxeRadioConstructor
+  }
+
+  export interface ChangeParams {
+    label: any
+  }
+  export interface ChangeEventParams extends RadioEventParams, ChangeParams { }
+}
+
+export type VxeRadioEventProps = {
+  'onUpdate:modelValue'?: VxeRadioEvents.UpdateModelValue
+  onChange?: VxeRadioEvents.Change
+}
+
+export interface VxeRadioListeners {
+  'update:modelValue'?: VxeRadioEvents.UpdateModelValue
+  change?: VxeRadioEvents.Change
+}
+
+export namespace VxeRadioEvents {
+  export type UpdateModelValue = (modelValue: VxeRadioPropTypes.ModelValue) => void
+  export type Change = (params: VxeRadioDefines.ChangeEventParams) => void
+}
+
+export namespace VxeRadioSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeRadioSlots {
+  default?: (params: VxeRadioSlotTypes.DefaultSlotParams) => any
+}
+
+export const Radio: typeof VxeRadio
+export default VxeRadio

package/dist/src/types/vxe-pc-ui/components/rate.d.ts

@@ -0,0 +1,88 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentSizeType, VxeComponentStatusType, VxeComponentBaseOptions, VxeComponentEventParams } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeRate: DefineVxeComponentApp<VxeRateProps, VxeRateEventProps, VxeRateSlots, VxeRateMethods>
+export type VxeRateComponent = DefineVxeComponentOptions<VxeRateProps, VxeRateEventProps>
+
+export type VxeRateInstance = DefineVxeComponentInstance<VxeRateProps, VxeRateConstructor>
+
+export interface VxeRateConstructor extends VxeComponentBaseOptions, VxeRateMethods {
+  props: VxeRateProps
+  context: SetupContext<VxeRateEmits>
+  reactData: RateReactData
+  getRefMaps(): RatePrivateRef
+  getComputeMaps(): RatePrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface RatePrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeRatePrivateRef extends RatePrivateRef { }
+
+export namespace VxeRatePropTypes {
+  export type Size = VxeComponentSizeType
+  export type ModelValue = undefined | null | number | string
+  export type Readonly = boolean
+  export type Disabled = boolean
+  export type Status = VxeComponentStatusType
+}
+
+export interface VxeRateProps {
+  size?: VxeRatePropTypes.Size
+  modelValue?: VxeRatePropTypes.ModelValue
+  readonly?: VxeRatePropTypes.Readonly
+  disabled?: VxeRatePropTypes.Disabled
+  status?: VxeRatePropTypes.Status
+}
+
+export interface RatePrivateComputed {
+}
+export interface VxeRatePrivateComputed extends RatePrivateComputed { }
+
+export interface RateReactData {
+  activeValue: VxeRatePropTypes.ModelValue | null
+}
+
+export interface RateMethods {
+}
+export interface VxeRateMethods extends RateMethods { }
+
+export interface RatePrivateMethods { }
+export interface VxeRatePrivateMethods extends RatePrivateMethods { }
+
+export type VxeRateEmits = [
+  'update:modelValue',
+  'change'
+]
+
+export namespace VxeRateDefines {
+  export interface RateEventParams extends VxeComponentEventParams {
+    $rate: VxeRateConstructor
+  }
+}
+
+export type VxeRateEventProps = {
+  'onUpdate:modelValue'?: VxeRateEvents.UpdateModelValue
+}
+
+export interface VxeRateListeners {
+  'update:modelValue'?: VxeRateEvents.UpdateModelValue
+}
+
+export namespace VxeRateEvents {
+  export type UpdateModelValue = (modelValue: VxeRatePropTypes.ModelValue) => void
+}
+
+export namespace VxeRateSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeRateSlots {
+  default?: (params: VxeRateSlotTypes.DefaultSlotParams) => any
+}
+
+export const Rate: typeof VxeRate
+export default VxeRate

package/dist/src/types/vxe-pc-ui/components/result.d.ts

@@ -0,0 +1,84 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentStyleType, VxeComponentStatusType, VxeComponentBaseOptions, VxeComponentEventParams } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeResult: DefineVxeComponentApp<VxeResultProps, VxeResultEventProps, VxeResultSlots, VxeResultMethods>
+export type VxeResultComponent = DefineVxeComponentOptions<VxeResultProps, VxeResultEventProps>
+
+export type VxeResultInstance = DefineVxeComponentInstance<VxeResultProps, VxeResultConstructor>
+
+export interface VxeResultConstructor extends VxeComponentBaseOptions, VxeResultMethods {
+  props: VxeResultProps
+  context: SetupContext<VxeResultEmits>
+  reactData: ResultReactData
+  getRefMaps(): ResultPrivateRef
+  getComputeMaps(): ResultPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface ResultPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeResultPrivateRef extends ResultPrivateRef { }
+
+export namespace VxeResultPropTypes {
+  export type ImageUrl = string
+  export type ImageStyle = VxeComponentStyleType
+  export type Icon = string
+  export type Type = 'success' | 'error' | 'info' | 'warning' | 'question' | 'loading'
+  export type Status = VxeComponentStatusType
+  export type Title = number | string
+  export type Content = number | string
+}
+
+export interface VxeResultProps {
+  imageUrl?: VxeResultPropTypes.ImageUrl
+  imageStyle?: VxeResultPropTypes.ImageStyle
+  icon?: VxeResultPropTypes.Icon
+  type?: VxeResultPropTypes.Type
+  status?: VxeResultPropTypes.Status
+  title?: VxeResultPropTypes.Title
+  content?: VxeResultPropTypes.Content
+}
+
+export interface ResultPrivateComputed {
+}
+export interface VxeResultPrivateComputed extends ResultPrivateComputed { }
+
+export interface ResultReactData {
+}
+
+export interface ResultMethods {
+}
+export interface VxeResultMethods extends ResultMethods { }
+
+export interface ResultPrivateMethods { }
+export interface VxeResultPrivateMethods extends ResultPrivateMethods { }
+
+export type VxeResultEmits = []
+
+export namespace VxeResultDefines {
+  export interface ResultEventParams extends VxeComponentEventParams {
+    $result: VxeResultConstructor
+  }
+}
+
+export type VxeResultEventProps = {}
+
+export interface VxeResultListeners { }
+
+export namespace VxeResultEvents { }
+
+export namespace VxeResultSlotTypes {
+  export interface DefaultSlotParams {}
+  export interface ExtraSlotParams {}
+}
+
+export interface VxeResultSlots {
+  default?: (params: VxeResultSlotTypes.DefaultSlotParams) => any
+  extra?: (params: VxeResultSlotTypes.ExtraSlotParams) => any
+}
+
+export const Result: typeof VxeResult
+export default VxeResult

package/dist/src/types/vxe-pc-ui/components/row.d.ts

@@ -0,0 +1,79 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, ValueOf } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeRow: DefineVxeComponentApp<VxeRowProps, VxeRowEventProps, VxeRowSlots, VxeRowMethods>
+export type VxeRowComponent = DefineVxeComponentOptions<VxeRowProps, VxeRowEventProps>
+
+export type VxeRowInstance = DefineVxeComponentInstance<VxeRowProps, VxeRowConstructor>
+
+export interface VxeRowConstructor extends VxeComponentBaseOptions, VxeRowMethods {
+  props: VxeRowProps
+  context: SetupContext<VxeRowEmits>
+  reactData: RowReactData
+  getRefMaps(): RowPrivateRef
+  getComputeMaps(): RowPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface RowPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeRowPrivateRef extends RowPrivateRef { }
+
+export namespace VxeRowPropTypes {
+  export type Gutter = string | number | (string | number)[]
+  export type Wrap = boolean
+  export type Vertical = boolean
+  export type Size = VxeComponentSizeType
+}
+
+export type VxeRowProps = {
+  gutter?: VxeRowPropTypes.Gutter
+  wrap?: VxeRowPropTypes.Wrap
+  vertical?: VxeRowPropTypes.Vertical
+  size?: VxeRowPropTypes.Size
+}
+
+export interface RowPrivateComputed {
+}
+export interface VxeRowPrivateComputed extends RowPrivateComputed { }
+
+export interface RowReactData {
+}
+
+export interface RowMethods {
+  dispatchEvent(type: ValueOf<VxeRowEmits>, params: Record<string, any>, evnt: Event | null): void
+}
+export interface VxeRowMethods extends RowMethods { }
+
+export interface RowPrivateMethods { }
+export interface VxeRowPrivateMethods extends RowPrivateMethods { }
+
+export type VxeRowEmits = [
+  'click'
+]
+
+export namespace VxeRowDefines {
+  export interface RowEventParams extends VxeComponentEventParams {
+    $row: VxeRowConstructor
+  }
+}
+
+export type VxeRowEventProps = {}
+
+export interface VxeRowListeners { }
+
+export namespace VxeRowEvents { }
+
+export namespace VxeRowSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeRowSlots {
+  default?: (params: VxeRowSlotTypes.DefaultSlotParams) => any
+}
+
+export const Row: typeof VxeRow
+export default VxeRow

package/dist/src/types/vxe-pc-ui/components/segmented.d.ts

@@ -0,0 +1,123 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentStatusType, VxeComponentEventParams, ValueOf, VxeComponentSizeType } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeSegmented: DefineVxeComponentApp<VxeSegmentedProps, VxeSegmentedEventProps, VxeSegmentedSlots, VxeSegmentedMethods>
+export type VxeSegmentedComponent = DefineVxeComponentOptions<VxeSegmentedProps, VxeSegmentedEventProps>
+
+export type VxeSegmentedInstance = DefineVxeComponentInstance<VxeSegmentedProps, VxeSegmentedConstructor>
+
+export interface VxeSegmentedConstructor extends VxeComponentBaseOptions, VxeSegmentedMethods {
+  props: VxeSegmentedProps
+  context: SetupContext<VxeSegmentedEmits>
+  reactData: SegmentedReactData
+  getRefMaps(): SegmentedPrivateRef
+  getComputeMaps(): SegmentedPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface SegmentedPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeSegmentedPrivateRef extends SegmentedPrivateRef { }
+
+export namespace VxeSegmentedPropTypes {
+  export type ModelValue = undefined | null | string | number
+  export type Size = VxeComponentSizeType
+  export type Type = null | '' | 'default' | 'round' | 'inside'
+  export type Disabled = boolean
+  export type Name = string
+  export type Width = string | number
+  export type Height = string | number
+  export type Status = VxeComponentStatusType
+  export interface Option {
+    value: string | number
+    label: string | number
+    disabled?: boolean
+    width?: string | number
+    icon?: string
+    [key: string]: any
+  }
+  export type Options = Option[]
+  export interface OptionConfig {
+    width?: string | number
+  }
+}
+
+export interface VxeSegmentedProps {
+  modelValue?: VxeSegmentedPropTypes.ModelValue
+  size?: VxeSegmentedPropTypes.Size
+  type?: VxeSegmentedPropTypes.Type
+  disabled?: VxeSegmentedPropTypes.Disabled
+  name?: VxeSegmentedPropTypes.Name
+  width?: VxeSegmentedPropTypes.Width
+  height?: VxeSegmentedPropTypes.Height
+  status?: VxeSegmentedPropTypes.Status
+  options?: VxeSegmentedPropTypes.Options
+  optionConfig?: VxeSegmentedPropTypes.OptionConfig
+}
+
+export interface SegmentedPrivateComputed {
+}
+export interface VxeSegmentedPrivateComputed extends SegmentedPrivateComputed { }
+
+export interface SegmentedReactData {
+  groupName: string
+  selectStyle: {
+    display: string
+    left: string
+    width: string
+  }
+}
+
+export interface SegmentedMethods {
+  dispatchEvent(type: ValueOf<VxeSegmentedEmits>, params: Record<string, any>, evnt: Event | null): void
+}
+export interface VxeSegmentedMethods extends SegmentedMethods { }
+
+export interface SegmentedPrivateMethods { }
+export interface VxeSegmentedPrivateMethods extends SegmentedPrivateMethods { }
+
+export type VxeSegmentedEmits = [
+  'update:modelValue',
+  'change'
+]
+
+export namespace VxeSegmentedDefines {
+  export interface SegmentedEventParams extends VxeComponentEventParams {
+    $segmented: VxeSegmentedConstructor
+  }
+
+  export interface ChangeEventParams extends SegmentedEventParams {
+    value: any
+  }
+}
+
+export type VxeSegmentedEventProps = {
+  'onUpdate:modelValue'?: VxeSegmentedEvents.UpdateModelValue
+  onChange?: VxeSegmentedEvents.Change
+}
+
+export interface VxeSegmentedListeners {
+  'update:modelValue'?: VxeSegmentedEvents.UpdateModelValue
+  change?: VxeSegmentedEvents.Change
+}
+
+export namespace VxeSegmentedEvents {
+  export type UpdateModelValue = (modelValue: VxeSegmentedPropTypes.ModelValue) => void
+  export type Change = (params: VxeSegmentedDefines.ChangeEventParams) => void
+}
+
+export namespace VxeSegmentedSlotTypes {
+  export interface DefaultSlotParams {
+    option: VxeSegmentedPropTypes.Option
+  }
+}
+
+export interface VxeSegmentedSlots {
+  default?: (params: VxeSegmentedSlotTypes.DefaultSlotParams) => any
+}
+
+export const Segmented: typeof VxeSegmented
+export default VxeSegmented