dhx-chart 8.2.4 → 8.2.5

package/codebase/types/ts-form/sources/elements/checkbox.d.ts

@@ -0,0 +1,84 @@
+import { IEventSystem } from "../../../ts-common/events";
+import { Popup } from "../../../ts-popup";
+import { ItemEvent, IBaseLayoutItem, IMessage, ILabel, IBaseState, IBaseItem, IBaseHandlersMap } from "../types";
+import { Label } from "./helper/label";
+import { IFieldset } from "./fieldset";
+export interface ICheckboxProps extends IBaseLayoutItem, ILabel, IMessage {
+    text?: string;
+}
+export interface ICheckboxConfig extends ICheckboxProps, IBaseState, IBaseItem {
+    type: "checkbox";
+    checked?: boolean;
+    value?: string;
+    $group?: boolean;
+    $required?: boolean;
+}
+export interface ICheckbox {
+    parent?: IFieldset;
+    config: ICheckboxConfig;
+    events: IEventSystem<ItemEvent, ICheckboxEventHandlersMap>;
+    destructor(): void;
+    getValue(): string | boolean;
+    setValue(checked: boolean): void;
+    focus(): void;
+    blur(): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    clear(): void;
+    validate(silent?: boolean): boolean;
+    clearValidate(): void;
+    isChecked(): boolean;
+    setProperties(propertyConfig: ICheckboxProps, silent?: boolean): void;
+    getProperties(): ICheckboxProps;
+}
+export interface ICheckboxEventHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: string | boolean) => boolean | void;
+    [ItemEvent.change]: (value: string | boolean) => void;
+    [ItemEvent.focus]: (value: string | boolean, id?: string) => void;
+    [ItemEvent.blur]: (value: string | boolean, id?: string) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent, id?: string) => void;
+    [ItemEvent.beforeHide]: (value: string | boolean, init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: string | boolean) => boolean | void;
+    [ItemEvent.afterHide]: (value: string | boolean, init: boolean) => void;
+    [ItemEvent.afterShow]: (value: string | boolean) => void;
+    [ItemEvent.beforeValidate]: (value: string | boolean) => boolean | void;
+    [ItemEvent.afterValidate]: (value: string | boolean, isValidate: boolean) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: ICheckboxProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: ICheckboxProps) => void;
+}
+export declare class Checkbox extends Label implements ICheckbox {
+    parent: IFieldset;
+    config: ICheckboxConfig;
+    events: IEventSystem<ItemEvent, ICheckboxEventHandlersMap>;
+    protected _handlers: any;
+    protected _helper: Popup;
+    private _inGroup;
+    private _propsItem;
+    private _props;
+    constructor(container: HTMLElement | string, config?: {});
+    setProperties(propertyConfig: ICheckboxProps, silent?: boolean): void;
+    getProperties(): ICheckboxProps;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    validate(silent?: boolean): boolean;
+    clearValidate(): void;
+    setValue(checked: boolean, silent?: boolean): void;
+    getValue(): string | boolean;
+    clear(silent?: boolean): void;
+    destructor(): void;
+    focus(): void;
+    blur(): void;
+    isChecked(): boolean;
+    private _getValue;
+    private _initView;
+    protected _initHandlers(): void;
+    protected _draw(): any;
+}

package/codebase/types/ts-form/sources/elements/checkboxGroup.d.ts

