mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/services/customModules/facades/utils/IUiComponentsFacade.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="mithril" />
+import { ProcessPrincipalsListItem } from "../../../../components/processPrincipalsList/ProcessPrincipalsListItem";
+import { Markdown, MithrilAttributes, Valued } from "../../../../helpers/types";
+import { Icon, IconOptions } from "../../../../components/icon/iconOptions";
+import { InputOptions } from "../../../../components/baseFormControls/input/inputView";
+import { CommonControlOptions } from "../../../../views/form/controls/commonControl/ICommonControl";
+import { ButtonFacade } from "../Form/IFormFacade";
+import { DropdownInputItemOptions } from "../../../../components/dropdown/menu/item/dropdownInputItemOptions";
+import { DropdownItemViewOptions } from "../../../../components/dropdown/menu/item/dropdownItemWrapOptions";
+export interface IUiComponentsFacade {
+    button(button: ButtonFacade, translate?: boolean): _mithril.MithrilVirtualElement;
+    topNavButton(options: TopNavButton): _mithril.MithrilVirtualElement;
+    icon(code: string, options?: IconOptions): _mithril.MithrilVirtualElement;
+    processFormBlock(options: IProcessFormBlockOptions): _mithril.MithrilVirtualElement;
+    commonControl(options: CommonControlOptions): _mithril.MithrilVirtualElement;
+    unstyledInput(options: InputOptions): _mithril.MithrilVirtualElement;
+    input(options: InputOptions): _mithril.MithrilVirtualElement;
+    dropdownItem(options: DropdownItemViewOptions): _mithril.MithrilVirtualElement;
+    dropdownInputItem(options: DropdownInputItemOptions): _mithril.MithrilVirtualElement;
+}
+export interface IProcessFormBlockOptions {
+    title: string;
+    subtitle: string;
+    titleTooltip: string;
+    subtitleTooltip: string;
+    icon?: Icon;
+    description?: Markdown;
+    principals?: ProcessPrincipalsListItem[];
+    principalsTooltip?: string;
+    principalsTextError?: string;
+    principalsOnclick?: (item: ProcessPrincipalsListItem) => void;
+    historyAction?: ButtonFacade;
+    actions?: ButtonFacade[];
+}
+export interface TopNavButton {
+    title: string;
+    icon?: Icon;
+    attrs?: MithrilAttributes;
+    showCaret?: boolean;
+    focused?: Valued<boolean>;
+    execute?: () => void;
+}

package/types/_core/scripts/services/customModules/facades/utils/IUiFacade.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="mithril" />
+import { MithrilControl } from "../../../../helpers/types";
+import { DropdownOptions } from "../../../dropdown/IDropDownMenu";
+import { ButtonFacade } from "../Form/IFormFacade";
+import { DropdownTargetContext, IDropdownMenu } from "mdtServices/dropdown/IDropDownMenu";
+export declare type onModalResizeCallback = (data: IModalSizingState) => void;
+export interface IType<T> {
+    new (...args: any[]): T;
+}
+export interface ParentCtrl {
+    getViewControl(): MithrilControl;
+}
+export interface CustomNotification {
+    /** Заголовок сообщения */
+    title: string;
+    /** Текст сообщения */
+    text: string;
+    /** Наименование иконки */
+    icon?: string;
+    /** Тип выводимого сообщения*/
+    type?: "default" | "info" | "success" | "warning" | "danger";
+    /** Кнопки, отображаемые в сообщении*/
+    actions?: ButtonFacade[];
+}
+export interface IUiFacade {
+    /** Вызвать окно уведомления */
+    showNotification(msg: CustomNotification, duration?: number): any;
+    /** Вызвать модальное окно */
+    showModal(ctrl: MithrilControl | ParentCtrl, options?: IModalOptions): any;
+    /** Вызвать боковую панель */
+    showSidebar(ctrl: MithrilControl | ParentCtrl, options?: IPanelOptions): any;
+    /** Создать выпадающее меню */
+    createDropdown<I>(options: DropdownOptions<I>, el: Element, ctx: DropdownTargetContext<I>): IDropdownMenu<I>;
+    /** Создать компонент с пользовательской версткой */
+    createControl(view: () => _mithril.MithrilVirtualElement): MithrilControl;
+}
+export declare type ModalTypes = "info" | "success" | "warning" | "danger" | "primary" | "fatal";
+export interface IModalOptions {
+    /** CSS класс */
+    class?: string;
+    /** Подписка на инциализацию модального окна */
+    initContainer?: (container: any) => void;
+    /** Размер модального окна */
+    size?: "lg" | "sm" | "md";
+    /** Классы CSS для содержимого модального окна */
+    css?: string;
+    /** Заголовок модального окна */
+    title?: string;
+    /** Иконка для модального окна */
+    icon?: string;
+    /** Затемнение заднего фона */
+    backdrop?: boolean;
+    /** Параметры размеров модального окна */
+    initialSizingState?: IModalSizingState;
+    /** Тип модального окна */
+    type?: ModalTypes;
+}
+export interface IPanelOptions {
+    /** Отображать боковую панель в расширенном на весь экран виде */
+    maximized?: boolean;
+}
+export interface IModalSizingState {
+    /** Отображать окно в расширенном на весь экран виде */
+    full: boolean;
+    /** Ширина */
+    width: number;
+    /** Высота */
+    height: number;
+}

