native-document 1.0.15 → 1.0.16-8.1

package/src/components/form/types/FieldCollection.d.ts

@@ -0,0 +1,53 @@
+import type { ValidChild } from '../../../../types/elements';
+import type { ObservableItem } from '../../../../types/observable';
+import type { BaseComponent } from '../../BaseComponent';
+import type { HasValidation } from '../../$traits/has-validation/HasValidation';
+import type { FieldInterface } from './Field';
+import type { GlobalAttributes } from '../../../../types/globals';
+
+export type FieldCollectionDescription = {
+        name: string;
+        value: ObservableItem<unknown[]>;
+        rules: Array<{ fn: Function; params: unknown; message: string }>;
+        hasErrors: ObservableItem<boolean>;
+        errors: ObservableItem<string[]>;
+        showErrors: ObservableItem<boolean>;
+        defaultItem: unknown;
+        fieldBuilder: ((fields: FieldCollectionInterface, index: number) => ValidChild) | null;
+        renderItem: ((item: unknown, index: number) => ValidChild) | null;
+        renderAdd: (() => ValidChild) | null;
+        transition: string | null;
+        props: GlobalAttributes;
+    };
+
+export interface FieldCollectionInterface extends BaseComponent, HasValidation {
+    fields(fieldBuilder: (fields: FieldCollectionInterface, index: number) => ValidChild): this;
+    data(defaultItem: unknown): this;
+    renderItem(fn: (item: unknown, index: number) => ValidChild): this;
+    renderAdd(fn: () => ValidChild): this;
+    transition(transitionName: string): this;
+    model(observable: ObservableItem<unknown[]>): this;
+    add(): void;
+    remove(item: unknown): this;
+    clear(): this;
+    reset(): this;
+    value(): unknown[];
+    count(): number;
+    isEmpty(): boolean;
+    onChange(handler: () => void): this;
+    onAdd(handler: () => void): this;
+    onRemove(handler: (item: unknown) => void): this;
+    min(minCount: number, message?: string): this;
+    max(maxCount: number, message?: string): this;
+    render(template: (description: FieldCollectionDescription, instance: FieldCollectionInterface) => ValidChild): this;
+}
+
+
+export declare function FieldCollection(name?: string, props?: Record<string, unknown>): FieldCollectionInterface;
+export declare namespace FieldCollection {
+
+
+    function use(template: (description: FieldCollectionDescription, instance: FieldCollectionInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/FormControl.d.ts

@@ -0,0 +1,64 @@
+import type { ValidChild } from '../../../../types/elements';
+import type { ObservableItem } from '../../../../types/observable';
+import type { BaseComponent } from '../../BaseComponent';
+import type { FieldInterface } from './Field';
+import type { GlobalAttributes } from '../../../../types/globals';
+
+export type FormControlDescription = {
+        data: unknown | null;
+        fieldBuilder: ((form: FormControlInterface) => void) | null;
+        layout: ((fields: Record<string, FieldInterface>) => ValidChild) | null;
+        errorsMode: 'dispatch' | 'inline' | 'summary' | 'none';
+        errorsPosition: 'top' | 'bottom';
+        errorsMapper: Record<string, string> | null;
+        renderErrors: ((errors: Record<string, string[]>) => ValidChild) | null;
+        submitting: ObservableItem<boolean>;
+        errors: ObservableItem<Record<string, string[]> | null>;
+        isDirty: ObservableItem<boolean>;
+        isValid: ObservableItem<boolean>;
+        props: GlobalAttributes;
+    };
+
+export interface FormControlInterface extends BaseComponent {
+    fields(fieldBuilder: (form: FormControlInterface) => void): this;
+    get(fieldName: string): FieldInterface | null;
+    layout(layoutCallback: (fields: Record<string, FieldInterface>) => ValidChild): this;
+    errorsMode(mode: 'inline' | 'summary' | 'none'): this;
+    dispatchErrors(mapper?: Record<string, string> | null): this;
+    summarizeErrors(): Record<string, string[]>;
+    dispatchAndSummarize(mapper?: Record<string, string> | null): this;
+    errorsPosition(position: 'top' | 'bottom'): this;
+    errorsAtTop(): this;
+    errorsAtBottom(): this;
+    renderErrors(renderFn: (errors: Record<string, string[]>) => ValidChild): this;
+    reset(): this;
+    resetField(name: string): this;
+    submit(event?: Event): this;
+    trigger(...fieldNames: string[]): this;
+    disable(fieldName?: string | null): this;
+    enable(fieldName?: string | null): this;
+    values(): Record<string, unknown>;
+    watch(fieldName: string, handler: (value: unknown, field: FieldInterface) => void): this;
+    onSubmit(callback: (values: Record<string, unknown>, form: FormControlInterface) => void | Promise<void>): this;
+    onPreventSubmit(callback: (event: Event) => void): this;
+    onDebouncedSubmit(callback: (values: Record<string, unknown>) => void, delay?: number): this;
+    onSuccess(callback: (values: Record<string, unknown>) => void): this;
+    onError(callback: (errors: Record<string, string[]>) => void): this;
+    onChange(callback: () => void): this;
+    onReset(callback: () => void): this;
+    onBeforeSubmit(callback: () => void): this;
+    onAfterSubmit(callback: () => void): this;
+    onValidationError(callback: (errors: Record<string, string[]>) => void): this;
+    render(template: (description: FormControlDescription, instance: FormControlInterface) => ValidChild): this;
+}
+
+
+export declare function FormControl(props?: Record<string, unknown>): FormControlInterface;
+export declare namespace FormControl {
+
+
+    function use(template: (description: FormControlDescription, instance: FormControlInterface) => ValidChild): void;
+    function create(props?: Record<string, unknown>): FormControlInterface;
+
+
+}

package/src/components/form/types/fields/AutocompleteField.d.ts

@@ -0,0 +1,48 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type AutocompleteFieldDescription = {
+    name: string;
+    type: 'autocomplete';
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<unknown> | null;
+    source: unknown[] | ((query: string) => Promise<unknown[]>) | null;
+    minChars: number;
+    debounce: number;
+    maxResults: number;
+    valueKey: string;
+    labelKey: string;
+    renderItem: ((item: unknown) => ValidChild) | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface AutocompleteFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: AutocompleteFieldDescription, instance: AutocompleteFieldInterface) => ValidChild): this;
+    source(dataSource: unknown[] | ((query: string) => Promise<unknown[]>)): this;
+    minChars(min: number): this;
+    debounce(ms: number): this;
+    maxResults(max: number): this;
+    oneOf(allowedValues: unknown[], message?: string): this;
+    valueKey(key: string): this;
+    labelKey(key: string): this;
+    onSelect(handler: (item: unknown) => void): this;
+    renderItem(callback: (item: unknown) => ValidChild): this;
+}
+
+
+export declare function AutocompleteField(name: string, props?: GlobalAttributes): AutocompleteFieldInterface;
+export declare namespace AutocompleteField {
+
+
+    function use(template: (description: AutocompleteFieldDescription, instance: AutocompleteFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/CheckboxField.d.ts

@@ -0,0 +1,33 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type CheckboxFieldDescription = {
+    name: string;
+    type: 'checkbox';
+    label: ValidChild | null;
+    checked: ObservableItem<boolean> | boolean;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface CheckboxFieldInterface extends Omit<FieldInterface, 'render' | 'model'> {
+    render(renderFn: (description: CheckboxFieldDescription, instance: CheckboxFieldInterface) => ValidChild): this;
+    model(observable: ObservableItem<boolean>): this;
+    checked(): boolean;
+}
+
+
+export declare function CheckboxField(name: string, props?: GlobalAttributes): CheckboxFieldInterface;
+export declare namespace CheckboxField {
+
+
+    function use(template: (description: CheckboxFieldDescription, instance: CheckboxFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/CheckboxGroupField.d.ts

@@ -0,0 +1,49 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+interface CheckboxGroupOption {
+    value: unknown;
+    label: ValidChild;
+    props: GlobalAttributes;
+}
+
+export type CheckboxGroupFieldDescription = {
+    name: string;
+    type: 'checkbox-group';
+    label: ValidChild | null;
+    options: CheckboxGroupOption[];
+    layout: 'vertical' | 'horizontal' | 'grid';
+    value: ObservableItem<unknown[]> | null;
+    defaultValue: unknown[];
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface CheckboxGroupFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: CheckboxGroupFieldDescription, instance: CheckboxGroupFieldInterface) => ValidChild): this;
+    options(opts: CheckboxGroupOption[]): this;
+    option(value: unknown, label: ValidChild, props?: GlobalAttributes): this;
+    layout(value: 'vertical' | 'horizontal' | 'grid'): this;
+    horizontal(): this;
+    vertical(): this;
+    grid(): this;
+    minChecked(min: number, message?: string): this;
+    maxChecked(max: number, message?: string): this;
+    exactChecked(count: number, message?: string): this;
+}
+
+
+export declare function CheckboxGroupField(name: string, props?: GlobalAttributes): CheckboxGroupFieldInterface;
+export declare namespace CheckboxGroupField {
+
+
+    function use(template: (description: CheckboxGroupFieldDescription, instance: CheckboxGroupFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/ColorField.d.ts

@@ -0,0 +1,37 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type ColorFieldDescription = {
+    name: string;
+    type: 'color';
+    label: ValidChild | null;
+    value: ObservableItem<string> | null;
+    format: 'hex' | 'rgb' | 'hsl';
+    presets: string[] | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface ColorFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: ColorFieldDescription, instance: ColorFieldInterface) => ValidChild): this;
+    format(formatType: 'hex' | 'rgb' | 'hsl'): this;
+    presets(colors: string[]): this;
+    hex(message?: string): this;
+    rgb(message?: string): this;
+}
+
+
+export declare function ColorField(name: string, props?: GlobalAttributes): ColorFieldInterface;
+export declare namespace ColorField {
+
+
+    function use(template: (description: ColorFieldDescription, instance: ColorFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/DateField.d.ts

@@ -0,0 +1,70 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type DateFieldDescription = {
+    name: string;
+    type: 'date';
+    label: ValidChild | null;
+    format: string;
+    minDate: ObservableItem<string | Date> | null;
+    maxDate: ObservableItem<string | Date> | null;
+    disabledDates: ObservableItem<(string | Date)[]> | null;
+    clearable: boolean;
+    withTime: ObservableItem<boolean>;
+    range: ObservableItem<boolean>;
+    firstDayOfWeek: 'monday' | 'sunday';
+    locale: string | null;
+    timeStep: number | null;
+    timezone: string | null;
+    valueStart: ObservableItem<unknown> | null;
+    valueEnd: ObservableItem<unknown> | null;
+    rangeSeparator: string | null;
+    value: ObservableItem<unknown> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface DateFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: DateFieldDescription, instance: DateFieldInterface) => ValidChild): this;
+    rangeSeparator(rangeSeparator: string): this;
+    format(formatString: string): this;
+    minDate(date: Date | string): this;
+    maxDate(date: Date | string): this;
+    disabledDates(dates: (Date | string)[]): this;
+    withTime(enabled?: boolean): this;
+    range(enabled?: boolean): this;
+    mondayAsFirstDay(): this;
+    sundayAsFirstDay(): this;
+    locale(locale: string): this;
+    timeStep(secondes: number): this;
+    fromToday(): this;
+    untilToday(): this;
+    timezone(tz: string): this;
+    useLocalTimezone(): this;
+    modelStart(observable: ObservableItem<unknown>): this;
+    modelEnd(observable: ObservableItem<unknown>): this;
+    onChange(handler: (date: unknown) => void): this;
+    onClear(handler: () => void): this;
+    min(date: Date | string, message?: string): this;
+    max(date: Date | string, message?: string): this;
+    between(startDate: Date | string, endDate: Date | string, message?: string): this;
+    before(date: Date | string, message?: string): this;
+    weekday(message?: string): this;
+    after(date: Date | string, message?: string): this;
+}
+
+
+export declare function DateField(name: string, props?: GlobalAttributes): DateFieldInterface;
+export declare namespace DateField {
+
+
+    function use(template: (description: DateFieldDescription, instance: DateFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/EmailField.d.ts

@@ -0,0 +1,35 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+
+export type EmailFieldDescription = {
+    name: string;
+    type: 'email';
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<string> | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface EmailFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: EmailFieldDescription, instance: EmailFieldInterface) => ValidChild): this;
+    email(message?: string): this;
+    allowedDomain(allowedDomains: string[], message?: string): this;
+    notAllowedDomain(blockedDomains: string[], message?: string): this;
+}
+
+
+export declare function EmailField(name: string, defaultConfig?: GlobalAttributes): EmailFieldInterface;
+export declare namespace EmailField {
+
+
+    function use(template: (description: EmailFieldDescription, instance: EmailFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/FileAvatarMode.d.ts

@@ -0,0 +1,46 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { BaseComponent } from '../../../BaseComponent';
+
+export type FileAvatarModeDescription = {
+    variant: 'hover-overlay' | 'corner-badge' | 'action-buttons';
+    shape: 'circle' | 'square';
+    size: number | string;
+    placeholderIcon: ValidChild | null;
+    overlayIcon: ValidChild | null;
+    editImageIcon: ValidChild | null;
+    changeLabel: ValidChild;
+    removeLabel: ValidChild;
+    renderAvatar: ((desc: unknown, instance: FileAvatarModeInterface) => ValidChild) | null;
+    renderOverlay: ((desc: unknown, instance: FileAvatarModeInterface) => ValidChild) | null;
+    renderActions: ((desc: unknown, instance: FileAvatarModeInterface) => ValidChild) | null;
+    props: GlobalAttributes;
+};
+
+export interface FileAvatarModeInterface extends BaseComponent {
+    render(renderFn: (description: FileAvatarModeDescription, instance: FileAvatarModeInterface) => ValidChild): this;
+    hoverOverlay(): this;
+    cornerBadge(): this;
+    actionButtons(): this;
+    circle(): this;
+    square(): this;
+    size(size: number | string): this;
+    placeholderIcon(icon: ValidChild): this;
+    overlayIcon(icon: ValidChild): this;
+    editImageIcon(icon: ValidChild): this;
+    changeLabel(label: ValidChild): this;
+    removeLabel(label: ValidChild): this;
+    renderAvatar(fn: (desc: unknown, instance: FileAvatarModeInterface) => ValidChild): this;
+    renderOverlay(fn: (desc: unknown, instance: FileAvatarModeInterface) => ValidChild): this;
+    renderActions(fn: (desc: unknown, instance: FileAvatarModeInterface) => ValidChild): this;
+}
+
+
+export declare function FileAvatarMode(props?: GlobalAttributes): FileAvatarModeInterface;
+export declare namespace FileAvatarMode {
+
+
+    function use(template: (description: FileAvatarModeDescription, instance: FileAvatarModeInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/FileDropzoneMode.d.ts

@@ -0,0 +1,28 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { BaseComponent } from '../../../BaseComponent';
+
+export type FileDropzoneModeDescription = {
+    icon: ValidChild | null;
+    text: ValidChild;
+    hint: ValidChild | null;
+    height: string | number | null;
+    renderZone: ((desc: FileDropzoneModeDescription, instance: FileDropzoneModeInterface) => ValidChild) | null;
+    removeIcon: ValidChild | null;
+    props: GlobalAttributes;
+};
+
+export interface FileDropzoneModeInterface extends BaseComponent {
+    render(renderFn: (description: FileDropzoneModeDescription, instance: FileDropzoneModeInterface) => ValidChild): this;
+    icon(icon: ValidChild): this;
+    text(text: ValidChild): this;
+    hint(hint: ValidChild): this;
+    height(value: string | number): this;
+    renderZone(fn: (desc: FileDropzoneModeDescription, instance: FileDropzoneModeInterface) => ValidChild): this;
+    removeIcon(icon: ValidChild): this;
+}
+
+export declare function FileDropzoneMode(props?: GlobalAttributes): FileDropzoneModeInterface;
+export declare namespace FileDropzoneMode {
+    function use(template: (description: FileDropzoneModeDescription, instance: FileDropzoneModeInterface) => ValidChild): void;
+}

package/src/components/form/types/fields/FileField.d.ts

@@ -0,0 +1,56 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FieldInterface } from '../Field';
+import type { FileItemPreviewInterface } from './FileItemPreview';
+
+export type FileFieldDescription = {
+    name: string;
+    type: 'file';
+    label: ValidChild | null;
+    accept: string | null;
+    multiple: boolean;
+    mode: 'native' | 'dropzone' | 'button' | 'wall' | 'avatar' | null;
+    files: ObservableItem<FileItemPreviewInterface[]>;
+    fileIcons: Array<(file: File) => ValidChild>;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface FileFieldInterface extends Omit<FieldInterface, 'render' | 'reset'> {
+    accept(mimeTypes: string | string[]): this;
+    multiple(enabled?: boolean): this;
+    mode(mode: 'native' | 'dropzone' | 'button' | 'wall' | 'avatar'): this;
+    maxSize(bytes: number, message?: string): this;
+    minSize(bytes: number, message?: string): this;
+    mimeTypes(types: string[], message?: string): this;
+    extensions(extensions: string[], message?: string): this;
+    maxFiles(max: number, message?: string): this;
+    minFiles(min: number, message?: string): this;
+    onFileAdd(handler: (file: File) => void): this;
+    onReset(handler: () => void): this;
+    onFileRemove(handler: (file: File) => void): this;
+    addFile(file: File, update?: boolean): this;
+    setFiles(files: File[]): this;
+    addFiles(files: File[]): this;
+    removeFile(file: File): this;
+    getFiles(): File[];
+    reset(): this;
+    fileIcon(desc: (file: File) => ValidChild): this;
+    fileIcons(icons: Record<string, ValidChild>): this;
+    render(renderFn: (description: FileFieldDescription, instance: FileFieldInterface) => ValidChild): this;
+}
+
+
+export declare function FileField(name: string, props?: GlobalAttributes): FileFieldInterface;
+export declare namespace FileField {
+
+
+    function use(template: (description: FileFieldDescription, instance: FileFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/FileItemPreview.d.ts

@@ -0,0 +1,35 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { BaseComponent } from '../../../BaseComponent';
+
+export type FileItemPreviewDescription = {
+    file: File | null;
+    status: ObservableItem<'idle' | 'uploading' | 'done' | 'error'>;
+    progress: ObservableItem<number>;
+    error: ObservableItem<string | null>;
+    props: GlobalAttributes;
+};
+
+export interface FileItemPreviewInterface extends BaseComponent {
+    render(renderFn: (description: FileItemPreviewDescription, instance: FileItemPreviewInterface) => ValidChild): this;
+    file(): File;
+    status(status: 'idle' | 'uploading' | 'done' | 'error'): this;
+    progress(value: number): this;
+    error(message: string): this;
+    done(): this;
+    uploading(): this;
+    onClick(handler: (file: File, event: MouseEvent) => void): this;
+    onRemove(handler: (file: File) => void): this;
+    onReplace(handler: (file: File) => void): this;
+}
+
+
+export declare function FileItemPreview(file: File, props?: GlobalAttributes): FileItemPreviewInterface;
+export declare namespace FileItemPreview {
+
+
+    function use(template: (description: FileItemPreviewDescription, instance: FileItemPreviewInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/FileNativeMode.d.ts

@@ -0,0 +1,21 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { BaseComponent } from '../../../BaseComponent';
+
+export type FileNativeModeDescription = {
+    props: GlobalAttributes;
+};
+
+export interface FileNativeModeInterface extends BaseComponent {
+    render(renderFn: (description: FileNativeModeDescription, instance: FileNativeModeInterface) => ValidChild): this;
+}
+
+
+export declare function FileNativeMode(props?: GlobalAttributes): FileNativeModeInterface;
+export declare namespace FileNativeMode {
+
+
+    function use(template: (description: FileNativeModeDescription, instance: FileNativeModeInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/FileUploadButtonMode.d.ts

@@ -0,0 +1,34 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { BaseComponent } from '../../../BaseComponent';
+import type { FileItemPreviewInterface } from './FileItemPreview';
+
+export type FileUploadButtonModeDescription = {
+    buttonLabel: ValidChild;
+    buttonIcon: ValidChild | null;
+    showProgress: boolean;
+    renderItem: ((file: File, preview: FileItemPreviewInterface) => ValidChild) | null;
+    renderButton: ((desc: unknown, instance: FileUploadButtonModeInterface) => ValidChild) | null;
+    renderList: ((files: File[]) => ValidChild) | null;
+    props: GlobalAttributes;
+};
+
+export interface FileUploadButtonModeInterface extends BaseComponent {
+    render(renderFn: (description: FileUploadButtonModeDescription, instance: FileUploadButtonModeInterface) => ValidChild): this;
+    buttonLabel(label: ValidChild): this;
+    buttonIcon(icon: ValidChild): this;
+    showProgress(enabled?: boolean): this;
+    renderItem(fn: (file: File, preview: FileItemPreviewInterface) => ValidChild): this;
+    renderButton(fn: (desc: unknown, instance: FileUploadButtonModeInterface) => ValidChild): this;
+    renderList(fn: (files: File[]) => ValidChild): this;
+}
+
+
+export declare function FileUploadButtonMode(props?: GlobalAttributes): FileUploadButtonModeInterface;
+export declare namespace FileUploadButtonMode {
+
+
+    function use(template: (description: FileUploadButtonModeDescription, instance: FileUploadButtonModeInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/FileWallMode.d.ts

@@ -0,0 +1,32 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { BaseComponent } from '../../../BaseComponent';
+import type { FileItemPreviewInterface } from './FileItemPreview';
+
+export type FileWallModeDescription = {
+    cellSize: string | number;
+    addLabel: ValidChild;
+    addIcon: ValidChild | null;
+    renderCell: ((file: File, preview: FileItemPreviewInterface) => ValidChild) | null;
+    renderAdd: (() => ValidChild) | null;
+    props: GlobalAttributes;
+};
+
+export interface FileWallModeInterface extends BaseComponent {
+    render(renderFn: (description: FileWallModeDescription, instance: FileWallModeInterface) => ValidChild): this;
+    cellSize(size: string | number): this;
+    addLabel(label: ValidChild): this;
+    addIcon(icon: ValidChild): this;
+    renderCell(fn: (file: File, preview: FileItemPreviewInterface) => ValidChild): this;
+    renderAdd(fn: () => ValidChild): this;
+}
+
+
+export declare function FileWallMode(props?: GlobalAttributes): FileWallModeInterface;
+export declare namespace FileWallMode {
+
+
+    function use(template: (description: FileWallModeDescription, instance: FileWallModeInterface) => ValidChild): void;
+
+
+}