@mittwald/flow-react-components 0.1.0-alpha.31 → 0.1.0-alpha.310

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

@@ -0,0 +1,47 @@
+import { PropertyRecord } from '../types';
+import { FilterMode } from '../filter/types';
+import { AsyncResource } from '@mittwald/react-use-promise';
+import { SearchValue } from '../search/types';
+import { DependencyList } from 'react';
+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>>;
+export 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>;
+    dependencies?: DependencyList;
+} & DynamicLoaderShape;
+export type DataSource<T> = StaticDataLoaderShape<T> | AsyncResourceFactoryDataLoaderShape<T> | AsyncDataLoaderShape<T>;
+export interface IncrementalLoaderShape<T> {
+    source?: DataSource<T>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+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/js/types/components/List/model/pagination/types.d.ts

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

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

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

package/dist/js/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;
+    defaultValue?: string;
+}
+export {};

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

@@ -0,0 +1,19 @@
+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/js/types/components/List/model/sorting/types.d.ts

@@ -0,0 +1,9 @@
+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/js/types/components/List/model/table/Table.d.ts

@@ -0,0 +1,11 @@
+import { TableShape, TableSupportedComponentProps } from './types';
+import { default as List } from '../List';
+import { TableHeader } from './TableHeader';
+import { TableBody } from './TableBody';
+export declare class Table<T> {
+    readonly list: List<T>;
+    readonly header: TableHeader<T>;
+    readonly body: TableBody<T>;
+    readonly componentProps: TableSupportedComponentProps;
+    constructor(list: List<T>, shape?: TableShape<T>);
+}

package/dist/js/types/components/List/model/table/TableBody.d.ts

@@ -0,0 +1,9 @@
+import { Table } from './Table';
+import { TableBodyShape, TableBodySupportedComponentProps } from './types';
+import { TableRow } from './TableRow';
+export declare class TableBody<T> {
+    readonly table: Table<T>;
+    readonly componentProps: TableBodySupportedComponentProps;
+    readonly row: TableRow<T>;
+    constructor(table: Table<T>, shape?: TableBodyShape<T>);
+}

package/dist/js/types/components/List/model/table/TableCell.d.ts

@@ -0,0 +1,9 @@
+import { TableCellShape, TableCellSupportedComponentProps } from './types';
+import { TableRow } from './TableRow';
+import { RenderItemFn } from '../..';
+export declare class TableCell<T> {
+    readonly row: TableRow<T>;
+    readonly renderFn?: RenderItemFn<T>;
+    readonly componentProps: TableCellSupportedComponentProps;
+    constructor(row: TableRow<T>, shape?: TableCellShape<T>);
+}

package/dist/js/types/components/List/model/table/TableColumn.d.ts

@@ -0,0 +1,7 @@
+import { TableColumnShape, TableColumnSupportedComponentProps } from './types';
+import { TableHeader } from './TableHeader';
+export declare class TableColumn<T> {
+    readonly tableHeader: TableHeader<T>;
+    readonly componentProps: TableColumnSupportedComponentProps;
+    constructor(tableHeader: TableHeader<T>, shape?: TableColumnShape);
+}

package/dist/js/types/components/List/model/table/TableHeader.d.ts

@@ -0,0 +1,9 @@
+import { Table } from './Table';
+import { TableHeaderShape, TableHeaderSupportedComponentProps } from './types';
+import { TableColumn } from './TableColumn';
+export declare class TableHeader<T> {
+    readonly table: Table<T>;
+    readonly componentProps: TableHeaderSupportedComponentProps;
+    readonly columns: TableColumn<T>[];
+    constructor(table: Table<T>, shape?: TableHeaderShape);
+}

package/dist/js/types/components/List/model/table/TableRow.d.ts