package/types/_core/scripts/services/customModules/facades/utils/IUtilsFacade.d.ts

@@ -0,0 +1,6 @@
+import { FormatOptions } from "../../../../helpers/formatOptions";
+export interface IUtilsFacade {
+    getText(textCode: string, args?: any): string;
+    format(value: any, options?: FormatOptions): any;
+    guid(): string;
+}

package/types/_core/scripts/services/customModules/facades/utils/ImUtilsFacade.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="mithril" />
+import { MithrilControl } from "mdtScripts/helpers/types";
+export declare type ConfigFunction = (element: HTMLElement, isInitialized: boolean, context?: any) => void;
+export interface ImUtilsFacade {
+    /** Проверка, есть ли класс у элемента */
+    hasClass(obj: _mithril.MithrilVirtualElement, className: string): boolean;
+    /** Добавить класс для элемента */
+    addClass(obj: _mithril.MithrilVirtualElement, className: string): void;
+    /** Удалить класс у элемента */
+    removeClass(obj: _mithril.MithrilVirtualElement, className: string): void;
+    /** Переключить класс элемента. Если у элемента есть данный класс, то он будет удален. Если у элемента нет данного класса, то он будет добавлен. */
+    toggleClass(obj: _mithril.MithrilVirtualElement, className: string): void;
+    /** Добавить стили для элемента */
+    addStyle(obj: _mithril.MithrilVirtualElement, prop: string, value: string): void;
+    /** Установить функцию жизненного цикла Mithril компонента */
+    config(obj: _mithril.MithrilVirtualElement, config: ConfigFunction, before?: boolean): _mithril.MithrilVirtualElement;
+    /** Подписаться на событие удаления компонента со страницы */
+    onunload(ctx: any, fn: Function): void;
+    /** Установить атрибут элемента */
+    attr(obj: {
+        $attrs: any;
+    }, attr?: string, value?: string, op?: boolean): void;
+    /** Проверить наличие view у компонента */
+    hasView(ctrl: MithrilControl): boolean;
+}