@@ -0,0 +1,103 @@
+import { Layout } from "../../../ts-layout";
+import { IEventSystem } from "../../../ts-common/events";
+import { Label } from "./helper/label";
+import { ItemEvent, IBaseLayoutItem, IBaseItem, IBaseState, IGroup, ILabel, IMessage, IBaseHandlersMap } from "../types";
+import { IFieldset } from "./fieldset";
+export interface ICheckboxGroupValue {
+    [id: string]: boolean | string;
+}
+export interface ICheckboxGroupItemProps extends IBaseLayoutItem {
+    id?: string;
+    checked?: boolean;
+    value?: string;
+    text?: string;
+}
+export interface ICheckboxGroupItemConfig extends IBaseItem, IBaseState, ICheckboxGroupItemProps {
+    type: "checkbox";
+    $group?: boolean;
+}
+export interface ICheckboxGroupOption extends IGroup {
+    rows?: ICheckboxGroupItemConfig[];
+    cols?: ICheckboxGroupItemConfig[];
+}
+export interface ICheckboxGroupProps extends IBaseLayoutItem, ILabel, IMessage {
+    options?: ICheckboxGroupOption;
+}
+export interface ICheckboxGroupConfig extends IBaseItem, IBaseState, ICheckboxGroupProps {
+    type: "checkboxgroup";
+    value?: ICheckboxGroupValue;
+}
+export interface ICheckboxGroup {
+    parent?: IFieldset;
+    config: ICheckboxGroupConfig;
+    events: IEventSystem<ItemEvent, ICheckboxGroupEventHandlersMap>;
+    destructor(): void;
+    getValue(): ICheckboxGroupValue;
+    getValue(id: string): string | boolean;
+    getValue(id?: string): ICheckboxGroupValue | string | boolean;
+    setValue(value: ICheckboxGroupValue): void;
+    focus(id?: string): void;
+    blur(): void;
+    show(id?: string): void;
+    hide(id?: string, init?: boolean): void;
+    isVisible(id?: string): boolean;
+    disable(id?: string): void;
+    enable(id?: string): void;
+    isDisabled(id?: string): boolean;
+    clear(): void;
+    validate(silent?: boolean): boolean;
+    clearValidate(): void;
+    isChecked(id?: string): boolean | {
+        [key: string]: boolean;
+    };
+    getProperties(id?: string): ICheckboxGroupProps | ICheckboxGroupItemProps;
+    setProperties(arg?: string | ICheckboxGroupProps, props?: ICheckboxGroupItemProps): void;
+}
+export interface ICheckboxGroupEventHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: ICheckboxGroupValue) => boolean | void;
+    [ItemEvent.change]: (value: ICheckboxGroupValue) => void;
+    [ItemEvent.focus]: (value: ICheckboxGroupValue, id: string) => void;
+    [ItemEvent.blur]: (value: ICheckboxGroupValue, id: string) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent, id: string) => void;
+    [ItemEvent.beforeHide]: (value: ICheckboxGroupValue, id?: string, init?: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: ICheckboxGroupValue, id?: string) => boolean | void;
+    [ItemEvent.afterHide]: (value: ICheckboxGroupValue, id?: string, init?: boolean) => void;
+    [ItemEvent.afterShow]: (value: ICheckboxGroupValue, id?: string) => void;
+    [ItemEvent.beforeValidate]: (value: ICheckboxGroupValue) => boolean | void;
+    [ItemEvent.afterValidate]: (value: ICheckboxGroupValue, isValidate: boolean) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: ICheckboxGroupProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: ICheckboxGroupProps) => void;
+}
+export declare class CheckboxGroup extends Label implements ICheckboxGroup {
+    parent: IFieldset;
+    config: ICheckboxGroupConfig;
+    layout: Layout;
+    events: IEventSystem<ItemEvent, ICheckboxGroupEventHandlersMap>;
+    private _buttons;
+    private _propsItem;
+    private _props;
+    constructor(container: any, config: ICheckboxGroupConfig);
+    destructor(): void;
+    setProperties(arg?: string | ICheckboxGroupProps, props?: ICheckboxGroupItemProps): void;
+    getProperties(id?: string): ICheckboxGroupProps | ICheckboxGroupItemProps;
+    getValue(): ICheckboxGroupValue;
+    getValue(id: string): string | boolean;
+    setValue(newValue: ICheckboxGroupValue): void;
+    isChecked(id?: string): boolean | {
+        [key: string]: boolean;
+    };
+    focus(id?: string): void;
+    blur(): void;
+    show(id?: string): void;
+    hide(id?: string, init?: boolean): void;
+    isVisible(id?: string): boolean;
+    enable(id?: string): void;
+    disable(id?: string, init?: boolean): void;
+    isDisabled(id?: string): boolean;
+    clear(): void;
+    validate(silent?: boolean): boolean;
+    clearValidate(): void;
+    protected _initView(config: ICheckboxGroupConfig): void;
+    protected _initHandlers(): void;
+    protected _draw(): any;
+}

