@iooo/element 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,48 @@
-# Temporary Holding Version
+# v-element
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Vue (Official)](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
+
+## Recommended Browser Setup
+
+- Chromium-based browsers (Chrome, Edge, Brave, etc.):
+  - [Vue.js devtools](https://chromewebstore.google.com/detail/vuejs-devtools/nhdogjmejiglipccpnnnanhbledajbpd)
+  - [Turn on Custom Object Formatter in Chrome DevTools](http://bit.ly/object-formatters)
+- Firefox:
+  - [Vue.js devtools](https://addons.mozilla.org/en-US/firefox/addon/vue-js-devtools/)
+  - [Turn on Custom Object Formatter in Firefox DevTools](https://fxdx.dev/firefox-devtools-custom-object-formatters/)
+
+## Type Support for `.vue` Imports in TS
+
+TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) to make the TypeScript language service aware of `.vue` types.
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vite.dev/config/).
+
+## Project Setup
+
+```sh
+pnpm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+pnpm dev
+```
+
+### Type-Check, Compile and Minify for Production
+
+```sh
+pnpm build
+```
+
+### Lint with [ESLint](https://eslint.org/)
+
+```sh
+pnpm lint
+```

package/dist/es/components/Alert/Alert.vue.d.ts

@@ -0,0 +1,16 @@
+import { AlertProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<AlertProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Alert/types.d.ts

@@ -0,0 +1,13 @@
+export type NameType = string | number;
+export interface AlertProps {
+    name?: NameType;
+    type?: "success" | "error" | "warning" | "info";
+    effect?: "light" | "dark";
+    content?: string;
+    closeable?: boolean;
+    center?: boolean;
+    visible?: boolean;
+}
+export interface AlertEmits {
+    (e: "update:visible", value: boolean): void;
+}

package/dist/es/components/Button/Button.vue.d.ts

@@ -0,0 +1,16 @@
+import { ButtonProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Button/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Button } from './Button.vue';
+export default Button;
+export * from './types';

package/dist/es/components/Button/types.d.ts

@@ -0,0 +1,12 @@
+export type ButtonType = "primary" | "success" | "info" | "warning" | "danger";
+export type ButtonSize = "small" | "large";
+export interface ButtonProps {
+    type?: ButtonType;
+    size?: ButtonSize;
+    plain?: boolean;
+    disabled?: boolean;
+    round?: boolean;
+    circle?: boolean;
+    icon?: string;
+    loading?: boolean;
+}

package/dist/es/components/Collapse/Collapse.vue.d.ts

@@ -0,0 +1,22 @@
+import { NameType, CollapseProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<CollapseProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: NameType[]) => any;
+    change: (value: NameType[]) => any;
+}, string, import('vue').PublicProps, Readonly<CollapseProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: NameType[]) => any) | undefined;
+    onChange?: ((value: NameType[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Collapse/CollapseItem.vue.d.ts

@@ -0,0 +1,18 @@
+import { CollapseItemProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        title?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<CollapseItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CollapseItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Collapse/index.d.ts

@@ -0,0 +1,5 @@
+import { default as Collapse } from './Collapse.vue';
+import { default as CollapseItem } from './CollapseItem.vue';
+export default Collapse;
+export { CollapseItem };
+export * from './types';

package/dist/es/components/Collapse/types.d.ts

@@ -0,0 +1,20 @@
+import { Ref, InjectionKey } from 'vue';
+export type NameType = string | number;
+export interface CollapseProps {
+    modelValue: NameType[];
+    accordion?: boolean;
+}
+export interface CollapseItemProps {
+    name: NameType;
+    title?: string;
+    disabled?: boolean;
+}
+export interface CollapseContext {
+    activeNames: Ref<NameType[]>;
+    handleItemClick: (item: NameType) => void;
+}
+export interface CollapseEmits {
+    (e: "update:modelValue", value: NameType[]): void;
+    (e: "change", value: NameType[]): void;
+}
+export declare const collapseContextKey: InjectionKey<CollapseContext>;

package/dist/es/components/Common/RenderVnode.d.ts

@@ -0,0 +1,11 @@
+export declare const RenderVnode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    vnode: {
+        type: (ObjectConstructor | StringConstructor)[];
+        required: true;
+    };
+}>, () => string | Record<string, any>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    vnode: {
+        type: (ObjectConstructor | StringConstructor)[];
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/es/components/Dropdown/Dropdown.vue.d.ts

@@ -0,0 +1,24 @@
+import { DropdownProps, DropdownInstance, menuOption } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<DropdownProps, DropdownInstance, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    select: (value: menuOption) => any;
+    "visible-change": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<DropdownProps> & Readonly<{
+    onSelect?: ((value: menuOption) => any) | undefined;
+    "onVisible-change"?: ((value: boolean) => any) | undefined;
+}>, {
+    hideAfterClick: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Dropdown/types.d.ts

@@ -0,0 +1,20 @@
+import { VNode } from 'vue';
+import { TooltipProps } from '../Tooltip/types';
+export interface DropdownProps extends TooltipProps {
+    menuOptions?: menuOption[];
+    hideAfterClick?: boolean;
+}
+export interface menuOption {
+    label: string | VNode;
+    key: string | number;
+    disabled?: boolean;
+    divided?: boolean;
+}
+export interface DropdownEmits {
+    (e: "visible-change", value: boolean): void;
+    (e: "select", value: menuOption): void;
+}
+export interface DropdownInstance {
+    show: () => void;
+    hide: () => void;
+}

package/dist/es/components/Form/Form.vue.d.ts

@@ -0,0 +1,16 @@
+import { FormProps, FormInstance } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<FormProps, FormInstance, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Form/FormItem.vue.d.ts

@@ -0,0 +1,22 @@
+import { FormItemProps, FormItemInstance } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        label?: (props: {
+            label: string;
+        }) => any;
+    } & {
+        default?: (props: {
+            validate: (trigger?: string) => Promise<true | void>;
+        }) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<FormItemProps, FormItemInstance, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FormItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Form/types.d.ts

@@ -0,0 +1,46 @@
+import { InjectionKey } from 'vue';
+import { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+export interface FormItemProps {
+    label: string;
+    prop?: string;
+}
+export interface FormItemRule extends RuleItem {
+    trigger?: string;
+}
+export type FormRules = Record<string, FormItemRule[]>;
+export interface FormProps {
+    model: Record<string, any>;
+    rules: FormRules;
+}
+export interface FormInstance {
+    validate: () => Promise<any>;
+    resetFields: (props?: string[]) => void;
+    clearValidate: (props?: string[]) => void;
+}
+export interface ValidateStatusProp {
+    state: "init" | "success" | "error";
+    errMessage: string;
+    loading: boolean;
+}
+export interface FormContext extends FormProps {
+    addField: (field: FormItemContext) => void;
+    removeField: (field: FormItemContext) => void;
+}
+export interface FormItemContext {
+    prop: string;
+    validate: (trigger?: string) => Promise<any>;
+    resetField: () => void;
+    clearValidate: () => void;
+}
+export interface FormItemInstance {
+    validateStatus: ValidateStatusProp;
+    validate: (trigger?: string) => Promise<any>;
+    resetField: () => void;
+    clearValidate: () => void;
+}
+export interface FormValidateFailure {
+    errors: ValidateError[] | null;
+    fields: ValidateFieldsError;
+}
+export declare const FormContextKey: InjectionKey<FormContext>;
+export declare const FormItemContextKey: InjectionKey<FormItemContext>;

package/dist/es/components/Icon/Icon.vue.d.ts

@@ -0,0 +1,4 @@
+import { SpIconProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<SpIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SpIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/es/components/Icon/types.d.ts

@@ -0,0 +1,29 @@
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+export interface SpIconProps {
+    border?: boolean;
+    fixedwidth?: boolean;
+    flip?: "horizontal" | "vertical" | "both";
+    icon: object | Array<string> | string | IconDefinition;
+    mask?: object | Array<string> | string;
+    listItem?: boolean;
+    pull?: "right" | "left";
+    pulse?: boolean;
+    rotation?: 90 | 180 | 270 | "90" | "180" | "270";
+    swapOpacity?: boolean;
+    small?: boolean;
+    size?: "2xs" | "xs" | "sm" | "lg" | "xl" | "2xl" | "1x" | "2x";
+    spin?: boolean;
+    transform?: object | string;
+    symbol?: boolean | string;
+    title?: string;
+    inverse?: boolean;
+    bounce?: boolean;
+    shake?: boolean;
+    beat?: boolean;
+    fade?: boolean;
+    beatFade?: boolean;
+    spinPulse?: boolean;
+    spinReverse?: boolean;
+    type?: "primary" | "success" | "info" | "warning" | "danger";
+    color?: string;
+}

package/dist/es/components/Input/Input.vue.d.ts

@@ -0,0 +1,55 @@
+import { Ref } from 'vue';
+type __VLS_Props = {
+    type?: string;
+    modelValue: string;
+    size?: "large" | "small";
+    disabled?: boolean;
+    clearable?: boolean;
+    showPassword?: boolean;
+    placeholder?: string;
+    readonly?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    form?: string;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        prepend?: (props: {}) => any;
+    } & {
+        prefix?: (props: {}) => any;
+    } & {
+        suffix?: (props: {}) => any;
+    } & {
+        append?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    ref: Ref<HTMLInputElement, HTMLInputElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    input: (value: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+    change: (value: string) => any;
+    blur: (value: FocusEvent) => any;
+    focus: (value: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onInput?: ((value: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    onBlur?: ((value: FocusEvent) => any) | undefined;
+    onFocus?: ((value: FocusEvent) => any) | undefined;
+}>, {
+    type: string;
+    modelValue: string;
+    autocomplete: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Input/types.d.ts

@@ -0,0 +1,24 @@
+export interface InputProps {
+    type?: string;
+    modelValue: string;
+    size?: "large" | "small";
+    disabled?: boolean;
+    clearable?: boolean;
+    showPassword?: boolean;
+    placeholder?: string;
+    readonly?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    form?: string;
+}
+export interface InputEmits {
+    (e: "update:modelValue", value: string): void;
+    (e: "input", value: string): void;
+    (e: "change", value: string): void;
+    (e: "focus", value: FocusEvent): void;
+    (e: "blur", value: FocusEvent): void;
+    (e: "clear"): void;
+}
+export interface InputInstance {
+    ref: HTMLInputElement | HTMLTextAreaElement;
+}

package/dist/es/components/Message/Message.vue.d.ts

@@ -0,0 +1,35 @@
+import { VNode } from 'vue';
+type __VLS_Props = {
+    message?: string | VNode;
+    duration?: number;
+    showClose?: boolean;
+    type?: "success" | "danger" | "info" | "warning";
+    onDestroy: () => void;
+    offset?: number;
+    id: string;
+    zIndex: number;
+    transitionName?: string;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    bottomOffset: import('vue').ComputedRef<any>;
+    visible: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    type: "success" | "info" | "warning" | "danger";
+    duration: number;
+    offset: number;
+    transitionName: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/components/Message/index.d.ts

@@ -0,0 +1,5 @@
+import { default as Message } from './Message.vue';
+import { createMessage, closeAll } from './method';
+export default Message;
+export { createMessage, closeAll };
+export * from './types';

package/dist/es/components/Message/method.d.ts

@@ -0,0 +1,23 @@
+import { createMessageProps, MessageContext } from './types';
+export declare const createMessage: (props: createMessageProps) => {
+    id: string;
+    vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    vm: import('vue').ComponentInternalInstance;
+    props: {
+        id: string;
+        onDestroy: () => void;
+        zIndex: number;
+        type?: "success" | "warning" | "info" | "danger" | undefined;
+        message?: (string | import('vue').VNode) | undefined;
+        duration?: number | undefined;
+        showClose?: boolean | undefined;
+        offset?: number | undefined;
+        transitionName?: string | undefined;
+    };
+    destroy: () => void;
+};
+export declare const getLastInstance: () => MessageContext | undefined;
+export declare const getLastButtomOffset: (id: string) => any;
+export declare const closeAll: () => void;

package/dist/es/components/Message/types.d.ts

@@ -0,0 +1,20 @@
+import { VNode, ComponentInternalInstance } from 'vue';
+export interface MessageProps {
+    message?: string | VNode;
+    duration?: number;
+    showClose?: boolean;
+    type?: "success" | "warning" | "info" | "danger";
+    onDestroy: () => void;
+    offset?: number;
+    id: string;
+    zIndex: number;
+    transitionName?: string;
+}
+export interface MessageContext {
+    id: string;
+    vnode: VNode;
+    vm: ComponentInternalInstance;
+    props: MessageProps;
+    destroy: () => void;
+}
+export type createMessageProps = Omit<MessageProps, "onDestroy" | "id" | "zIndex">;

package/dist/es/components/Select/Select.vue.d.ts

@@ -0,0 +1,16 @@
+import { SelectOption, SelectProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<SelectProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+    change: (value: string) => any;
+    "visible-change": (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<SelectProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    options: SelectOption[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/es/components/Select/types.d.ts

@@ -0,0 +1,34 @@
+import { VNode } from 'vue';
+export interface SelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+export interface SelectProps {
+    modelValue: string;
+    options?: SelectOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    renderLabel?: RenderLableFunc;
+    filterable?: boolean;
+    filterMethod?: CustomFilterFunc;
+    remote?: boolean;
+    remoteMethod?: CustomFilterRemoteFunc;
+}
+export interface SelectStates {
+    inputValue: string;
+    selectedOption: SelectOption | null;
+    mouseHover: boolean;
+    loading: boolean;
+    highlightIndex: number;
+}
+export type RenderLableFunc = (option: SelectOption) => VNode;
+export type CustomFilterFunc = (value: string) => SelectOption[];
+export type CustomFilterRemoteFunc = (value: string) => Promise<SelectOption[]>;
+export interface SelectEmits {
+    (e: "update:modelValue", value: string): void;
+    (e: "change", value: string): void;
+    (e: "visible-change", visible: boolean): void;
+    (e: "clear"): void;
+}

package/dist/es/components/Switch/Switch.vue.d.ts

@@ -0,0 +1,13 @@
+import { SwtichProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<SwtichProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: import('./types').SwitchValueType) => any;
+    change: (value: import('./types').SwitchValueType) => any;
+}, string, import('vue').PublicProps, Readonly<SwtichProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('./types').SwitchValueType) => any) | undefined;
+    onChange?: ((value: import('./types').SwitchValueType) => any) | undefined;
+}>, {
+    activeValue: import('./types').SwitchValueType;
+    inactiveValue: import('./types').SwitchValueType;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/es/components/Switch/types.d.ts

@@ -0,0 +1,16 @@
+export type SwitchValueType = boolean | string | number;
+export interface SwtichProps {
+    modelValue: SwitchValueType;
+    disabled?: boolean;
+    activeText?: string;
+    inactiveText?: string;
+    activeValue?: SwitchValueType;
+    inactiveValue?: SwitchValueType;
+    name?: string;
+    id?: string;
+    size?: "small" | "large";
+}
+export interface SwtichEmits {
+    (e: "update:modelValue", value: SwitchValueType): void;
+    (e: "change", value: SwitchValueType): void;
+}

package/dist/es/components/Tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,30 @@
+import { TooltipProps, TooltipInstance } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    } & {
+        content?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<TooltipProps, TooltipInstance, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "visible-change": (visible: boolean) => any;
+    "click-outside": (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<TooltipProps> & Readonly<{
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+    "onClick-outside"?: ((visible: boolean) => any) | undefined;
+}>, {
+    transition: string;
+    trigger: "click" | "hover";
+    placement: import('@popperjs/core').Placement;
+    openDelay: number;
+    closeDelay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};