@mittwald/flow-react-components 0.1.0-alpha.20 → 0.1.0-alpha.200

package/dist/types/components/List/model/item/types.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+
+export type RenderItemFn<T> = (data: T) => ReactNode;

package/dist/types/components/List/model/loading/IncrementalLoader.d.ts

@@ -0,0 +1,24 @@
+import { default as List } from '../List';
+import { IncrementalLoaderShape } from './types';
+import { IncrementalLoaderState } from './IncrementalLoaderState';
+
+export declare class IncrementalLoader<T> {
+    private readonly list;
+    private readonly dataSource;
+    readonly manualSorting: boolean;
+    readonly manualFiltering: boolean;
+    readonly manualPagination: boolean;
+    readonly loaderState: IncrementalLoaderState<T>;
+    private constructor();
+    static useNew<T>(list: List<T>, shape?: IncrementalLoaderShape<T>): IncrementalLoader<T>;
+    private reset;
+    useIsLoading(): boolean;
+    useIsInitiallyLoading(): boolean;
+    useData(): T[];
+    getLoaderInvocationHooks(): (() => void)[];
+    private useLoadBatch;
+    private useObserveBatchLoadingState;
+    private useObserveBatchData;
+    private getDataLoaderOptions;
+    private getBatchDataAsyncResource;
+}

package/dist/types/components/List/model/loading/IncrementalLoaderState.d.ts

@@ -0,0 +1,21 @@
+import { AsyncResource } from '@mittwald/react-use-promise';
+import { ListData } from './types';
+
+type AsyncResourceLoadingState = AsyncResource["state"]["value"];
+type DataBatches<T> = ListData<T>[];
+type BatchesLoadingState = AsyncResourceLoadingState[];
+export declare class IncrementalLoaderState<T> {
+    dataBatches: DataBatches<T>;
+    prevDataBatches: DataBatches<T>;
+    batchLoadingStates: BatchesLoadingState;
+    private constructor();
+    static useNew<T>(): IncrementalLoaderState<T>;
+    reset(): void;
+    setDataBatch(index: number, data: ListData<T>): void;
+    setBatchLoadingState(index: number, state: AsyncResourceLoadingState): void;
+    get mergedData(): T[];
+    useMergedData(): T[];
+    get isLoading(): boolean;
+    useIsLoading(): boolean;
+}
+export {};

package/dist/types/components/List/model/loading/types.d.ts

@@ -0,0 +1,46 @@
+import { PropertyRecord } from '../types';
+import { FilterMode } from '../filter/types';
+import { AsyncResource } from '@mittwald/react-use-promise';
+import { SearchValue } from '../search/types';
+
+type DataLoaderSortOptions<T> = PropertyRecord<T, "asc" | "desc">;
+type DataLoaderFilterOptions<T> = PropertyRecord<T, {
+    mode: FilterMode;
+    values: unknown[];
+}>;
+interface DataLoaderPaginationOptions {
+    offset: number;
+    limit: number;
+}
+export interface DataLoaderOptions<T> {
+    sorting?: DataLoaderSortOptions<T>;
+    filtering?: DataLoaderFilterOptions<T>;
+    searchString?: SearchValue;
+    pagination?: DataLoaderPaginationOptions;
+}
+export type ListData<T> = readonly T[];
+export interface DataLoaderResult<T> {
+    data: ListData<T>;
+    itemTotalCount?: number;
+}
+export type AsyncDataLoader<T> = (options?: DataLoaderOptions<T>) => Promise<DataLoaderResult<T>>;
+type AsyncResourceFactory<T> = (options?: DataLoaderOptions<T>) => AsyncResource<DataLoaderResult<T>>;
+interface DynamicLoaderShape {
+    manualSorting?: boolean;
+    manualFiltering?: boolean;
+    manualPagination?: boolean;
+}
+export interface StaticDataLoaderShape<T> {
+    staticData: ListData<T>;
+}
+export type AsyncResourceFactoryDataLoaderShape<T> = {
+    asyncResourceFactory: AsyncResourceFactory<T>;
+} & DynamicLoaderShape;
+export type AsyncDataLoaderShape<T> = {
+    asyncLoader: AsyncDataLoader<T>;
+} & DynamicLoaderShape;
+export type DataSource<T> = StaticDataLoaderShape<T> | AsyncResourceFactoryDataLoaderShape<T> | AsyncDataLoaderShape<T>;
+export interface IncrementalLoaderShape<T> {
+    source?: DataSource<T>;
+}
+export {};