package/codebase/types/ts-form/sources/elements/colorpicker.d.ts

@@ -0,0 +1,101 @@
+import { Colorpicker, ViewsMode } from "../../../ts-colorpicker";
+import { IEventSystem } from "../../../ts-common/events";
+import { Label } from "./helper/label";
+import { ItemEvent, IBaseHandlersMap, IBaseLayoutItem, ILabel, IMessage, ValidationFn, IBaseItem, IBaseState } from "../types";
+import { IFieldset } from "./fieldset";
+export interface IColorpickerProps extends IBaseLayoutItem, ILabel, IMessage {
+    validation?: ValidationFn;
+    icon?: string;
+    placeholder?: string;
+    editable?: boolean;
+    mode?: ViewsMode;
+    grayShades?: boolean;
+    customColors?: string[];
+    palette?: string[][];
+    paletteOnly?: boolean;
+    pickerOnly?: boolean;
+}
+export interface IColorPickerConfig extends IBaseItem, IBaseState, IColorpickerProps {
+    type: "colorpicker";
+    value?: string;
+}
+export interface IColorPicker {
+    parent?: IFieldset;
+    config: IColorPickerConfig;
+    colorpicker: Colorpicker;
+    events: IEventSystem<ItemEvent, IColorPickerEventHandlersMap>;
+    destructor(): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    validate(silent?: boolean, validateValue?: string): boolean;
+    clearValidate(): void;
+    setValue(value: string): void;
+    getValue(): string;
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    getWidget(): Colorpicker;
+    setProperties(propertyConfig: IColorpickerProps): void;
+    getProperties(): IColorpickerProps;
+}
+export interface IColorPickerEventHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: string) => boolean | void;
+    [ItemEvent.change]: (value: string) => void;
+    [ItemEvent.focus]: (value: string) => void;
+    [ItemEvent.blur]: (value: string) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent) => void;
+    [ItemEvent.input]: (inputValue: string) => void;
+    [ItemEvent.beforeHide]: (value: string, init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: string) => boolean | void;
+    [ItemEvent.afterHide]: (value: string, init: boolean) => void;
+    [ItemEvent.afterShow]: (value: string) => void;
+    [ItemEvent.beforeValidate]: (value: string) => boolean | void;
+    [ItemEvent.afterValidate]: (value: string, isValidate: boolean) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: IColorpickerProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: IColorpickerProps) => void;
+}
+export declare class ColorPicker extends Label implements IColorPicker {
+    parent: IFieldset;
+    config: IColorPickerConfig;
+    colorpicker: Colorpicker;
+    events: IEventSystem<ItemEvent, IColorPickerEventHandlersMap>;
+    private _keyManager;
+    private _popup;
+    private _popupIsFocus;
+    private _propsItem;
+    private _propsColorpicker;
+    private _props;
+    constructor(container: any, config: IColorPickerConfig);
+    destructor(): void;
+    setProperties(propertyConfig: IColorpickerProps): void;
+    getProperties(): IColorpickerProps;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    validate(silent?: boolean, value?: string): boolean;
+    clearValidate(): void;
+    setValue(value: string): void;
+    getValue(): string;
+    clear(): void;
+    getWidget(): Colorpicker;
+    focus(): void;
+    blur(): void;
+    protected _initView(config: IColorPickerConfig): void;
+    protected _initHandlers(): void;
+    protected _getHandlers(): {
+        onblur: () => void;
+        onfocus: () => void;
+        oninput: (e: Event) => void;
+        onchange: (e: Event) => void;
+    };
+    protected _initHotkeys(): void;
+    protected _draw(): any;
+    private _applyTab;
+}

package/codebase/types/ts-form/sources/elements/combo.d.ts

