mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/components/form/label/label.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="mithril" />
+import { IconButtonOptions } from "mdtScripts/components/iconButton/iconButton";
+import "./label.less";
+export interface LabelIconButton {
+    name: string;
+    options: IconButtonOptions;
+}
+export interface LabelOptions {
+    title: string;
+    description?: string;
+    required?: boolean;
+    error?: string;
+    iconButtons?: LabelIconButton[];
+}
+export interface LabelViewOptions extends LabelOptions {
+    for?: string;
+    attrs?: _mithril.MithrilAttributes;
+}
+export declare function labelView(options: LabelViewOptions): _mithril.MithrilVirtualElement;
+export declare function fieldRequiredMark(): _mithril.MithrilVirtualElement;
+export declare function fieldErrorIcon(error: string): LabelIconButton;
+export declare function fieldDescriptionIcon(description: string): LabelIconButton;

package/types/_core/scripts/components/form/layout/json/FinalFormJsonRenderer.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="mithril" />
+import { FieldState } from "final-form";
+import { AnyObject, ViewElement } from "mdtScripts/helpers/types";
+import { JSONSchema7 } from "_core/_res/lib/types/jsonSchema";
+import { ControlPropStore } from "../../finalFormAdapter/ControlStore";
+import { FormLayoutRendererInitOptions, IFormLayoutRenderer } from "../../finalFormAdapter/IFormLayoutRenderer";
+export interface JsonRendererFieldData<Values = any> {
+    key: string;
+    propKey: string;
+    state: FieldState<Values>;
+    schema: JSONSchema7;
+    parentSchema: JSONSchema7[];
+    parentState?: FieldState<any>[];
+    /** Index of current property if parent is array */
+    itemIndex?: number;
+}
+export interface FieldData {
+    code: string;
+    title: string;
+    description?: string;
+    required?: boolean;
+    error?: string;
+    itemIndex?: number;
+}
+export interface FormSchemaControlsView<Values = AnyObject> {
+    control: (data: JsonRendererFieldData<Values>) => ViewElement;
+    extControls?: ((data: JsonRendererFieldData<Values>) => ViewElement)[];
+}
+export interface FinalFormJsonRendererOptions<T = AnyObject> {
+    renderProperty?: (data: JsonRendererFieldData<T>, store: ControlPropStore) => ViewElement | void;
+    showPropertyLabel?: (data: JsonRendererFieldData<T>, store: ControlPropStore) => boolean;
+}
+export declare class FinalFormJsonRenderer<Values = any> implements IFormLayoutRenderer {
+    private getSchema;
+    private options?;
+    private bindState;
+    private store;
+    private view;
+    constructor(getSchema: () => JSONSchema7, options?: FinalFormJsonRendererOptions<Values>);
+    init({ renderField }: FormLayoutRendererInitOptions): void;
+    private isInited;
+    renderForm(): _mithril.MithrilVirtualElement;
+    private renderRoot;
+    private renderSchemaForm;
+    private renderField;
+    private renderProperty;
+    private getTitle;
+    private getFieldData;
+    private showFieldLabel;
+    private showRemoveButton;
+    private removeAction;
+    private renderControl;
+    private getBaseAttrs;
+    private renderInput;
+    private renderCheckbox;
+    private renderSelect;
+    private renderSubForm;
+    private renderList;
+    private renderAnyOf;
+}