package/dist/types/components/List/model/pagination/BatchesController.d.ts

@@ -0,0 +1,16 @@
+import { default as List } from '../List';
+import { BatchesControllerShape } from './types';
+
+export declare class BatchesController<T> {
+    readonly batchSize: number;
+    private readonly list;
+    constructor(list: List<T>, shape?: BatchesControllerShape);
+    private get reactTable();
+    getBatchIndex(): number;
+    hasNextBatch(): boolean;
+    getTotalItemsCount(): number;
+    getVisibleItemsCount(): number;
+    updateItemTotalCount(value: number): void;
+    reset(): void;
+    nextBatch(): void;
+}

package/dist/types/components/List/model/pagination/types.d.ts

@@ -0,0 +1,3 @@
+export interface BatchesControllerShape {
+    batchSize?: number;
+}

package/dist/types/components/List/model/search/Search.d.ts

@@ -0,0 +1,15 @@
+import { default as List } from '../List';
+import { SearchFieldRenderComponent, SearchShape, SearchValue } from './types';
+
+export declare class Search<T> {
+    readonly list: List<T>;
+    readonly render?: SearchFieldRenderComponent;
+    readonly textFieldProps: SearchShape<T>["textFieldProps"];
+    private onUpdateCallbacks;
+    constructor(list: List<T>, searchShape: SearchShape<T>);
+    get value(): SearchValue;
+    get isSet(): boolean;
+    setValue(value: SearchValue): void;
+    clear(): void;
+    onUpdated(cb: () => unknown): void;
+}

package/dist/types/components/List/model/search/types.d.ts

@@ -0,0 +1,15 @@
+import { ComponentType } from 'react';
+import { SearchFieldProps } from '../../../SearchField';
+
+type SupportedSearchFieldProps = Pick<SearchFieldProps, "className" | "autoFocus">;
+interface SearchFieldRenderProps extends SupportedSearchFieldProps {
+    onChange: (value: SearchValue) => unknown;
+    value: SearchValue;
+}
+export type SearchFieldRenderComponent = ComponentType<SearchFieldRenderProps>;
+export type SearchValue = string | undefined;
+export interface SearchShape<IgnoredT> {
+    render?: SearchFieldRenderComponent;
+    textFieldProps: SupportedSearchFieldProps;
+}
+export {};

package/dist/types/components/List/model/sorting/Sorting.d.ts

@@ -0,0 +1,20 @@
+import { Column, ColumnDef, ColumnSort, SortDirection } from '@tanstack/react-table';
+import { default as List } from '../List';
+import { SortingDefaultMode, SortingShape } from './types';
+import { PropertyName } from '../types';
+
+export declare class Sorting<T> {
+    readonly list: List<T>;
+    readonly property: PropertyName<T>;
+    readonly name?: string;
+    readonly direction: SortDirection;
+    readonly defaultEnabled: SortingDefaultMode;
+    constructor(list: List<T>, shape: SortingShape<T>);
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    getReactTableColumnSort(): ColumnSort;
+    isSorted(): boolean;
+    getTableColumn(): Column<T>;
+    enable(): void;
+    clear(): void;
+    get id(): string;
+}

package/dist/types/components/List/model/sorting/types.d.ts

@@ -0,0 +1,10 @@
+import { SortDirection } from '@tanstack/react-table';
+import { PropertyName } from '../types';
+
+export type SortingDefaultMode = boolean | "hidden";
+export interface SortingShape<T> {
+    property: PropertyName<T>;
+    name?: string;
+    direction?: SortDirection;
+    defaultEnabled?: SortingDefaultMode;
+}

package/dist/types/components/List/model/types.d.ts

