@skewedaspect/sleekspace-ui 0.2.0-beta.1 → 0.2.0-beta.3

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

@@ -0,0 +1,120 @@
+import { ComponentCustomColors } from '../../types';
+import { SkSwitchKind, SkSwitchSize } from './types';
+export interface SkSwitchComponentProps extends ComponentCustomColors {
+    /**
+     * The current state of the switch. `true` means on (checked), `false` means off (unchecked).
+     * Use with `v-model` for two-way binding. Required prop that must be explicitly provided.
+     */
+    modelValue: boolean;
+    /**
+     * Static label text displayed next to the switch. When `labelOn` or `labelOff` are not
+     * provided, this label remains constant regardless of switch state. Can be overridden
+     * by the default slot for custom label content.
+     * @default undefined
+     */
+    label?: string;
+    /**
+     * Label text displayed when the switch is in the "on" (true) state. When provided along
+     * with `labelOff`, the label animates between the two values as the switch toggles.
+     * Falls back to `label` prop if not provided.
+     * @default undefined
+     */
+    labelOn?: string;
+    /**
+     * Label text displayed when the switch is in the "off" (false) state. When provided along
+     * with `labelOn`, the label animates between the two values as the switch toggles.
+     * Falls back to `label` prop if not provided.
+     * @default undefined
+     */
+    labelOff?: string;
+    /**
+     * Semantic color kind for the switch track (background). Controls the color when the
+     * switch is in the "on" state. The "off" state uses a neutral muted color by default.
+     * @default 'neutral'
+     */
+    kind?: SkSwitchKind;
+    /**
+     * Semantic color kind for the switch thumb (the sliding circle). When provided, overrides
+     * the default thumb color derived from the main `kind`. Use for two-tone switch designs
+     * where the thumb should be a different color than the track.
+     * @default undefined
+     */
+    thumbKind?: SkSwitchKind;
+    /**
+     * Switch size controlling the track dimensions, thumb size, and label text size.
+     * Available sizes: 'sm' (small), 'md' (medium, default), 'lg' (large), 'xl' (extra large).
+     * @default 'md'
+     */
+    size?: SkSwitchSize;
+    /**
+     * When true, disables the switch preventing all user interaction. The switch appears
+     * with reduced opacity and the cursor changes to not-allowed. Disabled switches are
+     * excluded from form submission.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * When true, disables the fade animation when switching between `labelOn` and `labelOff`
+     * labels. The label will change instantly instead of cross-fading. Has no effect if
+     * only a static `label` is provided.
+     * @default false
+     */
+    disableLabelAnimation?: boolean;
+    /**
+     * The form field name used when submitting the switch value. When the switch is on,
+     * the `value` prop is submitted under this name. When off, nothing is submitted
+     * (standard checkbox behavior).
+     * @default undefined
+     */
+    name?: string;
+    /**
+     * The value submitted with the form when the switch is on. Combined with the `name`
+     * prop for form submission. When the switch is off, this value is not submitted.
+     * @default 'on'
+     */
+    value?: string;
+    /**
+     * When true, marks the switch as required for form validation. The browser will prevent
+     * form submission if the switch is not in the "on" state. Use for mandatory agreements
+     * or confirmations.
+     * @default false
+     */
+    required?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        'label-on'?(_: {}): any;
+        'label-on'?(_: {}): any;
+        'label-off'?(_: {}): any;
+        'label-off'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkSwitchComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<SkSwitchComponentProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    kind: SkSwitchKind;
+    disabled: boolean;
+    value: string;
+    size: SkSwitchSize;
+    label: string;
+    required: boolean;
+    name: string;
+    labelOn: string;
+    labelOff: string;
+    thumbKind: SkSwitchKind;
+    disableLabelAnimation: boolean;
+}, {}, {}, {}, 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;
+    };
+};

package/dist/components/Switch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SkSwitch } from './SkSwitch.vue';
+export type { SkSwitchKind, SkSwitchSize } from './types.ts';

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

