@sakoa/ui 0.1.0

package/dist/components/ui/radio/SRadio.d.ts

@@ -0,0 +1,58 @@
+export interface Props {
+    modelValue?: any;
+    value?: any;
+    size?: 'small' | 'medium' | 'large';
+    color?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    label?: string;
+    labelPosition?: 'left' | 'right';
+    variant?: 'default' | 'filled' | 'outlined' | 'button';
+    icon?: string;
+    required?: boolean;
+    name?: string;
+    error?: string;
+    radioClass?: string;
+    labelClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+        icon?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: any) => any;
+    change: (value: any, event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    onChange?: ((value: any, event: Event) => any) | undefined;
+}>, {
+    modelValue: any;
+    size: "small" | "medium" | "large";
+    name: string;
+    icon: string;
+    disabled: boolean;
+    label: string;
+    value: any;
+    required: boolean;
+    color: string;
+    variant: "default" | "filled" | "outlined" | "button";
+    loading: boolean;
+    labelClass: string;
+    error: string;
+    labelPosition: "left" | "right";
+    radioClass: 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/ui/radio/SRadioGroup.d.ts

@@ -0,0 +1,52 @@
+export interface RadioOption {
+    value: any;
+    label: string;
+    disabled?: boolean;
+    icon?: string;
+}
+export interface Props {
+    modelValue?: any;
+    options?: RadioOption[];
+    orientation?: 'horizontal' | 'vertical' | 'grid';
+    size?: 'small' | 'medium' | 'large';
+    color?: string;
+    variant?: 'default' | 'filled' | 'outlined' | 'button';
+    disabled?: boolean;
+    gap?: 'tight' | 'normal' | 'loose';
+    gridCols?: number;
+    name?: string;
+}
+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<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: any) => any;
+    change: (value: any) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    onChange?: ((value: any) => any) | undefined;
+}>, {
+    modelValue: any;
+    size: "small" | "medium" | "large";
+    name: string;
+    disabled: boolean;
+    color: string;
+    variant: "default" | "filled" | "outlined" | "button";
+    gap: "tight" | "normal" | "loose";
+    options: RadioOption[];
+    orientation: "horizontal" | "vertical" | "grid";
+    gridCols: number;
+}, {}, {}, {}, 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/ui/radio/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SRadio } from './SRadio';
+export { default as SRadioGroup } from './SRadioGroup';

package/dist/components/ui/stepper/SStepper.d.ts