@@ -0,0 +1,25 @@
+import { DeepKeys, DeepValue } from '@tanstack/react-table';
+import { SortingShape } from './sorting/types';
+import { BatchesControllerShape } from './pagination/types';
+import { FilterShape } from './filter/types';
+import { IncrementalLoaderShape } from './loading/types';
+import { SearchShape } from './search/types';
+import { ItemViewShape } from './item/ItemView';
+import { ReactNode } from 'react';
+import { ItemType } from '../../../lib/types/array';
+
+export declare const customPropertyPrefix: "$";
+export type CustomPropertyName = `${typeof customPropertyPrefix}${string}`;
+export type PropertyName<T> = DeepKeys<T> | CustomPropertyName;
+export type PropertyValue<T, TProp> = TProp extends CustomPropertyName ? T : DeepValue<T, TProp>;
+export type PropertyValueRenderMethod<TMatcherValue> = (prop: NonNullable<ItemType<TMatcherValue>>) => ReactNode;
+export interface ListShape<T> {
+    loader?: IncrementalLoaderShape<T>;
+    filters?: FilterShape<T, never, never>[];
+    itemView?: ItemViewShape<T>;
+    search?: SearchShape<T>;
+    sorting?: SortingShape<T>[];
+    batchesController?: BatchesControllerShape;
+    hasAction: boolean;
+}
+export type PropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;

package/dist/types/components/List/setupComponents/ListFilter.d.ts

@@ -0,0 +1,10 @@
+import { FilterShape } from '../model/filter/types';
+import { ReactNode } from 'react';
+import { PropertyName, PropertyValue, PropertyValueRenderMethod } from '../model/types';
+
+type Props<T, TProp extends PropertyName<T>, TMatcherValue> = Omit<FilterShape<T, TProp, TMatcherValue>, "type" | "renderItem"> & {
+    children?: PropertyValueRenderMethod<TMatcherValue>;
+};
+export declare const ListFilter: <T, const TProp extends PropertyName<T> = PropertyName<T>, TMatcherValue = PropertyValue<T, TProp>>(ignoredProps: Props<T, TProp, TMatcherValue>) => null;
+export declare const TypedListFilter: <T>() => <const TProp extends PropertyName<T>, TMatcherValue = PropertyValue<T, TProp>>(props: Props<T, TProp, TMatcherValue>) => ReactNode;
+export {};

package/dist/types/components/List/setupComponents/ListItem.d.ts

@@ -0,0 +1,10 @@
+import { ComponentType } from 'react';
+import { RenderItemFn } from '../model/item/types';
+import { ItemViewShape } from '../model/item/ItemView';
+
+type Props<T> = Omit<ItemViewShape<T>, "renderFn"> & {
+    children: RenderItemFn<T>;
+};
+export declare const ListItem: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListItem: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListLoaderAsync.d.ts

@@ -0,0 +1,9 @@
+import { AsyncDataLoaderShape } from '../model/loading/types';
+import { ComponentType } from 'react';
+
+type Props<T> = Omit<AsyncDataLoaderShape<T>, "asyncLoader"> & {
+    children: AsyncDataLoaderShape<T>["asyncLoader"];
+};
+export declare const ListLoaderAsync: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListLoaderAsync: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListLoaderAsyncResource.d.ts

@@ -0,0 +1,9 @@
+import { AsyncResourceFactoryDataLoaderShape } from '../model/loading/types';
+import { ComponentType } from 'react';
+
+type Props<T> = Omit<AsyncResourceFactoryDataLoaderShape<T>, "asyncResourceFactory"> & {
+    children: AsyncResourceFactoryDataLoaderShape<T>["asyncResourceFactory"];
+};
+export declare const ListLoaderAsyncResource: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListLoaderAsyncResource: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListSearch.d.ts

@@ -0,0 +1,9 @@
+import { SearchFieldRenderComponent, SearchShape } from '../model/search/types';
+import { ComponentType } from 'react';
+
+type Props<T> = Omit<SearchShape<T>, "render" | "textFieldProps"> & {
+    children?: SearchFieldRenderComponent;
+} & SearchShape<T>["textFieldProps"];
+export declare function ListSearch<T = never>(ignoredProps: Props<T>): null;
+export declare const TypedListSearch: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListSorting.d.ts

