@nxgt/material 1.0.0

package/dist/lib/components/ui/transfer-list/transfer-list.slice.d.ts

@@ -0,0 +1,110 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { TransferListChromeState, TransferPane } from './types';
+export declare const transferListSlice: import('@reduxjs/toolkit').Slice<TransferListChromeState, {
+    setQuery: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        query: string;
+    }>) => void;
+    setChecked: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        values: string[];
+    }>) => void;
+    toggleChecked: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        value: string;
+    }>) => void;
+    setFocused: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        value: string | null;
+    }>) => void;
+    clearPaneChecked: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<TransferPane>) => void;
+}, "transfer-list", "transfer-list", import('@reduxjs/toolkit').SliceSelectors<TransferListChromeState>>;
+export declare const transferListActions: import('@reduxjs/toolkit').CaseReducerActions<{
+    setQuery: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        query: string;
+    }>) => void;
+    setChecked: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        values: string[];
+    }>) => void;
+    toggleChecked: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        value: string;
+    }>) => void;
+    setFocused: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<{
+        pane: TransferPane;
+        value: string | null;
+    }>) => void;
+    clearPaneChecked: (state: {
+        availableQuery: string;
+        selectedQuery: string;
+        availableChecked: string[];
+        selectedChecked: string[];
+        focusedPane: TransferPane;
+        focusedValue: string | null;
+    }, action: PayloadAction<TransferPane>) => void;
+}, "transfer-list">;

package/dist/lib/components/ui/transfer-list/transfer-list.stories.d.ts

