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

package/dist/components/Accordion/SkAccordion.vue.d.ts

@@ -0,0 +1,65 @@
+import { ComponentCustomColors } from '../../types';
+import { SkAccordionKind, SkAccordionType } from './types';
+export interface SkAccordionComponentProps extends ComponentCustomColors {
+    /**
+     * Controls whether one or multiple accordion items can be open simultaneously.
+     * In 'single' mode, opening a new item automatically closes the previously open item.
+     * In 'multiple' mode, users can expand any number of items independently.
+     * @default 'single'
+     */
+    type?: SkAccordionType;
+    /**
+     * The value(s) of currently open accordion item(s). Use with `v-model` for two-way binding.
+     * In 'single' mode, this is a string matching one item's `value` prop.
+     * In 'multiple' mode, this is an array of strings matching multiple items' `value` props.
+     */
+    modelValue?: string | string[];
+    /**
+     * When true and in 'single' mode, allows all items to be collapsed by clicking the open item again.
+     * When false, one item must always remain open (the first click selects, subsequent clicks don't collapse).
+     * This prop has no effect in 'multiple' mode where items are always independently collapsible.
+     * @default false
+     */
+    collapsible?: boolean;
+    /**
+     * Semantic color kind that controls the accordion's header and border colors. The kind is automatically
+     * inherited by all child SkAccordionItem components unless they specify their own kind.
+     * Semantic kinds (neutral, primary, accent, etc.) adapt to your theme.
+     * @default 'neutral'
+     */
+    kind?: SkAccordionKind;
+    /**
+     * When true, disables all accordion items. Items cannot be expanded or collapsed, and
+     * the accordion appears with reduced opacity. Individual items can also be disabled
+     * independently via their own `disabled` prop.
+     * @default false
+     */
+    disabled?: 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<SkAccordionComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[] | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<SkAccordionComponentProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
+}>, {
+    type: SkAccordionType;
+    modelValue: string | string[];
+    collapsible: boolean;
+    kind: SkAccordionKind;
+    disabled: 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/Accordion/SkAccordionItem.vue.d.ts

@@ -0,0 +1,52 @@
+import { SkAccordionKind } from './types';
+export interface SkAccordionItemComponentProps {
+    /**
+     * A unique identifier for this accordion item. This value is used by the parent SkAccordion
+     * to track which item(s) are currently open. Must be unique among siblings within the same
+     * accordion. The value is exposed in v-model bindings on the parent accordion.
+     */
+    value: string;
+    /**
+     * Text displayed in the accordion item's header/trigger button. This is the clickable
+     * area that expands or collapses the content. Can be overridden with the `title` slot
+     * for custom header content including icons, badges, or formatted text.
+     */
+    title?: string;
+    /**
+     * When true, this specific accordion item cannot be expanded or collapsed. The item
+     * appears with reduced opacity and the cursor changes to not-allowed. If the item
+     * was already open when disabled, it remains in its current state.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Overrides the semantic color kind inherited from the parent SkAccordion. Use this
+     * to highlight specific items differently, such as marking one section as 'warning'
+     * or 'danger'. When not specified, the item uses the parent accordion's kind.
+     */
+    kind?: SkAccordionKind;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {
+            open: boolean;
+        }): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkAccordionItemComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkAccordionItemComponentProps> & Readonly<{}>, {
+    kind: SkAccordionKind;
+    disabled: boolean;
+    title: 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/Accordion/index.d.ts

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

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

@@ -0,0 +1,3 @@
+import { ComponentKind } from '../../types';
+export type SkAccordionKind = ComponentKind;
+export type SkAccordionType = 'single' | 'multiple';

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

@@ -0,0 +1,39 @@
+import { SkAlertKind } from './types';
+import { ComponentCustomColors } from '../../types';
+export interface SkAlertComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic kind that determines the alert's color scheme and default icon. Each kind
+     * conveys a different meaning: 'info' for general information, 'success' for positive
+     * confirmations, 'warning' for cautionary messages, and 'danger' for errors or critical issues.
+     * @default 'info'
+     */
+    kind?: SkAlertKind;
+    /**
+     * When true, applies prominent styling with a more vivid background color and stronger
+     * visual presence. Use prominent alerts for critical messages that require immediate
+     * user attention, such as errors or important warnings.
+     * @default false
+     */
+    prominent?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkAlertComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkAlertComponentProps> & Readonly<{}>, {
+    kind: SkAlertKind;
+    prominent: 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/Alert/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Alert semantic kinds (feedback-focused subset)
+ */
+export type SkAlertKind = 'info' | 'success' | 'warning' | 'danger';

package/dist/components/Avatar/SkAvatar.vue.d.ts

@@ -0,0 +1,75 @@
+import { ComponentKind } from '../../types';
+import { SkAvatarSize } from './types';
+export interface SkAvatarComponentProps {
+    /**
+     * URL of the avatar image to display. When provided, the component attempts to load and display
+     * this image. If the image fails to load (404, network error, etc.), the component automatically
+     * falls back to initials or the default icon. Supports any valid image URL including data URIs.
+     */
+    src?: string;
+    /**
+     * Alternative text for the avatar image, used for accessibility. Screen readers announce this
+     * text, so provide meaningful descriptions like "Jane Doe's profile photo" rather than generic
+     * text like "avatar". Only applies when displaying an image.
+     * @default ''
+     */
+    alt?: string;
+    /**
+     * Fallback text to display when no image is provided or the image fails to load. Typically
+     * a user's initials (first and last name letters). Automatically truncated to 2 characters
+     * and uppercased. If neither src nor initials are provided, displays the default user icon.
+     */
+    initials?: string;
+    /**
+     * Semantic color kind that controls the avatar's background and text colors when displaying
+     * initials or the fallback icon. Has no visible effect when displaying an image. Semantic kinds
+     * (neutral, primary, accent, info, success, warning, danger) adapt to your theme.
+     * @default 'neutral'
+     */
+    kind?: ComponentKind;
+    /**
+     * Avatar size controlling both dimensions and text/icon scaling. Available sizes: 'xs' (extra
+     * small, 24px), 'sm' (small, 32px), 'md' (medium, 40px), 'lg' (large, 48px), 'xl' (extra large,
+     * 64px), '2xl' (double extra large, 80px). Choose based on context: 'sm' for lists, 'lg' for
+     * profile headers, 'xl' for profile pages.
+     * @default 'md'
+     */
+    size?: SkAvatarSize;
+    /**
+     * Custom background color that overrides the kind's default. Use for brand colors, user-selected
+     * colors, or dynamically generated colors based on user ID. Accepts any valid CSS color value.
+     * Only visible when displaying initials or the fallback icon.
+     */
+    baseColor?: string;
+    /**
+     * Custom text/icon color that overrides the kind's default. Should provide sufficient contrast
+     * against baseColor for accessibility. Accepts any valid CSS color value. Only visible when
+     * displaying initials or the fallback icon.
+     */
+    textColor?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkAvatarComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkAvatarComponentProps> & Readonly<{}>, {
+    kind: ComponentKind;
+    baseColor: string;
+    textColor: string;
+    size: SkAvatarSize;
+    src: string;
+    alt: string;
+    initials: 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;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default } from './SkAvatar.vue';
+export * from './types';

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

@@ -0,0 +1,20 @@
+import { ComponentKind, ComponentSize } from '../../types';
+/** Avatar size */
+export type SkAvatarSize = ComponentSize;
+/** Avatar props interface */
+export interface SkAvatarProps {
+    /** Image source URL */
+    src?: string;
+    /** Alt text for image */
+    alt?: string;
+    /** Fallback initials (1-2 characters) */
+    initials?: string;
+    /** Semantic color kind */
+    kind?: ComponentKind;
+    /** Avatar size */
+    size?: SkAvatarSize;
+    /** Custom background color (overrides kind) */
+    baseColor?: string;
+    /** Custom text color */
+    textColor?: string;
+}

package/dist/components/Breadcrumbs/SkBreadcrumbItem.vue.d.ts

@@ -0,0 +1,51 @@
+import { SkBreadcrumbItemProps } from './types';
+export interface SkBreadcrumbItemComponentProps {
+    /**
+     * Vue Router destination for client-side navigation. When provided, the item renders as a
+     * `RouterLink` component. Accepts any valid `RouteLocationRaw` value including path strings,
+     * named routes, and route objects with params.
+     */
+    to?: SkBreadcrumbItemProps['to'];
+    /**
+     * URL for standard anchor link navigation. When provided (and `to` is not set), the item
+     * renders as an `<a>` element. Use this for external links or non-Vue-Router navigation.
+     */
+    href?: string;
+    /**
+     * When true, marks this item as the current page in the breadcrumb trail. The item renders
+     * as a non-interactive `<span>` and receives `aria-current="page"` for accessibility.
+     * Typically used on the last item in the breadcrumb list.
+     * @default false
+     */
+    current?: boolean;
+    /**
+     * When true, the item is disabled and cannot be interacted with. The item renders as a
+     * non-interactive `<span>` with reduced opacity. Use for items that represent inaccessible
+     * or locked sections of the application.
+     * @default false
+     */
+    disabled?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLIElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkBreadcrumbItemComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkBreadcrumbItemComponentProps> & Readonly<{}>, {
+    disabled: boolean;
+    to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
+    href: string;
+    current: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLIElement>;
+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/Breadcrumbs/SkBreadcrumbSeparator.vue.d.ts

@@ -0,0 +1,13 @@
+export interface SkBreadcrumbSeparatorComponentProps {
+    /**
+     * Custom separator character or string to display. When not provided, inherits the separator
+     * from the parent `SkBreadcrumbs` component. Use this to override specific separators while
+     * keeping others consistent with the parent setting.
+     * @default '/' (inherited from parent)
+     */
+    separator?: string;
+}
+declare const _default: import('vue').DefineComponent<SkBreadcrumbSeparatorComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkBreadcrumbSeparatorComponentProps> & Readonly<{}>, {
+    separator: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;

package/dist/components/Breadcrumbs/SkBreadcrumbs.vue.d.ts

@@ -0,0 +1,24 @@
+import { ComponentCustomColors } from '../../types';
+import { SkBreadcrumbsProps } from './types';
+export interface SkBreadcrumbsComponentProps extends SkBreadcrumbsProps, ComponentCustomColors {
+    /**
+     * Semantic color kind that controls the appearance of breadcrumb links. The kind affects link colors
+     * for normal, hover, and active states. All child `SkBreadcrumbItem` components inherit this kind.
+     * @default 'neutral'
+     */
+    kind?: SkBreadcrumbsProps['kind'];
+    /**
+     * Character or string displayed between breadcrumb items. Common separators include '/', '>', and
+     * unicode characters like '\u203A' (single right-pointing angle quotation mark). Can be overridden
+     * on individual `SkBreadcrumbSeparator` components for custom patterns.
+     * @default '/'
+     */
+    separator?: string;
+}
+declare const _default: import('vue').DefineComponent<SkBreadcrumbsComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkBreadcrumbsComponentProps> & Readonly<{}>, {
+    kind: import('../../types').ComponentKind;
+    baseColor: string;
+    textColor: string;
+    separator: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

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

@@ -0,0 +1,4 @@
+export { default as SkBreadcrumbItem } from './SkBreadcrumbItem.vue';
+export { default as SkBreadcrumbs } from './SkBreadcrumbs.vue';
+export { default as SkBreadcrumbSeparator } from './SkBreadcrumbSeparator.vue';
+export * from './types';

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

@@ -0,0 +1,18 @@
+import { ComponentKind } from '../../types';
+import { RouteLocationRaw } from 'vue-router';
+export type SkBreadcrumbsKind = ComponentKind;
+export interface SkBreadcrumbsProps {
+    kind?: SkBreadcrumbsKind;
+    separator?: string;
+    baseColor?: string;
+    textColor?: string;
+}
+export interface SkBreadcrumbItemProps {
+    to?: string | RouteLocationRaw;
+    href?: string;
+    current?: boolean;
+    disabled?: boolean;
+}
+export interface SkBreadcrumbSeparatorProps {
+    separator?: string;
+}

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

@@ -0,0 +1,97 @@
+import { ComponentCustomColors } from '../../types';
+import { SkButtonKind, SkButtonSize, SkButtonType, SkButtonVariant } from './types';
+export interface SkButtonComponentProps extends ComponentCustomColors {
+    /**
+     * The HTML `type` attribute for the button element. Only applies when rendering as a `<button>`
+     * (i.e., when neither `href` nor `to` props are provided). Use 'submit' for form submission
+     * buttons and 'reset' for form reset buttons.
+     * @default 'button'
+     */
+    type?: SkButtonType;
+    /**
+     * Semantic color kind that controls the button's color scheme. Semantic kinds (neutral, primary,
+     * accent, etc.) adapt to your theme colors, while color kinds (neon-blue, neon-purple, etc.)
+     * provide fixed branding colors that remain consistent across themes.
+     * @default 'neutral'
+     */
+    kind?: SkButtonKind;
+    /**
+     * Visual variant that determines the button's styling approach. 'solid' provides a filled
+     * background, 'outline' shows a bordered button with transparent background, and 'ghost'
+     * renders a minimal button with no background or border until hovered.
+     * @default 'solid'
+     */
+    variant?: SkButtonVariant;
+    /**
+     * Button size controlling padding, font size, and overall dimensions. Available sizes:
+     * 'sm' (small, compact), 'md' (medium, default), 'lg' (large), 'xl' (extra large).
+     * Icon-only buttons automatically adjust to square proportions at each size.
+     * @default 'md'
+     */
+    size?: SkButtonSize;
+    /**
+     * When true, disables the button preventing all user interaction. The button appears with
+     * reduced opacity and the cursor changes to not-allowed. Also disables any navigation
+     * for link-style buttons.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * When true, displays a loading spinner and disables the button. The button content remains
+     * visible but dimmed while the spinner overlays it. Use this to indicate async operations
+     * like form submissions or data fetching.
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Toggle state for buttons used as toggle controls. When true, applies the pressed visual
+     * state and sets `aria-pressed="true"` for accessibility. Use with `@click` to toggle
+     * the value for toolbar buttons or toggle switches.
+     * @default false
+     */
+    pressed?: boolean;
+    /**
+     * URL for the button to navigate to. When provided, the button renders as an `<a>` element
+     * instead of a `<button>`. Use for external links or simple navigation that doesn't require
+     * Vue Router.
+     * @default undefined
+     */
+    href?: string;
+    /**
+     * Vue Router route for the button to navigate to. When provided, the button renders as a
+     * `<router-link>` component. Accepts either a string path or a route location object with
+     * name, params, and query properties.
+     * @default undefined
+     */
+    to?: string | Record<string, any>;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        icon?(_: {}): any;
+        default?(_: {}): any;
+        trailing?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkButtonComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkButtonComponentProps> & Readonly<{}>, {
+    type: SkButtonType;
+    kind: SkButtonKind;
+    disabled: boolean;
+    size: SkButtonSize;
+    to: string | Record<string, any>;
+    href: string;
+    variant: SkButtonVariant;
+    loading: boolean;
+    pressed: 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/Button/types.d.ts

@@ -0,0 +1,5 @@
+import { ComponentKind, ComponentSize, ComponentVariant } from '../../types';
+export type SkButtonType = 'button' | 'submit' | 'reset';
+export type SkButtonKind = ComponentKind;
+export type SkButtonVariant = ComponentVariant;
+export type SkButtonSize = ComponentSize;

package/dist/components/Card/SkCard.vue.d.ts

@@ -0,0 +1,88 @@
+import { ComponentCustomColors } from '../../types';
+import { SkCardKind } from './types';
+import { SkPanelSize } from '../Panel/types';
+export interface SkCardComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic color kind that controls the card's border color and decorative accent stripe.
+     * Semantic kinds (neutral, primary, accent, etc.) automatically adapt to your current theme,
+     * while color kinds (neon-blue, neon-purple, etc.) provide fixed branding colors.
+     * @default 'neutral'
+     */
+    kind?: SkCardKind;
+    /**
+     * Controls the internal padding of the card's content areas. Larger sizes provide more
+     * breathing room, while smaller sizes create compact layouts. The header, content, and
+     * footer sections all respect this sizing. Available: 'sm', 'md', 'lg', 'xl'.
+     * @default 'md'
+     */
+    size?: SkPanelSize;
+    /**
+     * When true, displays a colored accent stripe along the top edge of the card.
+     * Can be explicitly set to override the default behavior. Takes precedence over
+     * `noDecoration` when explicitly set to true.
+     * @default undefined (defaults to true unless noDecoration is set)
+     */
+    showDecoration?: boolean;
+    /**
+     * When true, explicitly disables the decorative accent stripe. Use this for cleaner
+     * card appearances where the color accent is not needed. This is overridden if
+     * `showDecoration` is explicitly set to true.
+     * @default false
+     */
+    noDecoration?: boolean;
+    /**
+     * When true, removes the border entirely from the card. Useful for flat card designs
+     * or when cards are displayed on contrasting backgrounds. Note: This automatically
+     * disables the decoration stripe since it's part of the border styling.
+     * @default false
+     */
+    noBorder?: boolean;
+    /**
+     * Title text displayed prominently in the card header section. The title is rendered
+     * as an h3 element for proper document semantics. For more complex headers, use the
+     * `header` slot instead of or alongside this prop.
+     */
+    title?: string;
+    /**
+     * Custom CSS background color for the header section only. Accepts any valid CSS color
+     * value (hex, rgb, oklch, etc.). Use this to create visual distinction between the
+     * header and content areas, or to match brand colors.
+     */
+    headerColor?: string;
+    /**
+     * When true, makes the content area scrollable with a fixed maximum height. The card
+     * itself must have a constrained height (via CSS or parent container) for scrolling
+     * to take effect. Header and footer remain fixed while content scrolls.
+     * @default false
+     */
+    scrollable?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        media?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SkCardComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SkCardComponentProps> & Readonly<{}>, {
+    kind: SkCardKind;
+    size: SkPanelSize;
+    title: string;
+    showDecoration: boolean;
+    noBorder: boolean;
+    noDecoration: boolean;
+    headerColor: string;
+    scrollable: 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/Card/types.d.ts

@@ -0,0 +1,2 @@
+import { ComponentKind } from '../../types';
+export type SkCardKind = ComponentKind;

package/dist/components/Checkbox/SkCheckbox.vue.d.ts

@@ -0,0 +1,71 @@
+import { ComponentCustomColors } from '../../types';
+import { SkCheckboxKind, SkCheckboxSize } from './types';
+export interface SkCheckboxComponentProps extends ComponentCustomColors {
+    /**
+     * Semantic color kind that controls the checkbox appearance when checked. Semantic kinds
+     * (neutral, primary, accent, etc.) adapt to your theme, while color kinds (neon-blue,
+     * neon-purple, etc.) provide fixed branding colors.
+     * @default 'neutral'
+     */
+    kind?: SkCheckboxKind;
+    /**
+     * Checkbox size. Controls both the checkbox box dimensions and the label text size.
+     * Available sizes: 'sm' (small), 'md' (medium), 'lg' (large), 'xl' (extra large).
+     * @default 'md'
+     */
+    size?: SkCheckboxSize;
+    /**
+     * When true, the checkbox is disabled and cannot be interacted with. The checkbox
+     * appears with reduced opacity and the cursor changes to not-allowed.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * When true, marks the checkbox as required for form validation. This does not
+     * add visual indication—use a SkField wrapper for required field styling.
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * The form field name used when submitting the checkbox value in a form.
+     * Required for native form submission.
+     */
+    name?: string;
+    /**
+     * Label text displayed next to the checkbox. Can be overridden by the default slot
+     * for custom label content (icons, formatted text, etc.).
+     */
+    label?: string;
+}
+type __VLS_Props = SkCheckboxComponentProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean | 'indeterminate';
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean | "indeterminate") => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean | "indeterminate") => any) | undefined;
+}>, {
+    kind: SkCheckboxKind;
+    disabled: boolean;
+    size: SkCheckboxSize;
+    label: string;
+    required: boolean;
+    name: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+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/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SkCheckbox } from './SkCheckbox.vue';
+export type { SkCheckboxKind, SkCheckboxSize } from './types';