@@ -0,0 +1,7 @@
+import { SortingShape } from '../model/sorting/types';
+import { ComponentType } from 'react';
+
+type Props<T> = SortingShape<T>;
+export declare const ListSorting: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListSorting: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListStaticData.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType } from 'react';
+
+type Props<T> = {} & {
+    data: readonly T[];
+};
+export declare const ListStaticData: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListStaticData: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/stories/Default.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as List } from '../List';
+
+declare const meta: Meta<typeof List>;
+export default meta;
+type Story = StoryObj<typeof List>;
+export declare const Default: Story;

package/dist/types/components/List/stories/ListItem.stories.d.ts

@@ -0,0 +1,12 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as List } from '../List';
+
+declare const meta: Meta<typeof List>;
+export default meta;
+type Story = StoryObj<typeof List>;
+export declare const Default: Story;
+export declare const WithTopContent: Story;
+export declare const WithContent: Story;
+export declare const SmallSpace: Story;
+export declare const CustomContainerBreakpoint: Story;
+export declare const WithActionGroup: Story;

package/dist/types/components/List/testData/domainApi.d.ts

@@ -0,0 +1,26 @@
+export interface Domain {
+    hostname: string;
+    domain: string;
+    type: "Subdomain" | "Domain";
+    verified: boolean;
+    tld: string;
+}
+export declare const getTypes: () => Promise<("Subdomain" | "Domain")[]>;
+interface Request {
+    pagination?: {
+        limit: number;
+        skip: number;
+    };
+    filter?: {
+        types?: string[];
+    };
+    search?: string;
+}
+interface Response {
+    data: Domain[];
+    totalCount: number;
+}
+export declare const getDomains: (req: Request) => Promise<Response>;
+export declare const domains: Domain[];
+export declare const types: ("Subdomain" | "Domain")[];
+export {};

package/dist/types/components/List/typedList.d.ts

@@ -0,0 +1,30 @@
+export declare const typedList: <T>() => {
+    List: import('react').ForwardRefExoticComponent<import('./List').ListProps & import('react').RefAttributes<never>>;
+    Filter: <const TProp extends import('./model/types').PropertyName<T>, TMatcherValue = import('./model/types').PropertyValue<T, TProp>>(props: Omit<import('./model/filter/types').FilterShape<T, TProp, TMatcherValue>, "type" | "renderItem"> & {
+        children?: import('./model/types').PropertyValueRenderMethod<TMatcherValue> | undefined;
+    }) => import('react').ReactNode;
+    Search: import('react').ComponentType<Omit<import('./model/search/types').SearchShape<T>, "render" | "textFieldProps"> & {
+        children?: import('./model/search/types').SearchFieldRenderComponent;
+    } & {
+        className?: string | ((values: import('react-aria-components').SearchFieldRenderProps & {
+            defaultClassName: string | undefined;
+        }) => string) | undefined;
+        autoFocus?: boolean | undefined;
+    }>;
+    Sorting: import('react').ComponentType<import('./model/sorting/types').SortingShape<T>>;
+    Item: import('react').ComponentType<Omit<import('./model/item/ItemView').ItemViewShape<T>, "renderFn"> & {
+        children: import('.').RenderItemFn<T>;
+    }>;
+    ItemView: (props: {
+        children?: import('react').ReactNode | undefined;
+    } & import('../../lib/types/props').PropsWithClassName & import('../../lib/types/props').PropsWithContainerBreakpointSize) => import("react").JSX.Element;
+    StaticData: import('react').ComponentType<{
+        data: readonly T[];
+    }>;
+    LoaderAsync: import('react').ComponentType<Omit<import('./model/loading/types').AsyncDataLoaderShape<T>, "asyncLoader"> & {
+        children: import('./model/loading/types').AsyncDataLoader<T>;
+    }>;
+    LoaderAsyncResource: import('react').ComponentType<Omit<import('./model/loading/types').AsyncResourceFactoryDataLoaderShape<T>, "asyncResourceFactory"> & {
+        children: (options?: import('./model/loading/types').DataLoaderOptions<T> | undefined) => import('@mittwald/react-use-promise').AsyncResource<import('./model/loading/types').DataLoaderResult<T>>;
+    }>;
+};

package/dist/types/components/List/typedList.test-types.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { IconProps } from '../Icon';
+
+export declare const LoadingSpinner: FC<IconProps>;
+export default LoadingSpinner;