@@ -0,0 +1,9 @@
+import { TableRowShape, TableRowSupportedComponentProps } from './types';
+import { TableCell } from './TableCell';
+import { TableBody } from './TableBody';
+export declare class TableRow<T> {
+    readonly tableBody: TableBody<T>;
+    readonly cells: TableCell<T>[];
+    readonly componentProps: TableRowSupportedComponentProps;
+    constructor(tableBody: TableBody<T>, shape?: TableRowShape<T>);
+}

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

@@ -0,0 +1,32 @@
+import { PropsWithChildren } from 'react';
+import { TableBodyProps, TableCellProps, TableColumnProps, TableHeaderProps, TableProps, TableRowProps } from '../../../Table';
+import { RenderItemFn } from '../..';
+/** Cell */
+export type TableCellSupportedComponentProps = Omit<TableCellProps, "children">;
+export interface TableCellShape<T> extends TableCellSupportedComponentProps {
+    renderFn?: RenderItemFn<T>;
+}
+/** Row */
+export type TableRowSupportedComponentProps = Omit<TableRowProps, "onAction" | "children">;
+export interface TableRowShape<T> extends TableRowSupportedComponentProps, PropsWithChildren {
+    cells?: TableCellShape<T>[];
+}
+/** Column */
+export type TableColumnSupportedComponentProps = TableColumnProps;
+export type TableColumnShape = TableColumnSupportedComponentProps;
+/** Header */
+export type TableHeaderSupportedComponentProps = Omit<TableHeaderProps, "columns">;
+export interface TableHeaderShape extends TableHeaderSupportedComponentProps {
+    columns?: TableColumnShape[];
+}
+/** Body */
+export type TableBodySupportedComponentProps = TableBodyProps;
+export interface TableBodyShape<T> extends TableBodySupportedComponentProps {
+    row?: TableRowShape<T>;
+}
+/** Table */
+export type TableSupportedComponentProps = TableProps;
+export interface TableShape<T> extends TableSupportedComponentProps {
+    header?: TableHeaderShape;
+    body?: TableBodyShape<T>;
+}

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

@@ -0,0 +1,41 @@
+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';
+import { default as List } from './List';
+import { TableShape } from './table/types';
+import { MultipleSelection, SelectionBehavior } from '@react-types/shared';
+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 type OnListChanged<T> = (list: List<T>) => void;
+export interface ListSupportedComponentProps extends MultipleSelection {
+    "aria-labelledby"?: string;
+    "aria-label"?: string;
+    selectionBehavior?: SelectionBehavior;
+}
+export interface ListShape<T> extends ListSupportedComponentProps {
+    settingStorageKey?: string;
+    loader?: IncrementalLoaderShape<T>;
+    filters?: FilterShape<T, never, never>[];
+    itemView?: ItemViewShape<T>;
+    search?: SearchShape<T>;
+    sorting?: SortingShape<T>[];
+    batchesController?: BatchesControllerShape;
+    table?: TableShape<T>;
+    onAction?: ItemActionFn<T>;
+    getItemId?: GetItemId<T>;
+    onChange?: OnListChanged<T>;
+    defaultViewMode?: ListViewMode;
+}
+export type PropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;
+export type ListViewMode = "table" | "list";
+export type ItemActionFn<T> = (data: T) => void;
+export type GetItemId<T> = (data: T) => string;

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

@@ -0,0 +1,9 @@
+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/js/types/components/List/setupComponents/ListItem.d.ts

@@ -0,0 +1,9 @@
+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/js/types/components/List/setupComponents/ListLoaderAsync.d.ts

@@ -0,0 +1,8 @@
+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/js/types/components/List/setupComponents/ListLoaderAsyncResource.d.ts

@@ -0,0 +1,8 @@
+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/js/types/components/List/setupComponents/ListSearch.d.ts

@@ -0,0 +1,8 @@
+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/js/types/components/List/setupComponents/ListSorting.d.ts

@@ -0,0 +1,6 @@
+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/js/types/components/List/setupComponents/ListStaticData.d.ts