@@ -0,0 +1,3 @@
+import { ComponentKind, ComponentSize } from '../../types';
+export type SkSwitchKind = ComponentKind;
+export type SkSwitchSize = ComponentSize;

package/dist/components/Table/SkTable.vue.d.ts

@@ -0,0 +1,86 @@
+import { SkTableKind, SkTableVariant } from './types';
+import { ComponentCustomColors } from '../../types';
+export interface SkTableComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic color kind that controls header backgrounds and accent colors. The kind
+     * affects the table header row styling and can subtly influence row hover colors.
+     * Use semantic kinds to match your application's color language.
+     * @default 'neutral'
+     */
+    kind?: SkTableKind;
+    /**
+     * Controls the table's density and spacing. 'default' provides comfortable spacing
+     * for most use cases, 'compact' reduces padding for dense data displays, and
+     * 'comfortable' increases spacing for enhanced readability.
+     * @default 'default'
+     */
+    variant?: SkTableVariant;
+    /**
+     * When true, alternates row background colors (zebra striping) to improve
+     * readability of wide tables. The striping color adapts to the table's kind
+     * and background context.
+     * @default false
+     */
+    striped?: boolean;
+    /**
+     * When true, rows highlight on mouse hover to help users track which row
+     * they're viewing. Particularly useful for tables with many columns where
+     * the eye can lose track across the row.
+     * @default true
+     */
+    hoverable?: boolean;
+    /**
+     * When true, displays a beveled border around the entire table. Disable for
+     * a more minimal appearance or when embedding the table in a card that already
+     * provides visual containment.
+     * @default true
+     */
+    bordered?: boolean;
+    /**
+     * When true, shows borders between individual cells and rows. Enable for
+     * grid-like data where cell boundaries need clear visual separation. Disable
+     * for a cleaner, more modern appearance.
+     * @default false
+     */
+    innerBorders?: boolean;
+    /**
+     * When true, adjusts the table colors for display on dark backgrounds. This
+     * ensures proper contrast and visibility when the table is placed on dark
+     * surfaces outside of the normal theme context.
+     * @default false
+     */
+    darkBackground?: boolean;
+    /**
+     * When true, uses lighter, more subdued colors for the table styling. Useful
+     * when the table should not dominate the visual hierarchy or when displaying
+     * secondary data alongside more prominent content.
+     * @default false
+     */
+    subtle?: boolean;
+}
+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<SkTableComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkTableComponentProps> & Readonly<{}>, {
+    subtle: boolean;
+    kind: SkTableKind;
+    variant: SkTableVariant;
+    striped: boolean;
+    hoverable: boolean;
+    bordered: boolean;
+    innerBorders: boolean;
+    darkBackground: boolean;
+}, {}, {}, {}, 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;
+    };
+};

package/dist/components/Table/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SkTable } from './SkTable.vue';
+export type { SkTableKind, SkTableVariant } from './types';

package/dist/components/Table/types.d.ts

@@ -0,0 +1,3 @@
+import { ComponentKind } from '../../types';
+export type SkTableKind = ComponentKind;
+export type SkTableVariant = 'default' | 'compact' | 'comfortable';

package/dist/components/Tabs/SkTab.vue.d.ts

@@ -0,0 +1,49 @@
+import { ComponentKind } from '../../types';
+export interface SkTabComponentProps {
+    /**
+     * Unique identifier that links this tab trigger to its corresponding `SkTabPanel`. The `name`
+     * must exactly match the `name` prop on the panel you want to display when this tab is active.
+     * Can be a string or number for flexibility with dynamic tab generation.
+     */
+    name: string | number;
+    /**
+     * Text label displayed in the tab button. Can be overridden by the default slot for custom
+     * content like icons with text or formatted labels.
+     */
+    label?: string;
+    /**
+     * When true, the tab cannot be clicked or focused via keyboard. Disabled tabs are skipped
+     * during arrow key navigation and appear with reduced opacity.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Semantic color kind for this specific tab. When provided, overrides the `kind` set on the
+     * parent `SkTabs` component. Use this for highlighting important tabs or creating visual
+     * hierarchy within a tab bar.
+     */
+    kind?: ComponentKind;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkTabComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkTabComponentProps> & Readonly<{}>, {
+    kind: ComponentKind;
+    disabled: boolean;
+    label: string;
+}, {}, {}, {}, 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;
+    };
+};