package/dist/types/components/LoadingSpinner/index.d.ts

@@ -0,0 +1,4 @@
+import { LoadingSpinner } from './LoadingSpinner';
+
+export { LoadingSpinner } from './LoadingSpinner';
+export default LoadingSpinner;

package/dist/types/components/LoadingSpinner/stories/Default.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as LoadingSpinner } from '../LoadingSpinner';
+
+declare const meta: Meta<typeof LoadingSpinner>;
+export default meta;
+type Story = StoryObj<typeof LoadingSpinner>;
+export declare const Default: Story;

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

@@ -0,0 +1,9 @@
+import { PropsWithChildren, default as React } from 'react';
+import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
+
+import * as Aria from "react-aria-components";
+export interface MenuItemProps extends Omit<Aria.MenuItemProps, "children">, PropsWithChildren, FlowComponentProps {
+    selectionVariant?: "control" | "navigation";
+}
+export declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<never>>;
+export default MenuItem;

package/dist/types/components/MenuItem/MenuItemContent.d.ts

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from 'react';
+
+import type * as Aria from "react-aria-components";
+interface Props extends Aria.MenuItemRenderProps, PropsWithChildren {
+    selectionVariant?: "control" | "navigation";
+}
+export declare const MenuItemContent: FC<Props>;
+export {};

package/dist/types/components/MenuItem/index.d.ts

@@ -0,0 +1,4 @@
+import { MenuItem } from './MenuItem';
+
+export { MenuItem, type MenuItemProps } from './MenuItem';
+export default MenuItem;

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

@@ -0,0 +1,15 @@
+import { PropsWithChildren, default as React } from 'react';
+import { OverlayController } from '../../lib/controller/overlay';
+import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
+import { PropsWithClassName } from '../../lib/types/props';
+
+export interface ModalProps extends PropsWithChildren, FlowComponentProps, PropsWithClassName {
+    /** @default "s" */
+    size?: "s" | "m";
+    offCanvas?: boolean;
+    controller?: OverlayController;
+    slot?: string;
+    isDismissable?: boolean;
+}
+export declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<never>>;
+export default Modal;

package/dist/types/components/Modal/components/ModalTrigger/ModalTrigger.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { OverlayTriggerProps } from '../../../OverlayTrigger';
+
+export declare const ModalTrigger: FC<OverlayTriggerProps>;

package/dist/types/components/Modal/components/ModalTrigger/index.d.ts

@@ -0,0 +1,4 @@
+import { ModalTrigger } from './ModalTrigger';
+
+export * from './ModalTrigger';
+export default ModalTrigger;

package/dist/types/components/Modal/index.d.ts

@@ -0,0 +1,5 @@
+import { Modal } from './Modal';
+
+export * from './components/ModalTrigger';
+export { type ModalProps, Modal } from './Modal';
+export default Modal;

package/dist/types/components/Modal/stories/Default.stories.d.ts

@@ -0,0 +1,14 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as Modal } from '..';
+
+declare const meta: Meta<typeof Modal>;
+export default meta;
+type Story = StoryObj<typeof Modal>;
+export declare const Default: Story;
+export declare const WithController: Story;
+export declare const WithTrigger: Story;
+export declare const Mobile: Story;
+export declare const OffCanvas: Story;
+export declare const OffCanvasMobile: Story;
+export declare const WithForm: Story;
+export declare const OffCanvasWithForm: Story;

package/dist/types/components/Modal/stories/EdgeCases.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as Modal } from '../Modal';
+
+declare const meta: Meta<typeof Modal>;
+export default meta;
+type Story = StoryObj<typeof Modal>;
+export declare const LongContent: Story;
+export declare const LongContentOffCanvas: Story;

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

@@ -0,0 +1,10 @@
+import { FC, PropsWithChildren } from 'react';
+import { OverlayController } from '../../lib/controller';
+
+export interface ModalOverlayProps extends PropsWithChildren {
+    controller?: OverlayController;
+    isDismissable?: boolean;
+    className?: string;
+}
+export declare const ModalOverlay: FC<ModalOverlayProps>;
+export default ModalOverlay;