@@ -0,0 +1,101 @@
+import { Combobox } from "../../../ts-combobox";
+import { IEventSystem } from "../../../ts-common/events";
+import { Label } from "./helper/label";
+import { ItemEvent, ILabel, IBaseLayoutItem, IMessage, IBaseState, IBaseItem, IBaseHandlersMap } from "../types";
+import { Id } from "../../../ts-common/types";
+import { IFieldset } from "./fieldset";
+export type ValidationComboFn = (input: Id | Id[], text: string | string[]) => boolean;
+export interface IComboProps extends IBaseLayoutItem, ILabel, IMessage {
+    readOnly?: boolean;
+    validation?: ValidationComboFn;
+    template?: (item: any) => string;
+    filter?: (item: any, input: string) => boolean;
+    multiselection?: boolean;
+    placeholder?: string;
+    selectAllButton?: boolean;
+    itemsCount?: boolean | ((count: number) => string);
+    itemHeight?: number | string;
+    virtual?: boolean;
+    listHeight?: number | string;
+    newOptions?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    readonly?: boolean;
+}
+export interface IComboConfig extends IBaseItem, IBaseState, IComboProps {
+    type: "combo";
+    value?: Id | Id[];
+    data?: any[];
+}
+export interface ICombo {
+    parent?: IFieldset;
+    config: IComboConfig;
+    combobox: Combobox;
+    events: IEventSystem<ItemEvent, IComboEventHandlersMap>;
+    destructor(): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    validate(silent?: boolean, validateValue?: Id | Id[]): boolean;
+    clearValidate(): void;
+    setValue(value: Id | Id[]): void;
+    getValue(): Id | Id[];
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    getWidget(): Combobox;
+    setProperties(propertyConfig: IComboProps): void;
+    getProperties(): IComboProps;
+}
+export interface IComboEventHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: Id | Id[]) => boolean | void;
+    [ItemEvent.change]: (value: Id | Id[]) => void;
+    [ItemEvent.focus]: (value: Id | Id[]) => void;
+    [ItemEvent.blur]: (value: Id | Id[]) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent, id: Id | undefined) => void;
+    [ItemEvent.beforeHide]: (value: Id | Id[], init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: Id | Id[]) => boolean | void;
+    [ItemEvent.afterHide]: (value: Id | Id[], init: boolean) => void;
+    [ItemEvent.afterShow]: (value: Id | Id[]) => void;
+    [ItemEvent.beforeValidate]: (value: Id | Id[]) => boolean | void;
+    [ItemEvent.afterValidate]: (value: Id | Id[], isValidate: boolean) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: IComboProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: IComboProps) => void;
+}
+export declare class Combo extends Label implements ICombo {
+    parent: IFieldset;
+    config: IComboConfig;
+    combobox: Combobox;
+    events: IEventSystem<ItemEvent, IComboEventHandlersMap>;
+    private _propsItem;
+    private _propsCombo;
+    private _props;
+    private _isClear;
+    constructor(container: any, config: IComboConfig);
+    destructor(): void;
+    setProperties(propertyConfig: IComboProps): void;
+    getProperties(): IComboProps;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    clear(): void;
+    getValue(): Id | Id[];
+    setValue(value: Id | Id[]): void;
+    validate(silent?: boolean, value?: Id | Id[]): boolean;
+    clearValidate(): void;
+    getWidget(): Combobox;
+    focus(): void;
+    blur(): void;
+    protected _initView(config: IComboConfig): void;
+    protected _initHandlers(): void;
+    protected _validationStatus(): any;
+    protected _getRootView(): any;
+    protected _draw(): any;
+    private _exsistData;
+    private _getItemText;
+}

package/codebase/types/ts-form/sources/elements/container.d.ts

@@ -0,0 +1,52 @@
+import { View } from "../../../ts-common/view";
+import { ItemEvent, IBaseLayoutItem, IBaseItem, IBaseState, IBaseHandlersMap } from "../types";
+import { IEventSystem } from "../../../ts-common/events";
+import { Layout } from "../../../ts-layout";
+import { IFieldset } from "./fieldset";
+export type IContainerProps = IBaseLayoutItem;
+export interface IContainerConfig extends IContainerProps, IBaseItem, IBaseState {
+    type: "container";
+}
+export interface IContainer {
+    parent?: IFieldset;
+    config: IContainerConfig;
+    container: Layout;
+    events: IEventSystem<ItemEvent, IContainerHandlersMap>;
+    attach(widget: any): void;
+    attachHTML(html: string): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    setProperties(propertyConfig: IContainerProps): void;
+    getProperties(): IContainerProps;
+}
+export interface IContainerHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeHide]: (init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: () => boolean | void;
+    [ItemEvent.afterHide]: (init: boolean) => void;
+    [ItemEvent.afterShow]: () => void;
+    [ItemEvent.beforeChangeProperties]: (properties: IContainerProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: IContainerProps) => void;
+}
+export declare class Container extends View implements IContainer {
+    parent: IFieldset;
+    config: IContainerConfig;
+    container: Layout;
+    events: IEventSystem<ItemEvent, IContainerHandlersMap>;
+    constructor(container: any, config: IContainerConfig);
+    attach(widget: any): void;
+    attachHTML(html: string): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    setProperties(propertyConfig: IBaseLayoutItem): void;
+    getProperties(): IBaseLayoutItem;
+    protected _getRootView(): any;
+    protected _draw(): any;
+}

