@layers.digital/layers-design-system-vue3 1.0.2 → 1.0.4

package/dist/components/LSwitch/LSwitch.vue.d.ts

@@ -0,0 +1,357 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    value: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    loading: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    size: {
+        type: StringConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+}, {
+    props: any;
+    readonly ElSwitch: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+        readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly loading: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "default" | "small" | "large") | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => "" | "default" | "small" | "large") | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large">>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly width: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly inlinePrompt: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly inactiveActionIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly activeActionIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly activeIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly inactiveIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly activeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inactiveText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly activeValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, true, boolean>;
+        readonly inactiveValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+        readonly activeColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inactiveColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly borderColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly beforeChange: {
+            readonly type: import("vue").PropType<() => boolean | Promise<boolean>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly id: StringConstructor;
+        readonly tabindex: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly value: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+    }, {
+        COMPONENT_NAME: string;
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+            readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly loading: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "default" | "small" | "large") | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => "" | "default" | "small" | "large") | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large">>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly width: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly inlinePrompt: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly inactiveActionIcon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly activeActionIcon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly activeIcon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly inactiveIcon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly activeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inactiveText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly activeValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, true, boolean>;
+            readonly inactiveValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+            readonly activeColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inactiveColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly borderColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly beforeChange: {
+                readonly type: import("vue").PropType<() => boolean | Promise<boolean>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly id: StringConstructor;
+            readonly tabindex: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly value: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+        }>> & {
+            onChange?: ((val: string | number | boolean) => any) | undefined;
+            "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+            onInput?: ((val: string | number | boolean) => any) | undefined;
+        }>>;
+        emit: ((event: "update:modelValue", val: string | number | boolean) => void) & ((event: "change", val: string | number | boolean) => void) & ((event: "input", val: string | number | boolean) => void);
+        vm: import("vue").ComponentInternalInstance;
+        formItem: import("element-plus").FormItemContext | undefined;
+        switchSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        useBatchDeprecated: (list: string[][]) => void;
+        inputId: import("vue").Ref<string | undefined>;
+        switchDisabled: import("vue").ComputedRef<boolean>;
+        isControlled: import("vue").Ref<boolean>;
+        input: import("vue").Ref<HTMLInputElement | undefined>;
+        core: import("vue").Ref<HTMLSpanElement | undefined>;
+        switchKls: import("vue").ComputedRef<string[]>;
+        labelLeftKls: import("vue").ComputedRef<string[]>;
+        labelRightKls: import("vue").ComputedRef<string[]>;
+        coreStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        actualValue: import("vue").ComputedRef<import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>>;
+        checked: import("vue").ComputedRef<boolean>;
+        handleChange: () => void;
+        switchValue: () => void;
+        styles: import("vue").ComputedRef<Record<string, string>>;
+        focus: () => void;
+        ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, {}>> & Record<string, any>;
+        Loading: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: string | number | boolean) => boolean;
+        change: (val: string | number | boolean) => boolean;
+        input: (val: string | number | boolean) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+        readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly loading: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "" | "default" | "small" | "large") | (() => "" | "default" | "small" | "large") | ((new (...args: any[]) => "" | "default" | "small" | "large") | (() => "" | "default" | "small" | "large"))[], unknown, "" | "default" | "small" | "large">>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly width: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly inlinePrompt: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly inactiveActionIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly activeActionIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly activeIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly inactiveIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly activeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inactiveText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly activeValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, true, boolean>;
+        readonly inactiveValue: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+        readonly activeColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inactiveColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly borderColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly beforeChange: {
+            readonly type: import("vue").PropType<() => boolean | Promise<boolean>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly id: StringConstructor;
+        readonly tabindex: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly value: import("element-plus/es/utils").EpPropFinalized<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown, false, boolean>;
+    }>> & {
+        onChange?: ((val: string | number | boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+        onInput?: ((val: string | number | boolean) => any) | undefined;
+    }, {
+        readonly width: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly value: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly modelValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly disabled: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly name: string;
+        readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly borderColor: string;
+        readonly loading: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly inlinePrompt: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly activeText: string;
+        readonly inactiveText: string;
+        readonly activeValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly inactiveValue: import("element-plus/es/utils").EpPropMergeType<readonly [BooleanConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly activeColor: string;
+        readonly inactiveColor: string;
+    }, {}>> & Record<string, any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    loading: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    size: {
+        type: StringConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _sfc_main;

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { default as LSelect } from "./components/LSelect/LSelect.vue";
 export { default as LSlider } from "./components/LSlider/LSlider.vue";
 export { default as LAlert } from "./components/LAlert/LAlert.vue";
 export { default as LBreadcrumb } from "./components/LBreadcrumb/LBreadcrumb.vue";
-export { default as LLinearProgress } from "./components/LLinearProgress/LLinearProgress.vue";
+export { default as LSwitch } from "./components/LSwitch/LSwitch.vue";

package/dist/layers-design-system-vue3.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./layers-design-system-vue32.cjs"),r=require("./layers-design-system-vue33.cjs"),t=require("./layers-design-system-vue34.cjs"),u=require("./layers-design-system-vue35.cjs"),_=require("./layers-design-system-vue36.cjs"),i=require("./layers-design-system-vue37.cjs"),s=require("./layers-design-system-vue38.cjs"),n=require("./layers-design-system-vue39.cjs");require("./layers-design-system-vue310.cjs");exports.LButton=e;exports.LRadio=r;exports.LInput=t;exports.LSelect=u;exports.LSlider=_;exports.LAlert=i;exports.LBreadcrumb=s;exports.LLinearProgress=n;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./layers-design-system-vue32.cjs"),t=require("./layers-design-system-vue33.cjs"),r=require("./layers-design-system-vue34.cjs"),u=require("./layers-design-system-vue35.cjs"),_=require("./layers-design-system-vue36.cjs"),i=require("./layers-design-system-vue37.cjs"),c=require("./layers-design-system-vue38.cjs"),n=require("./layers-design-system-vue39.cjs");exports.LButton=e;exports.LRadio=t;exports.LInput=r;exports.LSelect=u;exports.LSlider=_;exports.LAlert=i;exports.LBreadcrumb=c;exports.LSwitch=n;

package/dist/layers-design-system-vue3.js

@@ -1,19 +1,18 @@
-import { default as o } from "./layers-design-system-vue32.js";
-import { default as f } from "./layers-design-system-vue33.js";
-import { default as l } from "./layers-design-system-vue34.js";
-import { default as m } from "./layers-design-system-vue35.js";
-import { default as s } from "./layers-design-system-vue36.js";
+import { default as r } from "./layers-design-system-vue32.js";
+import { default as o } from "./layers-design-system-vue33.js";
+import { default as d } from "./layers-design-system-vue34.js";
+import { default as u } from "./layers-design-system-vue35.js";
+import { default as p } from "./layers-design-system-vue36.js";
 import { default as x } from "./layers-design-system-vue37.js";
-import { default as n } from "./layers-design-system-vue38.js";
-import { default as B } from "./layers-design-system-vue39.js";
-import "./layers-design-system-vue310.js";
+import { default as c } from "./layers-design-system-vue38.js";
+import { default as S } from "./layers-design-system-vue39.js";
 export {
   x as LAlert,
-  n as LBreadcrumb,
-  o as LButton,
-  l as LInput,
-  B as LLinearProgress,
-  f as LRadio,
-  m as LSelect,
-  s as LSlider
+  c as LBreadcrumb,
+  r as LButton,
+  d as LInput,
+  o as LRadio,
+  u as LSelect,
+  p as LSlider,
+  S as LSwitch
 };

package/dist/layers-design-system-vue310.cjs

@@ -1 +1 @@
-"use strict";const e="";module.exports=e;
+"use strict";const t=require("vue");require("./layers-design-system-vue324.cjs");require("./layers-design-system-vue325.cjs");const a=require("./layers-design-system-vue326.cjs"),o=t.defineComponent({__name:"LButton",props:{text:{},color:{default:void 0},size:{default:"default"},disabled:{type:Boolean,default:!1},link:{type:Boolean,default:!1},loading:{type:Boolean,default:!1},type:{default:"primary"},round:{type:Boolean,default:!1},circle:{type:Boolean,default:!1},nativeType:{default:"button"},plain:{type:Boolean,default:!1},dark:{type:Boolean,default:!1}},setup(l){const e=l;return(n,i)=>(t.openBlock(),t.createBlock(t.unref(a.ElButton),{nativeType:e.nativeType,type:e.type,size:e.size,color:e.color,round:e.round,circle:e.circle,plain:e.plain,disabled:e.disabled,link:e.link,loading:e.loading,dark:e.dark,class:"button-class"},{default:t.withCtx(()=>[t.createTextVNode(t.toDisplayString(e.text),1)]),_:1},8,["nativeType","type","size","color","round","circle","plain","disabled","link","loading","dark"]))}});module.exports=o;

package/dist/layers-design-system-vue310.js

@@ -1,4 +1,46 @@
-const e = "";
+import { defineComponent as a, openBlock as l, createBlock as o, unref as n, withCtx as i, createTextVNode as d, toDisplayString as r } from "vue";
+import "./layers-design-system-vue324.js";
+import "./layers-design-system-vue325.js";
+import { ElButton as p } from "./layers-design-system-vue326.js";
+const k = /* @__PURE__ */ a({
+  __name: "LButton",
+  props: {
+    text: {},
+    color: { default: void 0 },
+    size: { default: "default" },
+    disabled: { type: Boolean, default: !1 },
+    link: { type: Boolean, default: !1 },
+    loading: { type: Boolean, default: !1 },
+    type: { default: "primary" },
+    round: { type: Boolean, default: !1 },
+    circle: { type: Boolean, default: !1 },
+    nativeType: { default: "button" },
+    plain: { type: Boolean, default: !1 },
+    dark: { type: Boolean, default: !1 }
+  },
+  setup(t) {
+    const e = t;
+    return (s, f) => (l(), o(n(p), {
+      nativeType: e.nativeType,
+      type: e.type,
+      size: e.size,
+      color: e.color,
+      round: e.round,
+      circle: e.circle,
+      plain: e.plain,
+      disabled: e.disabled,
+      link: e.link,
+      loading: e.loading,
+      dark: e.dark,
+      class: "button-class"
+    }, {
+      default: i(() => [
+        d(r(e.text), 1)
+      ]),
+      _: 1
+    }, 8, ["nativeType", "type", "size", "color", "round", "circle", "plain", "disabled", "link", "loading", "dark"]));
+  }
+});
 export {
-  e as default
+  k as default
 };

package/dist/layers-design-system-vue311.cjs

@@ -1 +1 @@
-"use strict";const t=require("vue");require("./layers-design-system-vue324.cjs");require("./layers-design-system-vue325.cjs");const a=require("./layers-design-system-vue326.cjs"),o=t.defineComponent({__name:"LButton",props:{text:{},color:{default:void 0},size:{default:"default"},disabled:{type:Boolean,default:!1},link:{type:Boolean,default:!1},loading:{type:Boolean,default:!1},type:{default:"primary"},round:{type:Boolean,default:!1},circle:{type:Boolean,default:!1},nativeType:{default:"button"},plain:{type:Boolean,default:!1},dark:{type:Boolean,default:!1}},setup(l){const e=l;return(n,i)=>(t.openBlock(),t.createBlock(t.unref(a.ElButton),{nativeType:e.nativeType,type:e.type,size:e.size,color:e.color,round:e.round,circle:e.circle,plain:e.plain,disabled:e.disabled,link:e.link,loading:e.loading,dark:e.dark,class:"button-class"},{default:t.withCtx(()=>[t.createTextVNode(t.toDisplayString(e.text),1)]),_:1},8,["nativeType","type","size","color","round","circle","plain","disabled","link","loading","dark"]))}});module.exports=o;
+"use strict";const _="";module.exports=_;

package/dist/layers-design-system-vue311.js

@@ -1,46 +1,4 @@
-import { defineComponent as a, openBlock as l, createBlock as o, unref as n, withCtx as i, createTextVNode as d, toDisplayString as r } from "vue";
-import "./layers-design-system-vue324.js";
-import "./layers-design-system-vue325.js";
-import { ElButton as p } from "./layers-design-system-vue326.js";
-const k = /* @__PURE__ */ a({
-  __name: "LButton",
-  props: {
-    text: {},
-    color: { default: void 0 },
-    size: { default: "default" },
-    disabled: { type: Boolean, default: !1 },
-    link: { type: Boolean, default: !1 },
-    loading: { type: Boolean, default: !1 },
-    type: { default: "primary" },
-    round: { type: Boolean, default: !1 },
-    circle: { type: Boolean, default: !1 },
-    nativeType: { default: "button" },
-    plain: { type: Boolean, default: !1 },
-    dark: { type: Boolean, default: !1 }
-  },
-  setup(t) {
-    const e = t;
-    return (s, f) => (l(), o(n(p), {
-      nativeType: e.nativeType,
-      type: e.type,
-      size: e.size,
-      color: e.color,
-      round: e.round,
-      circle: e.circle,
-      plain: e.plain,
-      disabled: e.disabled,
-      link: e.link,
-      loading: e.loading,
-      dark: e.dark,
-      class: "button-class"
-    }, {
-      default: i(() => [
-        d(r(e.text), 1)
-      ]),
-      _: 1
-    }, 8, ["nativeType", "type", "size", "color", "round", "circle", "plain", "disabled", "link", "loading", "dark"]));
-  }
-});
+const _ = "";
 export {
-  k as default
+  _ as default
 };

package/dist/layers-design-system-vue312.cjs

@@ -1 +1 @@
-"use strict";const _="";module.exports=_;
+"use strict";const e=(t,r)=>{const o=t.__vccOpts||t;for(const[s,c]of r)o[s]=c;return o};module.exports=e;

package/dist/layers-design-system-vue312.js

@@ -1,4 +1,9 @@
-const _ = "";
+const s = (t, e) => {
+  const o = t.__vccOpts || t;
+  for (const [r, c] of e)
+    o[r] = c;
+  return o;
+};
 export {
-  _ as default
+  s as default
 };

package/dist/layers-design-system-vue313.cjs

@@ -1 +1 @@
-"use strict";const e=(t,r)=>{const o=t.__vccOpts||t;for(const[s,c]of r)o[s]=c;return o};module.exports=e;
+"use strict";const e=require("vue"),i=require("./layers-design-system-vue327.cjs");require("./layers-design-system-vue328.cjs");require("./layers-design-system-vue329.cjs");const c=require("./layers-design-system-vue330.cjs"),p=e.defineComponent({__name:"LRadio",props:{modelValue:{},options:{},disabled:{type:Boolean},size:{},direction:{}},emits:["update:modelValue"],setup(n,{emit:u}){const t=n,o=c.useVModel(t,u,"modelValue"),s=e.computed(()=>t.size==="medium"?"default":t.size),a=e.computed(()=>t.direction=="vertical"?"vertical-direction":"");return(m,r)=>(e.openBlock(),e.createBlock(e.unref(i.ElRadioGroup),{modelValue:e.unref(o),"onUpdate:modelValue":r[0]||(r[0]=l=>e.isRef(o)?o.value=l:null),class:e.normalizeClass(a.value)},{default:e.withCtx(()=>[(e.openBlock(!0),e.createElementBlock(e.Fragment,null,e.renderList(t.options,(l,d)=>(e.openBlock(),e.createBlock(e.unref(i.ElRadio),{key:d,label:l.label,disabled:t.disabled,size:s.value},{default:e.withCtx(()=>[e.createTextVNode(e.toDisplayString(l.text),1)]),_:2},1032,["label","disabled","size"]))),128))]),_:1},8,["modelValue","class"]))}});module.exports=p;

package/dist/layers-design-system-vue313.js

@@ -1,9 +1,42 @@
-const s = (t, e) => {
-  const o = t.__vccOpts || t;
-  for (const [r, c] of e)
-    o[r] = c;
-  return o;
-};
+import { defineComponent as f, computed as a, openBlock as o, createBlock as n, unref as i, isRef as V, normalizeClass as b, withCtx as s, createElementBlock as z, Fragment as v, renderList as _, createTextVNode as x, toDisplayString as k } from "vue";
+import { ElRadioGroup as B, ElRadio as R } from "./layers-design-system-vue327.js";
+import "./layers-design-system-vue328.js";
+import "./layers-design-system-vue329.js";
+import { useVModel as y } from "./layers-design-system-vue330.js";
+const w = /* @__PURE__ */ f({
+  __name: "LRadio",
+  props: {
+    modelValue: {},
+    options: {},
+    disabled: { type: Boolean },
+    size: {},
+    direction: {}
+  },
+  emits: ["update:modelValue"],
+  setup(d, { emit: u }) {
+    const e = d, l = y(e, u, "modelValue"), m = a(() => e.size === "medium" ? "default" : e.size), p = a(() => e.direction == "vertical" ? "vertical-direction" : "");
+    return (C, r) => (o(), n(i(B), {
+      modelValue: i(l),
+      "onUpdate:modelValue": r[0] || (r[0] = (t) => V(l) ? l.value = t : null),
+      class: b(p.value)
+    }, {
+      default: s(() => [
+        (o(!0), z(v, null, _(e.options, (t, c) => (o(), n(i(R), {
+          key: c,
+          label: t.label,
+          disabled: e.disabled,
+          size: m.value
+        }, {
+          default: s(() => [
+            x(k(t.text), 1)
+          ]),
+          _: 2
+        }, 1032, ["label", "disabled", "size"]))), 128))
+      ]),
+      _: 1
+    }, 8, ["modelValue", "class"]));
+  }
+});
 export {
-  s as default
+  w as default
 };

package/dist/layers-design-system-vue314.cjs

@@ -1 +1 @@
-"use strict";const e=require("vue"),i=require("./layers-design-system-vue347.cjs");require("./layers-design-system-vue330.cjs");require("./layers-design-system-vue332.cjs");const c=require("./layers-design-system-vue338.cjs"),p=e.defineComponent({__name:"LRadio",props:{modelValue:{},options:{},disabled:{type:Boolean},size:{},direction:{}},emits:["update:modelValue"],setup(n,{emit:u}){const t=n,o=c.useVModel(t,u,"modelValue"),s=e.computed(()=>t.size==="medium"?"default":t.size),a=e.computed(()=>t.direction=="vertical"?"vertical-direction":"");return(m,r)=>(e.openBlock(),e.createBlock(e.unref(i.ElRadioGroup),{modelValue:e.unref(o),"onUpdate:modelValue":r[0]||(r[0]=l=>e.isRef(o)?o.value=l:null),class:e.normalizeClass(a.value)},{default:e.withCtx(()=>[(e.openBlock(!0),e.createElementBlock(e.Fragment,null,e.renderList(t.options,(l,d)=>(e.openBlock(),e.createBlock(e.unref(i.ElRadio),{key:d,label:l.label,disabled:t.disabled,size:s.value},{default:e.withCtx(()=>[e.createTextVNode(e.toDisplayString(l.text),1)]),_:2},1032,["label","disabled","size"]))),128))]),_:1},8,["modelValue","class"]))}});module.exports=p;
+"use strict";const _="";module.exports=_;