package/types/_core/scripts/services/customModules/facades/utils/UiComponentsFacade.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="mithril" />
+import { InputOptions } from "mdtScripts/components/baseFormControls/input/inputView";
+import { IconOptions } from "mdtScripts/components/icon/iconOptions";
+import { CommonControlOptions } from "mdtScripts/views/form/controls/commonControl/ICommonControl";
+import { ButtonFacade } from "../Form/IFormFacade";
+import { IProcessFormBlockOptions, IUiComponentsFacade, TopNavButton } from "./IUiComponentsFacade";
+import { DropdownInputItemOptions } from "mdtScripts/components/dropdown/menu/item/dropdownInputItemOptions";
+import { DropdownItemViewOptions } from "mdtScripts/components/dropdown/menu/item/dropdownItemWrapOptions";
+export declare class UiComponentsFacade implements IUiComponentsFacade {
+    button(button: ButtonFacade, translate?: boolean): _mithril.MithrilVirtualElement;
+    topNavButton(options: TopNavButton): _mithril.MithrilVirtualElement;
+    icon(icon: string, options?: IconOptions): _mithril.MithrilVirtualElement;
+    processFormBlock(options: IProcessFormBlockOptions): _mithril.MithrilVirtualElement;
+    commonControl(options: CommonControlOptions): _mithril.MithrilVirtualElement;
+    unstyledInput(options: InputOptions): _mithril.MithrilVirtualElement;
+    input(options: InputOptions): _mithril.MithrilVirtualElement;
+    dropdownItem(options: DropdownItemViewOptions): _mithril.MithrilVirtualElement;
+    dropdownInputItem(options: DropdownInputItemOptions): _mithril.MithrilVirtualElement;
+}

package/types/_core/scripts/services/customModules/facades/utils/UiFacade.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="mithril" />
+import { MithrilControl } from "mdtScripts/helpers/types";
+import { createDropdown as createDropdownOrig } from "mdtServices/dropdown/createDropdown";
+import { CustomNotification, IModalOptions, IPanelOptions, IUiFacade, ParentCtrl } from "./IUiFacade";
+export declare class UiFacade implements IUiFacade {
+    showNotification(msg: CustomNotification, duration?: number): void;
+    showModal(ctrl: MithrilControl | ParentCtrl, options?: IModalOptions): void;
+    showSidebar(ctrl: MithrilControl | ParentCtrl, options: any, panelOptions?: IPanelOptions): void;
+    private getViewControl;
+    createDropdown: typeof createDropdownOrig;
+    createControl(view: () => _mithril.MithrilVirtualElement): MithrilControl;
+}

package/types/_core/scripts/services/customModules/facades/utils/UtilsFacade.d.ts

@@ -0,0 +1,2 @@
+import { IUtilsFacade } from "./IUtilsFacade";
+export declare const utils: IUtilsFacade;

package/types/_core/scripts/services/customModules/facades/utils/mUtilsFacade.d.ts

@@ -0,0 +1,2 @@
+import { ImUtilsFacade } from "./ImUtilsFacade";
+export declare const mUtils: ImUtilsFacade;

package/types/_core/scripts/services/dropdown/DropdownManager.d.ts

@@ -0,0 +1,7 @@
+import { MithrilContext } from "../../helpers/types";
+import { DropdownMenu } from "./DropdownMenu";
+import { DropdownOptions, IDropdownMenu } from "./IDropDownMenu";
+export declare type DropdownTargetContext<I> = MithrilContext<{
+    $dropdown?: IDropdownMenu<I>;
+}>;
+export declare function createDropdown<I>(items: () => I[], el: HTMLElement, ctx: DropdownTargetContext<I>, options?: DropdownOptions<I>): IDropdownMenu<I> | DropdownMenu<I>;

package/types/_core/scripts/services/dropdown/DropdownMenu.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="mithril" />
+import { DropdownMenuViewOptions, DropdownOptions, IDropdownMenu } from "./IDropDownMenu";
+import "./DropdownMenu.less";
+export declare class DropdownMenu<I> implements IDropdownMenu<I> {
+    private options?;
+    private popover;
+    constructor(options?: DropdownOptions<I>);
+    bind(el: Element, ctx: any): void;
+    show(): void;
+    close(): void;
+    isShown(): boolean;
+}
+export declare const dropdownMenuView: <I>(options: DropdownMenuViewOptions<I>) => _mithril.MithrilVirtualElement;

package/types/_core/scripts/services/dropdown/IDropDownManager.d.ts

@@ -0,0 +1,5 @@
+import { DropdownOptions, IDropdownMenu } from "./IDropDownMenu";
+export declare class IDropdownManagerClass {
+    getDropdownMenu<I>(items: I[], uid: string, options?: DropdownOptions<I>): IDropdownMenu<I>;
+    deleteDropdownMenu(uid: string): void;
+}

