sit-onyx 1.0.0-beta.21 → 1.0.0-beta.211

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

@@ -1,5 +1,8 @@
 import type { DensityProp } from "../../composables/density";
+import type { SkeletonInjected } from "../../composables/useSkeletonState";
 import type { AutofocusProp } from "../../types";
+import type { FormInjected } from "../OnyxForm/OnyxForm.core";
+import type { WithLinkProp } from "../OnyxRouterLink/types";
 export type OnyxButtonProps = DensityProp & AutofocusProp & {
     /**
      * The text content of the button.
@@ -8,7 +11,7 @@ export type OnyxButtonProps = DensityProp & AutofocusProp & {
     /**
      * If the button should be disabled or not.
      */
-    disabled?: boolean;
+    disabled?: FormInjected<boolean>;
     /**
      * Shows a loading indicator.
      */
@@ -32,7 +35,12 @@ export type OnyxButtonProps = DensityProp & AutofocusProp & {
     /**
      * Whether to show a skeleton button.
      */
-    skeleton?: boolean;
+    skeleton?: SkeletonInjected;
+    /**
+     * If set, the button will be rendered as link.
+     * Note that not all button properties are supported when used as link, e.g. `disabled`, `type` and `autofocus` are not supported.
+     */
+    link?: WithLinkProp["link"];
 };
 export declare const BUTTON_TYPES: readonly ["button", "submit", "reset"];
 export type ButtonType = (typeof BUTTON_TYPES)[number];

package/dist/components/OnyxCard/OnyxCard.vue.d.ts

@@ -0,0 +1,17 @@
+import type { OnyxCardProps } from "./types";
+type __VLS_Slots = {
+    /**
+     * Card content.
+     */
+    default(): unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<OnyxCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OnyxCardProps> & Readonly<{}>, {
+    clickable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/OnyxCard/examples/DetailsCardExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxCard/examples/HeadlineCardExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxCard/examples/IconCardExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxCard/examples/ImageCardExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxCard/examples/KPICardExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,8 @@
+import type { DensityProp } from "../../composables/density";
+export type OnyxCardProps = DensityProp & {
+    /**
+     * Whether the whole card should be clickable (will render it as `<button>`).
+     * **Important**: If clickable, the card must not contain interactive elements like other buttons etc.
+     */
+    clickable?: boolean;
+};

package/dist/components/OnyxCheckbox/OnyxCheckbox.vue.d.ts

@@ -1,23 +1,20 @@
 import type { SelectOptionValue } from "../../types";
 import type { OnyxCheckboxProps } from "./types";
-declare const _default: <TValue extends SelectOptionValue = SelectOptionValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
-        onValidityChange?: ((validity: ValidityState) => any) | undefined;
-        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>> & {
-        onValidityChange?: ((validity: ValidityState) => any) | undefined;
-        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    }, never>, "onValidityChange" | "onUpdate:modelValue"> & OnyxCheckboxProps<TValue>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+declare const _default: <TValue extends SelectOptionValue = SelectOptionValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        readonly onValidityChange?: ((validity: ValidityState) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onValidityChange"> & OnyxCheckboxProps<TValue> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        input: Readonly<import("vue").ShallowRef<HTMLInputElement | null>>;
+    }>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
-    emit: (((evt: "validityChange", validity: ValidityState) => void) & ((evt: "update:modelValue", value: boolean) => void)) & {};
-}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}> & {
+    slots: {};
+    emit: ((evt: "update:modelValue", value: boolean) => void) & ((evt: "validityChange", validity: ValidityState) => void);
+}>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

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

@@ -1,11 +1,10 @@
-import type { RequiredMarkerProp } from "../../composables/required";
-import type { CustomValidityProp } from "../../composables/useCustomValidity";
-import type { AutofocusProp, BaseSelectOption, SelectOptionValue } from "../../types";
-export type OnyxCheckboxProps<TValue extends SelectOptionValue = SelectOptionValue> = BaseSelectOption<TValue> & RequiredMarkerProp & CustomValidityProp & AutofocusProp & {
+import type { Nullable } from "../../composables/useVModel";
+import type { BaseSelectOption, SelectOptionValue } from "../../types";
+export type OnyxCheckboxProps<TValue extends SelectOptionValue = SelectOptionValue> = BaseSelectOption<TValue> & {
     /**
      * Whether the checkbox is checked.
      */
-    modelValue?: boolean;
+    modelValue?: Nullable<boolean>;
     /**
      * If `true`, an indeterminate indicator is shown.
      */

package/dist/components/OnyxCheckboxGroup/OnyxCheckboxGroup.vue.d.ts

@@ -1,21 +1,20 @@
+import { type Nullable } from "../../composables/useVModel";
 import type { SelectOptionValue } from "../../types";
 import type { OnyxCheckboxGroupProps } from "./types";
-declare const _default: <TValue extends SelectOptionValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
-        "onUpdate:modelValue"?: ((value: TValue[]) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>> & {
-        "onUpdate:modelValue"?: ((value: TValue[]) => any) | undefined;
-    }, never>, "onUpdate:modelValue"> & OnyxCheckboxGroupProps<TValue>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+declare const _default: <TValue extends SelectOptionValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value?: Nullable<TValue[]>) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue"> & OnyxCheckboxGroupProps<TValue> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        inputs: import("vue").ComputedRef<HTMLInputElement[]>;
+    }>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
-    emit: ((evt: "update:modelValue", value: TValue[]) => void) & {};
-}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}> & {
+    slots: {};
+    emit: (evt: "update:modelValue", value?: Nullable<TValue[]>) => void;
+}>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

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

