@surgeui/ds-vue 1.0.0

package/dist/components/molecules/InputField.vue.d.ts

@@ -0,0 +1,200 @@
+import { InputFieldProps } from '../../types';
+type __VLS_Props = InputFieldProps;
+type __VLS_PublicProps = {
+    modelValue?: string | number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void | undefined;
+    select: () => void | undefined;
+    inputRef: HTMLInputElement | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    change: (event: Event) => any;
+    keyup: (event: KeyboardEvent) => any;
+    "update:modelValue": (value: string | number) => any;
+    "prefix-click": (event: MouseEvent) => any;
+    "prefix-icon-click": (event: MouseEvent) => any;
+    "suffix-click": (event: MouseEvent) => any;
+    "suffix-icon-click": (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onInput?: ((event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    "onPrefix-click"?: ((event: MouseEvent) => any) | undefined;
+    "onPrefix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+    "onSuffix-click"?: ((event: MouseEvent) => any) | undefined;
+    "onSuffix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    type: import('../../types').InputType;
+    size: import('../../types').Size;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    textAlign: import('../../types').TextAlign;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: string | number | undefined;
+            readonly type?: import('../../types').InputType | undefined;
+            readonly size?: import('../../types').Size | undefined;
+            readonly state?: import('../../types').State | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly required?: boolean | undefined;
+            readonly placeholder?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly suffix?: string | undefined;
+            readonly prefixIcon?: import('vue').Component | undefined;
+            readonly suffixIcon?: import('vue').Component | undefined;
+            readonly textAlign?: import('../../types').TextAlign | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly min?: number | string | undefined;
+            readonly max?: number | string | undefined;
+            readonly step?: number | string | undefined;
+            readonly minLength?: number | undefined;
+            readonly maxLength?: number | undefined;
+            readonly pattern?: string | undefined;
+            readonly ariaLabel?: string | undefined;
+            readonly ariaLabelledBy?: string | undefined;
+            readonly ariaDescribedBy?: string | undefined;
+            readonly ariaHidden?: boolean | undefined;
+            readonly ariaInvalid?: boolean | undefined;
+            readonly ariaRequired?: boolean | undefined;
+            readonly ariaValueText?: string | undefined;
+            readonly role?: string | undefined;
+            readonly tabIndex?: number | undefined;
+            readonly onInput?: ((event: Event) => any) | undefined;
+            readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+            readonly onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            readonly onChange?: ((event: Event) => any) | undefined;
+            readonly onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+            readonly "onPrefix-click"?: ((event: MouseEvent) => any) | undefined;
+            readonly "onPrefix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+            readonly "onSuffix-click"?: ((event: MouseEvent) => any) | undefined;
+            readonly "onSuffix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            inputRef: HTMLInputElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "blur", event: FocusEvent) => void) & ((event: "keydown", event: KeyboardEvent) => void) & ((event: "change", event: Event) => void) & ((event: "keyup", event: KeyboardEvent) => void) & ((event: "update:modelValue", value: string | number) => void) & ((event: "prefix-click", event: MouseEvent) => void) & ((event: "prefix-icon-click", event: MouseEvent) => void) & ((event: "suffix-click", event: MouseEvent) => void) & ((event: "suffix-icon-click", event: MouseEvent) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: string | number;
+        } & import('../../types').InputProps> & Readonly<{
+            onInput?: ((event: Event) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+            "onPrefix-click"?: ((event: MouseEvent) => any) | undefined;
+            "onPrefix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+            "onSuffix-click"?: ((event: MouseEvent) => any) | undefined;
+            "onSuffix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+        }>, {
+            focus: () => void | undefined;
+            select: () => void | undefined;
+            inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            blur: (event: FocusEvent) => any;
+            keydown: (event: KeyboardEvent) => any;
+            change: (event: Event) => any;
+            keyup: (event: KeyboardEvent) => any;
+            "update:modelValue": (value: string | number) => any;
+            "prefix-click": (event: MouseEvent) => any;
+            "prefix-icon-click": (event: MouseEvent) => any;
+            "suffix-click": (event: MouseEvent) => any;
+            "suffix-icon-click": (event: MouseEvent) => any;
+        }, string, {
+            type: import('../../types').InputType;
+            size: import('../../types').Size;
+            disabled: boolean;
+            state: import('../../types').State;
+            required: boolean;
+            readonly: boolean;
+            textAlign: import('../../types').TextAlign;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        type: import('../../types').InputType;
+        size: import('../../types').Size;
+        disabled: boolean;
+        state: import('../../types').State;
+        required: boolean;
+        readonly: boolean;
+        textAlign: import('../../types').TextAlign;
+    }> & Omit<Readonly<{
+        modelValue?: string | number;
+    } & import('../../types').InputProps> & Readonly<{
+        onInput?: ((event: Event) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+        "onPrefix-click"?: ((event: MouseEvent) => any) | undefined;
+        "onPrefix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+        "onSuffix-click"?: ((event: MouseEvent) => any) | undefined;
+        "onSuffix-icon-click"?: ((event: MouseEvent) => any) | undefined;
+    }>, "select" | "focus" | "inputRef" | ("type" | "size" | "disabled" | "state" | "required" | "readonly" | "textAlign")> & import('vue').ShallowUnwrapRef<{
+        focus: () => void | undefined;
+        select: () => void | undefined;
+        inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prefix?(_: {
+                class: string;
+            }): any;
+            suffix?(_: {
+                class: string;
+            }): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=InputField.vue.d.ts.map

package/dist/components/molecules/InputField.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/InputField.vue"],"names":[],"mappings":"AA+FA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,KAAK,WAAW,GAAG,eAAe,CAAC;AA4EnC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6K6sc,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzBn1c,wBAWG"}

package/dist/components/molecules/LinkGroup.vue.d.ts

@@ -0,0 +1,25 @@
+import { LinkGroupProps } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): any;
+    }> & {
+        default(): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<LinkGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LinkGroupProps> & Readonly<{}>, {
+    direction: "horizontal" | "vertical";
+    gap: "sm" | "md" | "lg" | "none";
+    separator: import('../../types').LinkGroupSeparator;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=LinkGroup.vue.d.ts.map

package/dist/components/molecules/LinkGroup.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/LinkGroup.vue"],"names":[],"mappings":"AAyQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AA2H7C,iBAAS,cAAc;WA+BT,OAAO,IAA6B;;mBAhJrC,GAAG;;mBAAH,GAAG;;;;EAqJf;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;wFAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/molecules/Password.vue.d.ts

@@ -0,0 +1,87 @@
+import { PasswordProps, PasswordValidation } from '../../types';
+export interface Props extends PasswordProps {
+}
+type __VLS_Props = Props;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            validation: PasswordValidation;
+            isValid: boolean;
+            score: number;
+            satisfied: string[];
+            unsatisfied: string[];
+            details: {
+                length: {
+                    required: number;
+                    current: number;
+                    satisfied: boolean;
+                };
+                uppercase: {
+                    required: number;
+                    current: number;
+                    satisfied: boolean;
+                };
+                lowercase: {
+                    required: number;
+                    current: number;
+                    satisfied: boolean;
+                };
+                digits: {
+                    required: number;
+                    current: number;
+                    satisfied: boolean;
+                };
+                specialChars: {
+                    required: number;
+                    current: number;
+                    satisfied: boolean;
+                };
+            };
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    change: (event: Event) => any;
+    keyup: (event: KeyboardEvent) => any;
+    "update:modelValue": (value: string) => any;
+    validation: (validation: PasswordValidation) => any;
+    "toggle-visibility": (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onInput?: ((event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValidation?: ((validation: PasswordValidation) => any) | undefined;
+    "onToggle-visibility"?: ((visible: boolean) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    rules: import('../../types').PasswordRules;
+    showProgress: boolean;
+    showToggle: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Password.vue.d.ts.map

package/dist/components/molecules/Password.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Password.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/Password.vue"],"names":[],"mappings":"AA+RA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAIhE,MAAM,WAAW,KAAM,SAAQ,aAAa;CAAG;AAE/C,KAAK,WAAW,GAAG,KAAK,CAAC;AAmNzB,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WA6IT,OAAO,IAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAVpB,GAAG;;;;EAehC;AAyBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/molecules/RadioGroupField.vue.d.ts

@@ -0,0 +1,29 @@
+import { RadioGroupFieldProps } from '../../types';
+export interface Props extends Omit<RadioGroupFieldProps, 'value'> {
+}
+type __VLS_Props = Props;
+type __VLS_PublicProps = {
+    'modelValue'?: string | number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: string | number) => any;
+    "update:modelValue": (value: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: string | number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    disabled: boolean;
+    options: import('../../types').RadioOption[];
+    state: import('../../types').State;
+    required: boolean;
+    displayType: import('../../types').RadioDisplayType;
+    direction: "horizontal" | "vertical";
+    maxHeight: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=RadioGroupField.vue.d.ts.map

package/dist/components/molecules/RadioGroupField.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RadioGroupField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/RadioGroupField.vue"],"names":[],"mappings":"AAkFA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEnD,MAAM,WAAW,KAAM,SAAQ,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC;CAAG;AAErE,KAAK,WAAW,GAAG,KAAK,CAAC;AA8DzB,KAAK,iBAAiB,GAAG;IACzB,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;AAwGhB,wBASG"}

package/dist/components/molecules/RangeField.vue.d.ts

@@ -0,0 +1,63 @@
+import { AccessibilityProps, Size, State, Orientation, FormFieldProps } from '../../types';
+export interface BaseRangeProps extends AccessibilityProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    size?: Size;
+    state?: State;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    orientation?: Orientation;
+    dual?: boolean;
+    showValue?: boolean;
+    showTicks?: boolean;
+    showLabels?: boolean;
+    formatValue?(value: number): string;
+}
+export type RangeFieldProps = FormFieldProps & BaseRangeProps;
+type __VLS_Props = RangeFieldProps;
+type __VLS_PublicProps = {
+    modelValue?: number | [number, number];
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void;
+    rangeRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    thumb1Ref: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    thumb2Ref: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: number | [number, number]) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    change: (value: number | [number, number]) => any;
+    "update:modelValue": (value: number | [number, number]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onInput?: ((value: number | [number, number]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onChange?: ((value: number | [number, number]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number | [number, number]) => any) | undefined;
+}>, {
+    max: number;
+    size: Size;
+    disabled: boolean;
+    state: State;
+    required: boolean;
+    readonly: boolean;
+    min: number;
+    step: number;
+    orientation: Orientation;
+    showValue: boolean;
+    showTicks: boolean;
+    showLabels: boolean;
+    dual: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rangeRef: HTMLDivElement;
+    trackRef: HTMLDivElement;
+    thumb1Ref: HTMLDivElement;
+    thumb2Ref: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=RangeField.vue.d.ts.map

package/dist/components/molecules/RangeField.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RangeField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/RangeField.vue"],"names":[],"mappings":"AAo4BA,OAAO,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE3F,MAAM,WAAW,cAAe,SAAQ,kBAAkB;IACxD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,WAAW,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CACpC;AAED,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,cAAc,CAAA;AAE7D,KAAK,WAAW,GAAG,eAAe,CAAC;AAqVnC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;SAxWR,MAAM;UAEL,IAAI;;;;cAGA,OAAO;SANZ,MAAM;UAEL,MAAM;iBAMC,WAAW;eAEb,OAAO;eACP,OAAO;gBACN,OAAO;UAHb,OAAO;;;;;;;AAgkBhB,wBAWG"}

package/dist/components/molecules/SelectBoxField.vue.d.ts

@@ -0,0 +1,147 @@
+import { SelectBoxFieldProps } from '../../types';
+type __VLS_Props = SelectBoxFieldProps;
+type __VLS_PublicProps = {
+    modelValue?: string | number | (string | number)[] | undefined;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void | undefined;
+    open: () => void | undefined;
+    close: () => void | undefined;
+    selectRef: HTMLDivElement | undefined;
+    inputRef: HTMLInputElement | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (query: string) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: string | number | (string | number)[] | undefined) => any;
+    close: () => any;
+    "update:modelValue": (value: string | number | (string | number)[] | undefined) => any;
+    open: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    loading: boolean;
+    disabled: boolean;
+    options: import('../../types').SelectOption[];
+    state: import('../../types').State;
+    required: boolean;
+    maxHeight: string;
+    multiple: boolean;
+    readonly: boolean;
+    placeholder: string;
+    textAlign: import('../../types').TextAlign;
+    groups: import('../../types').SelectGroup[];
+    searchable: boolean;
+    clearable: boolean;
+    searchPlaceholder: string;
+    noOptionsText: string;
+    noResultsText: string;
+    dir: "ltr" | "rtl" | "auto";
+    closeOnSelect: boolean;
+    maxSelectedItems: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    selectBoxRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: string | number | (string | number)[] | undefined;
+    } & import('../../types').SelectBoxProps> & Readonly<{
+        onSearch?: ((query: string) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+        onClose?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+        onOpen?: (() => any) | undefined;
+    }>, {
+        focus: () => void;
+        open: () => void;
+        close: () => void;
+        selectRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        search: (query: string) => any;
+        focus: (event: FocusEvent) => any;
+        blur: (event: FocusEvent) => any;
+        change: (value: string | number | (string | number)[] | undefined) => any;
+        close: () => any;
+        "update:modelValue": (value: string | number | (string | number)[] | undefined) => any;
+        open: () => any;
+    }, import('vue').PublicProps, {
+        size: import('../../types').Size;
+        loading: boolean;
+        disabled: boolean;
+        options: import('../../types').SelectOption[];
+        state: import('../../types').State;
+        required: boolean;
+        maxHeight: string;
+        multiple: boolean;
+        readonly: boolean;
+        placeholder: string;
+        textAlign: import('../../types').TextAlign;
+        groups: import('../../types').SelectGroup[];
+        searchable: boolean;
+        clearable: boolean;
+        searchPlaceholder: string;
+        noOptionsText: string;
+        noResultsText: string;
+        dir: "ltr" | "rtl" | "auto";
+        closeOnSelect: boolean;
+        maxSelectedItems: number;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        selectRef: HTMLDivElement;
+        inputRef: HTMLDivElement;
+        dropdownRef: HTMLDivElement;
+        searchInputRef: HTMLInputElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: string | number | (string | number)[] | undefined;
+    } & import('../../types').SelectBoxProps> & Readonly<{
+        onSearch?: ((query: string) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+        onClose?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | undefined) => any) | undefined;
+        onOpen?: (() => any) | undefined;
+    }>, {
+        focus: () => void;
+        open: () => void;
+        close: () => void;
+        selectRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        inputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    }, {}, {}, {}, {
+        size: import('../../types').Size;
+        loading: boolean;
+        disabled: boolean;
+        options: import('../../types').SelectOption[];
+        state: import('../../types').State;
+        required: boolean;
+        maxHeight: string;
+        multiple: boolean;
+        readonly: boolean;
+        placeholder: string;
+        textAlign: import('../../types').TextAlign;
+        groups: import('../../types').SelectGroup[];
+        searchable: boolean;
+        clearable: boolean;
+        searchPlaceholder: string;
+        noOptionsText: string;
+        noResultsText: string;
+        dir: "ltr" | "rtl" | "auto";
+        closeOnSelect: boolean;
+        maxSelectedItems: number;
+    }> | null;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=SelectBoxField.vue.d.ts.map

package/dist/components/molecules/SelectBoxField.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectBoxField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/SelectBoxField.vue"],"names":[],"mappings":"AAgGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA6FvC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,SAAS,CAAC;CAC9D,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqIhB,wBAWG"}

package/dist/components/molecules/SliderField.vue.d.ts

@@ -0,0 +1,70 @@
+import { SliderFieldProps } from '../../types';
+export interface Props extends Omit<SliderFieldProps, 'value'> {
+}
+type __VLS_Props = Props;
+type __VLS_PublicProps = {
+    modelValue?: number | [number, number];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        before?(_: {}): any;
+        after?(_: {}): any;
+    };
+    refs: {
+        sliderRef: HTMLDivElement;
+        trackRef: HTMLDivElement;
+        thumb1Ref: HTMLDivElement;
+        thumb2Ref: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void;
+    sliderRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    thumb1Ref: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    thumb2Ref: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: number | [number, number]) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    change: (value: number | [number, number]) => any;
+    "update:modelValue": (value: number | [number, number]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onInput?: ((value: number | [number, number]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onChange?: ((value: number | [number, number]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number | [number, number]) => any) | undefined;
+}>, {
+    max: number;
+    size: import('../../types').Size;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    min: number;
+    step: number;
+    orientation: import('../../types').Orientation;
+    tooltip: "none" | "top" | "bottom";
+    marks: number[];
+    showValue: boolean;
+    showTicks: boolean;
+    showLabels: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sliderRef: HTMLDivElement;
+    trackRef: HTMLDivElement;
+    thumb1Ref: HTMLDivElement;
+    thumb2Ref: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=SliderField.vue.d.ts.map

package/dist/components/molecules/SliderField.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SliderField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/SliderField.vue"],"names":[],"mappings":"AA0lCA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,MAAM,WAAW,KAAM,SAAQ,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC;CAAG;AAEjE,KAAK,WAAW,GAAG,KAAK,CAAC;AAmYzB,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAiQT,OAAO,IAA6B;;wBAftB,GAAG;uBACJ,GAAG;;;;;;;;;EAmB7B;AAuCD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}