package/codebase/types/ts-form/sources/elements/dateinput.d.ts

@@ -0,0 +1,107 @@
+import { Calendar, ViewMode } from "../../../ts-calendar";
+import { IEventSystem } from "../../../ts-common/events";
+import { Label } from "./helper/label";
+import { ItemEvent, IBaseLayoutItem, ILabel, IMessage, IBaseItem, IBaseState, IBaseHandlersMap } from "../types";
+import { IFieldset } from "./fieldset";
+export type ValidationDateInput = (input: string | Date) => boolean;
+export interface IDatePickerProps extends IBaseLayoutItem, ILabel, IMessage {
+    editable?: boolean;
+    validation?: ValidationDateInput;
+    valueFormat?: IDatePickerValueFormat;
+    icon?: string;
+    placeholder?: string;
+    mode?: ViewMode;
+    mark?: (a: Date) => string;
+    disabledDates?: (a: Date) => boolean;
+    weekStart?: "monday" | "sunday";
+    weekNumbers?: boolean;
+    timePicker?: boolean;
+    dateFormat?: string;
+    timeFormat?: 24 | 12;
+    thisMonthOnly?: boolean;
+}
+export type IDatePickerValueFormat = "string" | "Date";
+export interface IDatePickerConfig extends IBaseItem, IBaseState, IDatePickerProps {
+    type: "datepicker";
+    value?: Date | string;
+}
+export interface IDatePicker {
+    parent?: IFieldset;
+    config: IDatePickerConfig;
+    calendar: Calendar;
+    events: IEventSystem<ItemEvent, IDatePickerEventHandlersMap>;
+    destructor(): void;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    validate(silent?: boolean, validateValue?: string | Date): boolean;
+    clearValidate(): void;
+    setValue(value: string | Date): void;
+    getValue<T extends boolean = false>(asDateObject?: T): string | Date;
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    getWidget(): Calendar;
+    setProperties(propertyConfig: IDatePickerProps): void;
+    getProperties(): IDatePickerProps;
+}
+export interface IDatePickerEventHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChange]: (value: string | Date) => boolean | void;
+    [ItemEvent.change]: (value: string | Date) => void;
+    [ItemEvent.focus]: (value: string | Date) => void;
+    [ItemEvent.blur]: (value: string | Date) => void;
+    [ItemEvent.keydown]: (event: KeyboardEvent) => void;
+    [ItemEvent.input]: (inputValue: string) => void;
+    [ItemEvent.beforeHide]: (value: string | Date, init: boolean) => boolean | void;
+    [ItemEvent.beforeShow]: (value: string | Date) => boolean | void;
+    [ItemEvent.afterHide]: (value: string | Date, init: boolean) => void;
+    [ItemEvent.afterShow]: (value: string | Date) => void;
+    [ItemEvent.beforeValidate]: (value: string | Date) => boolean | void;
+    [ItemEvent.afterValidate]: (value: string | Date, isValidate: boolean) => void;
+    [ItemEvent.beforeChangeProperties]: (properties: IDatePickerProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (properties: IDatePickerProps) => void;
+}
+export declare class DatePicker extends Label implements IDatePicker {
+    parent: IFieldset;
+    config: IDatePickerConfig;
+    calendar: Calendar;
+    events: IEventSystem<ItemEvent, IDatePickerEventHandlersMap>;
+    private _keyManager;
+    private _popup;
+    private _popupIsFocus;
+    private _propsItem;
+    private _propsCalendar;
+    private _props;
+    constructor(container: any, config: IDatePickerConfig);
+    destructor(): void;
+    setProperties(propertyConfig: IDatePickerProps): void;
+    getProperties(): IDatePickerProps;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    validate(silent?: boolean, value?: string | Date): boolean;
+    clearValidate(): void;
+    setValue(value: string | Date): void;
+    getValue<T extends boolean = false>(asDateObject?: T): string | Date;
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    getWidget(): Calendar;
+    protected _initView(config: IDatePickerConfig): void;
+    protected _initHandlers(): void;
+    protected _getHandlers(): {
+        onblur: () => void;
+        onfocus: () => void;
+        oninput: (e: Event) => void;
+        onchange: (e: Event) => void;
+    };
+    protected _initHotkeys(): void;
+    protected _draw(): any;
+    private _applyTab;
+}

