sit-onyx 1.0.0-beta.241 → 1.0.0-beta.243

package/dist/components/OnyxDataGrid/examples/AsyncExample.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/base/base.d.ts

@@ -7,7 +7,7 @@ export type BaseFeatureOptions = {
 /**
  * The Base feature includes everything that should be provided as built-in functionality of the `OnyxDataGrid` component.
  */
-export declare const BASE_FEATURE: ({ skeleton }: BaseFeatureOptions) => {
+export declare const BASE_FEATURE: ({ skeleton }: BaseFeatureOptions) => () => {
     readonly name: typeof BASE_FEATURE_SYMBOL;
     readonly modifyColumns: {
         readonly func: (columns: readonly import("..").InternalColumnConfig<any, any>[]) => {

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

@@ -3,11 +3,9 @@ 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>) => {
+export declare const useFiltering: <TEntry extends DataGridEntry>(options?: FilterOptions<TEntry>) => (ctx: import("..").DataGridFeatureContext) => {
     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;

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

@@ -1,3 +1,4 @@
+import type { Ref } from "vue";
 import type { DataGridFeatureOptions } from "..";
 import type { DataGridEntry } from "../../types";
 /**
@@ -41,25 +42,25 @@ export type FilterConfig<TEntry extends DataGridEntry> = {
      */
     exactMatch?: boolean;
 };
+/**
+ * Defines the current filter/search term per column
+ */
+export type FilterState<TEntry> = Partial<Record<keyof TEntry, string | undefined>>;
 /**
  * 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>;
     };
-}>;
+}, true> & {
+    filterState?: Ref<FilterState<TEntry>>;
+    /**
+     * Configuration for how the filtering should behave across all columns.
+     */
+    filterConfig?: FilterConfig<TEntry>;
+};

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

@@ -5,7 +5,7 @@ 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>) => {
+export declare const useHideColumns: <TEntry extends DataGridEntry>(options?: HideColumnsOptions<TEntry>) => (ctx: import("..").DataGridFeatureContext) => {
     name: symbol;
     watch: Ref<Set<keyof TEntry>, Set<keyof TEntry>>[];
     modifyColumns: {

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

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

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

@@ -1,4 +1,4 @@
-import { type Component, type HTMLAttributes, type MaybeRef, type MaybeRefOrGetter, type TdHTMLAttributes, type ThHTMLAttributes, type WatchSource } from "vue";
+import { type Component, type HTMLAttributes, type MaybeRef, type MaybeRefOrGetter, type Ref, type TdHTMLAttributes, type ThHTMLAttributes, type WatchSource } from "vue";
 import { type OnyxI18n } from "../../../i18n";
 import type { DatetimeFormat } from "../../../i18n/datetime-formats";
 import { type OrderableMapping } from "../../../utils/feature";
@@ -83,16 +83,33 @@ export type PublicNormalizedColumnConfig<TEntry extends DataGridEntry, TColumnGr
     /**
      * Key of the ColumnGroup that this column should be visually grouped in.
      * The columns have to be defined in the correct order.
-     * So columns that should be grouped together have to actually be defined after eachother.
+     * So columns that should be grouped together have to actually be defined after each other.
      *
      * The label for the column group can be configured via the `columnGroups` prop.
      */
     columnGroupKey?: keyof TColumnGroup;
 };
+/**
+ * Context that is passed to a feature when it is set up by the `useDataGridFeatures` composable.
+ */
+export type DataGridFeatureContext = {
+    /**
+     * Ref for the `async` state of the `OnyxDataGrid`. If `true` data mutations should be skipped, if they are expected to be handled by a backend.
+     */
+    async: Readonly<Ref<boolean>>;
+    /**
+     * The `i18n` object, which can be used to access messages, formatters and the current locale.
+     */
+    i18n: OnyxI18n;
+};
 /**
  * Complete Type for a single data grid feature.
  */
-export type DataGridFeature<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = {
+export type DataGridFeature<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = (ctx: DataGridFeatureContext) => DataGridFeatureDescription<TEntry, TTypeRenderer, TFeatureName>;
+/**
+ * Object that describes the hooks and properties of a datagrid feature.
+ */
+export type DataGridFeatureDescription<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = {
     /**
      * Unique name and identifier of the datagrid feature
      */
@@ -113,7 +130,7 @@ export type DataGridFeature<TEntry extends DataGridEntry, TTypeRenderer extends
         order?: number;
     };
     /**
-     * Defines a renderer for a type.
+     * Defines a renderer for a column type.
      */
     typeRenderer?: TTypeRenderer;
     /**
@@ -153,7 +170,7 @@ export type DataGridFeature<TEntry extends DataGridEntry, TTypeRenderer extends
     };
     scrollContainerAttributes?: () => HTMLAttributes;
 };
-export type DataGridFeatureOptions<TEntry extends DataGridEntry, TOptions extends object, TColumnOptions extends Partial<Record<keyof TEntry, object>>> = TOptions & {
+export type DataGridFeatureOptions<TEntry extends DataGridEntry, TColumnOptions extends Partial<Record<keyof TEntry, object>>, TWithAsync extends boolean = false> = {
     /**
      * Whether the feature is enabled by default. Can be overridden per column.
      *
@@ -171,7 +188,12 @@ export type DataGridFeatureOptions<TEntry extends DataGridEntry, TOptions extend
             enabled?: boolean;
         };
     } | undefined>;
-};
+} & (TWithAsync extends true ? {
+    /**
+     * When async is `true`, then the internal data transformations of this feature  are disabled and have to be performed manually.
+     */
+    async?: boolean;
+} : unknown);
 /**
  * Helper function that checks the generics of the DataGridFeature type, without breaking type inference.
  * @example
@@ -192,12 +214,13 @@ export type DataGridFeatureOptions<TEntry extends DataGridEntry, TOptions extend
  * });
  * ```
  */
-export declare function createFeature<TArgs extends any[], TFeature extends DataGridFeature<any, any, any>, T extends (...args: TArgs) => CheckDataGridFeature<TFeature>>(featureDefinition: T): T;
+export declare function createFeature<TFeature extends DataGridFeature<any, any, any>, T extends CheckDataGridFeature<TFeature>>(featureDefinition: T): T;
 type CheckDataGridFeature<T> = T extends DataGridFeature<infer A, TypeRenderMap<infer A>, infer C> ? DataGridFeature<A, TypeRenderMap<A>, C> : never;
 export type UseDataGridFeaturesOptions<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>> = {
     columnConfig: MaybeRefOrGetter<ColumnConfig<TEntry, TColumnGroup, TTypes>[]>;
     i18n: OnyxI18n;
     columnGroups: MaybeRefOrGetter<TColumnGroup>;
+    async: Readonly<Ref<boolean>>;
 };
 export declare const createTableColumnGroups: <TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig>(columns?: InternalColumnConfig<TEntry, TColumnGroup>[], columnGroups?: ColumnGroupConfig) => TableColumnGroup[] | undefined;
 /**
@@ -234,7 +257,7 @@ export declare const createTableColumnGroups: <TEntry extends DataGridEntry, TCo
  * </template>
  * ```
  */
-export declare const useDataGridFeatures: <TEntry extends DataGridEntry, TFeatureName extends symbol, TTypeRenderer extends TypeRenderMap<TEntry>, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>, T extends DataGridFeature<TEntry, TTypeRenderer, TFeatureName>[] | []>(features: T, { i18n, columnConfig, columnGroups }: UseDataGridFeaturesOptions<TEntry, TColumnGroup, TTypes>) => {
+export declare const useDataGridFeatures: <TEntry extends DataGridEntry, TFeatureName extends symbol, TTypeRenderer extends TypeRenderMap<TEntry>, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>, T extends DataGridFeature<TEntry, TTypeRenderer, TFeatureName>[] | []>(featureDefinitions: T, { i18n, columnConfig, columnGroups, async, }: UseDataGridFeaturesOptions<TEntry, TColumnGroup, TTypes>) => {
     /**
      * Takes the table attributes and maps all
      */
@@ -247,7 +270,7 @@ export declare const useDataGridFeatures: <TEntry extends DataGridEntry, TFeatur
     createRendererColumns: () => DataGridRendererColumn<TEntry>[];
     watchSources: WatchSource[];
 };
-export declare const useIsFeatureEnabled: (options?: DataGridFeatureOptions<DataGridEntry, object, object>) => {
+export declare const useFeatureContext: (ctx: DataGridFeatureContext, options?: DataGridFeatureOptions<DataGridEntry, object, boolean>) => {
     /**
      * Checks whether a data grid feature is enabled for a given column.
      * Considers the feature defaults as well as column-specific overrides.
@@ -255,5 +278,9 @@ export declare const useIsFeatureEnabled: (options?: DataGridFeatureOptions<Data
      * @default true
      */
     isEnabled: import("vue").ComputedRef<(column: PropertyKey) => boolean>;
+    /**
+     * Whether the feature only or all features have data transformations enabled.
+     */
+    isAsync: import("vue").ComputedRef<boolean>;
 };
 export {};

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

@@ -1,4 +1,4 @@
-import { type DataGridFeature, type TypeRenderer, type TypeRenderMap } from ".";
+import { type DataGridFeatureDescription, type TypeRenderer, type TypeRenderMap } from ".";
 import { type OnyxDateFormatOptions, type OnyxNumberFormatOptions } from "../../../i18n";
 import type { DataGridEntry } from "../types";
 import "./renderer.scss";
@@ -43,7 +43,7 @@ export declare const DATETIME_RENDERER: Readonly<TypeRenderer<DataGridEntry, Dat
 export declare const TIME_RENDERER: Readonly<TypeRenderer<DataGridEntry, DateCellOptions>>;
 export declare const TIMESTAMP_RENDERER: Readonly<TypeRenderer<DataGridEntry, DateCellOptions>>;
 export declare const SKELETON_RENDERER: Readonly<TypeRenderer<DataGridEntry, StringCellOptions>>;
-export declare const createRenderer: <TEntry extends DataGridEntry>(features: DataGridFeature<TEntry, TypeRenderMap<TEntry>, symbol>[]) => {
+export declare const createRenderer: <TEntry extends DataGridEntry>(features: DataGridFeatureDescription<TEntry, TypeRenderMap<TEntry>, symbol>[]) => {
     /**
      * Returns a renderer for any given component and type.
      * Uses the fallbackRenderer if necessary.

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

@@ -5,7 +5,7 @@ import "./resizing.scss";
 import type { ResizingOptions } from "./types";
 export declare const RESIZING_FEATURE: unique symbol;
 export declare const EMPTY_COLUMN: unique symbol;
-export declare const useResizing: <TEntry extends DataGridEntry>(options?: ResizingOptions<TEntry>) => {
+export declare const useResizing: <TEntry extends DataGridEntry>(options?: ResizingOptions<TEntry>) => (ctx: import("..").DataGridFeatureContext) => {
     name: symbol;
     watch: import("vue").Ref<boolean, boolean>[];
     modifyColumns: {

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

@@ -4,4 +4,4 @@ import type { DataGridEntry } from "../../types";
  * The configuration options for the resizing feature in the OnyxDataGrid component.
  * Includes settings for the individual columns and general resizing behavior.
  */
-export type ResizingOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, object, object>;
+export type ResizingOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, object>;

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

@@ -3,7 +3,7 @@ import type { DataGridEntry } from "../../types";
 import "./selection.scss";
 import type { SelectionOptions, SelectionState } from "./types";
 export declare const SELECTION_FEATURE: unique symbol;
-export declare const useSelection: <TEntry extends DataGridEntry>(options?: SelectionOptions) => {
+export declare const useSelection: <TEntry extends DataGridEntry>(options?: SelectionOptions) => ({ i18n }: import("..").DataGridFeatureContext) => {
     name: symbol;
     watch: (Readonly<Ref<boolean, boolean>> | Ref<SelectionState, SelectionState>)[];
     modifyColumns: import("../../../../utils/feature.ts").SingleOrderableMapping<import("..").InternalColumnConfig<TEntry, any>[], import("..").InternalColumnConfig<TEntry, any>[], readonly import("..").InternalColumnConfig<TEntry, any>[]>;

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

@@ -3,11 +3,11 @@ import type { DataGridEntry } from "../../types";
 import type { SortDirection, SortOptions, SortState } from "./types";
 export declare const nextSortDirection: (current?: SortDirection, skipNone?: boolean) => SortDirection;
 export declare const SORTING_FEATURE: unique symbol;
-export declare const useSorting: <TEntry extends DataGridEntry>(options?: SortOptions<TEntry>) => {
+export declare const useSorting: <TEntry extends DataGridEntry>(options?: SortOptions<TEntry>) => (ctx: import("..").DataGridFeatureContext) => {
     name: symbol;
     watch: (Ref<SortState<TEntry>, SortState<TEntry>> | import("vue").ComputedRef<(a: unknown, b: unknown) => number>)[];
     mutation: {
-        func: (data: Readonly<TEntry>[]) => void;
+        func: (data: Readonly<TEntry>[]) => Readonly<TEntry>[];
     };
     header: {
         actions: ({ key: column, label }: import("..").InternalColumnConfig<any, any>) => ({

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

@@ -1,4 +1,4 @@
-import { type MaybeRef } from "vue";
+import type { MaybeRef } from "vue";
 import type { DataGridFeatureOptions } from "..";
 import type { DataGridEntry } from "../../types";
 export type SortDirection = "asc" | "desc" | "none";
@@ -28,11 +28,6 @@ export type SortState<TEntry extends DataGridEntry> = {
  * The options of the sorting feature for the OnyxDataGrid component.
  */
 export type SortOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, {
-    /**
-     * The currently applied sorting. Will be updated by the data grid, can be used for reading, updating and watching the applied sorting.
-     */
-    sortState?: MaybeRef<SortState<TEntry>>;
-}, {
     [TKey in keyof TEntry]?: {
         /**
          * A custom sorting function for this column.
@@ -40,4 +35,9 @@ export type SortOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<T
          */
         sortFunc?: Compare<TEntry[TKey]>;
     };
-}>;
+}, true> & {
+    /**
+     * The currently applied sorting. Will be updated by the data grid, can be used for reading, updating and watching the applied sorting.
+     */
+    sortState?: MaybeRef<SortState<TEntry>>;
+};

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

@@ -4,7 +4,7 @@ import type { DataGridEntry } from "../../types";
 import "./stickyColumns.scss";
 import type { StickyColumnsOptions } from "./types";
 export declare const STICKY_COLUMNS_FEATURE: unique symbol;
-export declare const useStickyColumns: <TEntry extends DataGridEntry>(options?: StickyColumnsOptions<TEntry>) => {
+export declare const useStickyColumns: <TEntry extends DataGridEntry>(options?: StickyColumnsOptions<TEntry>) => () => {
     name: symbol;
     watch: (import("vue").Ref<boolean, boolean> | import("vue").ComputedRef<"left" | "right"> | import("vue").ComputedRef<(keyof TEntry)[]>)[];
     modifyColumns: ModifyColumns<TEntry>;

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

@@ -14,7 +14,7 @@ export type MapTypeRenderOptions<T> = {
 /**
  * Unwraps the defined typeRenderers
  */
-export type RenderTypesFromFeature<TFeatures extends DataGridFeature<any, any, any>[]> = IfExtends<RecordValues<MapTypeRenderOptions<IfNotEmpty<MaybePick<UnionByKey<TFeatures[number]>, "typeRenderer">>>>, ColumnConfigTypeOption<PropertyKey, unknown>>;
+export type RenderTypesFromFeature<TFeatures extends DataGridFeature<any, any, any>[]> = IfExtends<RecordValues<MapTypeRenderOptions<IfNotEmpty<MaybePick<UnionByKey<ReturnType<TFeatures[number]>>, "typeRenderer">>>>, ColumnConfigTypeOption<PropertyKey, unknown>>;
 /**
  * @experimental The DataGrid is still working in progress and the props will change in the future.
  */
@@ -29,6 +29,11 @@ export type OnyxDataGridProps<TEntry extends DataGridEntry, TColumnGroup extends
      * Check the Storybook examples (e.g. [Sorting](/?path=/story/data-datagrid-features--sorting)) for more details on how the features are used and configured.
      */
     features?: TFeatures;
+    /**
+     * When `async` is `true`, the data transformation of supported features is disabled and externalized.
+     * This allows for backend handling of data fetching and data transformation.
+     */
+    async?: boolean;
     /**
      * The order of and which columns should be rendered.
      */

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

@@ -15,7 +15,9 @@ type __VLS_Slots = {
      */
     headerActions?: unknown;
 };
-declare const __VLS_component: import("vue").DefineComponent<OnyxNotificationCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OnyxNotificationCardProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<OnyxNotificationCardProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OnyxNotificationCardProps> & Readonly<{}>, {
+    skeleton: import("../../composables/useSkeletonState").SkeletonInjected;
+}, {}, {}, {}, 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 & {

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

@@ -1,4 +1,5 @@
 import type { DensityProp } from "../../composables/density";
+import type { SkeletonInjected } from "../../composables/useSkeletonState";
 import type { DateValue } from "../OnyxDatePicker/types";
 export type OnyxNotificationCardProps = DensityProp & {
     /**
@@ -17,4 +18,8 @@ export type OnyxNotificationCardProps = DensityProp & {
      * Optional icon to show.
      */
     icon?: string;
+    /**
+     * Whether to show a skeleton.
+     */
+    skeleton?: SkeletonInjected;
 };

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

@@ -1,3 +1,4 @@
+import { type ComputedRef } from "vue";
 import type { Nullable, SelectOptionValue } from "../../types";
 import type { OnyxSelectProps, SelectOption } from "./types";
 declare const _default: <TModelValue extends SelectOptionValue | SelectOptionValue[], TMultiple extends TModelValue extends any[] ? true : false | undefined, TValue extends TModelValue extends (infer TInner)[] ? TInner : TModelValue>(__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<{
@@ -9,7 +10,7 @@ declare const _default: <TModelValue extends SelectOptionValue | SelectOptionVal
         readonly "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onValidityChange" | "onUpdate:open" | "onLazyLoad" | "onUpdate:searchTerm"> & OnyxSelectProps<TModelValue, TMultiple, TValue> & Partial<{}>> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{
-        input: import("vue").ComputedRef<HTMLInputElement | null | undefined>;
+        input: ComputedRef<HTMLInputElement | null | undefined>;
     }>): void;
     attrs: any;
     slots: {

package/dist/components/examples/NotificationCenter/NotificationCenter.vue.d.ts

@@ -1,2 +1,14 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+import { type OnyxNotificationCardProps } from "../../..";
+/**
+ * Custom notification type for your project. This can also include custom properties depending in your needs (e.g. an ID etc.).
+ */
+type MyNotification = OnyxNotificationCardProps & {
+    /**
+     * Description/content of the notification.
+     */
+    description: string;
+};
+declare const _default: import("vue").DefineComponent<MyNotification, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MyNotification> & Readonly<{}>, {
+    skeleton: import("../../../composables/useSkeletonState").SkeletonInjected;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/i18n/index.d.ts

@@ -73,7 +73,7 @@ export type OnyxI18n = ReturnType<typeof createI18n>;
 /**
  * Creates a new i18n instance.
  */
-declare const createI18n: (options?: ProvideI18nOptions) => {
+export declare const createI18n: (options?: ProvideI18nOptions) => {
     t: Readonly<import("vue").Ref<TranslationFunction, TranslationFunction>>;
     locale: Readonly<import("vue").Ref<string, string>>;
     d: import("vue").ComputedRef<(date: DateValue, format?: OnyxDateFormatOptions) => string>;