@surgeui/ds-vue 1.0.0

package/dist/components/atoms/Panel.vue.d.ts

@@ -0,0 +1,27 @@
+import { PanelProps } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        head?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<PanelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PanelProps> & Readonly<{}>, {
+    variant: "default" | "subtle" | "highlight";
+    tag: "div" | "section" | "article";
+    radius: import('../../types').Radius;
+    bordered: boolean;
+    elevated: 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=Panel.vue.d.ts.map

package/dist/components/atoms/Panel.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Panel.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Panel.vue"],"names":[],"mappings":"AAmFA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAoBzC,iBAAS,cAAc;WAiET,OAAO,IAA6B;;sBAZxB,GAAG;yBACA,GAAG;wBACJ,GAAG;;;;EAe9B;AASD,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/atoms/Progress.vue.d.ts

@@ -0,0 +1,31 @@
+import { ProgressProps } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ProgressProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+    max: number;
+    size: "sm" | "md" | "lg";
+    color: string;
+    backgroundColor: string;
+    state: "default" | "error" | "success" | "warning";
+    min: number;
+    formatValue: (value: number) => string;
+    modelValue: number;
+    showLabel: boolean;
+    indeterminate: boolean;
+    indeterminateLabel: string;
+}, {}, {}, {}, 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=Progress.vue.d.ts.map

package/dist/components/atoms/Progress.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Progress.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Progress.vue"],"names":[],"mappings":"AAwOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAoF5C,iBAAS,cAAc;WAsET,OAAO,IAA6B;;yBAVrB,GAAG;;;;EAe/B;AAaD,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/atoms/RadioGroup.vue.d.ts

@@ -0,0 +1,43 @@
+import { RadioGroupProps } from '../../types';
+type __VLS_Props = RadioGroupProps;
+type __VLS_PublicProps = {
+    'modelValue'?: string | number;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        before?(_: {}): any;
+        after?(_: {}): 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, {
+    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, {}, 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=RadioGroup.vue.d.ts.map

package/dist/components/atoms/RadioGroup.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RadioGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/RadioGroup.vue"],"names":[],"mappings":"AAqqBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,KAAK,WAAW,GAAG,eAAe,CAAC;AAmGnC,KAAK,iBAAiB,GAAG;IACzB,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAoGT,OAAO,IAA6B;;wBAXtB,GAAG;uBACJ,GAAG;;;;EAe7B;AAmBD,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/atoms/SelectBox.vue.d.ts

@@ -0,0 +1,56 @@
+import { SelectOption, SelectBoxProps } from '../../types';
+type __VLS_Props = SelectBoxProps;
+type __VLS_PublicProps = {
+    modelValue?: string | number | (string | number)[] | undefined;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    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;
+}, 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: 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, {
+    selectRef: HTMLDivElement;
+    inputRef: HTMLDivElement;
+    dropdownRef: HTMLDivElement;
+    searchInputRef: HTMLInputElement;
+}, any>;
+export default _default;
+//# sourceMappingURL=SelectBox.vue.d.ts.map

package/dist/components/atoms/SelectBox.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectBox.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/SelectBox.vue"],"names":[],"mappings":"AAkuCA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI3D,KAAK,WAAW,GAAG,cAAc,CAAC;AA0blC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,SAAS,CAAC;CAC9D,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2YhB,wBAUG"}

package/dist/components/atoms/Slider.vue.d.ts

@@ -0,0 +1,68 @@
+import { SliderProps } from '../../types';
+type __VLS_Props = SliderProps;
+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=Slider.vue.d.ts.map

package/dist/components/atoms/Slider.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slider.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Slider.vue"],"names":[],"mappings":"AA0kCA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,KAAK,WAAW,GAAG,WAAW,CAAC;AAkY/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAsOT,OAAO,IAA6B;;wBAftB,GAAG;uBACJ,GAAG;;;;;;;;;EAmB7B;AAsCD,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"}

package/dist/components/atoms/Spinner.vue.d.ts

@@ -0,0 +1,13 @@
+import { SpinnerProps } from '../../types';
+declare const _default: import('vue').DefineComponent<SpinnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SpinnerProps> & Readonly<{}>, {
+    type: "classic" | "dots" | "pulse" | "bars" | "modern";
+    fill: string;
+    label: string;
+    size: number | string;
+    color: string;
+    showLabel: boolean;
+    thickness: number;
+    speed: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;
+//# sourceMappingURL=Spinner.vue.d.ts.map

package/dist/components/atoms/Spinner.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Spinner.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Spinner.vue"],"names":[],"mappings":"AA4RA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;;;;;;;;;;;AAmK3C,wBAQG"}

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

@@ -0,0 +1,32 @@
+import { SwitchProps } from '../../types';
+type __VLS_Props = SwitchProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    switchRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    handleToggle: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    change: (value: boolean) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: import('../../types').Size;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    switchRef: HTMLDivElement;
+}, any>;
+export default _default;
+//# sourceMappingURL=Switch.vue.d.ts.map

package/dist/components/atoms/Switch.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Switch.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Switch.vue"],"names":[],"mappings":"AA2VA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAI1C,KAAK,WAAW,GAAG,WAAW,CAAC;AA0G/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;gBADH,OAAO;;;;AA8GpB,wBAUG"}

package/dist/components/atoms/Textarea.vue.d.ts

@@ -0,0 +1,43 @@
+import { TextareaProps } from '../../types';
+type __VLS_Props = TextareaProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void;
+    select: () => void;
+    textareaRef: import('vue').Ref<HTMLTextAreaElement | undefined, HTMLTextAreaElement | 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) => 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;
+}>, {
+    size: import('../../types').Size;
+    disabled: boolean;
+    state: import('../../types').State;
+    required: boolean;
+    readonly: boolean;
+    rows: number;
+    minRows: number;
+    maxRows: number;
+    showCounter: boolean;
+    autoResize: boolean;
+    spellcheck: boolean;
+    wrap: "soft" | "hard" | "off";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    textareaRef: HTMLTextAreaElement;
+}, any>;
+export default _default;
+//# sourceMappingURL=Textarea.vue.d.ts.map