package/types/_core/scripts/services/dropdown/IDropDownMenu.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="mithril" />
+import { MithrilContext, MithrilControl } from "../../helpers/types";
+export declare class IDropdownMenu<I> {
+    constructor(items: I[], uid: string, options?: DropdownOptions<I>);
+    bind(el: HTMLElement, ctx: MithrilContext): void;
+    show(): void;
+    close(): void;
+    isShown(): boolean;
+}
+export interface DropdownOptions<I> {
+    getItems: () => I[];
+    onSelect: (item: Exclude<I, MithrilControl>) => void;
+    itemView: (item: Exclude<I, MithrilControl>) => _mithril.MithrilVirtualElement;
+    class?: string;
+    onShow?: () => void;
+    onClose?: () => void;
+}
+export interface DropdownMenuViewOptions<I> {
+    items: I[];
+    itemView?: (item: Exclude<I, MithrilControl>) => _mithril.MithrilVirtualElement;
+    onSelect: (item: Exclude<I, MithrilControl>) => void;
+    class?: string;
+}
+export declare type DropdownTargetContext<I> = MithrilContext<{
+    $dropdown?: IDropdownMenu<I>;
+}>;

package/types/_core/scripts/services/dropdown/createDropdown.d.ts

@@ -0,0 +1,3 @@
+import { DropdownMenu } from "./DropdownMenu";
+import { DropdownOptions, DropdownTargetContext } from "./IDropDownMenu";
+export declare function createDropdown<I>(options: DropdownOptions<I>, el: Element, ctx: DropdownTargetContext<I>): import("./IDropDownMenu").IDropdownMenu<I> | DropdownMenu<I>;

package/types/_core/scripts/services/jsonSchema/JsonSchemaManager.d.ts

@@ -0,0 +1,17 @@
+import { JSONSchema7 } from "_core/_res/lib/types/jsonSchema";
+interface JsonDefinitions {
+    [key: string]: JSONSchema7;
+}
+export interface JsonSchemaSource {
+    $schema: string;
+    definitions: JsonDefinitions;
+}
+export declare class JsonSchemaManagerClass {
+    private source;
+    constructor(source: () => Promise<JsonSchemaSource>);
+    getDefinitions(): Promise<JsonDefinitions>;
+    getSchemaWithDefinitions(code: string): Promise<JSONSchema7>;
+    getSchema(code: string): Promise<JSONSchema7>;
+}
+export declare const JsonSchemaManager: JsonSchemaManagerClass;
+export {};

package/types/_core/scripts/services/jsonSchema/JsonSchemaValidator.d.ts

@@ -0,0 +1,11 @@
+import * as Ajv from "ajv";
+export declare type JsonSchemaError = {
+    [path: string]: JsonSchemaErrorData;
+};
+export interface JsonSchemaErrorData {
+    message: string;
+}
+export declare class JsonSchemaValidator {
+    static validateSchema(schema: any): boolean;
+    static validate(schema: any, data: any): Ajv.ErrorObject[];
+}

package/types/_core/scripts/services/objectRules/ObjectRuleTypes.d.ts

@@ -0,0 +1,32 @@
+import { ObjectValidationRuleData, ValidationObjectRuleOptions } from "mdtServices/objectRules/ObjectRules";
+export interface ScriptContext {
+    $mdt: ScriptMdtObject;
+}
+interface ScriptMdtObject {
+    /** Правила объекта */
+    rules: {
+        /**
+         * Правила валидации объекта
+         *
+         * @param message - Сообщение, описывающее правило валидации
+         * @param isValid - Функция валидации. Если возвращает true, запись считается валидной.
+         * @param options - Настройки правила или поле (поля, если массив) к которому относится правило.
+         */
+        validate: (message: string, isValid: (data: ObjectValidationRuleData) => boolean, options?: ValidationObjectRuleOptions | string | string[]) => void;
+    };
+    /** Запрос к MDT API под текущим пользователем */
+    fetchRaw: (query: ApiRawQuery) => Promise<FetchRawResult>;
+}
+interface FetchRawResult {
+    Rows: any[];
+}
+interface ApiRawQuery {
+    table?: string;
+    select?: string;
+    top?: number;
+    filter?: string;
+    skip?: number;
+    sorting?: string;
+    count?: boolean;
+}
+export {};