@@ -1,8 +1,9 @@
-import type { DensityProp } from "../../composables/density";
-import type { RequiredMarkerProp } from "../../composables/required";
+import type { RequiredProp } from "../../composables/required";
 import type { CustomValidityProp } from "../../composables/useCustomValidity";
+import type { Nullable } from "../../composables/useVModel";
 import type { AutofocusProp, BaseSelectOption, Direction, SelectOptionValue } from "../../types";
-export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOptionValue> = DensityProp & Pick<BaseSelectOption, "truncation"> & {
+import type { SharedFormElementProps } from "../OnyxFormElement/types";
+export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOptionValue> = Pick<BaseSelectOption, "truncation"> & Pick<SharedFormElementProps, "label" | "labelTooltip" | "hideLabel" | "density" | "skeleton" | "disabled" | "requiredMarker"> & {
     /**
      * Checkbox options.
      */
@@ -10,11 +11,7 @@ export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOpti
     /**
      * Currently checked checkboxes.
      */
-    modelValue?: TValue[];
-    /**
-     * Headline to show above all checkboxes which is also the fieldset legend.
-     */
-    headline?: string;
+    modelValue?: Nullable<TValue[]>;
     /**
      * Direction of the checkboxes.
      */
@@ -30,13 +27,5 @@ export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOpti
          */
         label?: string;
     };
-    /**
-     * Whether all checkboxes should be disabled.
-     */
-    disabled?: boolean;
-    /**
-     * If set, the specified number of skeleton radio buttons will be shown.
-     */
-    skeleton?: number;
 };
-export type CheckboxGroupOption<TValue extends SelectOptionValue = SelectOptionValue> = BaseSelectOption<TValue> & RequiredMarkerProp & CustomValidityProp & AutofocusProp;
+export type CheckboxGroupOption<TValue extends SelectOptionValue = SelectOptionValue> = BaseSelectOption<TValue> & RequiredProp & CustomValidityProp & AutofocusProp;

package/dist/components/OnyxDataGrid/OnyxDataGrid.vue.d.ts

@@ -0,0 +1,22 @@
+import { type ColumnGroupConfig, type DataGridFeature, type TypeRenderMap } from "./features";
+import type { DataGridEntry, OnyxDataGridProps } from "./types";
+declare const _default: <TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry>, TColumnGroup extends ColumnGroupConfig, TFeatureName extends symbol, TFeatures extends DataGridFeature<TEntry, TTypeRenderer, TFeatureName>[] | []>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & OnyxDataGridProps<TEntry, TColumnGroup, TTypeRenderer, TFeatureName, TFeatures> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /**
+         * Optional slot to customize the empty state when no data exist.
+         *
+         * If unset, the default empty content of OnyxTable will be displayed.
+         */
+        empty?(): unknown;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/OnyxDataGrid/OnyxDataGridRenderer/OnyxDataGridRenderer.vue.d.ts