@@ -0,0 +1,7 @@
+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/js/types/components/List/setupComponents/Table.d.ts

@@ -0,0 +1,6 @@
+import { ComponentType } from 'react';
+import { TableShape } from '../model/table/types';
+type Props<T> = Omit<TableShape<T>, "header" | "body">;
+export declare const Table: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTable: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/types/components/List/setupComponents/TableBody.d.ts

@@ -0,0 +1,6 @@
+import { ComponentType } from 'react';
+import { TableBodyShape } from '../model/table/types';
+type Props<IgnoredT> = TableBodyShape<IgnoredT>;
+export declare const TableBody: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableBody: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/types/components/List/setupComponents/TableCell.d.ts

@@ -0,0 +1,9 @@
+import { ComponentType } from 'react';
+import { TableCellShape } from '../model/table/types';
+import { RenderItemFn } from '..';
+type Props<T> = Omit<TableCellShape<T>, "renderFn"> & {
+    children: RenderItemFn<T>;
+};
+export declare const TableCell: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableCell: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/types/components/List/setupComponents/TableColumn.d.ts

@@ -0,0 +1,6 @@
+import { ComponentType } from 'react';
+import { TableColumnShape } from '../model/table/types';
+type Props<IgnoredT> = TableColumnShape;
+export declare const TableColumn: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableColumn: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/types/components/List/setupComponents/TableHeader.d.ts

@@ -0,0 +1,6 @@
+import { ComponentType } from 'react';
+import { TableHeaderShape } from '../model/table/types';
+type Props<IgnoredT> = TableHeaderShape;
+export declare const TableHeader: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableHeader: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/types/components/List/setupComponents/TableRow.d.ts

@@ -0,0 +1,6 @@
+import { ComponentType } from 'react';
+import { TableRowShape } from '../model/table/types';
+type Props<T> = Omit<TableRowShape<T>, "cells">;
+export declare const TableRow: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableRow: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/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;
+export declare const WithSummary: Story;

package/dist/js/types/components/List/stories/EdgeCases.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 LoadingListItem: Story;
+export declare const LoadingTableCell: Story;

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

@@ -0,0 +1,11 @@
+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/js/types/components/List/testData/domainApi.d.ts