package/dist/components/Tabs/SkTabList.vue.d.ts

@@ -0,0 +1,28 @@
+import { SkTabsOrientation } from './types.ts';
+export interface SkTabListComponentProps {
+    /**
+     * Layout orientation for arranging tab triggers. When 'horizontal', tabs appear in a row
+     * with left/right arrow key navigation. When 'vertical', tabs stack in a column with
+     * up/down arrow key navigation. If not provided, inherits from the parent `SkTabs` component.
+     */
+    orientation?: SkTabsOrientation;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkTabListComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkTabListComponentProps> & Readonly<{}>, {
+    orientation: SkTabsOrientation;
+}, {}, {}, {}, 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;
+    };
+};

package/dist/components/Tabs/SkTabPanel.vue.d.ts

@@ -0,0 +1,33 @@
+export interface SkTabPanelComponentProps {
+    /**
+     * Unique identifier that links this panel to its corresponding `SkTab` trigger. The `name`
+     * must exactly match the `name` prop on the tab that should activate this panel.
+     */
+    name: string | number;
+    /**
+     * When true, the panel content remains mounted in the DOM even when the tab is inactive.
+     * This is useful for preserving form state, scroll position, or expensive component state
+     * that would otherwise be lost when switching tabs. Use sparingly as it increases memory usage.
+     * @default false
+     */
+    keepAlive?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkTabPanelComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkTabPanelComponentProps> & Readonly<{}>, {
+    keepAlive: 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;
+    };
+};

package/dist/components/Tabs/SkTabPanels.vue.d.ts

@@ -0,0 +1,17 @@
+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<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Tabs/SkTabs.vue.d.ts

@@ -0,0 +1,60 @@
+import { SkTabsOrientation, SkTabsPlacement } from './types';
+import { ComponentCustomColors, ComponentKind } from '../../types';
+export interface SkTabsComponentProps extends ComponentCustomColors {
+    /**
+     * The currently active tab identifier, matching the `name` prop of the corresponding `SkTab`
+     * and `SkTabPanel`. Use with `v-model` for two-way binding to control which tab is displayed.
+     */
+    modelValue: string | number;
+    /**
+     * Layout orientation for the tab list. In 'horizontal' mode, tabs are arranged in a row and
+     * arrow keys navigate left/right. In 'vertical' mode, tabs stack vertically and arrow keys
+     * navigate up/down.
+     * @default 'horizontal'
+     */
+    orientation?: SkTabsOrientation;
+    /**
+     * Alignment of the tab list within its container. 'start' aligns tabs to the left (horizontal)
+     * or top (vertical), 'end' aligns to the opposite side. Useful for positioning tabs in
+     * different layout contexts.
+     * @default 'start'
+     */
+    placement?: SkTabsPlacement;
+    /**
+     * Semantic color kind applied to all tabs in this group. Individual `SkTab` components can
+     * override this with their own `kind` prop for mixed-color tab bars.
+     */
+    kind?: ComponentKind;
+    /**
+     * When true, applies negative margins to align the tab list flush with the parent container's
+     * edges. Useful when the parent has padding but you want tabs to extend edge-to-edge.
+     * @default false
+     */
+    flush?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkTabsComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<SkTabsComponentProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+    kind: ComponentKind;
+    orientation: SkTabsOrientation;
+    placement: SkTabsPlacement;
+    flush: 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;
+    };
+};

package/dist/components/Tabs/types.d.ts

@@ -0,0 +1,5 @@
+import { SkButtonKind, SkButtonSize, SkButtonVariant } from '../Button/types';
+export type SkTabsVariant = 'underline' | 'buttons';
+export type SkTabsOrientation = 'horizontal' | 'vertical';
+export type SkTabsPlacement = 'start' | 'end';
+export type { SkButtonKind, SkButtonVariant, SkButtonSize };

