mdt-client 1.0.26 → 1.0.29

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

@@ -0,0 +1,17 @@
+/// <reference types="mithril" />
+import { FieldCtrl, FieldFormControl } from "../field";
+import { BaseFieldOptions } from "../LayoutTypes";
+export interface ChangeableControlOptions extends BaseFieldOptions {
+    childControl: (fieldCtrl: FieldCtrl) => any;
+}
+export declare class ChangeableFieldControl implements FieldFormControl {
+    options: ChangeableControlOptions;
+    fieldCtrl: any;
+    hasReadonly: any;
+    control: any;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    constructor(options: ChangeableControlOptions, fieldCtrl: any);
+    rebuild(): void;
+}

package/types/_core/scripts/views/form/controls/code/adapters/base.d.ts

@@ -0,0 +1,6 @@
+import { CodeFieldCtrl } from "../code";
+export declare class CodeFieldAdapter {
+    init(owner: CodeFieldCtrl, options: any): void;
+    viewConfig(ctrl: CodeFieldCtrl, el: any, ctx: any): void;
+    value(CodeTextFieldCtrl: any): void;
+}

package/types/_core/scripts/views/form/controls/code/adapters/markdown.d.ts

@@ -0,0 +1,10 @@
+import { ApiService } from "../../../../../services/api/ApiService";
+import { CodeFieldAdapterOptions, CodeFieldCtrl } from "../code";
+import { CodeFieldAdapter } from "./base";
+export declare class CodeFieldMarkdownAdapter extends CodeFieldAdapter {
+    private owner;
+    api: ApiService;
+    constructor(owner: CodeFieldCtrl, options: CodeFieldAdapterOptions);
+    insertLink(file: any): void;
+    viewConfig(ctrl: any, el: any, ctx: any): void;
+}

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

@@ -0,0 +1,31 @@
+import { ActionItem } from "../../../../helpers/ui/el";
+import { FieldCtrl } from "../../field";
+import { CodeTextFieldCtrl, AceCommand } from "./codeText";
+import { CodeFieldAdapter } from "./adapters/base";
+export interface CodeFieldAdapterOptions {
+    mode: string;
+    wrap?: boolean;
+}
+export interface CodeFieldOptions extends CodeFieldAdapterOptions {
+    previewType: string;
+    previewMode: string;
+    height?: string;
+    fullscreen?: boolean;
+    commands?: AceCommand[];
+}
+export declare class CodeFieldCtrl {
+    options: CodeFieldOptions;
+    private fieldCtrl;
+    hasReadonly: boolean;
+    codeCtrl: CodeTextFieldCtrl;
+    content: any;
+    actions: ActionItem[];
+    adapter: CodeFieldAdapter;
+    createPreviewCtrl(): any;
+    constructor(options: CodeFieldOptions, fieldCtrl: FieldCtrl);
+    init(): void;
+    private _fullscreen;
+    fullscreen(): void;
+    isFullscreen(): boolean;
+    fullscreenAvailable(): boolean;
+}

package/types/_core/scripts/views/form/controls/code/codeText.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="mithril" />
+import { FieldCtrl, FieldFormControl } from "../../field";
+export interface AceCommand {
+    name: string;
+    bindKey: string;
+    exec: () => void;
+}
+export interface CodeTextFieldOptions {
+    mode: string;
+    gutter?: boolean;
+    edit?: boolean;
+    wrap?: boolean;
+    validate?: boolean;
+    syntaxCheck?: boolean;
+    commands?: AceCommand[];
+}
+export declare class CodeTextFieldCtrl implements FieldFormControl {
+    fieldCtrl: FieldCtrl;
+    editor: any;
+    hasReadonly: any;
+    options: CodeTextFieldOptions;
+    inited: _mithril.MithrilPromise<any>;
+    events: {
+        changed: any[];
+        scroll: any[];
+        enable: any[];
+        insert: any[];
+    };
+    value: any;
+    constructor(options: CodeTextFieldOptions, fieldCtrl: FieldCtrl);
+    enable(flag: any): void;
+    scroll(e: any): void;
+    insertLink(e: any): void;
+    init(): void;
+}

