@mittwald/flow-react-components 0.1.0-alpha.13 → 0.1.0-alpha.131

package/dist/types/components/List/components/Footer/PaginationInfos/PaginationInfos.d.ts

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

package/dist/types/components/List/components/Footer/PaginationInfos/index.d.ts

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

package/dist/types/components/List/components/Footer/ShowNextBatchButton/ShowNextBatchButton.d.ts

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

package/dist/types/components/List/components/Footer/ShowNextBatchButton/index.d.ts

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

package/dist/types/components/List/components/Header/ActiveFilters/ActiveFilters.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+
+export declare const ActiveFilters: FC;
+export default ActiveFilters;

package/dist/types/components/List/components/Header/ActiveFilters/index.d.ts

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

package/dist/types/components/List/components/Header/FilterPicker/FilterPicker.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { Filter } from '../../../model/filter/Filter';
+import { AnyData } from '../../../model/item/types';
+
+interface Props {
+    filter: Filter<AnyData>;
+}
+export declare const FilterPicker: FC<Props>;
+export {};

package/dist/types/components/List/components/Header/FilterPicker/index.d.ts

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

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

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { PropsWithClassName } from '../../../../../lib/types/props';
+
+type Props = PropsWithClassName;
+export declare const Header: FC<Props>;
+export default Header;

package/dist/types/components/List/components/Header/Header/index.d.ts

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

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

@@ -0,0 +1,5 @@
+import { FilterShape } from '../../model/filter/types';
+
+type Props<T> = Omit<FilterShape<T>, "type">;
+export declare function ListFilter<T = never>(ignoredProps: Props<T>): null;
+export {};

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

@@ -0,0 +1,7 @@
+import { SortingShape } from '../../model/sorting/types';
+
+interface Props<T> extends SortingShape<T> {
+    defaultEnabled?: boolean;
+}
+export declare function ListSorting<T = never>(ignoredProps: Props<T>): null;
+export {};

package/dist/types/components/List/components/Header/SortingPicker/SortingPicker.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+
+export declare const SortingPicker: FC;

package/dist/types/components/List/components/Header/SortingPicker/index.d.ts

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

package/dist/types/components/List/components/Header/SortingPickerItem/SortingPickerItem.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { AnyData } from '../../../model/item/types';
+import { Sorting } from '../../../model/sorting/Sorting';
+
+interface Props {
+    sorting: Sorting<AnyData>;
+}
+export declare const SortingPickerItem: FC<Props>;
+export {};

package/dist/types/components/List/components/Header/SortingPickerItem/index.d.ts

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

package/dist/types/components/List/components/Items/ItemList/ItemList.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { PropsWithClassName } from '../../../../../lib/types/props';
+
+type Props = PropsWithClassName;
+export declare const ItemList: FC<Props>;
+export default ItemList;

package/dist/types/components/List/components/Items/ItemList/index.d.ts

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

package/dist/types/components/List/components/Items/ItemSkeleton/ItemSkeleton.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+
+export declare const ItemSkeleton: FC;

package/dist/types/components/List/components/Items/ListItem/FallbackRenderer.d.ts

@@ -0,0 +1,8 @@
+import { AnyData } from '../../../model/item/types';
+import { FC } from 'react';
+
+interface Props {
+    data: AnyData;
+}
+export declare const FallbackRenderer: FC<Props>;
+export {};

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

@@ -0,0 +1,6 @@
+import { PropsWithChildren, default as React } from 'react';
+import { LinkDOMProps } from '@react-types/shared';
+
+type Props = PropsWithChildren & LinkDOMProps;
+export declare const ListItem: (props: Props) => React.JSX.Element;
+export default ListItem;

package/dist/types/components/List/components/Items/ListItem/index.d.ts

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

package/dist/types/components/List/components/Items/ListItemView.d.ts

@@ -0,0 +1,7 @@
+import { RenderItemFn } from '../../model/item/Item';
+
+interface Props<T> {
+    children: RenderItemFn<T>;
+}
+export declare function ListItemView<T = never>(ignoredProps: Props<T>): null;
+export {};

package/dist/types/components/List/components/Items/OptionsButton/OptionsButton.d.ts

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

package/dist/types/components/List/components/Items/OptionsButton/index.d.ts

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

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

@@ -0,0 +1,7 @@
+import { AsyncDataLoaderShape } from '../model/loading/types';
+
+interface Props<T> extends Omit<AsyncDataLoaderShape<T>, "asyncLoader"> {
+    children: AsyncDataLoaderShape<T>["asyncLoader"];
+}
+export declare function ListLoaderAsync<T = never>(ignoredProps: Props<T>): null;
+export {};

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