package/types/_core/scripts/components/form/layout/json/JsonFormView.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="mithril" />
+import { LabeledCheckboxViewOptions } from "mdtScripts/components/baseFormControls/boolean/labeledCheckbox/labeledCheckbox";
+import { InputOptions } from "mdtScripts/components/baseFormControls/input/inputView";
+import { SelectOptions } from "mdtScripts/components/baseFormControls/select/select";
+import { ViewElement } from "mdtScripts/helpers/types";
+import { FieldData } from "./FinalFormJsonRenderer";
+import "./JsonFormView.less";
+declare type JsonFieldViewOptions = JsonFieldViewBaseOptions & HeaderViewOptions & JsonFieldLabelOptions;
+interface JsonFieldViewBaseOptions {
+    content?: ViewElement;
+}
+interface JsonFieldLabelOptions {
+    showLabel?: boolean;
+}
+interface HeaderViewOptions {
+    showRemoveButton?: boolean;
+    onRemove?: () => void;
+    headerElements?: _mithril.MithrilVirtualElement[];
+}
+interface ArrayViewOptions {
+    items: any;
+    itemView: any;
+    onAdd: any;
+}
+interface AnyOfViewOptions {
+    selectOptions: any;
+    onchange: any;
+}
+export declare class JsonFormView {
+    renderForm(view: ViewElement): _mithril.MithrilVirtualElement;
+    fieldView(fieldData: FieldData, options: JsonFieldViewOptions): _mithril.MithrilVirtualElement;
+    private getTitle;
+    input(options: InputOptions): _mithril.MithrilVirtualElement;
+    checkbox(options: LabeledCheckboxViewOptions): _mithril.MithrilVirtualElement;
+    select(options: SelectOptions): _mithril.MithrilVirtualElement;
+    subForm(fieldData: FieldData, options: JsonFieldViewOptions, state: StateManager): _mithril.MithrilVirtualElement;
+    list(fieldData: FieldData, options: ArrayViewOptions & HeaderViewOptions, state: StateManager): _mithril.MithrilVirtualElement;
+    anyOf(fieldData: FieldData, viewOptions: JsonFieldViewBaseOptions & HeaderViewOptions & AnyOfViewOptions, state: StateManager): _mithril.MithrilVirtualElement;
+    private removeButton;
+    private panel;
+}
+interface StateManager<T = any> {
+    setValue(key: string, value: T): void;
+    getValue(key: string): T;
+}
+export {};

package/types/_core/scripts/components/form/layout/json/JsonUtils.d.ts

@@ -0,0 +1,5 @@
+import { JSONSchema7, JSONSchema7TypeName } from "_core/_res/lib/types/jsonSchema";
+export declare function resolveRefs(schema: JSONSchema7, parent: JSONSchema7): any;
+export declare function prepareRefString(ref: string): string;
+export declare function getInitedValueByType(type: JSONSchema7TypeName): {};
+export declare function getAnyOfCurrentSchema(anyOf: JSONSchema7[], value: Record<string, any>): number;

package/types/_core/scripts/components/form/layout/json/fullWidthFormComponent/fullWidthFormComponent.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="mithril" />
+import { ViewElement } from "mdtScripts/helpers/types";
+import "./fullWidthFormComponent.less";
+interface FullWidthFormComponentOptions {
+    content: ViewElement;
+}
+export declare function fullWidthFormComponent(options: FullWidthFormComponentOptions): _mithril.MithrilVirtualElement;
+export {};