@@ -0,0 +1,22 @@
+import type { DataGridEntry, DataGridMetadata } from "../types";
+import type { OnyxDataGridRendererProps } from "./types";
+declare const _default: <TEntry extends DataGridEntry, TMetadata extends DataGridMetadata>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & OnyxDataGridRendererProps<TEntry, TMetadata> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /**
+         * Optional slot to customize the empty state when no data exist.
+         *
+         * If unset, the default empty content of OnyxTable will be displayed.
+         */
+        empty?(): unknown;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/OnyxDataGrid/OnyxDataGridRenderer/types.d.ts

@@ -0,0 +1,92 @@
+import type { Component, FunctionalComponent, HTMLAttributes, TdHTMLAttributes, ThHTMLAttributes } from "vue";
+import type { WithHTMLAttributes } from "../../../types";
+import type { OnyxTableProps } from "../../OnyxTable/types";
+import type { DataGridEntry, DataGridMetadata } from "../types";
+export type OnyxDataGridRendererProps<TEntry extends DataGridEntry = DataGridEntry, TMetadata extends DataGridMetadata = DataGridMetadata> = OnyxTableProps & {
+    /**
+     * Will define which columns and their headers are rendered in which order.
+     */
+    columns: DataGridRendererColumn<TEntry>[];
+    rows: DataGridRendererRow<TEntry, TMetadata>[];
+};
+/**
+ * Describes how a column header is rendered in the data grid.
+ */
+export type DataGridRendererColumn<TEntry extends DataGridEntry> = {
+    /**
+     * (Unique) Key of the column - usually a key of the table data.
+     * But can also be used for custom columns.
+     */
+    key: keyof TEntry;
+    /**
+     * The component that renders the header content and is placed into the `<th>` element.
+     */
+    component: Component;
+    /**
+     * Width of the column. Any track-list value that can be used by [`grid-template-columns`](https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns) is possible.
+     * So the column can have a fixed width using a static value like `100px` or `2rem`.
+     * The width can also be defined using a fractional flex value like `1fr` or `0.5fr`.
+     * To define min and max widths, use the [`minmax`](https://developer.mozilla.org/en-US/docs/Web/CSS/minmax) function, e.g. `minmax(4rem, 10rem)`.
+     *
+     * @default "minmax(min-content, 1fr)"
+     */
+    width?: string;
+    /**
+     * Attributes that are bound directly to the `<th>` element of the column.
+     */
+    thAttributes?: ThHTMLAttributes;
+};
+/**
+ * Describes how a specific row is rendered in the data grid.
+ */
+export type DataGridRendererRow<TEntry extends DataGridEntry, TMetadata extends DataGridMetadata = DataGridMetadata> = {
+    /**
+     * Unique id of the row.
+     */
+    id: PropertyKey;
+    /**
+     * Describes how a cell in a specific row is rendered in the data grid.
+     * Only cells that are defined in the columns will be rendered in the defined order.
+     */
+    cells: Partial<Record<keyof TEntry, DataGridRendererCell<TEntry, TMetadata>>>;
+    /**
+     * Attributes that are bound directly to the `<tr>` element of the row.
+     */
+    trAttributes?: HTMLAttributes;
+};
+/**
+ * Describes how a single cell in a specific row is rendered in the data grid.
+ */
+export type DataGridRendererCell<TEntry extends DataGridEntry, TMetadata extends DataGridMetadata = DataGridMetadata> = {
+    /**
+     * The component that renders the actual cell content and is placed into the `<td>` element.
+     */
+    component: DataGridRendererCellComponent<TEntry, TMetadata>;
+    /**
+     * Attributes and data that is provided to the component using `v-bind`.
+     */
+    props: DataGridRendererCellComponentProps<TEntry, TMetadata>;
+    /**
+     * Attributes that are bound directly to the `<td>` element of the cell.
+     */
+    tdAttributes?: TdHTMLAttributes;
+};
+/**
+ * Vue component that renders the actual content of a single data grid cell.
+ */
+export type DataGridRendererCellComponent<TEntry extends DataGridEntry, TMetadata extends DataGridMetadata = DataGridMetadata> = FunctionalComponent<WithHTMLAttributes<DataGridRendererCellComponentProps<TEntry, TMetadata>, TdHTMLAttributes>>;
+export type DataGridRendererCellComponentProps<TEntry extends DataGridEntry, TMetadata extends DataGridMetadata> = {
+    /**
+     * Complete row data.
+     */
+    row: Readonly<TEntry>;
+    /**
+     * Cell data that is provided to the component via the `metadata` prop.
+     */
+    metadata?: TMetadata;
+    /**
+     * Cell data that is provided to the component via the `modelValue` prop.
+     * If the cell renders readonly, this will just be the non-editable value.
+     */
+    modelValue?: TEntry[keyof TEntry];
+};