package/types/_core/scripts/services/objectRules/ObjectRules.d.ts

@@ -0,0 +1,27 @@
+import { Record } from "mdtScripts/common/Record";
+import { Table } from "mdtScripts/common/Table";
+import { ObjectRulesValidator } from "./ObjectRulesValidator";
+export interface ObjectRulesData {
+    validation?: ObjectValidationRule[];
+}
+export interface ObjectValidationRule {
+    isValid: (data: ObjectValidationRuleData) => boolean | Promise<boolean>;
+    message?: string;
+    options?: ValidationObjectRuleOptions;
+}
+export interface ObjectValidationRuleData {
+    /** Значения записи */
+    record: Record;
+    /** Информация о таблице */
+    table: Table;
+}
+export interface ValidationObjectRuleOptions {
+    /** Поля, к которым относится правило валидации */
+    fields?: string[];
+}
+export declare class ObjectRulesManager {
+    private data;
+    validator: ObjectRulesValidator;
+    constructor(data: ObjectRulesData);
+    necessaryFields(): string[];
+}

package/types/_core/scripts/services/objectRules/ObjectRulesApiDatasource.d.ts

@@ -0,0 +1,6 @@
+import { Table } from "mdtScripts/common/Table";
+import { ObjectRulesDatasource } from "./ObjectRulesScriptProvider";
+export declare class ObjectRulesApiDatasource implements ObjectRulesDatasource {
+    fetch(object: Table): Promise<string>;
+    save(object: Table, code: string): any;
+}

package/types/_core/scripts/services/objectRules/ObjectRulesDataPurifier.d.ts

@@ -0,0 +1,4 @@
+import { ObjectValidationRuleData } from "./ObjectRules";
+export declare class ObjectRulesDataPurifier {
+    purify(args: ObjectValidationRuleData): ObjectValidationRuleData;
+}

package/types/_core/scripts/services/objectRules/ObjectRulesEditorSetup.d.ts

@@ -0,0 +1,2 @@
+import { MonacoLibService } from "mdtScripts/views/form/controls/monacoEditor/monacoLibService";
+export declare function setupObjectRuleDefinitions(): MonacoLibService;

package/types/_core/scripts/services/objectRules/ObjectRulesFormAdapter.d.ts

@@ -0,0 +1,28 @@
+import { Field } from "mdtScripts/common/Field";
+import { FormCtrl } from "mdtScripts/views/form/form";
+import { ObjectValidationRuleData } from "./ObjectRules";
+import { ObjectRulesValidator } from "./ObjectRulesValidator";
+export declare class ObjectRulesFormAdapter {
+    constructor(form: FormCtrl);
+}
+interface FormObjectValidatorOptions {
+    objectRulesValidator: ObjectRulesValidator;
+    form: FormCtrl;
+}
+export declare class FormObjectRulesValidator {
+    private options;
+    private formObjectRulesKey;
+    private fieldUpdateKey;
+    private form;
+    private objectRulesValidator;
+    constructor(options: FormObjectValidatorOptions);
+    validate(data: ObjectValidationRuleData): Promise<{
+        key: string;
+        field: Field;
+        fields?: string[];
+        message: string;
+    }[]>;
+    clearObjectRuleErrors(field?: Field): void;
+    validateField(field: Field, fireEvent: boolean): void;
+}
+export {};

package/types/_core/scripts/services/objectRules/ObjectRulesScriptProvider.d.ts