package/types/_core/scripts/views/form/controls/code/preview/markdown.d.ts

@@ -0,0 +1,14 @@
+import { FieldCtrl } from "../../../field";
+import { CodeTextFieldCtrl } from "../codeText";
+declare global {
+    const marked: any;
+}
+export declare class MarkdownPreviewCtrl {
+    fieldCtrl: FieldCtrl;
+    private codeCtrl;
+    constructor(fieldCtrl: FieldCtrl, codeCtrl: CodeTextFieldCtrl);
+    events: {
+        scroll: any[];
+    };
+    scrollTo(top: any): void;
+}

package/types/_core/scripts/views/form/controls/commonControl/ICommonControl.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="mithril" />
+import { Valued, ViewElement } from "../../../../helpers/types";
+export interface Action {
+    icon?: Valued<string>;
+    code?: string;
+    title?: Valued<string>;
+    command?: () => void;
+}
+export interface ClearAction {
+    show?: boolean;
+    title?: Valued<string>;
+    command?: () => void;
+}
+export interface CommonControlOptions {
+    actions?: Action[];
+    clearAction?: ClearAction;
+    icon?: Valued<string>;
+    readonly?: boolean;
+    attrs?: _mithril.MithrilAttributes;
+    contentAttrs?: _mithril.MithrilAttributes;
+    content?: ViewElement;
+    invalid?: boolean;
+}

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