package/dist/components/OnyxDataGrid/examples/CustomColumnTypes.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/CustomFeatureExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/DefaultExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/FilteringExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/HideColumnsExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/ResizingExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/SelectionExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/SortingExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/examples/StickyColumnsExample.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/features/HeaderCell.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    /**
+     * label of the column
+     */
+    label: string;
+};
+type __VLS_Slots = {
+    actions?(): unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/OnyxDataGrid/features/all.d.ts

@@ -0,0 +1,12 @@
+export * from "./filtering/types";
+export * from "./hideColumns/types";
+export * from "./resizing/types";
+export * from "./selection/types";
+export * from "./sorting/types";
+export * from "./stickyColumns/types";
+export { useFiltering } from "./filtering/filtering";
+export { useHideColumns } from "./hideColumns/hideColumns";
+export { useResizing } from "./resizing/resizing";
+export { useSelection } from "./selection/selection";
+export { useSorting } from "./sorting/sorting";
+export { useStickyColumns } from "./stickyColumns/stickyColumns";

package/dist/components/OnyxDataGrid/features/filtering/TestCase.vue.d.ts

@@ -0,0 +1,10 @@
+import type { DataGridEntry, OnyxDataGridProps } from "../../../..";
+import type { FilterOptions } from "./types";
+type __VLS_Props = Pick<OnyxDataGridProps<any, any, any, any, any>, "columns" | "data"> & {
+    /**
+     * config
+     */
+    filterOptions?: FilterOptions<DataGridEntry>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/OnyxDataGrid/features/filtering/filtering.d.ts

@@ -0,0 +1,32 @@
+import { type Ref } from "vue";
+import type { DataGridEntry } from "../../types";
+import "./filtering.scss";
+import type { FilterOptions } from "./types";
+export declare const FILTERING_FEATURE: unique symbol;
+export type FilterState<TEntry> = Partial<Record<keyof TEntry, string | undefined>>;
+export declare const useFiltering: <TEntry extends DataGridEntry>(options?: FilterOptions<TEntry>) => {
+    name: symbol;
+    watch: (Ref<Partial<Record<keyof DataGridEntry, string | undefined>>, Partial<Record<keyof DataGridEntry, string | undefined>>> | import("vue").ComputedRef<{ [TKey in keyof TEntry]?: ({ [TKey_1 in keyof TEntry]?: {
+        searchTerm?: string;
+        config?: import("./types").FilterConfig<TEntry> | undefined;
+    } | undefined; }[TKey] & {
+        enabled?: boolean;
+    }) | undefined; } | undefined>)[];
+    mutation: {
+        func: (entries: Readonly<TEntry>[]) => Readonly<TEntry>[];
+    };
+    header: {
+        actions: ({ key: column }: import("..").InternalColumnConfig<any, any, PropertyKey>) => {
+            iconComponent: {
+                iconComponent: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                    [key: string]: any;
+                }>;
+                alwaysShowInHeader: true;
+            } | undefined;
+            menuItems: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>[];
+            showFlyoutMenu: true;
+        }[];
+    };
+};

package/dist/components/OnyxDataGrid/features/filtering/types.d.ts

@@ -0,0 +1,65 @@
+import type { DataGridFeatureOptions } from "..";
+import type { DataGridEntry } from "../../types";
+/**
+ * Configuration for how filtering should behave.
+ */
+export type FilterConfig<TEntry extends DataGridEntry> = {
+    /**
+     * A custom filtering function for this column.
+     * This function is used to filter the column data, instead of using the default filtering behavior.
+     */
+    filterFunc?: (
+    /**
+     * The searchTerm as entered by the user.
+     */
+    searchTerm: string, 
+    /**
+     * The current row value to be checked.
+     */
+    value: TEntry[keyof TEntry], 
+    /**
+     * The column that is filtered by.
+     */
+    column: keyof TEntry, 
+    /**
+     * The complete row data.
+     */
+    entry: TEntry) => boolean;
+    /**
+     * If true, filtering will be case-sensitive.
+     * If false, filtering will be case-insensitive.
+     */
+    caseSensitive?: boolean;
+    /**
+     * If true, the filter will start searching from the beginning of the value.
+     * If false, it will search anywhere in the value.
+     */
+    searchFromStart?: boolean;
+    /**
+     * If true, the filter will match the value exactly, without partial matches.
+     * If false, partial matches will be allowed.
+     */
+    exactMatch?: boolean;
+};
+/**
+ * The configuration options for the filtering feature in the OnyxDataGrid component.
+ * Includes settings for the individual columns and general filter behavior.
+ */
+export type FilterOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, {
+    /**
+     * Configuration for how the filtering should behave across all columns.
+     */
+    filterConfig?: FilterConfig<TEntry>;
+}, {
+    [TKey in keyof TEntry]?: {
+        /**
+         * The filter value for this column.
+         * This value will be used to filter the data in this column.
+         */
+        searchTerm?: string;
+        /**
+         * Configuration for how filtering should behave for this column.
+         */
+        config?: FilterConfig<TEntry>;
+    };
+}>;

package/dist/components/OnyxDataGrid/features/hideColumns/TestCase.vue.d.ts

@@ -0,0 +1,20 @@
+import type { DataGridEntry, OnyxDataGridProps } from "../../../..";
+import type { HideColumnsOptions } from "./types";
+declare const _default: <TEntry extends DataGridEntry>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & (Pick<OnyxDataGridProps<TEntry, any, any, any, any>, "data" | "columns"> & {
+        /**
+         * config
+         */
+        hideColumnsOptions?: HideColumnsOptions<TEntry>;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/OnyxDataGrid/features/hideColumns/hideColumns.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from "vue";
+import type { DataGridEntry } from "../../types";
+import "./hideColumns.scss";
+import type { HideColumnsOptions } from "./types";
+export declare const HIDE_COLUMNS_FEATURE: unique symbol;
+export declare const HIDDEN_COLUMN: unique symbol;
+export declare const useHideColumns: <TEntry extends DataGridEntry>(options?: HideColumnsOptions<TEntry>) => {
+    name: symbol;
+    watch: Ref<(keyof TEntry)[], (keyof TEntry)[]>[];
+    modifyColumns: {
+        func: (columnConfig: readonly import("..").InternalColumnConfig<TEntry, any, PropertyKey>[]) => import("..").InternalColumnConfig<TEntry, any, PropertyKey>[];
+    };
+    typeRenderer: {
+        [HIDDEN_COLUMN]: {
+            header: {
+                thAttributes: {
+                    class: string;
+                };
+                component: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                    [key: string]: any;
+                }>;
+            };
+            cell: {
+                tdAttributes: {
+                    class: string;
+                };
+                component: () => null;
+            };
+        };
+    };
+    header: {
+        actions: ({ key: column }: import("..").InternalColumnConfig<any, any, PropertyKey>) => {
+            menuItems: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>[];
+            showFlyoutMenu: true;
+        }[];
+    };
+};

package/dist/components/OnyxDataGrid/features/hideColumns/types.d.ts

@@ -0,0 +1,15 @@
+import type { DataGridFeatureOptions } from "..";
+import type { DataGridEntry } from "../../types";
+/**
+ * The options of the sorting feature for the OnyxDataGrid component.
+ */
+export type HideColumnsOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, object, {
+    [TKey in keyof TEntry]?: {
+        /**
+         * Whether the column is hidden.
+         *
+         * @default false
+         */
+        hidden?: boolean;
+    };
+}>;