@@ -0,0 +1,24 @@
+import { Table } from "mdtScripts/common/Table";
+import { Notifier } from "mdtScripts/helpers/types";
+import { CacheManager } from "mdtScripts/helpers/utils/CacheManager";
+import { ObjectRulesData } from "./ObjectRules";
+import { ObjectRulesProvider } from "./ObjectRulesService";
+export interface ObjectRulesDatasource {
+    fetch(object: Table): Promise<string>;
+}
+interface ObjectRulesScriptProviderDeps {
+    datasource?: ObjectRulesDatasource;
+    notifier?: Notifier;
+    cache?: CacheManager;
+}
+export declare class ObjectRulesScriptProvider implements ObjectRulesProvider {
+    ds: ObjectRulesDatasource;
+    notifier: Notifier;
+    cache: CacheManager;
+    constructor(dependencies?: ObjectRulesScriptProviderDeps);
+    loadRules(object: Table): Promise<ObjectRulesData>;
+    onRulesUpdate(object?: Table): void;
+    private fetchRulesScript;
+    private parseScript;
+}
+export {};

package/types/_core/scripts/services/objectRules/ObjectRulesService.d.ts

@@ -0,0 +1,19 @@
+import { Table } from "mdtScripts/common/Table";
+import { ObjectRulesManager, ObjectRulesData } from "./ObjectRules";
+interface ObjectRulesManagerDeps {
+    provider: ObjectRulesProvider;
+}
+export declare class ObjectRulesServiceClass {
+    provider: ObjectRulesProvider;
+    private onRulesUpdateCallbacks;
+    constructor(dependencies?: ObjectRulesManagerDeps);
+    getObjectRulesManager(object: Table): Promise<ObjectRulesManager>;
+    rulesUpdated(object?: Table): void;
+    onRulesUpdate(callback: any): () => void;
+}
+export declare const ObjectRulesService: ObjectRulesServiceClass;
+export interface ObjectRulesProvider {
+    loadRules(object: Table): Promise<ObjectRulesData>;
+    onRulesUpdate(object: Table): void;
+}
+export {};

package/types/_core/scripts/services/objectRules/ObjectRulesValidator.d.ts

@@ -0,0 +1,25 @@
+import { Notifier } from "mdtScripts/helpers/types";
+import { ObjectValidationRule, ObjectValidationRuleData } from "./ObjectRules";
+export interface ObjectRulesValidatorOptions {
+    messageHandler?: (msg: string) => string;
+}
+interface ObjectRulesValidatorDeps {
+    notifier: Notifier;
+}
+export declare class ObjectRulesValidator {
+    private validationRules;
+    private options?;
+    private notifier;
+    private dataPurifier;
+    constructor(validationRules?: ObjectValidationRule[], options?: ObjectRulesValidatorOptions, deps?: ObjectRulesValidatorDeps);
+    private createErrorMessage;
+    private isValidResult;
+    private runRules;
+    validate(data: ObjectValidationRuleData): Promise<ObjectValidationError[]>;
+    validateField(data: ObjectValidationRuleData, fieldCode: string): Promise<ObjectValidationError[]>;
+}
+export interface ObjectValidationError {
+    fields?: string[];
+    message: string;
+}
+export {};