package/dist/components/atoms/Textarea.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Textarea.vue.d.ts","sourceRoot":"","sources":["../../../src/components/atoms/Textarea.vue"],"names":[],"mappings":"AA2UA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAI5C,KAAK,WAAW,GAAG,aAAa,CAAC;AAiNjC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuGhB,wBAUG"}

package/dist/components/global/_stories/Preview.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryFn } from '@storybook/vue3';
+declare const _default: Meta;
+export default _default;
+export declare const GlobalPreview: StoryFn;
+export declare const ThemeAndRTLToggler: StoryFn;
+//# sourceMappingURL=Preview.d.ts.map

package/dist/components/global/_stories/Preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Preview.d.ts","sourceRoot":"","sources":["../../../../src/components/global/_stories/Preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;wBAiB/C,IAAI;AAXT,wBAWS;AAET,eAAO,MAAM,aAAa,EAAE,OAkF1B,CAAA;AAEF,eAAO,MAAM,kBAAkB,EAAE,OAkC/B,CAAA"}

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

@@ -0,0 +1,48 @@
+import { AccordionItemProps } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {
+            item: {
+                id: string;
+                title: string | undefined;
+                content: string | undefined;
+                open: boolean;
+                disabled: boolean;
+            };
+        }): any;
+        default?(_: {
+            item: {
+                id: string;
+                title: string | undefined;
+                content: string | undefined;
+                open: boolean;
+                disabled: boolean;
+            };
+        }): any;
+    };
+    refs: {
+        headerRef: HTMLButtonElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AccordionItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<AccordionItemProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    disabled: boolean;
+    open: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    headerRef: HTMLButtonElement;
+}, 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=AccordionItem.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AccordionItem.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/AccordionItem.vue"],"names":[],"mappings":"AAmZA,OAAO,KAAK,EAAoB,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA+GpE,iBAAS,cAAc;WAqGT,OAAO,IAA6B;;;;;;;;;;YAZtB,GAAG;;;;;;;;;YACD,GAAG;;;;;;EAgBhC;AAmBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;kBAUnB,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/AvatarGroup.vue.d.ts