@@ -0,0 +1,7 @@
+import { AsyncResourceFactoryDataLoaderShape } from '../model/loading/types';
+
+interface Props<T> extends Omit<AsyncResourceFactoryDataLoaderShape<T>, "asyncResourceFactory"> {
+    children: AsyncResourceFactoryDataLoaderShape<T>["asyncResourceFactory"];
+}
+export declare function ListLoaderAsyncResource<T = never>(ignoredProps: Props<T>): null;
+export {};

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

@@ -0,0 +1,5 @@
+interface Props<T> {
+    data: T[];
+}
+export declare function ListStaticData<T = never>(ignoredProps: Props<T>): null;
+export {};

package/dist/types/components/List/hooks/useList.d.ts

@@ -0,0 +1 @@
+export declare const useList: () => import('../model/List').List<any>;

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

@@ -0,0 +1,10 @@
+import { List } from './List';
+
+export * from './List';
+export * from './components/Header/ListFilter';
+export * from './components/Header/ListSorting';
+export * from './components/Items/ListItemView';
+export * from './components/Items/ListItem';
+export * from './components/ListLoaderAsync';
+export * from './components/ListStaticData';
+export default List;

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

@@ -0,0 +1,8 @@
+import { default as List } from './model/List';
+import { AnyData } from './model/item/types';
+
+interface ListContext {
+    list: List<AnyData>;
+}
+export declare const listContext: import('react').Context<ListContext>;
+export {};

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

@@ -0,0 +1,26 @@
+import { ItemCollection } from './item/ItemCollection';
+import { BatchesController } from './pagination/BatchesController';
+import { PropertyName, RenderItemFn } from './item/Item';
+import { Filter } from './filter/Filter';
+import { Sorting } from './sorting/Sorting';
+import { default as ReactTable } from './ReactTable';
+import { ListShape } from './types';
+import { IncrementalLoader } from './loading/IncrementalLoader';
+
+export declare class List<T> {
+    readonly filters: Filter<T>[];
+    readonly sorting: Sorting<T>[];
+    readonly items: ItemCollection<T>;
+    readonly render?: RenderItemFn<T>;
+    readonly reactTable: ReactTable<T>;
+    readonly batches: BatchesController<T>;
+    readonly loader: IncrementalLoader<T>;
+    private constructor();
+    static useNew<T>(shape: ListShape<T>): List<T>;
+    isFiltered(): boolean;
+    getSorting(property: PropertyName<T>): Sorting<T>;
+    clearSorting(): void;
+    clearFilters(): void;
+    useIsEmpty(): boolean;
+}
+export default List;

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

@@ -0,0 +1,18 @@
+import { Column, Table, TableOptions } from '@tanstack/react-table';
+import { default as List } from './List';
+import { PropertyName } from './item/Item';
+
+export declare class ReactTable<T> {
+    readonly list: List<T>;
+    readonly table: Table<T>;
+    private readonly tableState;
+    private constructor();
+    static useNew<T>(list: List<T>, tableOptions?: Partial<TableOptions<T>>): ReactTable<T>;
+    private useReactTable;
+    private useUpdateTableState;
+    private onTableStateChange;
+    private getUpdatedTableState;
+    getTableColumn(property: PropertyName<T>): Column<T>;
+    private getTableColumnDefs;
+}
+export default ReactTable;

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

@@ -0,0 +1,31 @@
+import { Column, ColumnDef, ColumnFilter } from '@tanstack/react-table';
+import { default as List } from '../List';
+import { PropertyName } from '../item/Item';
+import { FilterMatcher, FilterMode, FilterShape } from './types';
+
+export declare class Filter<T> {
+    private readonly _values?;
+    readonly list: List<T>;
+    readonly property: PropertyName<T>;
+    readonly mode: FilterMode;
+    readonly matcher: FilterMatcher;
+    readonly name?: string;
+    private onFilterUpdateCallbacks;
+    constructor(list: List<T>, shape: FilterShape<T>);
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    private getReactTableFilterFn;
+    private checkFilterMatches;
+    protected getTableColumnFilter(): ColumnFilter | undefined;
+    protected getTableColumn(): Column<T>;
+    getValue(): unknown;
+    getValueId(value: unknown): string;
+    get values(): unknown[];
+    getArrayValue(): unknown[];
+    isValueActive(value: unknown): boolean;
+    isActive(): boolean;
+    activateValue(newValue: unknown): void;
+    deactivateValue(newValue: unknown): void;
+    clearValues(): void;
+    toggleValue(newValue: unknown): void;
+    onFilterUpdated(cb: () => unknown): void;
+}

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