package/types/_core/scripts/services/objectRules/ui/ObjectRuleModal.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="mithril" />
+import { Table } from "mdtScripts/common/Table";
+import { Button } from "mdtScripts/helpers/ui/el";
+import "./ObjectRuleModal.less";
+export declare function getObjectRuleButton(table?: Table, extend?: Partial<Button>): {
+    isPrimary?: boolean;
+    itemClass?: string;
+    type?: import("../../../views/form/controls/monacoEditor/jsonSchemas/Button.schema").ButtonTypes | (() => import("../../../views/form/controls/monacoEditor/jsonSchemas/Button.schema").ButtonTypes);
+    size?: import("../../../views/controls/Control").ControlSize;
+    items?: Button[];
+    group?: boolean;
+    icon: string | (() => string);
+    hoverIcon?: string | (() => string);
+    iconAttrs?: any;
+    iconClass?: string;
+    title: any;
+    tooltip?: import("../../../helpers/formattedText").FormattedText | (() => import("../../../helpers/formattedText").FormattedText);
+    supIcon?: string;
+    onselect?: any;
+    control?: any;
+    command: ((ctrl?: any, e?: any) => void) | (() => Promise<void>);
+    expandPromise?: () => _mithril.MithrilPromise<any>;
+    wrapTag?: string;
+    wrapClass?: string;
+    enabled?: (ctrl?: any) => boolean;
+    visible: ((ctrl?: any) => boolean) | (() => boolean);
+    class?: any;
+    _parent?: import("../../../views/controls/DropdownMenu").DropdownMenuCtrl;
+    attrs?: _mithril.MithrilAttributes;
+    itemSelected?: (r: import("mdtScripts/helpers/ui/el").ActionItem) => any;
+    titleClass?: string;
+    itemsShowOnHover?: boolean;
+    showItemsOnClick?: boolean;
+    hideCaret?: boolean;
+    forceShowCaret?: boolean;
+    order?: number;
+    highlighted?: boolean;
+    href?: string | (() => string);
+    hrefTargetBlank?: boolean;
+    config?: any;
+    code?: string;
+    btnClass?: string;
+    active?: import("../../../helpers/types").Valued<boolean>;
+    focused?: import("../../../helpers/types").Valued<boolean>;
+    visibility$?: any;
+    visible$?: any;
+    isDefault?: boolean;
+    dropdownOptions?: any;
+    $dropdown?: import("../../../views/controls/DropdownMenu").DropdownMenuCtrl;
+};

package/types/_core/scripts/services/schema/IExp.schema.d.ts

@@ -0,0 +1,2 @@
+import { ExpBase, IExpItem } from "mdtServices/Evaluator";
+export declare type IExp = IExpItem & ExpBase;

package/types/_core/scripts/setupMainForms.d.ts

@@ -0,0 +1 @@
+export declare function setupMainForms(): void;

package/types/_core/scripts/views/Animator.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="mithril" />
+export declare class Animator {
+    target: any;
+    aliases: {};
+    animating: boolean;
+    viewEl: _mithril.MithrilVirtualElement;
+    class: string;
+    playing: {};
+    events: {
+        animating: any[];
+        animated: any[];
+    };
+    constructor(target: any, aliases?: {});
+    wrap(viewEl: _mithril.MithrilVirtualElement): _mithril.MithrilVirtualElement;
+    play(name: any): _mithril.MithrilPromise<unknown>;
+    stop(name: any, success?: boolean): void;
+    is(name: any): any;
+    update(): void;
+}

package/types/_core/scripts/views/CenteredMessage.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="mithril" />
+export declare const CenteredMessage: (message: string, onunload?: () => void) => _mithril.MithrilVirtualElement;
+export declare const CenteredMessageCtrl: (message: string, onunload?: () => void) => {
+    $view: () => _mithril.MithrilVirtualElement;
+};

package/types/_core/scripts/views/CustomCss.d.ts

@@ -0,0 +1,13 @@
+export declare class CustomCss {
+    element: HTMLStyleElement;
+    sheet: CSSStyleSheet;
+    index: number;
+    existing: boolean;
+    constructor(id?: string);
+    private getBody;
+    addRule(selector: any, props: any): void;
+    addKeyframes(title: any, props: any): void;
+    changeRule(index: any, props: any): void;
+    clear(): void;
+    dispose(): void;
+}

package/types/_core/scripts/views/FramePage.d.ts

@@ -0,0 +1,6 @@
+import { FrameCtrl } from "./form/frame";
+import { NavigationNode } from "../common/NavigationNode";
+export declare class FramePage {
+    frame: FrameCtrl;
+    constructor(node: NavigationNode);
+}

package/types/_core/scripts/views/containers/ModalSizeManager.d.ts

@@ -0,0 +1,12 @@
+import { ModalSizingState } from "./modal";
+export declare class ModalSizeManager {
+    private static _prefix;
+    private static timeouts;
+    static save(key: string, state: ModalSizingState): void;
+    private static getKey;
+    static get(key: string): any;
+    static getModalOptions(key: string): {
+        onResize: (state: any) => void;
+        initialSizingState: any;
+    };
+}