package/dist/types/components/ModalOverlay/index.d.ts

@@ -0,0 +1,4 @@
+import { ModalOverlay } from './ModalOverlay';
+
+export { type ModalOverlayProps, ModalOverlay } from './ModalOverlay';
+export default ModalOverlay;

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

@@ -0,0 +1,7 @@
+import { ComponentProps, FC, PropsWithChildren } from 'react';
+import { PropsWithClassName } from '../../lib/types/props';
+
+export interface NavigationProps extends PropsWithChildren<ComponentProps<"nav">>, PropsWithClassName {
+}
+export declare const Navigation: FC<NavigationProps>;
+export default Navigation;

package/dist/types/components/Navigation/components/NavigationGroup/NavigationGroup.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps, FC, PropsWithChildren } from 'react';
+
+export interface NavigationGroupProps extends PropsWithChildren<ComponentProps<"section">> {
+    collapsable?: boolean;
+}
+export declare const NavigationGroup: FC<NavigationGroupProps>;
+export default NavigationGroup;

package/dist/types/components/Navigation/components/NavigationGroup/index.d.ts

@@ -0,0 +1,4 @@
+import { NavigationGroup } from './NavigationGroup';
+
+export { NavigationGroup, type NavigationGroupProps } from './NavigationGroup';
+export default NavigationGroup;

package/dist/types/components/Navigation/index.d.ts

@@ -0,0 +1,5 @@
+import { Navigation } from './Navigation';
+
+export { Navigation, type NavigationProps } from './Navigation';
+export * from './components/NavigationGroup';
+export default Navigation;

package/dist/types/components/Navigation/stories/Default.stories.d.ts

@@ -0,0 +1,11 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Navigation } from '..';
+
+declare const meta: Meta<typeof Navigation>;
+export default meta;
+type Story = StoryObj<typeof Navigation>;
+export declare const Default: Story;
+export declare const WithIcons: Story;
+export declare const WithGroups: Story;
+export declare const WithSeparator: Story;
+export declare const WithCollapsableGroups: Story;

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

@@ -0,0 +1,11 @@
+import { ComponentProps, FC, PropsWithChildren } from 'react';
+import { PropsWithStatus } from '../../lib/types/props';
+
+export interface NotificationProps extends PropsWithChildren<ComponentProps<"div">>, PropsWithStatus {
+    href?: string;
+    autoClose?: boolean;
+    onClick?: () => void;
+    onClose?: () => void;
+}
+export declare const Notification: FC<NotificationProps>;
+export default Notification;

package/dist/types/components/Notification/index.d.ts

@@ -0,0 +1,4 @@
+import { Notification } from './Notification';
+
+export { type NotificationProps, Notification } from './Notification';
+export default Notification;

package/dist/types/components/Notification/stories/Default.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Notification } from '..';
+
+declare const meta: Meta<typeof Notification>;
+export default meta;
+type Story = StoryObj<typeof Notification>;
+export declare const Default: Story;
+export declare const WithoutLink: Story;

package/dist/types/components/Notification/stories/EdgeCases.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Notification } from '..';
+
+declare const meta: Meta<typeof Notification>;
+export default meta;
+type Story = StoryObj<typeof Notification>;
+export declare const LongTexts: Story;

package/dist/types/components/Notification/stories/Variants.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Notification } from '..';
+
+declare const meta: Meta<typeof Notification>;
+export default meta;
+type Story = StoryObj<typeof Notification>;
+export declare const Info: Story;
+export declare const Warning: Story;
+export declare const Danger: Story;
+export declare const Success: Story;

package/dist/types/components/NotificationProvider/ControlledNotification.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { NotificationController, NotificationData } from './NotificationController';
+
+interface Props {
+    notification: NotificationData;
+    controller: NotificationController;
+}
+export declare const ControlledNotification: FC<Props>;
+export default ControlledNotification;

package/dist/types/components/NotificationProvider/NotificationContainer.d.ts

@@ -0,0 +1,5 @@
+import { ComponentProps, FC } from 'react';
+
+export type NotificationsContainerProps = ComponentProps<"div">;
+export declare const NotificationContainer: FC<NotificationsContainerProps>;
+export default NotificationContainer;