@@ -0,0 +1,34 @@
+import { AvatarGroupProps } from '../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        before?(): any;
+        after?(): any;
+    }> & {
+        before?(): any;
+        after?(): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AvatarGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "avatar-click": (avatar: any, index: number, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<AvatarGroupProps> & Readonly<{
+    "onAvatar-click"?: ((avatar: any, index: number, event: MouseEvent) => any) | undefined;
+}>, {
+    variant: import('../../types').AvatarVariant;
+    max: number;
+    size: import('../../types').AvatarSize;
+    clickable: boolean;
+    avatars: import('../../types').AvatarProps[];
+    spacing: "none" | "sm" | "md" | "lg";
+}, {}, {}, {}, 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=AvatarGroup.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/AvatarGroup.vue"],"names":[],"mappings":"AAyQA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAuF/C,iBAAS,cAAc;WAiGT,OAAO,IAA6B;;mBAtKrC,GAAG;kBACJ,GAAG;;mBADF,GAAG;kBACJ,GAAG;;;;EA0Kd;AAkBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;wFASnB,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/ButtonGroup.vue.d.ts

@@ -0,0 +1,23 @@
+import { ButtonGroupProps } 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<ButtonGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonGroupProps> & Readonly<{}>, {
+    gap: "sm" | "md" | "lg" | "none";
+}, {}, {}, {}, 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=ButtonGroup.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ButtonGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/ButtonGroup.vue"],"names":[],"mappings":"AAiHA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAgF/C,iBAAS,cAAc;WA+BT,OAAO,IAA6B;;mBAvGrC,GAAG;;mBAAH,GAAG;;;;EA4Gf;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/CheckboxGroupField.vue.d.ts

@@ -0,0 +1,28 @@
+import { CheckboxGroupFieldProps } from '../../types';
+export interface Props extends Omit<CheckboxGroupFieldProps, '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').CheckboxOption[];
+    state: import('../../types').State;
+    required: boolean;
+    displayType: import('../../types').CheckboxDisplayType;
+    direction: "horizontal" | "vertical";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=CheckboxGroupField.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CheckboxGroupField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/CheckboxGroupField.vue"],"names":[],"mappings":"AAiEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAEtD,MAAM,WAAW,KAAM,SAAQ,IAAI,CAAC,uBAAuB,EAAE,OAAO,CAAC;CAAG;AAExE,KAAK,WAAW,GAAG,KAAK,CAAC;AA6CzB,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CAChC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;AA2GhB,wBASG"}

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

@@ -0,0 +1,37 @@
+import { DropdownProps } from '../../types';
+declare const _default: import('vue').DefineComponent<DropdownProps, {
+    focus: () => void;
+    open: () => void;
+    close: () => void;
+    dropdownRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    triggerRef: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (option: any) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    close: () => any;
+    open: () => any;
+}, string, import('vue').PublicProps, Readonly<DropdownProps> & Readonly<{
+    onSelect?: ((option: any) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+}>, {
+    variant: import('../../types').ButtonVariant;
+    size: import('../../types').ButtonSize;
+    loading: boolean;
+    iconDisplay: "left" | "right" | "only";
+    disabled: boolean;
+    options: import('../../types').DropdownOption[];
+    maxHeight: string;
+    trigger: import('../../types').DropdownTrigger;
+    placement: import('../../types').DropdownPlacement;
+    closeOnSelect: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    dropdownRef: HTMLDivElement;
+    triggerRef: HTMLButtonElement;
+    menuRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=Dropdown.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Dropdown.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/Dropdown.vue"],"names":[],"mappings":"AA05BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyjB5C,wBAWG"}

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

@@ -0,0 +1,51 @@
+import { FileUploadFieldProps, UploadedFile } from '../../types';
+interface Props extends Omit<FileUploadFieldProps, 'value'> {
+}
+type __VLS_Props = Props;
+type __VLS_PublicProps = {
+    modelValue?: UploadedFile[];
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {
+    focus: () => void;
+    clear: () => void;
+    fileInputRef: import('vue').Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    dropZoneRef: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (error: string, file?: File | undefined) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    change: (files: UploadedFile[]) => any;
+    "update:modelValue": (value: UploadedFile[]) => any;
+    upload: (file: UploadedFile) => any;
+    remove: (file: UploadedFile) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onError?: ((error: string, file?: File | undefined) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((files: UploadedFile[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: UploadedFile[]) => any) | undefined;
+    onUpload?: ((file: UploadedFile) => any) | undefined;
+    onRemove?: ((file: UploadedFile) => any) | undefined;
+}>, {
+    variant: import('../../types').FileUploadVariant;
+    size: import('../../types').FileUploadSize;
+    loading: boolean;
+    disabled: boolean;
+    state: import('../../types').FileUploadState;
+    required: boolean;
+    multiple: boolean;
+    maxSize: number;
+    maxFiles: number;
+    readonly: boolean;
+    placeholder: string;
+    dragText: string;
+    browseText: string;
+    allowPreview: boolean;
+    showFileList: boolean;
+    showProgress: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    fileInputRef: HTMLInputElement;
+    dropZoneRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=FileUploadField.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileUploadField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/molecules/FileUploadField.vue"],"names":[],"mappings":"AA+gCA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEjE,UAAU,KAAM,SAAQ,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC;CAAG;AAE9D,KAAK,WAAW,GAAG,KAAK,CAAC;AAqWzB,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;CAC3B,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4VhB,wBAWG"}