package/dist/components/Tag/SkTag.vue.d.ts

@@ -0,0 +1,58 @@
+import { ComponentCustomColors, ComponentKind } from '../../types';
+import { SkTagSize, SkTagVariant } from './types';
+export interface SkTagComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic color kind that controls the tag's color scheme. The kind determines both
+     * background and text colors across all variants. Use semantic kinds (primary, success,
+     * danger, etc.) to convey meaning, or use accent for decorative highlighting.
+     * @default 'neutral'
+     */
+    kind?: ComponentKind;
+    /**
+     * Visual variant that controls how the tag is rendered. Choose based on visual hierarchy:
+     * 'solid' for maximum emphasis with filled background, 'outline' for medium emphasis with
+     * a border, 'subtle' for low emphasis with a tinted background, 'ghost' for minimal
+     * presence with just text color.
+     * @default 'solid'
+     */
+    variant?: SkTagVariant;
+    /**
+     * Controls the tag dimensions including padding, font size, and remove button size.
+     * Available sizes: 'sm' (compact), 'md' (default), 'lg' (prominent), 'xl' (maximum).
+     * @default 'md'
+     */
+    size?: SkTagSize;
+    /**
+     * When true, displays a small X button on the right side of the tag that emits a
+     * 'remove' event when clicked. Useful for filter chips, multi-select displays, or
+     * any tags that can be dismissed by the user.
+     * @default false
+     */
+    removable?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkTagComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: () => any;
+}, string, import('vue').PublicProps, Readonly<SkTagComponentProps> & Readonly<{
+    onRemove?: (() => any) | undefined;
+}>, {
+    kind: ComponentKind;
+    size: SkTagSize;
+    variant: SkTagVariant;
+    removable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Tag/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tag variant options
+ */
+export type SkTagVariant = 'solid' | 'outline' | 'subtle' | 'ghost';
+/**
+ * Tag size options
+ */
+export type SkTagSize = 'sm' | 'md' | 'lg' | 'xl';

package/dist/components/TagsInput/SkTagsInput.vue.d.ts

@@ -0,0 +1,77 @@
+import { ComponentCustomColors } from '../../types';
+import { SkTagsInputKind, SkTagsInputSize } from './types';
+export interface SkTagsInputComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic color kind that controls the input border and focus ring appearance.
+     * Also sets the default color for tags unless overridden by `tagKind`. When used
+     * inside SkField, inherits the field's kind if not explicitly set.
+     * @default 'neutral' (or inherited from parent SkField)
+     */
+    kind?: SkTagsInputKind;
+    /**
+     * Size of the input field and tags. Controls the input height, tag size, and
+     * text sizing throughout the component. Available sizes: 'sm' (small),
+     * 'md' (medium), 'lg' (large).
+     * @default 'md'
+     */
+    size?: SkTagsInputSize;
+    /**
+     * Placeholder text displayed in the input field when no text is being typed.
+     * Visible even when tags are present. Use to guide users on what type of
+     * values to enter.
+     * @default 'Add tag...'
+     */
+    placeholder?: string;
+    /**
+     * When true, the input is disabled and no tags can be added or removed.
+     * Existing tags remain visible but the delete buttons are non-functional.
+     * The entire component appears with reduced opacity.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Maximum number of tags allowed. When the limit is reached, the input field
+     * is disabled (preventing new tags) but existing tags can still be removed.
+     * Useful for limiting selections in constrained contexts like form fields.
+     */
+    max?: number;
+    /**
+     * When true, pasting text containing separators (commas, semicolons, newlines)
+     * automatically creates multiple tags. When false, pasted text is inserted as
+     * a single value in the input field.
+     * @default true
+     */
+    addOnPaste?: boolean;
+    /**
+     * Semantic color kind specifically for the tag badges. When not set, inherits
+     * from the `kind` prop. Use to differentiate tag appearance from the input
+     * styling, such as colorful tags in a neutral-bordered input.
+     */
+    tagKind?: string;
+    /**
+     * Visual variant for the tag badges. 'solid' renders filled tags with colored
+     * background, 'outline' shows bordered tags with transparent background, and
+     * 'ghost' provides subtle tags with minimal styling.
+     * @default 'solid'
+     */
+    tagVariant?: 'solid' | 'outline' | 'ghost';
+}
+type __VLS_Props = SkTagsInputComponentProps;
+type __VLS_PublicProps = {
+    modelValue?: string[];
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}>, {
+    kind: SkTagsInputKind;
+    disabled: boolean;
+    size: SkTagsInputSize;
+    placeholder: string;
+    max: number;
+    addOnPaste: boolean;
+    tagKind: string;
+    tagVariant: "solid" | "outline" | "ghost";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/TagsInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SkTagsInput } from './SkTagsInput.vue';
+export type { SkTagsInputKind, SkTagsInputSize } from './types';

