mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/views/form/controls/monacoEditor/MonacoCodeOptions.schema.d.ts

@@ -0,0 +1,18 @@
+import * as monaco from "monaco-editor";
+export interface MonacoCodeOptions {
+    lang?: string;
+    guid?: string;
+    value?: () => string;
+    onChange?: (value: string) => void;
+    onChangeErrorState?: (errMessage?: string) => void;
+    jsonSchema?: string;
+    /**
+     * @TJS-type any
+     */
+    editorOptions?: monaco.editor.IStandaloneEditorConstructionOptions;
+    showDescription?: boolean;
+    enableFullscreen?: boolean;
+    enableSuggestionOnEnter?: boolean;
+    /** Игнорировать валидационные ошибки формата данных */
+    ignoreControlValidation?: boolean;
+}

package/types/_core/scripts/views/form/controls/monacoEditor/MonacoFieldControlOptions.schema.d.ts

@@ -0,0 +1,5 @@
+import { MonacoCodeOptions } from "./MonacoCodeOptions.schema";
+export interface MonacoFieldControlOptions extends MonacoCodeOptions {
+    formatOnInit?: boolean;
+    lang?: string;
+}

package/types/_core/scripts/views/form/controls/monacoEditor/jsonSchemas/Button.schema.d.ts

@@ -0,0 +1,69 @@
+import { FormattedText } from "mdtScripts/helpers/formattedText";
+import { ControlSize } from "mdtScripts/views/controls/Control";
+export declare type ButtonTypes = "default" | "primary" | "success" | "info" | "warning" | "danger" | "link" | "group-title" | "extended" | "fatal";
+export interface IButton {
+    /**
+     * Тип кнопки
+     */
+    type?: ButtonTypes | (() => ButtonTypes);
+    /**
+     * Размер кнопки
+     */
+    size?: ControlSize;
+    /**
+     * Дочерние элементы
+     */
+    items?: Button[];
+    /**
+     * Поле является группировочным
+     */
+    group?: boolean;
+    /**
+     * Иконка
+     */
+    icon?: string | {
+        (): string;
+    };
+    /**
+     * Иконка при наведении
+     */
+    hoverIcon?: string | {
+        (): string;
+    };
+    /**
+     * Название
+     */
+    title?: any;
+    supIcon?: string;
+    /**
+     * Показывать дочерние при наведении
+     */
+    itemsShowOnHover?: boolean;
+    /**
+     * Показывать дочерние по клику
+     */
+    showItemsOnClick?: boolean;
+    /**
+     * Скрыть каретку
+     */
+    hideCaret?: boolean;
+    /**
+     * Порядок отображения
+     */
+    order?: number;
+    /**
+     * Ссылка
+     */
+    href?: string | {
+        (): string;
+    };
+    code?: string;
+}
+export interface Button extends IButton {
+    /**
+     * Всплывающая подсказка
+     */
+    tooltip?: FormattedText | {
+        (): FormattedText;
+    };
+}

package/types/_core/scripts/views/form/controls/monacoEditor/jsonSchemas/schemaIndex.d.ts

@@ -0,0 +1 @@
+export declare function getJSONSchema(): Promise<{}>;

package/types/_core/scripts/views/form/controls/monacoEditor/monacoCode.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="mithril" />
+import { MonacoCodeOptions } from "./MonacoCodeOptions.schema";
+export declare class MonacoCode {
+    private options;
+    editor: any;
+    model: any;
+    guid: string;
+    $inited: boolean;
+    private schema;
+    private errorState;
+    private lastKey;
+    constructor(options: MonacoCodeOptions);
+    setSchema(schema: string): void;
+    /** Creates or reinit model for monaco editor */
+    createModel(): any;
+    registerActions(el: any): void;
+    updateErrorState(): void;
+    private getEditorThemeType;
+    $view: () => _mithril.MithrilVirtualElement;
+}