@@ -0,0 +1,27 @@
+import { StoryObj } from '@storybook/react';
+import { TransferList, TransferListItem } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof TransferList;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+    args: {
+        items: TransferListItem[];
+        label: string;
+        defaultValue: string[];
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const Groups: Story;
+export declare const Max: Story;
+export declare const Reorderable: Story;
+export declare const CustomRender: Story;
+export declare const Empty: Story;
+export declare const Disabled: Story;
+export declare const FormField: Story;
+export declare const Dark: Story;
+export declare const I18n: Story;

package/dist/lib/components/ui/transfer-list/transfer-list.stories.data.d.ts

@@ -0,0 +1,3 @@
+import { TransferListItem } from './types';
+export declare const PERMISSIONS: TransferListItem[];
+export declare const PEOPLE: TransferListItem[];

package/dist/lib/components/ui/transfer-list/transfer-list.utils.d.ts

@@ -0,0 +1,20 @@
+import { TransferDropTarget } from './transfer-list.dnd';
+import { SelectAllState, TransferListItem } from './types';
+export declare function partitionItems(items: TransferListItem[], selectedValues: string[]): {
+    available: TransferListItem[];
+    selected: TransferListItem[];
+};
+export declare function matchesQuery(item: TransferListItem, query: string): boolean;
+export declare function filterItems(items: TransferListItem[], query: string): TransferListItem[];
+export declare function groupItems(items: TransferListItem[]): {
+    group: string | null;
+    items: TransferListItem[];
+}[];
+export declare function transferableValues(items: TransferListItem[]): string[];
+export declare function intersect(left: string[], right: string[]): string[];
+export declare function toggleValue(values: string[], value: string): string[];
+export declare function moveToSelected(selected: string[], toMove: string[], max?: number): string[];
+export declare function moveToAvailable(selected: string[], toMove: string[]): string[];
+export declare function reorderSelected(selected: string[], value: string, direction: 'up' | 'down'): string[];
+export declare function applyTransferDrop(selected: string[], dragged: string[], target: TransferDropTarget, max?: number): string[];
+export declare function selectAllState(checkedVisible: string[], transferable: string[]): SelectAllState;

package/dist/lib/components/ui/transfer-list/transfer-list.utils.test.d.ts

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

package/dist/lib/components/ui/transfer-list/types.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+export type TransferPane = 'available' | 'selected';
+export type TransferListItem = {
+    value: string;
+    label: string;
+    subtitle?: string;
+    icon?: ReactNode;
+    group?: string;
+    disabled?: boolean;
+    locked?: boolean;
+};
+export type TransferListItemContext = {
+    pane: TransferPane;
+    checked: boolean;
+};
+export type TransferListTitles = {
+    available?: string;
+    selected?: string;
+};
+export type TransferListRenderItem = (item: TransferListItem, ctx: TransferListItemContext) => ReactNode;
+export type TransferListChromeState = {
+    availableQuery: string;
+    selectedQuery: string;
+    availableChecked: string[];
+    selectedChecked: string[];
+    focusedPane: TransferPane;
+    focusedValue: string | null;
+};
+export type SelectAllState = 'none' | 'some' | 'all';

package/dist/lib/components/ui/transfer-list/use-transfer-list.d.ts

@@ -0,0 +1,52 @@
+import { TransferDropTarget } from './transfer-list.dnd';
+import { TransferListItem, TransferPane } from './types';
+export type UseTransferListOptions = {
+    items: TransferListItem[];
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    max?: number;
+    disabled?: boolean;
+};
+export declare function useTransferList({ items, value, defaultValue, onValueChange, max, disabled, }: UseTransferListOptions): {
+    selectedValues: string[];
+    chrome: import('./types').TransferListChromeState;
+    chromeActions: {
+        setQuery: (payload: {
+            pane: TransferPane;
+            query: string;
+        }) => void;
+        setChecked: (payload: {
+            pane: TransferPane;
+            values: string[];
+        }) => void;
+        toggleChecked: (payload: {
+            pane: TransferPane;
+            value: string;
+        }) => void;
+        setFocused: (payload: {
+            pane: TransferPane;
+            value: string | null;
+        }) => void;
+        clearPaneChecked: (payload: TransferPane) => void;
+    };
+    available: TransferListItem[];
+    selected: TransferListItem[];
+    availableVisible: TransferListItem[];
+    selectedVisible: TransferListItem[];
+    availableTransferable: string[];
+    selectedTransferable: string[];
+    availableChecked: string[];
+    selectedChecked: string[];
+    availableSelectAll: import('./types').SelectAllState;
+    selectedSelectAll: import('./types').SelectAllState;
+    atMax: boolean;
+    remaining: number;
+    disabled: boolean;
+    moveValues: (pane: TransferPane, ids: string[]) => void;
+    toggleChecked: (pane: TransferPane, id: string) => void;
+    selectAll: (pane: TransferPane) => void;
+    reorder: (id: string, direction: "up" | "down") => void;
+    dropValues: (dragged: string[], target: TransferDropTarget) => void;
+};
+export type TransferListModel = ReturnType<typeof useTransferList>;

package/dist/lib/components/ui/tree/index.d.ts

@@ -0,0 +1,6 @@
+export { Tree } from './tree';
+export { findTreeNode, flattenVisibleTree } from './tree.utils';
+export type { TreeItemProps } from './tree-item';
+export { TreeItem } from './tree-item';
+export type { TreeNode, TreeProps, TreeRow, TreeSelectionMode, } from './types';
+export { useTree } from './use-tree';

package/dist/lib/components/ui/tree/tree-item.d.ts

@@ -0,0 +1,11 @@
+import { TreeRow, TreeSelectionMode } from './types';
+export type TreeItemProps = {
+    row: TreeRow;
+    selected: boolean;
+    focused: boolean;
+    selectionMode: TreeSelectionMode;
+    onToggleExpanded: (id: string) => void;
+    onSelect: (id: string) => void;
+    onFocus: (id: string) => void;
+};
+export declare function TreeItem({ row, selected, focused, selectionMode, onToggleExpanded, onSelect, onFocus, }: TreeItemProps): import("react").JSX.Element;

package/dist/lib/components/ui/tree/tree.d.ts

@@ -0,0 +1,3 @@
+import { TreeProps } from './types';
+export type { TreeProps };
+export declare function Tree({ nodes, selectionMode, selectedIds, defaultSelectedIds, onSelectedIdsChange, expandedIds, defaultExpandedIds, onExpandedIdsChange, onSelect, className, 'aria-label': ariaLabel, }: TreeProps): import("react").JSX.Element;

package/dist/lib/components/ui/tree/tree.stories.d.ts

@@ -0,0 +1,16 @@
+import { StoryObj } from '@storybook/react';
+import { Tree } from '../..';
+declare const meta: {
+    title: string;
+    component: typeof Tree;
+    parameters: {
+        layout: string;
+    };
+    tags: string[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const FileExplorer: Story;
+export declare const NestedNavigation: Story;
+export declare const MultiSelect: Story;
+export declare const Dark: Story;

package/dist/lib/components/ui/tree/tree.utils.d.ts

@@ -0,0 +1,4 @@
+import { TreeNode, TreeRow } from './types';
+export declare function findTreeNode(nodes: TreeNode[], id: string): TreeNode | undefined;
+export declare function flattenVisibleTree(nodes: TreeNode[], expandedIds: ReadonlySet<string>, level?: number, parentId?: string | null): TreeRow[];
+export declare function toggleId(ids: string[], id: string): string[];

package/dist/lib/components/ui/tree/tree.utils.test.d.ts

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

package/dist/lib/components/ui/tree/types.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+export type TreeNode = {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    trailing?: ReactNode;
+    disabled?: boolean;
+    children?: TreeNode[];
+};
+export type TreeSelectionMode = 'none' | 'single' | 'multiple';
+export type TreeRow = {
+    id: string;
+    node: TreeNode;
+    level: number;
+    parentId: string | null;
+    expandable: boolean;
+    expanded: boolean;
+};
+export type TreeProps = {
+    nodes: TreeNode[];
+    selectionMode?: TreeSelectionMode;
+    selectedIds?: string[];
+    defaultSelectedIds?: string[];
+    onSelectedIdsChange?: (ids: string[]) => void;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    onExpandedIdsChange?: (ids: string[]) => void;
+    onSelect?: (id: string, node: TreeNode) => void;
+    className?: string;
+    'aria-label'?: string;
+};

package/dist/lib/components/ui/tree/use-tree.d.ts

@@ -0,0 +1,22 @@
+import { KeyboardEvent } from 'react';
+import { TreeNode, TreeSelectionMode } from './types';
+export declare function useTree({ nodes, selectionMode, selectedIds, defaultSelectedIds, onSelectedIdsChange, expandedIds, defaultExpandedIds, onExpandedIdsChange, onSelect, }: {
+    nodes: TreeNode[];
+    selectionMode?: TreeSelectionMode;
+    selectedIds?: string[];
+    defaultSelectedIds?: string[];
+    onSelectedIdsChange?: (ids: string[]) => void;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    onExpandedIdsChange?: (ids: string[]) => void;
+    onSelect?: (id: string, node: TreeNode) => void;
+}): {
+    rows: import('./types').TreeRow[];
+    selected: string[];
+    expanded: string[];
+    focusedId: string | null;
+    setFocusedId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+    toggleExpanded: (id: string) => void;
+    select: (id: string) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+};

package/dist/lib/components/ui/typography.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+import { ComponentProps } from 'react';
+export declare const typographyVariants: (props?: ({
+    variant?: "caption" | "normal" | "huge-larger" | "huge-large" | "huge-medium" | "huge-small" | "headline-larger" | "headline-large" | "headline-medium" | "headline-small" | "title-large" | "title-medium" | "title-small" | "body-medium" | "body-small" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type TypographyProps = ComponentProps<'p'> & VariantProps<typeof typographyVariants>;
+export declare function Typography({ className, variant, ...props }: TypographyProps): import("react").JSX.Element;

package/dist/lib/components/ui/upload/index.d.ts

@@ -0,0 +1,2 @@
+export * from './network-upload-field';
+export * from './s3-upload-field';

package/dist/lib/components/ui/upload/network-upload-field/index.d.ts

@@ -0,0 +1 @@
+export * from './network-upload-field';

package/dist/lib/components/ui/upload/network-upload-field/network-upload-field.d.ts

@@ -0,0 +1,33 @@
+import { ComponentProps, ReactNode } from 'react';
+export type NetworkUploadFieldProps = {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    error?: boolean;
+    disabled?: boolean;
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    onUpload: (file: File, onProgress?: (percent: number) => void) => Promise<string>;
+    onRemove?: (value: string) => void | Promise<void>;
+    onError?: (file: File, error: unknown) => void;
+    /**
+     * Maps a committed value to something an `<img src>` can load, so already
+     * saved images preview as thumbnails instead of a file icon.
+     *
+     * Only needed when the stored value is not itself a URL — a storage key or
+     * an id. Values that already are URLs preview without it. Called on every
+     * render, so keep it pure and cheap; anything that has to be fetched or
+     * signed belongs in the host's own state, not in here.
+     */
+    resolveUrl?: (value: string) => string | null | undefined;
+    name?: string;
+} & Omit<ComponentProps<'div'>, 'children'> & ({
+    mode: 'single';
+    value?: string;
+    onValueChange?: (value?: string | null) => void;
+} | {
+    mode: 'multiple';
+    value: string[];
+    onValueChange?: (value: string[]) => void;
+});
+export declare function NetworkUploadField(props: NetworkUploadFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/upload/network-upload-field/network-upload-field.slice.d.ts

@@ -0,0 +1,249 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+export type LocalFileItem = {
+    id: string;
+    file: File;
+    status: 'uploading' | 'error';
+    progress?: number;
+    errorMessage?: string;
+    replacesValue?: string;
+};
+export type NetworkUploadFieldState = {
+    localItems: LocalFileItem[];
+};
+export declare const networkUploadFieldSlice: import('@reduxjs/toolkit').Slice<NetworkUploadFieldState, {
+    addItem: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<LocalFileItem>) => void;
+    updateProgress: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<{
+        id: string;
+        percent: number;
+    }>) => void;
+    markUploading: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<{
+        id: string;
+        file?: File;
+    }>) => void;
+    markError: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<{
+        id: string;
+        file?: File;
+        errorMessage: string;
+        clearReplacesValue?: boolean;
+    }>) => void;
+    removeItem: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<string>) => void;
+}, "networkUploadField", "networkUploadField", import('@reduxjs/toolkit').SliceSelectors<NetworkUploadFieldState>>;
+export declare const networkUploadFieldActions: import('@reduxjs/toolkit').CaseReducerActions<{
+    addItem: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<LocalFileItem>) => void;
+    updateProgress: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<{
+        id: string;
+        percent: number;
+    }>) => void;
+    markUploading: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<{
+        id: string;
+        file?: File;
+    }>) => void;
+    markError: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<{
+        id: string;
+        file?: File;
+        errorMessage: string;
+        clearReplacesValue?: boolean;
+    }>) => void;
+    removeItem: (state: {
+        localItems: {
+            id: string;
+            file: {
+                lastModified: number;
+                name: string;
+                webkitRelativePath: string;
+                size: number;
+                type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            };
+            status: "uploading" | "error";
+            progress?: number | undefined;
+            errorMessage?: string | undefined;
+            replacesValue?: string | undefined;
+        }[];
+    }, action: PayloadAction<string>) => void;
+}, "networkUploadField">;
+export declare const networkUploadFieldReducer: import('redux').Reducer<NetworkUploadFieldState>;