package/dist/components/TagsInput/types.d.ts

@@ -0,0 +1,3 @@
+import { ComponentKind, ComponentSize } from '../../types';
+export type SkTagsInputKind = ComponentKind;
+export type SkTagsInputSize = ComponentSize;

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

@@ -0,0 +1,85 @@
+import { ComponentCustomColors } from '../../types';
+import { SkTextareaKind, SkTextareaSize } from './types';
+export interface SkTextareaComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic color kind for the textarea border and focus ring. Use semantic kinds like
+     * 'success' or 'danger' to indicate validation states. When used inside an SkField with
+     * a `state` prop, the field's kind automatically overrides this value.
+     * @default 'neutral'
+     */
+    kind?: SkTextareaKind;
+    /**
+     * Textarea size controlling padding and font size. The height is primarily controlled
+     * by the `rows` prop. Available sizes: 'sm' (small), 'md' (medium, default), 'lg' (large),
+     * 'xl' (extra large).
+     * @default 'md'
+     */
+    size?: SkTextareaSize;
+    /**
+     * Placeholder text displayed when the textarea is empty. Use to provide hints about
+     * expected content or formatting. The placeholder disappears when the user begins typing.
+     * @default undefined
+     */
+    placeholder?: string;
+    /**
+     * When true, disables the textarea preventing all user interaction. The textarea appears
+     * with reduced opacity and the cursor changes to not-allowed. Disabled textareas are
+     * excluded from form submission.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * When true, makes the textarea read-only. The user can select and copy text but cannot
+     * modify it. Unlike disabled, read-only textareas are still included in form submission
+     * and maintain normal visual appearance.
+     * @default false
+     */
+    readonly?: boolean;
+    /**
+     * When true, marks the textarea as required for form validation. The browser will prevent
+     * form submission if the textarea is empty. For visual required indicators, wrap the
+     * textarea in an SkField component with `required` prop.
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * The form field name used when submitting the textarea value. Required for native form
+     * submission and useful for form libraries that track fields by name.
+     * @default undefined
+     */
+    name?: string;
+    /**
+     * The number of visible text lines (rows) for the textarea. This sets the initial height
+     * of the textarea. Users can still resize it vertically if the CSS allows. Use more rows
+     * for content that typically requires more space (e.g., descriptions, messages).
+     * @default 4
+     */
+    rows?: number;
+    /**
+     * Autocomplete hint for the browser's autofill feature. For textareas, common values
+     * include 'off' to disable autofill, or 'street-address' for address fields. Most
+     * other autocomplete values are more relevant for single-line inputs.
+     * @default undefined
+     */
+    autocomplete?: string;
+}
+type __VLS_Props = SkTextareaComponentProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    kind: SkTextareaKind;
+    disabled: boolean;
+    size: SkTextareaSize;
+    placeholder: string;
+    required: boolean;
+    name: string;
+    readonly: boolean;
+    autocomplete: string;
+    rows: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTextAreaElement>;
+export default _default;

package/dist/components/Textarea/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SkTextarea } from './SkTextarea.vue';
+export type { SkTextareaKind, SkTextareaSize } from './types';