package/codebase/types/ts-form/sources/elements/fieldset.d.ts

@@ -0,0 +1,64 @@
+import { IEventSystem } from "../../../ts-common/events";
+import { ItemEvent, IItem, TFormDataCallback, IBaseHandlersMap, IBaseItem, IBaseState, IBlock, IBaseLayoutItem } from "../types";
+import { ICell } from "../../../ts-layout";
+import { FlexDirection } from "../../../ts-common/html";
+import { TLabelAlignment } from "../../../ts-common/types";
+export interface IFieldsetProps extends IBaseLayoutItem {
+    label?: string;
+    labelAlignment?: TLabelAlignment;
+    rows?: IBlock;
+    cols?: IBlock;
+    align?: FlexDirection;
+}
+export interface IFieldsetConfig extends IBaseItem, IFieldsetProps, IBaseState {
+    type: "fieldset";
+}
+export interface IFieldset {
+    parent?: IFieldset;
+    config: IFieldsetConfig;
+    events: IEventSystem<ItemEvent, IFieldsetHandlersMap>;
+    forEach(callback: TFormDataCallback, tree?: boolean): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    setProperties(config: IFieldsetProps): void;
+    getProperties(): IFieldsetProps;
+    destructor(): void;
+    setCell(cell: ICell): any;
+    getCell(): ICell;
+    setAttachments(attachments: IItem[]): void;
+    getAttachments(): IItem[];
+    getTreeAttachments(attachments: IItem[]): IItem[];
+}
+export interface IFieldsetHandlersMap extends IBaseHandlersMap {
+    [ItemEvent.beforeChangeProperties]: (config: IFieldsetProps) => boolean | void;
+    [ItemEvent.afterChangeProperties]: (config: IFieldsetProps) => void;
+}
+export declare class Fieldset implements IFieldset {
+    parent: IFieldset;
+    config: IFieldsetConfig;
+    events: IEventSystem<ItemEvent, IFieldsetHandlersMap>;
+    private attachments;
+    private cell;
+    private propsItem;
+    private props;
+    constructor(config: IFieldsetConfig);
+    forEach(callback: TFormDataCallback, tree?: boolean): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    show(): void;
+    hide(init?: boolean): void;
+    isVisible(): boolean;
+    setProperties(config: IFieldsetProps): void;
+    getProperties(): IFieldsetProps;
+    destructor(): void;
+    setCell(cell: ICell): void;
+    getCell(): ICell;
+    setAttachments(attachments: IItem[]): void;
+    getAttachments(): IItem[];
+    getTreeAttachments(attachments: IItem[]): IItem[];
+}

package/codebase/types/ts-form/sources/elements/helper/label.d.ts

@@ -0,0 +1,18 @@
+import { View } from "../../../../ts-common/view";
+import { Popup } from "../../../../ts-popup";
+import { ILabel } from "../../types";
+export declare class Label extends View {
+    config: ILabel & {
+        type?: string;
+        id?: string;
+    };
+    protected _handlers: any;
+    protected _helper: Popup;
+    constructor(container: null | string | HTMLElement, config?: {});
+    setValidationStatus(state?: "pre" | "error" | "success"): void;
+    protected _destructor(): void;
+    protected _getHandlers(): {};
+    protected _init(): void;
+    protected _draw(): any;
+    protected _drawLabel(): any;
+}