@@ -0,0 +1,11 @@
+import { PropertyName } from '../item/Item';
+
+export type FilterMode = "all" | "some" | "one";
+export type FilterMatcher = (filterValue: unknown, property: unknown) => boolean;
+export interface FilterShape<T> {
+    property: PropertyName<T>;
+    mode?: FilterMode;
+    matcher?: FilterMatcher;
+    values?: unknown[];
+    name?: string;
+}

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

@@ -0,0 +1,15 @@
+import { ItemCollection } from './ItemCollection';
+import { ReactNode } from 'react';
+import { DeepKeys, Row } from '@tanstack/react-table';
+
+export type PropertyName<T> = DeepKeys<T>;
+export type RenderItemFn<T> = (data: T) => ReactNode;
+export declare class Item<T> {
+    readonly id: string;
+    readonly data: T;
+    readonly collection: ItemCollection<T>;
+    constructor(collection: ItemCollection<T>, id: string, data: T);
+    render(): ReactNode;
+    static fromRow<T>(collection: ItemCollection<T>, row: Row<T>): Item<T>;
+    private static fallbackRenderItemFn;
+}

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

@@ -0,0 +1,9 @@
+import { default as List } from '../List';
+import { Item } from './Item';
+
+export declare class ItemCollection<T> {
+    readonly list: List<T>;
+    private constructor();
+    static useNew<T>(list: List<T>): ItemCollection<T>;
+    get entries(): Item<T>[];
+}

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

@@ -0,0 +1,5 @@
+export type AnyData = any;
+export interface ListDataLoaderResult<T> {
+    data: T[];
+    itemTotalCount?: number;
+}

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,20 @@
+import { AsyncResource } from '@mittwald/react-use-promise';
+
+type AsyncResourceLoadingState = AsyncResource["state"]["value"];
+type DataBatches<T> = 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: 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,44 @@
+import { PropertyRecord } from '../types';
+import { FilterMode } from '../filter/types';
+import { AsyncResource } from '@mittwald/react-use-promise';
+
+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>;
+    pagination?: DataLoaderPaginationOptions;
+}
+export interface DataLoaderResult<T> {
+    data: T[];
+    itemTotalCount?: number;
+}
+export type AsyncDataLoader<T> = (options?: DataLoaderOptions<T>) => Promise<DataLoaderResult<T>>;
+type AsyncResourceFactory<T> = (options?: DataLoaderOptions<T>) => AsyncResource<DataLoaderResult<T>>;
+type StaticData<T> = T[];
+interface DynamicLoaderShape {
+    manualSorting?: boolean;
+    manualFiltering?: boolean;
+    manualPagination?: boolean;
+}
+export interface StaticDataLoaderShape<T> {
+    staticData: StaticData<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,17 @@
+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 | undefined;
+    getFilteredItemsCount(): number;
+    getVisibleItemsCount(): number | undefined;
+    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/sorting/Sorting.d.ts

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

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

@@ -0,0 +1,9 @@
+import { PropertyName } from '../item/Item';
+import { SortDirection } from '@tanstack/react-table';
+
+export interface SortingShape<T> {
+    property: PropertyName<T>;
+    name?: string;
+    direction?: SortDirection;
+    defaultEnabled?: boolean;
+}

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

@@ -0,0 +1,14 @@
+import { PropertyName, RenderItemFn } from './item/Item';
+import { SortingShape } from './sorting/types';
+import { BatchesControllerShape } from './pagination/types';
+import { FilterShape } from './filter/types';
+import { IncrementalLoaderShape } from './loading/types';
+
+export interface ListShape<T> {
+    loader?: IncrementalLoaderShape<T>;
+    render?: RenderItemFn<T>;
+    filters?: FilterShape<T>[];
+    sorting?: SortingShape<T>[];
+    batchesController?: BatchesControllerShape;
+}
+export type PropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;

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

@@ -0,0 +1,8 @@
+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 ItemsWithLink: 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 WithLink: Story;
+export declare const WithButton: Story;
+export declare const SmallSpace: Story;

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

@@ -0,0 +1,25 @@
+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[];
+    };
+}
+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/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<"MenuItem"> {
+    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,14 @@
+import { PropsWithChildren, default as React } from 'react';
+import { OverlayController } from '../../lib/controller/overlay';
+import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
+
+export interface ModalProps extends PropsWithChildren, FlowComponentProps<"Modal"> {
+    /** @default "s" */
+    size?: "s" | "m" | "l";
+    offCanvas?: boolean;
+    controller?: OverlayController;
+    slot?: string;
+    isDismissable?: boolean;
+}
+export declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<never>>;
+export default Modal;