package/types/_core/scripts/views/form/controls/monacoEditor/monacoField.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="mithril" />
+import { FieldCtrl } from "_core/scripts/views/form/field";
+import { MonacoCode } from "./monacoCode";
+import { MonacoFieldControlOptions } from "./MonacoFieldControlOptions.schema";
+export declare class MonacoFieldControl {
+    private options;
+    private fieldCtrl;
+    hasReadonly: boolean;
+    editor: MonacoCode;
+    private $enabledState;
+    constructor(options: MonacoFieldControlOptions, fieldCtrl: FieldCtrl);
+    enabled(): boolean;
+    private updateEnabledState;
+    static registerOptionsPreparation(handler: (options: MonacoFieldControlOptions, fieldCtrl: FieldCtrl) => MonacoFieldControlOptions): void;
+    private static prepOptionsHandlers;
+    private static prepareOptions;
+    $view: () => _mithril.MithrilVirtualElement;
+}

package/types/_core/scripts/views/form/controls/monacoEditor/monacoLibService.d.ts

@@ -0,0 +1,9 @@
+export declare class MonacoLibService {
+    private content;
+    private filePath?;
+    private monacoLibDisposer;
+    constructor(content: string, filePath?: string);
+    setupLib(): void;
+    dispose(): void;
+    private setupMonacoLib;
+}

package/types/_core/scripts/views/form/controls/monacoEditor/monacoManager.d.ts

@@ -0,0 +1,23 @@
+import "./style.less";
+import "_core/scripts/views/form/controls/monacoEditor/pathResolver.ts";
+declare type MonacoManagerEvents = {
+    prepare: (() => Promise<void>)[];
+    defaultOptionsPrepare: any;
+    editorCreate: any;
+};
+export declare class MonacoManager {
+    private static amdLoaderPath;
+    private static vsPath;
+    static events: MonacoManagerEvents;
+    private static preparePromise;
+    static prepare(): Promise<void>;
+    static isPrepared(): boolean;
+    static create(el: HTMLElement, options?: any, lang?: string): Promise<any>;
+    static createModel(value: string, schema?: string, lang?: string, uid?: string): import("monaco-editor").editor.ITextModel;
+    private static registerJsonSchemas;
+    private static registerJsDefinitions;
+    static modelUri(code: string, lang?: string, uid?: string): string;
+    private static genCharArray;
+    private static getStorageService;
+}
+export {};

package/types/_core/scripts/views/form/controls/notFound.d.ts

@@ -0,0 +1,6 @@
+import { FieldCtrl, FieldFormControl } from "../field";
+export declare class NotFoundFieldCtrl implements FieldFormControl {
+    hasReadonly: any;
+    content: any;
+    constructor(options: any, fieldCtrl: FieldCtrl);
+}

package/types/_core/scripts/views/form/controls/picker/gridPicker.d.ts

@@ -0,0 +1,16 @@
+import { FieldCtrl, FieldFormControl } from "../../field";
+import { Table } from "mdtScripts/common/Table";
+import { IFilter } from "mdtServices/Filter";
+import { ListOptions } from "mdtScripts/views/list/ListOptions";
+import { ListExtConfig } from "mdtScripts/common/list/ListExt";
+export interface GridPickerFieldCtrlOptions {
+    table?: Table;
+    filter?: IFilter;
+    listOptions?: ListOptions;
+    listExtenders?: ListExtConfig;
+}
+export declare class GridPickerFieldCtrl implements FieldFormControl {
+    hasReadonly: any;
+    content: any;
+    constructor(options: GridPickerFieldCtrlOptions, fieldCtrl: FieldCtrl);
+}

package/types/_core/scripts/views/form/controls/picker/multiPicker.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="mithril" />
+import { Field } from "../../../../common/Field";
+import { Record } from "../../../../common/Record";
+export interface MultiPickerCtrlOptions {
+    inputControl?: any;
+    command?: Function;
+    remove?: Function;
+    field?: Field;
+    splitter?: string;
+    getTitle?: (r: Record) => string | _mithril.MithrilVirtualElement | _mithril.MithrilVirtualElement[];
+    readonly?: () => boolean;
+    onunload?: () => void;
+    pick?: () => void;
+    enabled?: () => boolean;
+    preItem?: {
+        element: string | _mithril.MithrilVirtualElement | _mithril.MithrilVirtualElement[];
+        hasSplitter: boolean;
+    };
+}
+export declare class MultiPickerCtrl {
+    items: (val?: any, val$?: any, fireEvent?: any) => any[];
+    options: MultiPickerCtrlOptions;
+    constructor(items: (val?: any, val$?: any, fireEvent?: any) => any[], options?: MultiPickerCtrlOptions);
+    append(item: any): void;
+    remove(item: any): void;
+    removeLast(): void;
+    clear(): void;
+}