@@ -0,0 +1,27 @@
+export interface Domain {
+    id: string;
+    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/js/types/components/List/typedList.d.ts

@@ -0,0 +1,94 @@
+import { ListProps } from './List';
+import { ComponentType } from 'react';
+export declare const TypedList: <T>() => ComponentType<ListProps<T>>;
+export declare const typedList: <T>() => {
+    List: ComponentType<ListProps<T>>;
+    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: 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: ComponentType<import('./model/sorting/types').SortingShape<T>>;
+    Item: 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;
+    TableHeader: (ignoredProps: import('./model/table/types').TableHeaderShape) => null;
+    TableColumn: (ignoredProps: import('react-aria-components').ColumnProps) => null;
+    TableBody: (ignoredProps: import('./model/table/types').TableBodyShape<T>) => null;
+    TableRow: (ignoredProps: {
+        footer?: boolean | undefined;
+        style?: import('react').CSSProperties | ((values: import('react-aria-components').RowRenderProps & {
+            defaultStyle: import('react').CSSProperties;
+        }) => import('react').CSSProperties | undefined) | undefined;
+        value?: undefined;
+        children?: import('react').ReactNode | undefined;
+        className?: string | ((values: import('react-aria-components').RowRenderProps & {
+            defaultClassName: string | undefined;
+        }) => string) | undefined;
+        id?: import('react-aria').Key | undefined;
+        target?: import('react').HTMLAttributeAnchorTarget | undefined;
+        href?: import('@react-types/shared').Href | undefined;
+        rel?: string | undefined;
+        isDisabled?: boolean | undefined;
+        onHoverStart?: ((e: import('react-aria').HoverEvent) => void) | undefined;
+        onHoverEnd?: ((e: import('react-aria').HoverEvent) => void) | undefined;
+        onHoverChange?: ((isHovering: boolean) => void) | undefined;
+        hrefLang?: string | undefined;
+        download?: (boolean | string) | undefined;
+        ping?: string | undefined;
+        referrerPolicy?: import('react').HTMLAttributeReferrerPolicy | undefined;
+        routerOptions?: import('@react-types/shared').RouterOptions | undefined;
+        textValue?: string | undefined;
+        dependencies?: any[] | undefined;
+        columns?: Iterable<never> | undefined;
+    }) => null;
+    TableCell: (ignoredProps: Omit<import('./model/table/types').TableCellShape<T>, "renderFn"> & {
+        children: import('.').RenderItemFn<T>;
+    }) => null;
+    Table: (ignoredProps: {
+        slot?: (string | null) | undefined;
+        style?: import('react').CSSProperties | ((values: import('react-aria-components').TableRenderProps & {
+            defaultStyle: import('react').CSSProperties;
+        }) => import('react').CSSProperties | undefined) | undefined;
+        children?: import('react').ReactNode;
+        className?: string | ((values: import('react-aria-components').TableRenderProps & {
+            defaultClassName: string | undefined;
+        }) => string) | undefined;
+        'aria-describedby'?: string | undefined;
+        'aria-details'?: string | undefined;
+        'aria-label'?: string | undefined;
+        'aria-labelledby'?: string | undefined;
+        onScroll?: ((e: import('react').UIEvent<HTMLTableElement, UIEvent>) => void) | undefined;
+        selectedKeys?: ("all" | Iterable<import('react-aria').Key>) | undefined;
+        defaultSelectedKeys?: ("all" | Iterable<import('react-aria').Key>) | undefined;
+        onSelectionChange?: ((keys: import('react-stately').Selection) => void) | undefined;
+        disabledKeys?: Iterable<import('react-aria').Key> | undefined;
+        selectionMode?: import('react-stately').SelectionMode | undefined;
+        disallowEmptySelection?: boolean | undefined;
+        selectionBehavior?: import('react-stately').SelectionBehavior | undefined;
+        dragAndDropHooks?: import('react-aria-components').DragAndDropHooks | undefined;
+        sortDescriptor?: import('react-stately').SortDescriptor | undefined;
+        onSortChange?: ((descriptor: import('react-stately').SortDescriptor) => any) | undefined;
+        verticalAlign?: ("top" | "middle") | undefined;
+        disabledBehavior?: import('react-stately').DisabledBehavior | undefined;
+        onRowAction?: ((key: import('react-aria').Key) => void) | undefined;
+    }) => null;
+    StaticData: ComponentType<{
+        data: readonly T[];
+    }>;
+    LoaderAsync: ComponentType<Omit<import('./model/loading/types').AsyncDataLoaderShape<T>, "asyncLoader"> & {
+        children: import('.').AsyncDataLoader<T>;
+    }>;
+    LoaderAsyncResource: ComponentType<Omit<import('./model/loading/types').AsyncResourceFactoryDataLoaderShape<T>, "asyncResourceFactory"> & {
+        children: import('.').AsyncResourceFactory<T>;
+    }>;
+};

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+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/js/types/components/MenuItem/MenuItem.d.ts

@@ -0,0 +1,8 @@
+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/js/types/components/MenuItem/MenuItemContent.d.ts

@@ -0,0 +1,7 @@
+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/js/types/components/MenuItem/index.d.ts

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

package/dist/js/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;
+    offCanvasOrientation?: "left" | "right";
+    controller?: OverlayController;
+    slot?: string;
+    isDismissable?: boolean;
+}
+export declare const Modal: React.ForwardRefExoticComponent<ModalProps & React.RefAttributes<never>>;
+export default Modal;

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

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

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

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

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

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