@@ -0,0 +1,5 @@
+/// <reference types="mithril" />
+import "./commonControl.less";
+import { CommonControlOptions } from "./ICommonControl";
+import "./inlineCommonControl.less";
+export declare function commonControl(options: CommonControlOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/views/form/controls/commonControl/mdtCommonControl.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="mithril" />
+import { CommonControlOptions } from "./ICommonControl";
+export declare function mdtCommonControl(options: CommonControlOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/views/form/controls/commonControl/removeInputStyle.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="mithril" />
+import "./removeInputStyle.less";
+export declare function removeInputStyle(content?: _mithril.MithrilVirtualElement): _mithril.MithrilVirtualElement;

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

@@ -0,0 +1,28 @@
+import { FieldCtrl, FieldFormControl } from "../field";
+declare global {
+    const Pikaday: any;
+}
+export declare type DateFieldCtrlOptions = {};
+export declare class DateFieldCtrl implements FieldFormControl {
+    options: DateFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    hasReadonly: any;
+    content: DateInputCtrl;
+    constructor(options: DateFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    init(): void;
+}
+export declare class DateInputCtrl {
+    value: any;
+    elementId: any;
+    options: any;
+    pikaday: any;
+    constructor(value: any, elementId?: any, options?: any);
+    clear(): void;
+    static i18n(): {
+        previousMonth: string;
+        nextMonth: string;
+        months: any[];
+        weekdays: any[];
+        weekdaysShort: any[];
+    };
+}

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

@@ -0,0 +1,11 @@
+import { FieldCtrl, FormlessFieldCtrlOptions, FieldFormControl } from "../field";
+export interface DateTextFieldOptions extends FormlessFieldCtrlOptions {
+    disableDayFn?: any;
+    customControl?: any;
+}
+export declare class DateTextFieldCtrl implements FieldFormControl {
+    options: DateTextFieldOptions;
+    fieldCtrl: FieldCtrl;
+    hasReadonly: any;
+    constructor(options: DateTextFieldOptions, fieldCtrl: FieldCtrl);
+}

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

@@ -0,0 +1,38 @@
+/// <reference types="mithril" />
+import { FieldFormControl, FieldCtrl } from "_core/scripts/views/form/field";
+import { FormCtrl } from "_core/scripts/views/form/form";
+import { Field } from "_core/scripts/common/Field";
+import { SchemaManager } from "_core/scripts/services/SchemaManager";
+import { Record } from "mdtScripts/common/Record";
+import { FormLayoutColOptions } from "../Layout";
+import { Table } from "mdtScripts/common/Table";
+import { FormColOptions } from "../LayoutTypes";
+import { ApiRequestOptions } from "mdtServices/api/ApiRequestOptions";
+export interface DynamicFkFormFieldCtrlOptions extends FormLayoutColOptions<FormColOptions> {
+    formExtenders?: any;
+    hideTitle?: boolean;
+    subtitle?: string;
+    hideSubtitle?: boolean;
+}
+export declare class DynamicFkFormFieldCtrl implements FieldFormControl {
+    private options;
+    private fieldCtrl;
+    hasReadonly: boolean;
+    form: FormCtrl;
+    parent: FormCtrl;
+    schema: SchemaManager;
+    objectPath: Field[];
+    recordField: Field;
+    map: {};
+    constructor(options: DynamicFkFormFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    private _visibilityState;
+    setupVisibilityValidationFix(): void;
+    isIDRelation(): boolean;
+    loadObjectId(): _mithril.MithrilPromise<any>;
+    static loadObjectId(field: Field, record: Record, requestOptions?: ApiRequestOptions): _mithril.MithrilPromise<any>;
+    showForm(): void;
+    show(objectId: any, recordId: any): void;
+    static dfkRecordField(field: Field, table: Table): Field;
+}
+export declare function addHeaderToLayout(layout: any, table: Table, ctrl: any): void;
+export declare function subFormView(ctrl: any): _mithril.MithrilVirtualElement;

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

@@ -0,0 +1,19 @@
+/// <reference types="mithril" />
+import { FieldPathCtrl } from "../../../common/controls/FieldPath";
+import { FieldCtrl, FieldFormControl } from "../field";
+export interface FieldPathFieldCtrlOptions {
+    objectIdPath: string;
+    changed: any;
+    limit?: number;
+    objectId?: () => number | number;
+}
+export declare class FieldPathFieldCtrl implements FieldFormControl {
+    options: any;
+    fieldCtrl: FieldCtrl;
+    pathCtrl: FieldPathCtrl;
+    focus: _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+    constructor(options: FieldPathFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    checkObject(): void;
+}

package/types/_core/scripts/views/form/controls/fileupload/AttachmentFormExtender.d.ts

@@ -0,0 +1,5 @@
+import { FormCtrl } from "../../form";
+export declare class AttachmentFormExtender {
+    constructor(form: FormCtrl);
+    static findFileM2M(table: any): any;
+}

package/types/_core/scripts/views/form/controls/fileupload/file.d.ts

@@ -0,0 +1,68 @@
+import { FieldCtrl, FieldFormControl } from "../../field";
+import { ThumbImage } from "../../../gallery/ThumbImage";
+import { BaseFieldOptions } from "../../LayoutTypes";
+export declare class FileFieldCtrl implements FieldFormControl {
+    options: FileInputOptions;
+    fieldCtrl: FieldCtrl;
+    private api;
+    private provider;
+    content: FileInputCtrl;
+    hasReadonly: boolean;
+    constructor(options: FileInputOptions, fieldCtrl: FieldCtrl);
+}
+export interface FileCtrlCommonOptions {
+    whiteList?: string[];
+}
+export interface FileInputOptions extends BaseFieldOptions, FileCtrlCommonOptions {
+    disk?: boolean;
+    uploadUrl: () => string;
+    downloadUrl: (att: boolean) => string;
+    previewSrc?: () => string;
+    thumbOnClick?: () => any;
+    value: () => any;
+    clear: () => void;
+    text: () => string;
+    uploaded?: (r: any, files?: any) => void;
+    readonly?: boolean | {
+        (): boolean;
+    };
+    type?: "default" | "image";
+    fileType?: string;
+    height?: number;
+    width?: number;
+    imageMode?: "fit" | "fill";
+    fileAdded?: (file: File) => void;
+    provider?: () => string;
+}
+export declare class FileInputCtrl {
+    options: FileInputOptions;
+    private api;
+    valueCtrl: any;
+    events: {
+        progress: any[];
+    };
+    types: {
+        default: typeof DefaultFileInputValueCtrl;
+        image: typeof ImageFileInputValueCtrl;
+    };
+    constructor(options: FileInputOptions);
+    type(): any;
+    upload(file: File): void;
+}
+export declare class DefaultFileInputValueCtrl {
+    fileName: () => string;
+    url: (att: boolean) => string;
+    options?: FileInputOptions;
+    name: string;
+    constructor(fileName: () => string, url: (att: boolean) => string, options?: FileInputOptions);
+    isOneDrive(): boolean;
+    getTooltipText(isFileNameCropped: boolean): string;
+}
+export declare class ImageFileInputValueCtrl {
+    fileName: () => string;
+    url: (att: boolean) => string;
+    options?: any;
+    name: string;
+    thumb: ThumbImage;
+    constructor(fileName: () => string, url: (att: boolean) => string, options?: any);
+}

package/types/_core/scripts/views/form/controls/fileupload/fileuploadService.d.ts

@@ -0,0 +1,3 @@
+export declare function getAcceptAttribute(whiteList: string[]): string;
+export declare function checkMultyFilesFormats(whiteList: string[], fileNames: string[]): boolean;
+export declare function checkFileFormat(whiteList: string[], fileName: string): boolean;

package/types/_core/scripts/views/form/controls/fileupload/multifile.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="mithril" />
+import { FieldCtrl } from "../../field";
+import { FileCtrlCommonOptions } from "./file";
+export interface FileListCtrlOptions extends FileCtrlCommonOptions {
+    readonly?: any;
+    downloadUrl?: (item: any) => string;
+    remove?: (item: any) => void;
+    upload?: (files: any) => void;
+}
+export interface FileListFieldCtrlOptions {
+    controlOptions: FileListCtrlOptions;
+    m2mField?: string;
+}
+export declare class FileListFieldCtrl {
+    options: FileListFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    content: any;
+    fileField: any;
+    hasReadonly: boolean;
+    private req;
+    constructor(options: FileListFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    initContent(): void;
+    readonly(): boolean;
+    remove(item: any): void;
+    upload(files: FileList): void;
+    getFilesData(): any;
+    refreshValue(): any;
+    private validateFormats;
+}
+export interface File {
+    ID: number;
+    Name: string;
+    ShortUid: string;
+    Title: string;
+}
+export declare class FileListCtrl {
+    source: () => File[];
+    options: FileListCtrlOptions;
+    constructor(source: () => File[], options?: FileListCtrlOptions);
+    readonly(): any;
+    upload(files: any): void;
+    downloadUrl(data: any): string;
+    remove(item: any): void;
+}
+export declare function multiFileInput(onChange: (e: any) => void, attrs: _mithril.MithrilAttributes): _mithril.MithrilVirtualElement;

package/types/_core/scripts/views/form/controls/fileupload/thumblist.d.ts

@@ -0,0 +1,35 @@
+import { FileListFieldCtrlOptions, FileListFieldCtrl, FileListCtrlOptions } from "./multifile";
+import { FieldCtrl } from "../../field";
+import { ImageServiceContext } from "../../../gallery/ImageService";
+export interface ImageListFieldCtrlOptions extends FileListFieldCtrlOptions {
+    controlOptions: ThumbListOptions;
+}
+export declare class ImageListFieldCtrl extends FileListFieldCtrl {
+    options: ImageListFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    hasReadonly: boolean;
+    constructor(options: ImageListFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    initContent(): void;
+}
+export interface ThumbListOptions extends FileListCtrlOptions {
+    title?: any;
+    downloadTitle?: string;
+    readonly?: any;
+    upload?: (files: any) => any;
+    remove?: (item: any) => any;
+    galleryDataHandler?: any;
+    galleryCtx?: ImageServiceContext;
+}
+export declare class ThumbList {
+    data: () => any;
+    options: ThumbListOptions;
+    title: any;
+    downloadTitle: any;
+    thumbImages: any[];
+    constructor(data: () => any, options?: ThumbListOptions);
+    update(): void;
+    getGalleryData(): any;
+    getZip(): Window;
+    readonly(): any;
+    upload(files: any): void;
+}

package/types/_core/scripts/views/form/controls/filter/filterFieldModal.d.ts

@@ -0,0 +1,15 @@
+export interface FilterModalFieldControlOptions {
+    objectId: string | number;
+}
+export declare class FilterModalFieldControl {
+    options: any;
+    fieldCtrl: any;
+    content: any;
+    constructor(options: any, fieldCtrl: any);
+}
+export declare class FilterFieldModal {
+    value: any;
+    objectIdFn: any;
+    constructor(value: any, objectIdFn: any);
+    modal(): void;
+}

package/types/_core/scripts/views/form/controls/filter/filterSettings.d.ts

@@ -0,0 +1,33 @@
+import { LabelMode } from "../../form";
+import { Field } from "../../../../common/Field";
+export declare class FilterSettings {
+    static defaultFilterGroup(r?: {}): {
+        op: string;
+        groups: {
+            $table: string;
+        }[];
+    };
+    static setupLayoutCol(objectId: number): {
+        refTable: import("../../../../common/Table").Table;
+        formOptions: {
+            objectId: () => number;
+            events: {
+                layout: {
+                    begin: (layout: any) => void;
+                };
+            };
+        };
+        control: string;
+        title: string;
+        labelMode: LabelMode;
+        css: string;
+    };
+    static filterGroupEvents(): {
+        layout: {
+            begin: (layout: any) => void;
+        };
+    };
+    static getSelectedField(code: any, objectId: any): Field;
+    static controlP2Type(type: any, op?: any, fk?: any): any;
+    static p2Available(op: string): boolean;
+}

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

@@ -0,0 +1,15 @@
+import { FieldCtrl } from "../field";
+export interface FilterFieldCtrlOptions {
+    objectId: any;
+}
+export declare class FilterFieldCtrl {
+    options: FilterFieldCtrlOptions;
+    private fieldCtrl;
+    content: any;
+    objectId: any;
+    constructor(options: FilterFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    init(): void;
+    checkObjectId(): void;
+    getObjectId(): any;
+    private cleanFilter;
+}

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

@@ -0,0 +1,58 @@
+/// <reference types="mithril" />
+import { Table } from "../../../common/Table";
+import { Button } from "../../../helpers/ui/el";
+import { FieldCtrl, FieldFormControl } from "../field";
+import { FormOptions, FormCtrl } from "../form";
+import { Record } from "../../../common/Record";
+export declare enum FormFieldMode {
+    Simple = 0,
+    Extend = 1
+}
+interface Form {
+    $destroy?: boolean;
+    record: any;
+    content: FormCtrl;
+}
+export interface FormFieldCtrlOptions {
+    refTable?: Table;
+    refTableCode?: string;
+    actions?: FormFieldButton[];
+    formOptions?: FormOptions;
+    compact?: boolean;
+    onadd?: (rec: any, table: Table) => void;
+    markAsDirty?: boolean;
+    useDelimiter?: boolean;
+    onInited?: (el: any, ctx: any) => void;
+    onFormInited?: (form: Form, ctx: any, el: any) => void;
+    mode?: FormFieldMode;
+    addButtonVisible?: () => boolean;
+    removeButtonVisible?: () => boolean;
+    fieldCss?: string;
+    sort?: (a: Record, b: Record) => number;
+}
+export interface FormFieldButton extends Button {
+    table?: Table;
+    onadd?: (rec: any, table: Table, form: FormCtrl) => void;
+}
+export declare class FormFieldCtrl implements FieldFormControl {
+    options: FormFieldCtrlOptions;
+    private fieldCtrl;
+    hasReadonly: any;
+    forms: Array<Form>;
+    refTable: Table;
+    isListField: boolean;
+    btns: FormFieldButton[];
+    removeBtn: Button;
+    addBtn: Button;
+    inited: _mithril.MithrilPromise<any>;
+    constructor(options: FormFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    private getAddButton;
+    private getRemoveButton;
+    rebuild(): void;
+    add(record?: any, table?: Table, afterForm?: Form, btn?: FormFieldButton, inited?: (form: FormCtrl) => void, setDirty?: boolean): FormCtrl;
+    remove(form: Form): void;
+    getForms(): Form[];
+    records(): any;
+    update(setDirty?: boolean): void;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { FieldCtrl, FieldFormControl } from "../field";
+export declare type GeographyFieldCtrlOptions = {};
+export declare class GeographyFieldCtrl implements FieldFormControl {
+    fieldCtrl: FieldCtrl;
+    hasReadonly: any;
+    constructor(options: GeographyFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    value(prop: any, val?: any): any;
+}

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

@@ -0,0 +1,27 @@
+/// <reference types="mithril" />
+import { FieldCtrl, FieldFormControl } from "../field";
+export interface HtmlFieldCtrlOptions {
+    height?: string;
+    container?: "div";
+    css?: string;
+    markdown?: boolean;
+}
+export declare class HtmlFieldCtrl implements FieldFormControl {
+    options: HtmlFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    hasReadonly: boolean;
+    content: HtmlCtrl;
+    constructor(options: HtmlFieldCtrlOptions, fieldCtrl: FieldCtrl);
+}
+interface HtmlFieldOptions extends HtmlFieldCtrlOptions {
+    value: () => string;
+}
+export declare class HtmlCtrl {
+    private options;
+    private el;
+    constructor(options: HtmlFieldOptions);
+    print(): void;
+    private initEl;
+    $view: () => _mithril.MithrilVirtualElement;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { FieldCtrl, FieldFormControl } from "../field";
+export declare type IconPickerFieldCtrlOptions = {};
+export declare class IconPickerFieldCtrl implements FieldFormControl {
+    fieldCtrl: FieldCtrl;
+    content: IconPicker;
+    hasReadonly: boolean;
+    constructor(options: IconPickerFieldCtrlOptions, fieldCtrl: FieldCtrl);
+}
+export declare class IconPicker {
+    icon: any;
+    onchange: any;
+    constructor(onchange?: (code: string) => string, current?: () => string);
+    pick(): void;
+}
+export declare class IconData {
+    description: string;
+    code: string;
+}
+export interface IconsBlockOptions {
+    pick?: (code: string, isDbl?: boolean) => void;
+    current?: string;
+}
+export declare class IconsBlock {
+    static iconCodes: IconData[];
+    search: string;
+    options: IconsBlockOptions;
+    current: string;
+    static systemClasses: string[];
+    static getIconCodes(): IconData[];
+    constructor(options: IconsBlockOptions);
+    pick(code: string, dblClick?: boolean): void;
+    $clickCounter: number;
+}
+export declare class IconPickerModal {
+    static create(onchange: any, current: any): import("../../containers/modal").ModalCtrl;
+}

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

@@ -0,0 +1,18 @@
+import { FieldFormControl } from "../field";
+export interface ListFieldCtrlOptions {
+    prop: string;
+}
+export declare class ListFieldCtrl implements FieldFormControl {
+    fieldCtrl: any;
+    hasReadonly: any;
+    prop: any;
+    list: any[];
+    lastItemIndex: number;
+    constructor(options: ListFieldCtrlOptions, fieldCtrl: any);
+    init(): void;
+    update(): void;
+    add(): void;
+    remove(t: any): void;
+    rename(v: any, idx: any): void;
+    private clearEmpty;
+}

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

@@ -0,0 +1,22 @@
+import { FieldCtrl, FieldFormControl } from "../field";
+import { ListCtrl } from "../../list/ListCtrl";
+import { ListOptions } from "mdtScripts/views/list/ListOptions";
+import { ListExtConfig } from "mdtScripts/common/list/ListExt";
+export interface ListGridFieldCtrlOptions {
+    root: boolean;
+    listOptions: ListOptions;
+    listExtenders: ListExtConfig;
+    /** Вызывать окно добавления при инициализации */
+    addOnLoad: boolean;
+    listPickOptions?: ListOptions;
+}
+export declare class ListGridFieldCtrl implements FieldFormControl {
+    options: ListGridFieldCtrlOptions;
+    fieldCtrl: FieldCtrl;
+    hasReadonly: any;
+    content: any;
+    list: ListCtrl;
+    constructor(options: ListGridFieldCtrlOptions, fieldCtrl: FieldCtrl);
+    add(): void;
+    remove(): void;
+}