@mittwald/flow-react-components 0.1.0-alpha.33 → 0.1.0-alpha.331

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

@@ -0,0 +1,13 @@
+import { PropertyName, PropertyValue, PropertyValueRenderMethod } from '../types';
+import { ItemType } from '../../../../lib/types/array';
+export type FilterMode = "all" | "some" | "one";
+export type FilterMatcher<T, P, TMatcherValue> = (filterBy: NonNullable<ItemType<TMatcherValue>>, filterFrom: PropertyValue<T, P>) => boolean;
+export interface FilterShape<T, TProp extends PropertyName<T>, TMatcherValue> {
+    property: TProp;
+    renderItem?: PropertyValueRenderMethod<TMatcherValue>;
+    mode?: FilterMode;
+    matcher?: FilterMatcher<T, TProp, TMatcherValue>;
+    values?: readonly TMatcherValue[];
+    name?: string;
+    defaultSelected?: readonly NonNullable<ItemType<TMatcherValue>>[];
+}

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

@@ -0,0 +1,9 @@
+import { ItemCollection } from './ItemCollection';
+import { Row } from '@tanstack/react-table';
+export declare class Item<T> {
+    readonly id: string;
+    readonly data: T;
+    readonly collection: ItemCollection<T>;
+    constructor(collection: ItemCollection<T>, id: string, data: T);
+    static fromRow<T>(collection: ItemCollection<T>, row: Row<T>): Item<T>;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { ReactElement, ReactNode } from 'react';
+import { RenderItemFn } from './types';
+import { default as List } from '../List';
+export interface ItemViewShape<T> {
+    textValue?: (data: T) => string;
+    href?: (data: T) => string;
+    renderFn?: RenderItemFn<T>;
+    fallback?: ReactElement;
+}
+export declare class ItemView<T> {
+    readonly list: List<T>;
+    readonly textValue?: (data: T) => string;
+    readonly href?: (data: T) => string;
+    readonly fallback?: ReactElement;
+    private readonly renderFn?;
+    constructor(list: List<T>, shape?: ItemViewShape<T>);
+    render(data: T): ReactNode;
+    private static fallbackRenderItemFn;
+}

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

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

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

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

@@ -0,0 +1,20 @@
+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/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 {};