@nxgt/material-vue 0.1.0

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

@@ -0,0 +1,46 @@
+import { TransferPane } from './types';
+export type TransferListKeyCommand = {
+    type: 'focus';
+    value: string;
+    pane?: TransferPane;
+} | {
+    type: 'toggle';
+    value: string;
+} | {
+    type: 'select-all';
+} | {
+    type: 'move';
+    values: string[];
+} | {
+    type: 'reorder';
+    direction: 'up' | 'down';
+};
+type KeyEventLike = {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    preventDefault: () => void;
+};
+export declare function handleTransferListKeyDown(event: KeyEventLike, ctx: {
+    pane?: TransferPane;
+    focusedValue: string | null;
+    visibleValues: string[];
+    otherPaneValues?: string[];
+    transferable: string[];
+}): TransferListKeyCommand | null;
+export declare function runTransferListCommand(command: TransferListKeyCommand, pane: TransferPane, list: {
+    chrome: {
+        focusedValue: string | null;
+    };
+    chromeActions: {
+        setFocused: (next: {
+            pane: TransferPane;
+            value: string;
+        }) => void;
+    };
+    toggleChecked: (pane: TransferPane, value: string) => void;
+    selectAll: (pane: TransferPane) => void;
+    reorder: (id: string, direction: 'up' | 'down') => void;
+    moveValues: (pane: TransferPane, values: string[]) => void;
+}): void;
+export {};

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

@@ -0,0 +1,6 @@
+import { MaterialLocaleKey, TranslationContext } from '../../../i18n';
+import { TransferListBoardLabels, TransferListTitles } from './types';
+import { TransferListModel } from './use-transfer-list';
+type Translate = (key: MaterialLocaleKey, fallback: string, options?: TranslationContext) => string;
+export declare function buildTransferListLabels(t: Translate, titles: TransferListTitles | undefined, list: TransferListModel): TransferListBoardLabels;
+export {};

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

@@ -0,0 +1,3 @@
+import { TransferListChromeState } from './types';
+export declare const createInitialState: () => TransferListChromeState;
+export declare const useTransferListStore: (initialState?: Partial<TransferListChromeState> | undefined) => any;

package/dist/lib/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/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/lib/components/ui/transfer-list/transfer-list.vue.d.ts