@@ -0,0 +1,83 @@
+import { InjectionKey, Ref } from 'vue';
+export interface Props {
+    modelValue?: number;
+    defaultValue?: number;
+    orientation?: StepperOrientation;
+    variant?: StepperVariant;
+    linear?: boolean;
+    size?: StepperSize;
+    color?: string;
+    animated?: boolean;
+    clickable?: boolean;
+    class?: string;
+}
+export type StepperOrientation = 'horizontal' | 'vertical';
+export type StepperSize = 'small' | 'medium' | 'large';
+export type StepperVariant = 'default' | 'line';
+export interface StepperItemInfo {
+    step: number;
+    disabled: boolean;
+    loading: boolean;
+    error: boolean;
+    optional: boolean;
+}
+export interface SStepperContext {
+    modelValue: Ref<number>;
+    orientation: StepperOrientation;
+    variant: StepperVariant;
+    linear: boolean;
+    size: StepperSize;
+    color: string;
+    animated: boolean;
+    clickable: boolean;
+    totalSteps: Ref<number>;
+    completedSteps: Ref<Set<number>>;
+    items: Ref<Map<number, StepperItemInfo>>;
+    registerItem: (item: StepperItemInfo) => void;
+    unregisterItem: (step: number) => void;
+    setStep: (step: number) => void;
+    markCompleted: (step: number) => void;
+    unmarkCompleted: (step: number) => void;
+    isCompleted: (step: number) => boolean;
+    isActive: (step: number) => boolean;
+    getState: (step: number) => 'active' | 'completed' | 'inactive' | 'error' | 'loading';
+    canNavigateTo: (step: number) => boolean;
+}
+export declare const SStepperContextKey: InjectionKey<SStepperContext>;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+    change: (value: number, oldValue: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    onChange?: ((value: number, oldValue: number) => any) | undefined;
+}>, {
+    modelValue: number;
+    size: StepperSize;
+    animated: boolean;
+    linear: boolean;
+    color: string;
+    variant: StepperVariant;
+    orientation: StepperOrientation;
+    clickable: boolean;
+    defaultValue: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {
+        modelValue: number;
+        totalSteps: number;
+        isFirstStep: boolean;
+        isLastStep: boolean;
+        canGoNext: boolean;
+        canGoPrev: boolean;
+        nextStep: () => void;
+        prevStep: () => void;
+        goToStep: (step: number) => void;
+        isCompleted: (step: number) => boolean;
+        isActive: (step: number) => boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/stepper/SStepperContent.d.ts

@@ -0,0 +1,24 @@
+export interface Props {
+    step: number;
+    forceMount?: boolean;
+    class?: string;
+}
+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<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    forceMount: 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/ui/stepper/SStepperDescription.d.ts

@@ -0,0 +1,20 @@
+export interface Props {
+    class?: string;
+}
+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<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, 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/ui/stepper/SStepperIndicator.d.ts

@@ -0,0 +1,37 @@
+export interface Props {
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {
+            step: number;
+        }): any;
+        error?(_: {
+            step: number;
+        }): any;
+        completed?(_: {
+            step: number;
+        }): any;
+        completed?(_: {
+            step: number;
+        }): any;
+        default?(_: {
+            step: number | undefined;
+        }): any;
+        default?(_: {
+            step: number | undefined;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, 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/ui/stepper/SStepperItem.d.ts

@@ -0,0 +1,37 @@
+import { InjectionKey, Ref } from 'vue';
+export interface Props {
+    step: number;
+    completed?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    error?: boolean;
+    optional?: boolean;
+    class?: string;
+}
+export interface SStepperItemContext {
+    step: number;
+    state: Ref<'active' | 'completed' | 'inactive' | 'error' | 'loading'>;
+    disabled: Ref<boolean>;
+    loading: Ref<boolean>;
+    error: Ref<boolean>;
+    optional: Ref<boolean>;
+    canNavigate: Ref<boolean>;
+}
+export declare const SStepperItemContextKey: InjectionKey<SStepperItemContext>;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    disabled: boolean;
+    loading: boolean;
+    error: boolean;
+    completed: boolean;
+    optional: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {
+        state: "loading" | "error" | "active" | "inactive" | "completed";
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/stepper/SStepperSeparator.d.ts

@@ -0,0 +1,5 @@
+export interface Props {
+    class?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/ui/stepper/SStepperTitle.d.ts

@@ -0,0 +1,20 @@
+export interface Props {
+    class?: string;
+}
+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<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, 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/ui/stepper/SStepperTrigger.d.ts

@@ -0,0 +1,22 @@
+export interface Props {
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            state: "loading" | "error" | "active" | "inactive" | "completed";
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, 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/ui/stepper/index.d.ts

@@ -0,0 +1,11 @@
+export { default as SStepper } from './SStepper';
+export { default as SStepperItem } from './SStepperItem';
+export { default as SStepperTrigger } from './SStepperTrigger';
+export { default as SStepperIndicator } from './SStepperIndicator';
+export { default as SStepperTitle } from './SStepperTitle';
+export { default as SStepperDescription } from './SStepperDescription';
+export { default as SStepperSeparator } from './SStepperSeparator';
+export { default as SStepperContent } from './SStepperContent';
+export type { StepperOrientation, StepperSize, StepperVariant, SStepperContext, } from './SStepper';
+export { SStepperContextKey } from './SStepper';
+export { SStepperItemContextKey } from './SStepperItem';

package/dist/components/ui/table/STableBody.d.ts

@@ -0,0 +1,27 @@
+interface Props {
+    /** Enable row animations */
+    animate?: boolean;
+    /** Custom class for tbody */
+    bodyClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    animate: boolean;
+    bodyClass: 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/ui/table/STableCell.d.ts

@@ -0,0 +1,55 @@
+import { ColumnAlign } from './index';
+interface Props {
+    /** Cell alignment */
+    align?: ColumnAlign;
+    /** Custom cell class */
+    cellClass?: string;
+    /** Column key (for accessing column config) */
+    columnKey?: string;
+    /** Whether this is a header cell */
+    header?: boolean;
+    /** Colspan */
+    colspan?: number;
+    /** Rowspan */
+    rowspan?: number;
+    /** Cell width */
+    width?: string;
+    /** Min width */
+    minWidth?: string;
+    /** Max width */
+    maxWidth?: string;
+    /** Sticky position */
+    sticky?: 'left' | 'right';
+    /** Truncate overflow text */
+    truncate?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    width: string;
+    header: boolean;
+    sticky: "left" | "right";
+    maxWidth: string;
+    minWidth: string;
+    truncate: boolean;
+    align: ColumnAlign;
+    colspan: number;
+    cellClass: string;
+    columnKey: string;
+    rowspan: number;
+}, {}, {}, {}, 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/ui/table/STableColumn.d.ts

@@ -0,0 +1,87 @@
+import { TableColumn, ColumnAlign, SortDirection } from './index';
+interface Props {
+    /** Unique column key (required) */
+    columnKey: string;
+    /** Display label for header */
+    label?: string;
+    /** Data accessor key */
+    accessor?: string;
+    /** Column width */
+    width?: string;
+    /** Minimum width */
+    minWidth?: string;
+    /** Maximum width */
+    maxWidth?: string;
+    /** Text alignment */
+    align?: ColumnAlign;
+    /** Whether column is sortable */
+    sortable?: boolean;
+    /** Whether column is visible */
+    visible?: boolean;
+    /** Sticky position */
+    sticky?: 'left' | 'right';
+    /** Custom header class */
+    headerClass?: string;
+    /** Custom cell class */
+    cellClass?: string;
+    /** Render priority for responsive hiding */
+    priority?: number;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Header cell content */
+        header?: (props: {
+            column: TableColumn;
+            sortState: {
+                column: string | null;
+                direction: SortDirection;
+            };
+        }) => unknown;
+        /** Cell content */
+        default?: (props: {
+            row: unknown;
+            value: unknown;
+            index: number;
+        }) => unknown;
+    }> & {
+        /** Header cell content */
+        header?: (props: {
+            column: TableColumn;
+            sortState: {
+                column: string | null;
+                direction: SortDirection;
+            };
+        }) => unknown;
+        /** Cell content */
+        default?: (props: {
+            row: unknown;
+            value: unknown;
+            index: number;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    width: string;
+    label: string;
+    sticky: "left" | "right";
+    maxWidth: string;
+    visible: boolean;
+    minWidth: string;
+    align: ColumnAlign;
+    headerClass: string;
+    accessor: string;
+    sortable: boolean;
+    cellClass: string;
+    priority: number;
+}, {}, {}, {}, 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/ui/table/STableEmpty.d.ts

@@ -0,0 +1,54 @@
+interface Props {
+    /** Icon class (MDI icons) */
+    icon?: string;
+    /** Primary message */
+    title?: string;
+    /** Secondary description */
+    description?: string;
+    /** Visual variant */
+    variant?: 'default' | 'minimal' | 'illustrated';
+    /** Icon size */
+    iconSize?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Column span (for td colspan) */
+    colspan?: number;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        /** Custom icon */
+        icon?: () => unknown;
+        /** Custom title */
+        title?: () => unknown;
+        /** Custom description */
+        description?: () => unknown;
+        /** Action button(s) */
+        action?: () => unknown;
+    }> & {
+        /** Custom icon */
+        icon?: () => unknown;
+        /** Custom title */
+        title?: () => unknown;
+        /** Custom description */
+        description?: () => unknown;
+        /** Action button(s) */
+        action?: () => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    icon: string;
+    title: string;
+    variant: "default" | "minimal" | "illustrated";
+    description: string;
+    colspan: number;
+    iconSize: "sm" | "md" | "lg" | "xl";
+}, {}, {}, {}, 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/ui/table/STableHeader.d.ts

@@ -0,0 +1,25 @@
+interface Props {
+    /** Custom class for thead */
+    headerClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`header-${string}`, (_: {
+        column: import('./index').TableColumn<unknown>;
+    }) => any>> & {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    headerClass: 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/ui/table/STableRow.d.ts

@@ -0,0 +1,38 @@
+interface Props {
+    /** Unique row key */
+    rowKey?: string | number;
+    /** Override hoverable state */
+    hoverable?: boolean;
+    /** Custom row class */
+    rowClass?: string;
+    /** Striped index (for striped variant) */
+    index?: number;
+}
+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<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    dblclick: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onDblclick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    index: number;
+    hoverable: boolean;
+    rowKey: string | number;
+    rowClass: 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;
+    };
+};