package/types/_core/scripts/views/form/controls/picker/multiPickerField.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="mithril" />
+import { Record } from "../../../../common/Record";
+import { IFilter } from "../../../../services/Filter";
+import { MultiPickerCtrl } from "./multiPicker";
+import { PickerInputShowMoreOptions } from "./pickerInput";
+import { FieldCtrl } from "../../field";
+import { ModalOptions } from "mdtScripts/views/containers/modal";
+export interface MultiPickerFieldCtrlOptions {
+    picked?: (r?: any) => void;
+    /** Загрузить дополнительные поля при выборе значения */
+    hintSelect?: string[];
+    select?: string[];
+    /** Фильтр для выбора значений */
+    filter?: IFilter | (() => IFilter);
+    modalOptions?: ModalOptions;
+}
+export declare class MultiPickerFieldCtrl {
+    options: MultiPickerFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    private refTable;
+    private m2mField;
+    private o2mField;
+    multiPicker: MultiPickerCtrl;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    hasReadonly: boolean;
+    private req;
+    constructor(options: MultiPickerFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    clear(): void;
+    refreshValue(): any;
+    private simpleValueUpdate;
+    private record;
+    value(record?: any, fireEvent?: any): any[];
+    added(item: Record): any;
+    pick(options?: PickerInputShowMoreOptions): void;
+    details(record: any): void;
+    private abortRequest;
+}

package/types/_core/scripts/views/form/controls/picker/picker.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="mithril" />
+import { Table } from "../../../../common/Table";
+import { IFilter } from "../../../../services/Filter";
+import { SearchOperation } from "../../../../services/RecordManager";
+import { PickRecordOptions } from "../../../pickRecordModal";
+import { FieldCtrl, FieldFormControl } from "../../field";
+import { PickerInputShowMoreOptions } from "./pickerInput";
+import { ListEvents } from "../../../list/ListCtrl";
+import { Query } from "_core/scripts/services/api/Query";
+import { ModalOptions } from "mdtScripts/views/containers/modal";
+import { BaseFieldOptions } from "../../LayoutTypes";
+import "./picker.less";
+import { Valued } from "mdtScripts/helpers/types";
+export interface PickerFieldCtrlOptions extends BaseFieldOptions {
+    refTable?: Valued<Table>;
+    pickOptions?: PickRecordOptions;
+    picked?: (r?: any) => void;
+    filter?: IFilter | (() => IFilter);
+    hintSelect?: string[];
+    hintSorting?: any[];
+    icon?: string;
+    events?: ListEvents;
+    itemClass?: (item: any) => any;
+    itemTooltip?: (item: any) => any;
+    linkClass?: (r: any) => any;
+    linkTitle?: (r: any) => any;
+    text?: (r: any) => string;
+    formatRecord?: string;
+    autopick?: {
+        query?: Query;
+    };
+    detailsEditable?: boolean;
+    searchOperation?: SearchOperation;
+    modalOptions?: ModalOptions;
+}
+export declare class PickerFieldCtrl implements FieldFormControl {
+    options: PickerFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    inputControl: any;
+    pickOptions: PickRecordOptions;
+    private schema;
+    hasReadonly: boolean;
+    defaultQuery: {
+        select: any[];
+    };
+    private pathData;
+    private displayValueReq;
+    constructor(options: PickerFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    value(r: any, fireEvent?: any, setDirty?: any, skipRequiredValidation?: any, updateData?: any): void;
+    text(): any;
+    pick(options?: PickerInputShowMoreOptions): void;
+    autoPickFirst(query?: any): any;
+    detailsEnabled(): any;
+    details(): import("mdtScripts/views/containers/modal").ModalCtrl;
+    clear(): void;
+    filter(): any;
+    private appendStyleToQuery;
+    private queryOptions;
+    private searchOptions;
+    private title;
+    private getTitleText;
+    private refTable;
+    private getLabelStyleView;
+    protected bound(): void;
+    private fetchDisplayValueFailed;
+    private fetchingDisplayValue;
+    protected fetchDisplayValue(): any;
+    abortRequest(): void;
+}

package/types/_core/scripts/views/form/controls/picker/pickerInput.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="mithril" />
+import { Field } from "../../../../common/Field";
+import { Record } from "../../../../common/Record";
+import { RecordManagerSearchByDefaultFieldOptions } from "../../../../services/RecordManager";
+import { ApiRequest } from "../../../../services/api/ApiRequestOptions";
+import { DropdownMenuCtrlOptions } from "../../../controls/DropdownMenu";
+import { FocusableControl } from "../../control";
+import { ActionItem } from "mdtScripts/helpers/ui/el";
+import { Table } from "mdtScripts/common/Table";
+import { IFilter } from "mdtServices/IFilter";
+export interface PickerInputShowMoreOptions {
+    filter?: IFilter;
+}
+export interface PickerInputCtrlOptions {
+    showMore: (options?: PickerInputShowMoreOptions) => void;
+    value?: () => Record[];
+    field?: Field;
+    enabled?: () => boolean;
+    searchable?: () => boolean;
+    selected?: (r: Record) => any;
+    remove?: () => any;
+    icon?: string;
+    placeholder?: string;
+    searchOptions?: RecordManagerSearchByDefaultFieldOptions;
+    focusTarget: FocusableControl;
+    refTable?: () => any;
+    dropdown?: DropdownMenuCtrlOptions;
+}
+export declare class PickerInputCtrl {
+    options: PickerInputCtrlOptions;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    req: _mithril.MithrilPromiseProperty<ApiRequest> & {
+        onchange: (v?: ApiRequest) => any;
+    };
+    private readonly defaultSearchTop;
+    constructor(options: PickerInputCtrlOptions);
+    enabled(): boolean;
+    hints(table: Table, text: string, filter: any): Promise<ActionItem[]>;
+    private isFoundLessThenTop;
+    private getShowMoreItem;
+}

package/types/_core/scripts/views/form/controls/query/BuilderFieldControlBase.d.ts

@@ -0,0 +1,23 @@
+import { FieldCtrl } from "../../field";
+import { FormCtrl } from "../../form";
+import { LayoutBuilder } from "../../Layout";
+export interface BuilderFieldControlOptions {
+    objectId?: any;
+    icon?: string;
+    title?: string;
+    showTitle?: string;
+}
+export declare abstract class BuilderFieldControlBase {
+    private fieldCtrl;
+    record: any;
+    content: FormCtrl;
+    options: BuilderFieldControlOptions;
+    protected value: (v?: any) => any;
+    constructor(options: BuilderFieldControlOptions, fieldCtrl: FieldCtrl);
+    protected defaultOptions(): BuilderFieldControlOptions;
+    init(): FormCtrl<import("../../../../common/Record").Record>;
+    protected table(): import("../../../../common/Table").Table;
+    protected layoutBuilder(): LayoutBuilder;
+    protected getObjectId(): any;
+    private initValueMediator;
+}

package/types/_core/scripts/views/form/controls/query/ControlsList.d.ts

@@ -0,0 +1,20 @@
+export interface ControlsListOptions {
+    createCtrl: () => any;
+    sortable?: any;
+}
+export interface ControlsListCallbacks {
+    add?: (ctrls: any, ctrl: any) => void;
+    remove?: (ctrls: any) => void;
+    change?: (ctrls: any) => void;
+}
+export declare class ControlsList {
+    controls: any[];
+    options: ControlsListOptions;
+    callbacks: ControlsListCallbacks;
+    constructor(controls?: any, options?: ControlsListOptions, callbacks?: ControlsListCallbacks);
+    init(controls: any): void;
+    add(): void;
+    remove(item: any): void;
+    reordered(ctrls: any): void;
+    setKey(ctrl: any): void;
+}

package/types/_core/scripts/views/form/controls/query/QueryBuilderControl.d.ts

@@ -0,0 +1,15 @@
+import { Table } from "../../../../common/Table";
+import { FieldCtrl } from "../../field";
+import { BuilderFieldControlOptions, BuilderFieldControlBase } from "./BuilderFieldControlBase";
+export interface QueryBuilderOptions extends BuilderFieldControlOptions {
+    selectEnabled?: boolean;
+    filterEnabled?: boolean;
+    selectOptions?: any;
+    filterOptions?: any;
+}
+export declare class QueryControl extends BuilderFieldControlBase {
+    options: QueryBuilderOptions;
+    constructor(options: QueryBuilderOptions, fieldCtrl: FieldCtrl);
+    table(): Table;
+    layoutBuilder(): import("../../Layout").LayoutBuilder;
+}

package/types/_core/scripts/views/form/controls/query/SelectBuilderControl.d.ts

@@ -0,0 +1,32 @@
+import { RecordId } from "./../../../../common/Record";
+import { Table } from "../../../../common/Table";
+import { FieldPathCtrl } from "../../../../common/controls/FieldPath";
+import { FieldCtrl } from "../../field";
+export interface SelectBuilderFieldCtrlOptions extends SelectBuilderControlOptions {
+    objectId?: RecordId | (() => RecordId);
+}
+export declare class SelectBuilderFieldCtrl {
+    options: SelectBuilderFieldCtrlOptions;
+    private fieldCtrl;
+    content: SelectBuilderControl;
+    objectId: number;
+    constructor(options: SelectBuilderFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    init(): void;
+    checkObjectId(): void;
+    getObjectId(): any;
+}
+interface SelectBuilderControlOptions {
+    single?: boolean;
+    fieldPathOptions?: any;
+}
+export declare class SelectBuilderControl {
+    options: SelectBuilderControlOptions;
+    controlsList: any;
+    pathControl: FieldPathCtrl;
+    value: (value?: any[]) => any[];
+    table: Table;
+    constructor(objectId: any, value?: (value?: any[]) => any[], options?: SelectBuilderControlOptions);
+    private createFieldPath;
+    private updateValue;
+}
+export {};

package/types/_core/scripts/views/form/controls/query/UpdateBuilderControl.d.ts

@@ -0,0 +1,12 @@
+import { Table } from "../../../../common/Table";
+import { FieldCtrl } from "../../field";
+import { LayoutBuilder } from "../../Layout";
+import { BuilderFieldControlOptions, BuilderFieldControlBase } from "./BuilderFieldControlBase";
+export declare type UpdateControlOptions = BuilderFieldControlOptions;
+export declare class UpdateControl extends BuilderFieldControlBase {
+    objectId: any;
+    constructor(options: UpdateControlOptions, fieldCtrl: FieldCtrl);
+    table(): Table;
+    layoutBuilder(): LayoutBuilder;
+    checkObjectId(): void;
+}

package/types/_core/scripts/views/form/controls/radio.d.ts

@@ -0,0 +1,24 @@
+import { FieldCtrl } from "../field";
+import { BaseFieldOptions } from "../LayoutTypes";
+export interface RadioFieldCtrlOptions extends BaseFieldOptions {
+    items?: any;
+    disabled?: (value: any, item: any) => boolean;
+}
+export declare class RadioFieldCtrl {
+    options: RadioFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    content: RadioCtrl;
+    constructor(options: RadioFieldCtrlOptions, fieldCtrl: FieldCtrl);
+}
+export interface RadioCtrlOptions {
+    items?: any;
+    disabled?: (value: any, item: any) => boolean;
+}
+export declare class RadioCtrl {
+    name: any;
+    value: (v?: any) => any;
+    options: RadioCtrlOptions;
+    constructor(name: any, value: (v?: any) => any, options?: RadioCtrlOptions);
+    items(): any;
+    disabled(value: any, item: any): boolean;
+}

package/types/_core/scripts/views/form/controls/radioPicker.d.ts

@@ -0,0 +1,10 @@
+import { RadioCtrl } from "./radio";
+import { FieldCtrl } from "../field";
+import { SelectMixin, SelectFieldCtrlOptions } from "../controls";
+export declare type RadioFieldFkCtrlOptions = SelectFieldCtrlOptions;
+export declare class RadioPickerFieldCtrl extends SelectMixin {
+    options: RadioFieldFkCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    content: RadioCtrl;
+    constructor(options: RadioFieldFkCtrlOptions, fieldCtrl: FieldCtrl);
+}

package/types/_core/scripts/views/form/controls/secretFieldCtrl.d.ts

@@ -0,0 +1,12 @@
+import { FieldCtrl, FieldFormControl } from "../field";
+import { TextFieldCtrlOptions } from "./text";
+declare type SecretFieldCtrlOptions = TextFieldCtrlOptions;
+export declare class SecretFieldCtrl implements FieldFormControl {
+    fieldCtrl: FieldCtrl;
+    hasReadonly: boolean;
+    private content;
+    private show;
+    constructor(options: SecretFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    private toggleShow;
+}
+export {};

package/types/_core/scripts/views/form/controls/select.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="mithril" />
+import { IFilter } from "../../../services/Filter";
+import { FieldCtrl } from "../field";
+import { QuerySorting } from "_core/scripts/services/api/Query";
+import { ControlSize } from "mdtScripts/views/controls/Control";
+export declare abstract class SelectMixin {
+    options: SelectFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    keyField: string;
+    valueField: string;
+    filter: IFilter;
+    sortField: QuerySorting;
+    rows: any[];
+    isRowsFetched: boolean;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    private req;
+    selectFields: any[];
+    $initFetch: boolean;
+    curFilter: any;
+    constructor(options: SelectFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    hasFilter(): boolean;
+    initFilter(): void;
+    turnOffControl: any;
+    refresh(init?: boolean): void;
+    isCurrentValueInOptions(): boolean;
+    fetchRows(): any;
+    fetchCurrentRow(): any;
+    private isAutoSelected;
+    autoSelectFirst(): void;
+    pushCurrentRows(rows: any[]): void;
+    clearCurrentRow(): void;
+    abortRequest(): void;
+}
+export interface SelectFieldCtrlOptions {
+    autoselect?: boolean;
+    selectFields?: string[];
+    keyField?: string;
+    valueField?: string;
+    sortField?: string;
+    filter?: IFilter | (() => IFilter);
+    datasource?: any;
+}
+export declare class SelectFieldCtrl extends SelectMixin {
+    fieldCtrl: FieldCtrl;
+    constructor(options: SelectFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    /**
+     * @deprecated
+     * use stringifyControlSize
+     */
+    getSelectSize(size: ControlSize): import("mdtScripts/helpers/utils/stringifyControlSize").ComponentSize;
+}

package/types/_core/scripts/views/form/controls/sortingList.d.ts

@@ -0,0 +1,13 @@
+import { SortingManager } from "../../../services/SortingManager";
+import { FieldCtrl } from "../field";
+import { ListCtrl } from "../../list/ListCtrl";
+export interface SortingListCtrlOptions {
+    sorting: any;
+}
+export declare class SortingListCtrl {
+    private options;
+    fieldCtrl: FieldCtrl;
+    sorting: SortingManager;
+    list: ListCtrl;
+    constructor(options: SortingListCtrlOptions, fieldCtrl: FieldCtrl);
+}

package/types/_core/scripts/views/form/controls/text.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="mithril" />
+import { FieldCtrl, FieldFormControl } from "../field";
+import { Button } from "mdtScripts/helpers/ui/el";
+export interface TextFieldCtrlOptions {
+    type?: any;
+    control?: any;
+    wordWrap?: any;
+    css?: any;
+    rows?: number;
+    hinted?: any;
+    autofocus?: boolean;
+    min?: number;
+    max?: number;
+    icon?: string | (() => string);
+    showClearAction?: boolean;
+    actions?: Button[];
+}
+export declare class TextFieldCtrl implements FieldFormControl {
+    fieldCtrl: FieldCtrl;
+    hints: (v: any) => any;
+    hintSelected: (v: any) => any;
+    options: TextFieldCtrlOptions;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    constructor(options: TextFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    hasClearAction: () => boolean;
+    showClearAction: () => boolean;
+    hasAddons: () => string | number | boolean | (() => string);
+}