@@ -0,0 +1,51 @@
+import { HTMLAttributes } from 'vue';
+import { TransferListItem, TransferListTitles } from './types';
+export type TransferListProps = {
+    items: TransferListItem[];
+    modelValue?: string[];
+    defaultValue?: string[];
+    titles?: TransferListTitles;
+    searchable?: boolean;
+    showSelectAll?: boolean;
+    showTransferAll?: boolean;
+    reorderable?: boolean;
+    draggable?: boolean;
+    max?: number;
+    disabled?: boolean;
+    height?: number | string;
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+    required?: boolean;
+    name?: string;
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_22: {
+    item: TransferListItem;
+    pane: import('./types').TransferPane;
+    checked: boolean;
+};
+type __VLS_Slots = {} & {
+    item?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TransferListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<TransferListProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    height: number | string;
+    draggable: boolean;
+    searchable: boolean;
+    reorderable: boolean;
+    showTransferAll: boolean;
+    showSelectAll: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,45 @@
+import { Component } from 'vue';
+export type TransferPane = 'available' | 'selected';
+export type TransferListItem = {
+    value: string;
+    label: string;
+    subtitle?: string;
+    icon?: Component;
+    group?: string;
+    disabled?: boolean;
+    locked?: boolean;
+};
+export type TransferListItemContext = {
+    pane: TransferPane;
+    checked: boolean;
+};
+export type TransferListTitles = {
+    available?: string;
+    selected?: string;
+};
+export type TransferListChromeState = {
+    availableQuery: string;
+    selectedQuery: string;
+    availableChecked: string[];
+    selectedChecked: string[];
+    focusedPane: TransferPane;
+    focusedValue: string | null;
+};
+export type SelectAllState = 'none' | 'some' | 'all';
+export type TransferListBoardLabels = {
+    availableTitle: string;
+    selectedTitle: string;
+    search: string;
+    emptyAvailable: string;
+    emptySelected: string;
+    emptyFilter: string;
+    availableCount: string;
+    selectedCount: string;
+    moveToSelected: string;
+    moveAllToSelected: string;
+    moveToAvailable: string;
+    moveAllToAvailable: string;
+    moveUp: string;
+    moveDown: string;
+    drag: string;
+};

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

@@ -0,0 +1,21 @@
+import { TransferPane } from './types';
+export declare function useTransferListBoard(): {
+    list: import('./use-transfer-list').TransferListModel;
+    labels: import('./types').TransferListBoardLabels;
+    ctx: import('./transfer-list-context').TransferListContextValue;
+    onKeyDown: (pane: TransferPane) => (event: KeyboardEvent) => void;
+    emptyAvailable: import('vue').ComputedRef<string>;
+    emptySelected: import('vue').ComputedRef<string>;
+    actions: import('vue').ComputedRef<{
+        disabled: boolean;
+        showTransferAll: boolean;
+        canMoveToSelected: boolean;
+        canMoveAllToSelected: boolean;
+        canMoveToAvailable: boolean;
+        canMoveAllToAvailable: boolean;
+        moveToSelectedLabel: string;
+        moveAllToSelectedLabel: string;
+        moveToAvailableLabel: string;
+        moveAllToAvailableLabel: string;
+    }>;
+};

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

@@ -0,0 +1,54 @@
+import { MaybeRefOrGetter } from 'vue';
+import { TransferDropTarget } from './transfer-list.dnd';
+import { useTransferListStore } from './transfer-list.store';
+import { SelectAllState, TransferListItem, TransferPane } from './types';
+export type UseTransferListOptions = {
+    items: MaybeRefOrGetter<TransferListItem[]>;
+    modelValue?: MaybeRefOrGetter<string[] | undefined>;
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    max?: MaybeRefOrGetter<number | undefined>;
+    disabled?: MaybeRefOrGetter<boolean>;
+};
+export type TransferListModel = {
+    selectedValues: string[];
+    chrome: ReturnType<typeof useTransferListStore>;
+    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: (pane: TransferPane) => void;
+    };
+    available: TransferListItem[];
+    selected: TransferListItem[];
+    availableVisible: TransferListItem[];
+    selectedVisible: TransferListItem[];
+    availableTransferable: string[];
+    selectedTransferable: string[];
+    availableChecked: string[];
+    selectedChecked: string[];
+    availableSelectAll: SelectAllState;
+    selectedSelectAll: 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 declare function useTransferList(options: UseTransferListOptions): TransferListModel;

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

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

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

@@ -0,0 +1,18 @@
+import { TreeRow, TreeSelectionMode } from './types';
+export type TreeItemProps = {
+    row: TreeRow;
+    selected: boolean;
+    focused: boolean;
+    selectionMode: TreeSelectionMode;
+};
+declare const __VLS_export: import('vue').DefineComponent<TreeItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (id: string) => any;
+    focus: (id: string) => any;
+    toggleExpanded: (id: string) => any;
+}, string, import('vue').PublicProps, Readonly<TreeItemProps> & Readonly<{
+    onSelect?: ((id: string) => any) | undefined;
+    onFocus?: ((id: string) => any) | undefined;
+    onToggleExpanded?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/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/lib/components/ui/tree/tree.vue.d.ts

@@ -0,0 +1,14 @@
+import { TreeNode, TreeProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<TreeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (id: string, node: TreeNode) => any;
+    "update:selectedIds": (ids: string[]) => any;
+    "update:expandedIds": (ids: string[]) => any;
+}, string, import('vue').PublicProps, Readonly<TreeProps> & Readonly<{
+    onSelect?: ((id: string, node: TreeNode) => any) | undefined;
+    "onUpdate:selectedIds"?: ((ids: string[]) => any) | undefined;
+    "onUpdate:expandedIds"?: ((ids: string[]) => any) | undefined;
+}>, {
+    selectionMode: import('./types').TreeSelectionMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,28 @@
+import { Component } from 'vue';
+export type TreeNode = {
+    id: string;
+    label: string;
+    icon?: Component;
+    trailing?: string;
+    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[];
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    class?: string;
+    'aria-label'?: string;
+};

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

@@ -0,0 +1,17 @@
+import { TreeNode, TreeProps, TreeSelectionMode } from './types';
+export type UseTreeOptions = TreeProps & {
+    selectionMode?: TreeSelectionMode;
+    onSelectedIdsChange?: (ids: string[]) => void;
+    onExpandedIdsChange?: (ids: string[]) => void;
+    onSelect?: (id: string, node: TreeNode) => void;
+};
+export declare function useTree(options: UseTreeOptions): {
+    rows: import('vue').ComputedRef<import('./types').TreeRow[]>;
+    selected: import('vue').ComputedRef<string[]>;
+    expanded: import('vue').ComputedRef<string[]>;
+    focusedId: import('vue').Ref<string | null, string | null>;
+    setFocusedId: (id: string) => void;
+    toggleExpanded: (id: string) => void;
+    select: (id: string) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+};

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

@@ -0,0 +1,3 @@
+export { type TypographyVariants, typographyVariants, } from './typography.variants';
+export type { TypographyProps } from './typography.vue';
+export { default as Typography } from './typography.vue';

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

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+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 TypographyVariants = VariantProps<typeof typographyVariants>;

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

@@ -0,0 +1,19 @@
+import { HTMLAttributes } from 'vue';
+import { TypographyVariants } from './typography.variants';
+export type TypographyProps = {
+    variant?: TypographyVariants['variant'];
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TypographyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TypographyProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

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

@@ -0,0 +1,8 @@
+export declare function createMockUpload(options?: {
+    failRate?: number;
+    durationMs?: number;
+}): (file: File, onProgress?: (percent: number) => void) => Promise<string>;
+export declare function createIndeterminateMockUpload(durationMs?: number): (file: File) => Promise<string>;
+export declare const defaultUpload: (file: File, onProgress?: (percent: number) => void) => Promise<string>;
+export declare const alwaysFailsUpload: (file: File, onProgress?: (percent: number) => void) => Promise<string>;
+export declare const indeterminateUpload: (file: File) => Promise<string>;

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

@@ -0,0 +1,9 @@
+export type { NetworkUploadFieldState } from './network-upload-field.store';
+export { useNetworkUploadFieldStore } from './network-upload-field.store';
+export { createFileId, filenameFromValue, getUploadErrorMessage, getValidationMessage, isDisplayableSrc, isImageValue, matchesAccept, resolvePreviewUrl, validateFile, } from './network-upload-field.utils';
+export { default as NetworkUploadField } from './network-upload-field.vue';
+export type { FileValidationError, LocalFileItem, NetworkUploadBaseProps, NetworkUploadDisplayItem, NetworkUploadFieldModelProps, NetworkUploadFieldProps, NetworkUploadItemProps, NetworkUploadItemStatus, ValidateFileOptions, } from './types';
+export { useFileDragDrop } from './use-file-drag-drop';
+export { useImagePreview } from './use-image-preview';
+export { useNetworkUploadField } from './use-network-upload-field';
+export { useUploadItems } from './use-upload-items';

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

@@ -0,0 +1,5 @@
+import { LocalFileItem } from './types';
+export type NetworkUploadFieldState = {
+    localItems: LocalFileItem[];
+};
+export declare const useNetworkUploadFieldStore: (initialState?: Partial<NetworkUploadFieldState> | undefined) => any;

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

@@ -0,0 +1,11 @@
+import { FileValidationError, ValidateFileOptions } from './types';
+export declare function matchesAccept(file: File, accept: string): boolean;
+export declare function validateFile(file: File, options: ValidateFileOptions): FileValidationError | null;
+export declare function formatFileSize(bytes: number): string;
+export declare function getValidationMessage(error: FileValidationError, options: ValidateFileOptions): string;
+export declare function createFileId(): string;
+export declare function filenameFromValue(value: string): string;
+export declare function getUploadErrorMessage(error: unknown): string;
+export declare function isImageValue(value: string): boolean;
+export declare function isDisplayableSrc(value: string): boolean;
+export declare function resolvePreviewUrl(value: string, resolveUrl?: (value: string) => string | null | undefined): string | undefined;

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

@@ -0,0 +1,8 @@
+import { NetworkUploadFieldModelProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<NetworkUploadFieldModelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[] | null | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<NetworkUploadFieldModelProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[] | null | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,12 @@
+import { NetworkUploadDisplayItem, NetworkUploadItemProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<NetworkUploadItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: (item: NetworkUploadDisplayItem) => any;
+    replace: (item: NetworkUploadDisplayItem, file: File) => any;
+    retry: (item: NetworkUploadDisplayItem) => any;
+}, string, import('vue').PublicProps, Readonly<NetworkUploadItemProps> & Readonly<{
+    onRemove?: ((item: NetworkUploadDisplayItem) => any) | undefined;
+    onReplace?: ((item: NetworkUploadDisplayItem, file: File) => any) | undefined;
+    onRetry?: ((item: NetworkUploadDisplayItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,20 @@
+type __VLS_Props = {
+    disabled?: boolean;
+    error?: boolean;
+    active?: boolean;
+    atCapacity?: boolean;
+    constraints?: string;
+};
+declare var __VLS_18: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/lib/lib/components/ui/upload/network-upload-field/partials/network-upload-item-actions.vue.d.ts

@@ -0,0 +1,14 @@
+import { NetworkUploadDisplayItem } from '../types';
+type __VLS_Props = {
+    item: NetworkUploadDisplayItem;
+    disabled?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: () => any;
+    retry: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRemove?: (() => any) | undefined;
+    onRetry?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/lib/lib/components/ui/upload/network-upload-field/partials/network-upload-item-preview.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    preview?: string;
+    name: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,61 @@
+import { HTMLAttributes } from 'vue';
+export type FileValidationError = 'accept' | 'max-size' | 'max-files';
+export type ValidateFileOptions = {
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    currentCount?: number;
+};
+export type LocalFileItem = {
+    id: string;
+    file: File;
+    status: 'uploading' | 'error';
+    progress?: number;
+    errorMessage?: string;
+    replacesValue?: string;
+};
+export type NetworkUploadItemStatus = 'uploading' | 'success' | 'error';
+export type NetworkUploadDisplayItem = {
+    id: string;
+    name: string;
+    size?: number;
+    status: NetworkUploadItemStatus;
+    progress?: number;
+    file?: File;
+    previewUrl?: string;
+    errorMessage?: string;
+};
+export type NetworkUploadBaseProps = {
+    label?: string;
+    helperText?: string;
+    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;
+    resolveUrl?: (value: string) => string | null | undefined;
+    name?: string;
+};
+export type NetworkUploadFieldProps = NetworkUploadBaseProps & ({
+    mode: 'single';
+    value?: string;
+    onValueChange?: (value?: string | null) => void;
+} | {
+    mode: 'multiple';
+    value: string[];
+    onValueChange?: (value: string[]) => void;
+});
+export type NetworkUploadFieldModelProps = NetworkUploadBaseProps & {
+    class?: HTMLAttributes['class'];
+    mode: 'single' | 'multiple';
+    modelValue?: string | string[] | null;
+};
+export type NetworkUploadItemProps = {
+    item: NetworkUploadDisplayItem;
+    accept?: string;
+    disabled?: boolean;
+    class?: HTMLAttributes['class'];
+};

package/dist/lib/lib/components/ui/upload/network-upload-field/use-file-drag-drop.d.ts

@@ -0,0 +1,14 @@
+import { MaybeRefOrGetter } from 'vue';
+export type UseFileDragDropOptions = {
+    disabled?: MaybeRefOrGetter<boolean>;
+    onDropFiles: (files: File[]) => void;
+};
+export declare function useFileDragDrop(options: UseFileDragDropOptions): {
+    isDragActive: import('vue').Ref<boolean, boolean>;
+    dragHandlers: {
+        onDragEnter: (event: DragEvent) => void;
+        onDragOver: (event: DragEvent) => void;
+        onDragLeave: (event: DragEvent) => void;
+        onDrop: (event: DragEvent) => void;
+    };
+};

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

@@ -0,0 +1 @@
+export declare function useImagePreview(file: () => File | undefined): import('vue').Ref<string | undefined, string | undefined>;

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

@@ -0,0 +1,18 @@
+import { NetworkUploadDisplayItem, NetworkUploadFieldProps } from './types';
+export declare function useNetworkUploadField(props: NetworkUploadFieldProps): {
+    displayItems: import('vue').ComputedRef<NetworkUploadDisplayItem[]>;
+    showEmptyZone: import('vue').ComputedRef<boolean>;
+    atCapacity: import('vue').ComputedRef<boolean>;
+    zoneDisabled: import('vue').ComputedRef<boolean>;
+    isDragActive: import('vue').Ref<boolean, boolean>;
+    dragHandlers: {
+        onDragEnter: (event: DragEvent) => void;
+        onDragOver: (event: DragEvent) => void;
+        onDragLeave: (event: DragEvent) => void;
+        onDrop: (event: DragEvent) => void;
+    };
+    handleFilesSelected: (files: File[]) => void;
+    handleItemReplace: (item: NetworkUploadDisplayItem, file: File) => void;
+    handleItemRetry: (item: NetworkUploadDisplayItem) => void;
+    handleItemRemove: (item: NetworkUploadDisplayItem) => void;
+};

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

@@ -0,0 +1,13 @@
+import { NetworkUploadDisplayItem, NetworkUploadFieldProps } from './types';
+export declare function useUploadItems(props: NetworkUploadFieldProps): {
+    store: any;
+    fileForValue: (value: string) => File | undefined;
+    addLocalItem: (file: File, options?: {
+        replacesValue?: string;
+        maxFiles?: number;
+        currentCount?: number;
+    }) => void;
+    handleItemReplace: (item: NetworkUploadDisplayItem, file: File) => void;
+    handleItemRetry: (item: NetworkUploadDisplayItem) => void;
+    handleItemRemove: (item: NetworkUploadDisplayItem) => void;
+};

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

@@ -0,0 +1,4 @@
+export type { PresignedUploadTarget, PutFileWithProgressOptions, } from './s3-upload-field.utils';
+export { putFileWithProgress } from './s3-upload-field.utils';
+export { default as S3UploadField } from './s3-upload-field.vue';
+export type { S3UploadFieldProps } from './types';

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

@@ -0,0 +1,10 @@
+export type PresignedUploadTarget = {
+    uploadUrl: string;
+    publicUrl: string;
+    headers?: Record<string, string>;
+};
+export type PutFileWithProgressOptions = {
+    headers?: Record<string, string>;
+    onProgress?: (percent: number) => void;
+};
+export declare function putFileWithProgress(url: string, file: File, { headers, onProgress }?: PutFileWithProgressOptions): Promise<void>;