native-document 1.0.164 → 1.0.166

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;
+
+
+}

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

@@ -0,0 +1,26 @@
+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 HiddenFieldDescription = {
+    name: string;
+    type: 'hidden';
+    value: ObservableItem<unknown> | null;
+    defaultValue: unknown;
+    props: GlobalAttributes;
+};
+
+export interface HiddenFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: HiddenFieldDescription, instance: HiddenFieldInterface) => ValidChild): this;
+}
+
+
+export declare function HiddenField(name: string, props?: GlobalAttributes): HiddenFieldInterface;
+export declare namespace HiddenField {
+
+
+    function use(template: (description: HiddenFieldDescription, instance: HiddenFieldInterface) => ValidChild): void;
+
+
+}

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

@@ -0,0 +1,45 @@
+import type { ValidChild } from '../../../../../types/elements';
+import type { ObservableItem } from '../../../../../types/observable';
+import type { GlobalAttributes } from '../../../../../types/globals';
+import type { FileFieldInterface } from './FileField';
+import type { FileItemPreviewInterface } from './FileItemPreview';
+
+export type ImageFieldDescription = {
+    name: string;
+    type: 'image';
+    label: ValidChild | null;
+    accept: string;
+    multiple: boolean;
+    mode: string | null;
+    files: ObservableItem<FileItemPreviewInterface[]>;
+    maxWidth: number | null;
+    maxHeight: number | null;
+    crop: boolean;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface ImageFieldInterface extends Omit<FileFieldInterface, 'render'> {
+    render(renderFn: (description: ImageFieldDescription, instance: ImageFieldInterface) => ValidChild): this;
+    maxWidth(width: number): this;
+    maxHeight(height: number): this;
+    crop(enabled?: boolean): this;
+    dimensions(width: number, height: number, message?: string): this;
+    maxDimensions(width: number, height: number, message?: string): this;
+    minDimensions(width: number, height: number, message?: string): this;
+    aspectRatio(ratio: number, message?: string): this;
+}
+
+
+export declare function ImageField(name: string, props?: GlobalAttributes): ImageFieldInterface;
+export declare namespace ImageField {
+
+
+    function use(template: (description: ImageFieldDescription, instance: ImageFieldInterface) => ValidChild): void;
+
+
+}

package/src/components/form/types/fields/NumberField.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 NumberFieldDescription = {
+    name: string;
+    type: string;
+    label: ValidChild | null;
+    placeholder: ValidChild | null;
+    value: ObservableItem<number> | null;
+    step: number | null;
+    decimals: number | null;
+    prefix: ValidChild | null;
+    suffix: ValidChild | null;
+    disabled: boolean | ObservableItem<boolean>;
+    readonly: boolean | ObservableItem<boolean>;
+    hasErrors: ObservableItem<boolean>;
+    errors: ObservableItem<string[]>;
+    showErrors: ObservableItem<boolean>;
+    props: GlobalAttributes;
+};
+
+export interface NumberFieldInterface extends Omit<FieldInterface, 'render'> {
+    render(renderFn: (description: NumberFieldDescription, instance: NumberFieldInterface) => ValidChild): this;
+    min(min: number, message?: string): this;
+    max(max: number, message?: string): this;
+    between(min: number, max: number, message?: string): this;
+    integer(message?: string): this;
+    positive(message?: string): this;
+    unsigned(): this;
+    negative(message?: string): this;
+    multipleOf(n: number, message?: string): this;
+    step(value: number): this;
+    decimals(value?: number): this;
+    prefix(text: ValidChild): this;
+    suffix(text: ValidChild): this;
+}
+
+
+export declare function NumberField(name: string, type?: string, props?: GlobalAttributes): NumberFieldInterface;
+export declare namespace NumberField {
+
+
+    function use(template: (description: NumberFieldDescription, instance: NumberFieldInterface) => ValidChild): void;
+
+
+}