package/types/_core/scripts/components/form/layout/json/monacoJsonControl.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="mithril" />
+import { MonacoCodeOptions } from "mdtScripts/views/form/controls/monacoEditor/MonacoCodeOptions.schema";
+import { ControlPropStore } from "../../finalFormAdapter/ControlStore";
+import { JsonRendererFieldData } from "./FinalFormJsonRenderer";
+export declare function monacoJsonControlView(data: JsonRendererFieldData, store: ControlPropStore, options: MonacoCodeOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/form/mdtFieldControl/JsonFormFieldControl.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="mithril" />
+import { FieldCtrl } from "mdtScripts/views/form/field";
+import { JSONSchema7 } from "_core/_res/lib/types/jsonSchema";
+import { FinalFormOptions } from "../finalFormAdapter/FinalForm";
+import { FinalFormJsonRendererOptions } from "../layout/json/FinalFormJsonRenderer";
+export interface JsonFormFieldControlOptions {
+    schema: JSONSchema7;
+    validate?: boolean;
+    finalFormAdapterOptions?: FinalFormOptions;
+    rendererOptions?: FinalFormJsonRendererOptions;
+}
+export declare class JsonFormFieldControl {
+    private options;
+    private fieldCtrl;
+    private finalForm;
+    private schema;
+    constructor(options: JsonFormFieldControlOptions, fieldCtrl: FieldCtrl);
+    private getValue;
+    private getSchema;
+    private validate;
+    setSchema: (schema: JSONSchema7) => void;
+    $view: () => _mithril.MithrilVirtualElement;
+}

package/types/_core/scripts/components/hotkey/hotkey.d.ts

@@ -0,0 +1,7 @@
+import { Hotkey } from "mdtServices/CommandManager";
+import "./hotkey.less";
+interface HotkeysViewOptions {
+    dark?: boolean;
+}
+export declare function hotkeys(hotkeys: Hotkey[], options?: HotkeysViewOptions): string;
+export {};

package/types/_core/scripts/components/icon/icon.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="mithril" />
+import { Icon, IconOptions } from "./iconOptions";
+export declare function icon(icon: Icon, options?: IconOptions): _mithril.MithrilVirtualElement;
+export declare function iconEl(icon: string, options?: IconOptions): HTMLElement;

package/types/_core/scripts/components/icon/iconOptions.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="mithril" />
+import { FormattedText } from "../../helpers/formattedText";
+export declare type Icon = string;
+export interface IconOptions {
+    size?: "2xs" | "xs" | "sm" | "lg" | "xl" | "2xl" | "1x" | "2x" | "3x" | "4x" | "5x" | "6x" | "7x" | "8x" | "9x" | "10x";
+    fixedWidth?: boolean;
+    rotate?: "90" | "180" | "270";
+    flip?: "horizontal" | "vertical" | "both";
+    animate?: "spin" | "beat" | "fade" | "flash";
+    /** @deprecated */
+    attrs?: _mithril.MithrilAttributes;
+    title?: string;
+    tooltip?: FormattedText;
+    className?: string;
+    onmousedown?: () => void;
+    onclick?: (e?: MouseEvent) => void;
+}

package/types/_core/scripts/components/iconButton/iconButton.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="mithril" />
+import { UiType } from "mdtScripts/helpers/IUi";
+import { CommandEvent } from "mdtScripts/helpers/types";
+import { IconOptions } from "../icon/iconOptions";
+import "./iconButton.less";
+export interface IconButtonOptions extends IconOptions {
+    command?: (e: CommandEvent) => void;
+    type?: UiType;
+}
+export declare function iconButtonView(iconName: string, options: IconButtonOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/iframe/iframe.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="mithril" />
+import "./iframe.less";
+interface IframeOptions {
+    html: string;
+    style?: any;
+    className?: string;
+    onCreated?: (el: HTMLIFrameElement) => void;
+}
+export declare function iframeView(options: IframeOptions): _mithril.MithrilVirtualElement;
+export {};

package/types/_core/scripts/components/jsonFormat/jsonFormatView.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="mithril" />
+import { ViewElement } from "mdtScripts/helpers/types";
+import "./jsonFormatView.less";
+export declare function jsonFormatView(options: JsonFormatViewOptions): _mithril.MithrilVirtualElement;
+export declare function toggler(options: JsonFormatTogglerViewOptions): _mithril.MithrilVirtualElement;
+export declare function objectFormatView(value: any): _mithril.MithrilVirtualElement;
+export declare function objectFormatRecordView(record: Record<string, any>): ViewElement;
+export declare function objectFormatArrayView(array: any[]): ViewElement;
+export declare function objectFormatStringView(value: string): _mithril.MithrilVirtualElement;
+export declare function objectFormatItemView(item: any): ViewElement;
+export declare function textFormatView(value: string): _mithril.MithrilVirtualElement;
+export interface JsonFormatViewOptions {
+    formatView: ViewElement;
+    togglerOptions?: JsonFormatTogglerViewOptions;
+    error?: boolean;
+    zones?: {
+        top?: ViewElement;
+    };
+}
+interface JsonFormatTogglerViewOptions {
+    enabled?: boolean;
+    command?: () => void;
+}
+export {};

package/types/_core/scripts/components/labelStyleBase/labelStyleBase.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="mithril" />
+import { ColorStyle } from "mdtScripts/helpers/types";
+import "./labelStyleBase.less";
+export declare type LabelStyleType = ColorStyle;
+export interface LabelStyleBaseOptions {
+    text: string;
+    type: LabelStyleType;
+    icon?: string;
+    attrs?: _mithril.MithrilAttributes;
+    valueAttrs?: _mithril.MithrilAttributes;
+}
+export declare function labelStyleBaseView(options: LabelStyleBaseOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/panel/panelView.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="mithril" />
+import { ViewElement } from "mdtScripts/helpers/types";
+import "./panel.less";
+export interface PanelViewOptions {
+    headerContent?: ViewElement;
+    content: ViewElement;
+    isCollapsible?: boolean;
+    isCollapsed?: boolean;
+}
+export declare function panelView(options: PanelViewOptions): _mithril.MithrilVirtualElement;

package/types/{components → _core/scripts/components}/popover/IPopoverBase.d.ts

@@ -2,13 +2,16 @@
 import { Placement } from "@floating-ui/core";
 export declare class IPopoverBase {
     constructor(options?: PopoverBaseOptions);
-    target: HTMLElement;
-    bind(el: HTMLElement, ctx: any): void;
+    target: Element;
+    bind(el: Element, ctx: any): void;
     show(): void;
     close(): void;
 }
 export interface PopoverBaseOptions {
-    onunload: () => void;
+    onTargetUnload?: () => void;
     contentView?: () => _mithril.MithrilVirtualElement;
+    onShow?: () => void;
+    onClose?: () => void;
     placement?: Placement;
+    class?: string;
 }

package/types/_core/scripts/components/popover/PopoverBase.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="mithril" />
+import { Placement } from "@floating-ui/core";
+import { IPopoverBase, PopoverBaseOptions } from "./IPopoverBase";
+import "./PopoverBase.less";
+export declare class PopoverBase implements IPopoverBase {
+    private options?;
+    target: Element;
+    private control;
+    private showed;
+    constructor(options?: PopoverBaseOptions);
+    bind(el: Element, ctx: any): void;
+    show(): void;
+    close(): void;
+    isShown(): boolean;
+}
+export interface PopoverBaseViewOptions {
+    contentView: () => _mithril.MithrilVirtualElement;
+    close: () => void;
+    target: Element;
+    placement?: Placement;
+    class?: string;
+}
+export declare const popoverBaseView: (options: PopoverBaseViewOptions) => _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/processFormBlock/ProcessFormBlockOptions.d.ts

@@ -0,0 +1,18 @@
+import { Button } from "mdtScripts/helpers/ui/el";
+import { Markdown } from "../../helpers/types";
+import { Icon } from "../icon/iconOptions";
+import { ProcessPrincipalsListItem } from "../processPrincipalsList/ProcessPrincipalsListItem";
+export interface ProcessFormBlockOptions {
+    title: string;
+    subtitle: string;
+    titleTooltip: string;
+    subtitleTooltip: string;
+    icon?: Icon;
+    description?: Markdown;
+    principals?: ProcessPrincipalsListItem[];
+    principalsTooltip?: string;
+    principalsTextError?: string;
+    principalsOnclick?: (item: ProcessPrincipalsListItem) => void;
+    historyAction?: Button;
+    actions?: Button[];
+}

package/types/_core/scripts/components/processFormBlock/processFormBlock.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="mithril" />
+import { ProcessFormBlockOptions } from "./ProcessFormBlockOptions";
+import "./processFormBlock.less";
+export declare function processFormBlockView(options: ProcessFormBlockOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/processPrincipalsList/ProcessPrincipalsListItem.d.ts

@@ -0,0 +1,5 @@
+import { RecordId } from "mdtScripts/common/Record";
+export interface ProcessPrincipalsListItem {
+    id: RecordId;
+    title: string;
+}

package/types/_core/scripts/components/processPrincipalsList/processPrincipalsList.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="mithril" />
+import "./processPrincipalsList.less";
+import { ProcessPrincipalsListItem } from "./ProcessPrincipalsListItem";
+export interface ProcessPrincipalsListOptions {
+    tooltip: string;
+    onclick?: (x: ProcessPrincipalsListItem) => void;
+}
+export declare function processPrincipalsListView(data: ProcessPrincipalsListItem[], options: ProcessPrincipalsListOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/progressBar/progressBar.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="mithril" />
+import "./progressBar.less";
+export interface ProgressBarOptions {
+    hide?: boolean;
+    progress?: string;
+    indeterminate?: boolean;
+    complete?: boolean;
+    loading?: boolean;
+}
+export declare function progressBar(options?: ProgressBarOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/progressBar/progressBarCtrl.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="mithril" />
+import { ProgressBarOptions } from "./progressBar";
+export declare class ProgressBarCtrl {
+    private options;
+    constructor(initialOptions: ProgressBarOptions);
+    setState<T extends keyof ProgressBarOptions>(v: T, value: ProgressBarOptions[T]): void;
+    $view: () => _mithril.MithrilVirtualElement;
+}

package/types/_core/scripts/components/progressBar/progressBarStateController.d.ts

@@ -0,0 +1,9 @@
+import { ProgressBarCtrl } from "./progressBarCtrl";
+export declare class ProgressBarStateController {
+    private progressBar;
+    private hidingTimeout;
+    constructor(progressBar: ProgressBarCtrl);
+    startLoading(): void;
+    completeAndHide(): void;
+    private updateView;
+}

package/types/_core/scripts/components/resizablePanels/panelSizeController/insetAdapter/insetAdapter.d.ts

@@ -0,0 +1,12 @@
+import { PanelSide } from "../resizeController";
+import { PanelSizeParams, SizeAdapter } from "../panelSizeController";
+export declare class InsetSizeAdapter implements SizeAdapter {
+    private service;
+    constructor();
+    setPanelWidth(el: HTMLElement, params: PanelSizeParams): void;
+    setPanelHeight(el: HTMLElement, params: PanelSizeParams): void;
+    validateSize(el: HTMLElement, changedSide: PanelSide, newSidePosition: number): boolean;
+    updatePanelSidePosition(el: HTMLElement, changedSide: PanelSide, newSidePosition: number): void;
+    private readInset;
+    private setInset;
+}

package/types/_core/scripts/components/resizablePanels/panelSizeController/insetAdapter/insetAdapterService.d.ts

@@ -0,0 +1,14 @@
+import { PanelSide } from "../resizeController";
+import { PanelSizeParams } from "../panelSizeController";
+export declare class InsetAdapterService {
+    getHorizontalSize(params: PanelSizeParams, totalSize: number): string;
+    getVerticalSize(params: PanelSizeParams, totalSize: number): string;
+    getSidePositionByCoordinate(side: PanelSide, sidePosition: number, wrapperSize: number): number;
+    getOppositeSidePosition(inset: string, side: PanelSide): number;
+    validateSize(inset: string, changedSide: PanelSide, newSidePosition: number, minSizeInPercent: number): boolean;
+    getUpdatedInset(oldInset: string, param: PanelSide, value: string): string;
+    getLongInset(insetValue: string): string;
+    private getLongInsetFromTwoParams;
+    private getLongInsetFromThreeParams;
+    private isEndSide;
+}

package/types/_core/scripts/components/resizablePanels/panelSizeController/panelSizeController.d.ts

@@ -0,0 +1,31 @@
+import { PanelsDirection } from "../resizablePanels";
+import { BoundingSide, PanelSide } from "./resizeController";
+export interface PanelSizeParams {
+    startPoint: number;
+    size: number;
+}
+export interface SizeAdapter {
+    setPanelWidth(el: HTMLElement, params: PanelSizeParams): void;
+    setPanelHeight(el: HTMLElement, params: PanelSizeParams): void;
+    validateSize(el: HTMLElement, changedSide: PanelSide, newSidePosition: number): boolean;
+    updatePanelSidePosition(el: HTMLElement, changedSide: PanelSide, newSidePosition: number): void;
+}
+export declare class PanelSizeController {
+    static TOTAL_SIZE_IN_PERCENT: number;
+    static MIN_PANEL_SIDE_IN_PERCENT: number;
+    static getMaxPanelsAmount(): number;
+    private adapter;
+    constructor();
+    setPanelSize(el: HTMLElement, params: PanelSizeParams, direction: PanelsDirection): void;
+    validateParamValue(el: HTMLElement, changedSide: PanelSide, newSidePosition: number): boolean;
+    updatePanelSidePosition(el: HTMLElement, changedSide: PanelSide, newSidePosition: number): void;
+    setPanelInitialSize(el: HTMLElement, direction: PanelsDirection, panelIndex: number, panelsAmount: number): void;
+    getPanelInitialSize(panelsAmount: number): number;
+    private getPanelSizeParams;
+}
+interface ElBounding {
+    width: number;
+    height: number;
+}
+export declare function valueInPxToPercent(valueInPx: number, wrapperSide: BoundingSide, wrapperBounding: ElBounding): number;
+export {};

package/types/_core/scripts/components/resizablePanels/panelSizeController/panelsDragController.d.ts

@@ -0,0 +1,19 @@
+import { ContentItem } from "./resizeController";
+interface DragContext {
+    resizer: ContentItem;
+}
+export declare class PanelsDragController {
+    private resizers;
+    private wrapperEl;
+    private isDraggingEnabled;
+    private context;
+    private draggingWrapperClass;
+    registerResizer(index: number, el: HTMLElement, onActivateDragging: (context: DragContext) => void): void;
+    registerWrapper(el: HTMLElement, onMove: (e: MouseEvent) => void): void;
+    private activateDragging;
+    private updateContext;
+    private disableResizing;
+    private setWrapperClass;
+    private removeWrapperClass;
+}
+export {};

package/types/_core/scripts/components/resizablePanels/panelSizeController/resizeController.d.ts

@@ -0,0 +1,25 @@
+import { PanelsDirection } from "../resizablePanels";
+import { OnPanelResize } from "../resizablePanel/resizablePanel";
+export interface ContentItem {
+    index: number;
+    el: HTMLElement;
+}
+export declare type BoundingSide = "width" | "height";
+export declare type PanelSide = "top" | "left" | "right" | "bottom";
+export declare class ResizingController {
+    private resizers;
+    private panels;
+    private wrapperEl;
+    private direction;
+    private sizeController;
+    private resizerPosController;
+    private resizingContext;
+    private dragController;
+    constructor(direction: PanelsDirection);
+    registerResizer(index: number, el: HTMLElement): void;
+    registerPanel(index: number, el: HTMLElement, onResize: OnPanelResize): void;
+    registerWrapper(el: HTMLElement): void;
+    private updateContext;
+    private findClosedPanelsByResizer;
+    private resize;
+}

package/types/_core/scripts/components/resizablePanels/panelTitle/panelTitle.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="mithril" />
+import { ViewElement } from "mdtScripts/helpers/types";
+import "./panelTitle.less";
+export interface PanelTitleOptions {
+    text: string;
+    endZone?: PanelTitleEndZone;
+    className?: string;
+    wrapperClassName?: string;
+}
+interface PanelTitleEndZone {
+    view: () => ViewElement;
+}
+export declare function panelTitleView(options: PanelTitleOptions): _mithril.MithrilVirtualElement;
+export {};

package/types/_core/scripts/components/resizablePanels/panelToolbar/panelToolbar.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="mithril" />
+import { ButtonGroupOptions } from "mdtScripts/components/buttonGroup/buttonGroup";
+export interface PanelToolbarOptions {
+    buttonGroup: ButtonGroupOptions;
+}
+export declare function panelToolbarView(options: PanelToolbarOptions): _mithril.MithrilVirtualElement;

package/types/_core/scripts/components/resizablePanels/resizablePanel/resizablePanel.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="mithril" />
+import { ViewElement } from "mdtScripts/helpers/types";
+import { PanelTitleOptions } from "../panelTitle/panelTitle";
+import { PanelToolbarOptions } from "../panelToolbar/panelToolbar";
+import "./resizablePanel.less";
+interface ResizablePanelOptions {
+    content: ResizablePanelContent;
+    onCreated?: (el: HTMLElement) => void;
+}
+export declare type OnPanelResize = () => void;
+export interface ResizablePanelContent {
+    view: () => ViewElement;
+    onResize?: OnPanelResize;
+    title?: PanelTitleOptions;
+    toolbar?: PanelToolbarOptions;
+    topZone?: PanelTopZone;
+    className?: string;
+}
+interface PanelTopZone {
+    view: () => ViewElement;
+}
+export declare function resizablePanelView(options: ResizablePanelOptions): _mithril.MithrilVirtualElement;
+export {};

package/types/_core/scripts/components/resizablePanels/resizablePanels.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="mithril" />
+import { ResizablePanelContent } from "./resizablePanel/resizablePanel";
+import "./resizablePanels.less";
+export declare type PanelsDirection = "row" | "column";
+export interface ResizablePanelsOptions {
+    direction: PanelsDirection;
+    content: ResizablePanelContent[];
+    resizerSize?: number;
+    highlightFocusedPanel?: boolean;
+}
+export declare function resizablePanelsView(options: ResizablePanelsOptions): _mithril.MithrilVirtualElement;
+export declare function getMaxPanelsAmount(): number;

package/types/_core/scripts/components/resizablePanels/resizablePanelsController.d.ts

@@ -0,0 +1,14 @@
+import { ResizablePanelsOptions } from "./resizablePanels";
+import { ViewElement } from "mdtScripts/helpers/types";
+export declare class ResizablePanelsController {
+    private options;
+    private resizeController;
+    private sizeController;
+    private focusController;
+    constructor(options: ResizablePanelsOptions);
+    registerPanelsWrapper(el: HTMLElement): void;
+    getContent(): ViewElement[];
+    private panelsAmount;
+    private getPanel;
+    private getResizer;
+}

package/types/_core/scripts/components/resizablePanels/resizablePanelsFocusController.d.ts

@@ -0,0 +1,16 @@
+export declare class PanelsFocusController {
+    private focusedPanelClassName;
+    private nextToFocusedClassName;
+    private panels;
+    registerPanel(panelEl: HTMLElement, panelIndex: number): void;
+    registerWrapper(wrapperEl: HTMLElement): void;
+    private registerHandlers;
+    private findPanelByPressedKey;
+    private focus;
+    private findFocusedPanel;
+    private blurPanel;
+    private focusPanel;
+    private setNextToFocusedPanelClass;
+    private removeNextFocusedPanelClass;
+    private findNextPanelTo;
+}

package/types/_core/scripts/components/resizablePanels/resizer/panelResizer.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="mithril" />
+import "./panelResizer.less";
+declare type ResizerOrientation = "horizontal" | "vertical";
+interface PanelResizerOptions {
+    orientation: ResizerOrientation;
+    size?: number;
+    onCreated?: (el: HTMLElement) => void;
+}
+export declare const DEFAULT_RESIZER_SIZE = 9;
+export declare function panelResizerView(options: PanelResizerOptions): _mithril.MithrilVirtualElement;
+export {};

package/types/_core/scripts/components/resizablePanels/resizer/resizerPositionController.d.ts

@@ -0,0 +1,6 @@
+import { PanelsDirection } from "../resizablePanels";
+export declare class ResizerPositionController {
+    setResizerPosition(el: HTMLElement, position: number, direction: PanelsDirection): void;
+    setResizerInitialPosition(el: HTMLElement, direction: PanelsDirection, panelIndex: number, panelInitialSize: number): void;
+    getResizerInitialPosition(panelIndex: number, panelInitialSize: number): number;
+}