mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/components/skeleton/Skeleton.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="mithril" />
+import { Button } from "mdtScripts/helpers/ui/el";
+import "./Skeleton.less";
+interface FormSkeletonConfig {
+    hideGrid?: boolean;
+    fieldWidthInCols?: number;
+    colsAmount?: number;
+}
+export declare class Skeleton {
+    static getListSkeleton(cols?: number[], rows?: number): _mithril.MithrilVirtualElement;
+    static getFormSkeleton(config?: FormSkeletonConfig): _mithril.MithrilVirtualElement;
+    static getButtonSkeletonOptions(): Button;
+}
+export {};

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

@@ -0,0 +1,17 @@
+/// <reference types="mithril" />
+import { IconOptions } from "../icon/iconOptions";
+import "./textWithIcon.less";
+export interface TextWithIconOptions {
+    icon: BeforeTextIconOptions;
+    textContent: TextContentOptions;
+}
+interface BeforeTextIconOptions {
+    name: string;
+    options?: IconOptions;
+}
+interface TextContentOptions {
+    text: string;
+    className?: string;
+}
+export declare function textWithIconView(options: TextWithIconOptions): _mithril.MithrilVirtualElement[];
+export {};

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

@@ -0,0 +1,34 @@
+/// <reference types="mithril" />
+import { ResizablePanelContent } from "../resizablePanels/resizablePanel/resizablePanel";
+import { PanelsDirection } from "../resizablePanels/resizablePanels";
+import "./toggleablePanels.less";
+import { ViewElement } from "mdtScripts/helpers/types";
+import { PanelTitleOptions } from "../resizablePanels/panelTitle/panelTitle";
+export interface ToggleablePanel {
+    title: PanelTitleOptions;
+    content: ResizablePanelContent;
+    isShown: boolean;
+    onToggle?: () => void;
+}
+export interface ToggleablePanelsToolbarOptions {
+    className?: string;
+    leftZone?: ToolbarZone;
+    rightZone?: ToolbarZone;
+}
+interface ToolbarZone {
+    view: () => ViewElement;
+}
+export interface ToggleablePanelsOptions {
+    direction: PanelsDirection;
+    highlightFocusedPanel?: boolean;
+    panels: PanelsGrid<ToggleablePanel>;
+    toolbar?: ToggleablePanelsToolbarOptions;
+    resizerSize?: number;
+}
+export interface PanelsGrid<T> {
+    rows: {
+        cols: T[];
+    }[];
+}
+export declare function toggleablePanelsView(options: ToggleablePanelsOptions, key?: number): _mithril.MithrilVirtualElement;
+export {};

package/types/_core/scripts/components/toggleablePanels/toggleablePanelsCtrl.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="mithril" />
+import { PanelsGrid, ToggleablePanel, ToggleablePanelsOptions, ToggleablePanelsToolbarOptions } from "./toggleablePanels";
+declare type ToggleablePanelOptions = Omit<ToggleablePanel, "onToggle">;
+export interface ToggleablePanelsCtrlOptions extends Omit<ToggleablePanelsOptions, "direction"> {
+    panels: PanelsGrid<ToggleablePanelOptions>;
+    highlightFocusedPanel?: boolean;
+    toolbar?: ToggleablePanelsToolbarOptions;
+}
+export declare class ToggleablePanelsCtrl {
+    private iterationKey;
+    private options;
+    private panels;
+    constructor(options: ToggleablePanelsCtrlOptions);
+    updateOptions(options: ToggleablePanelsCtrlOptions): void;
+    private initPanelsCopy;
+    private getPanelsOptions;
+    private updateIterationKey;
+    $view: () => _mithril.MithrilVirtualElement;
+}
+export {};

package/types/_core/scripts/components/tooltip/controllers/globalEventHandler.d.ts

@@ -0,0 +1,19 @@
+import { CursorPosition } from "./tooltipGenerator";
+import { FormattedText } from "mdtScripts/helpers/formattedText";
+declare class TooltipGlobalEventHandlerClass {
+    private targetEl;
+    private currentElement;
+    private tooltipGenerator;
+    private timeout;
+    private cursorPosition;
+    generateEvent(triggerElement: Element): void;
+    updateTooltipPosition(cursorPosition: CursorPosition): void;
+    clearTooltip(): void;
+    onElementClick(triggerElement: Element): void;
+    setTooltip(el: Element, content: FormattedText): void;
+    private dispatchEvent;
+    private removeTooltip;
+    private clearLinks;
+}
+export declare const TooltipGlobalEventHandler: TooltipGlobalEventHandlerClass;
+export {};

package/types/_core/scripts/components/tooltip/controllers/tooltipGenerator.d.ts

@@ -0,0 +1,11 @@
+import { TooltipTarget } from "./tooltipTarget";
+export interface CursorPosition {
+    x: number;
+    y: number;
+}
+export declare class TooltipGenerator {
+    private tooltipEl;
+    renderTooltip(targetEl: TooltipTarget, cursorPosition: CursorPosition): void;
+    removeTooltip(): void;
+    private updatePosition;
+}

package/types/_core/scripts/components/tooltip/controllers/tooltipPositionController.d.ts

@@ -0,0 +1,31 @@
+import { CursorPosition } from "./tooltipGenerator";
+export declare function setTooltipPosition(tooltipElement: HTMLElement, cursorPosition: CursorPosition, contextElement: Element, arrowEl?: HTMLElement): void;
+export declare function getTooltipXPos(cursorXPos: number, xPosByTarget: number, arrowOffset: number): number;
+interface TooltipConfig {
+    cursorOffset: number;
+}
+interface TooltipArrowConfig {
+    size: number;
+    tooltipBoundingOffset: number;
+}
+declare type TooltipArrowStyle = Partial<CSSStyleDeclaration>;
+export declare class TooltipPositionController {
+    private config;
+    arrowController: TooltipArrowPositionController;
+    constructor(config: TooltipConfig);
+    setArrowController(controller: TooltipArrowPositionController): void;
+    getTooltipOffset(): number;
+}
+export declare class TooltipArrowPositionController {
+    private arrowEl;
+    private config;
+    constructor(arrowEl: HTMLElement, config: TooltipArrowConfig);
+    isArrowExist(): boolean;
+    getArrowEl(): HTMLElement;
+    getTooltipOffsetByArrowSize(): number;
+    getArrowOffset(): number;
+    getArrowSize(): number;
+    getArrowXPos(cursorXPos: number, tooltipBlockXPos: number): number;
+    getArrowStyle(): TooltipArrowStyle;
+}
+export {};

package/types/_core/scripts/components/tooltip/controllers/tooltipTarget.d.ts

@@ -0,0 +1,10 @@
+import { FormattedText } from "mdtScripts/helpers/formattedText";
+import { TooltipOptions } from "../tooltip";
+export declare class TooltipTarget {
+    private el;
+    private content;
+    constructor(el: Element, content: FormattedText);
+    getTooltipContentOptions(): TooltipOptions;
+    contains(element: Element): boolean;
+    getElement(): Element;
+}

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

@@ -0,0 +1,9 @@
+import "./tooltip.less";
+export interface TooltipOptions {
+    textContent: string;
+    isMarkdown?: boolean;
+    showArrow?: boolean;
+}
+export declare function tooltipElement(options: TooltipOptions): HTMLElement;
+export declare function createElement(tagName: string, classList: string): HTMLElement;
+export declare function findArrowInTooltip(tooltipEl: HTMLElement): HTMLElement;

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

@@ -0,0 +1,6 @@
+/// <reference types="mithril" />
+import { Button } from "mdtScripts/helpers/ui/el";
+import { TopNavButton } from "mdtServices/customModules/facades/utils/IUiComponentsFacade";
+import "./topNavButton.less";
+export declare function topNavButton(options: Button): _mithril.MithrilVirtualElement;
+export declare function topNavItem(options: TopNavButton): _mithril.MithrilVirtualElement;

package/types/_core/scripts/data/active/ActivationCellTransformer.d.ts

@@ -0,0 +1,5 @@
+import { CellTransformerCtx } from "mdtScripts/views/list/ListView";
+export declare class ActivationCellTransformer {
+    private columnsWithActive;
+    $view(ctrl: ActivationCellTransformer, ctx: CellTransformerCtx): void;
+}

package/types/_core/scripts/data/active/ActivationFormAdapter.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="mithril" />
+import { FormCtrl } from "mdtScripts/views/form/form";
+import { ApiRequest } from "mdtServices/api/ApiRequestOptions";
+export declare class ActivationFormAdapter {
+    private form;
+    private options;
+    req: _mithril.MithrilPromiseProperty<ApiRequest> & {
+        onchange: (v?: ApiRequest) => any;
+    };
+    constructor(form: FormCtrl);
+    private initActive;
+}

package/types/_core/scripts/data/active/ActivationListAdapter.d.ts

@@ -0,0 +1,10 @@
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+export declare class ActivationListAdapter {
+    private list;
+    private filterItems;
+    private options;
+    constructor(list: ListCtrl);
+    private getSelectedRows;
+    private updateButtons;
+    private showLegend;
+}

package/types/_core/scripts/data/active/ActivationManager.d.ts

@@ -0,0 +1,8 @@
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+export declare class ActivationManager {
+    static isEnabled(table: any): boolean;
+    static changeActivity(record: any, activity?: any): any;
+    static columnsEnabledToFieldPath(list: ListCtrl): import("mdtScripts/views/list/ListCtrl").LayoutColumn[];
+    static isDeactivated(ctx: any): boolean;
+    static selectDeactivatedCells(list: any): void;
+}

package/types/_core/scripts/data/active/ActivationRowTransformer.d.ts

@@ -0,0 +1,3 @@
+export declare class ActivationRowTransformer {
+    $view(ctrl: any, ctx: any): void;
+}

package/types/_core/scripts/data/active/ActivationSchema.d.ts

@@ -0,0 +1,5 @@
+export declare const ActivationSchema: {
+    fields: {
+        flagActive: string;
+    };
+};

package/types/_core/scripts/data/active/FilterItems.d.ts

@@ -0,0 +1,18 @@
+import { Button } from "mdtScripts/helpers/ui/el";
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+import { IFilter } from "mdtServices/IFilter";
+export declare class FilterItems {
+    private list;
+    private filters;
+    private currentFilter;
+    constructor(list: ListCtrl, filters: FilterItem[]);
+    selectFilter(code: any): void;
+    getCurrentFilter(): string;
+    getButtons(): Button[];
+}
+export interface FilterItem {
+    code: string;
+    title?: string;
+    filter?: IFilter;
+    selected?: boolean;
+}

package/types/_core/scripts/data/fieldFilter/ToolbarFieldFilterListExtender.d.ts

@@ -0,0 +1,20 @@
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+import { BaseQuery } from "mdtServices/api/BaseQuery";
+import "./ToolbarFieldFilterListExtender.less";
+export interface ToolbarFieldFilterListExtenderOptions {
+    /** Путь до поля по которому будет фильтроваться список */
+    fieldPath: string;
+    /** Наименование кнопки в тулбаре */
+    title?: string;
+    /** Дополнительные настройки для запроса значений фильтра */
+    query?: Omit<BaseQuery, "select">;
+}
+export declare class ToolbarFieldFilterListExtender {
+    private list;
+    private filterItems;
+    private options;
+    constructor(list: ListCtrl, options: ToolbarFieldFilterListExtenderOptions[]);
+    private getFieldPath;
+    private getFetch;
+    private createFilters;
+}

package/types/_core/scripts/datasources/ApiDatasource.d.ts

@@ -0,0 +1,20 @@
+import { Datasource } from "../common/Datasource";
+import { Table } from "../common/Table";
+import { ApiService } from "../services/api/ApiService";
+import { ApiRequestOptions } from "_core/scripts/services/api/ApiRequestOptions";
+import { Query } from "_core/scripts/services/api/Query";
+import { FetchResult as FetchResultOrig } from "./FetchResult";
+export declare type FetchResult<R = any, I = any> = FetchResultOrig<R, I>;
+export declare class ApiDatasource implements Datasource {
+    api: ApiService;
+    events: {
+        destroy: any[];
+        fetch: ((query: Query, table: Table, requestOptions: ApiRequestOptions) => void)[];
+        save: any[];
+    };
+    fetch(query: Query, table: Table, options?: {}, batch?: boolean): any;
+    private prepareSortPath;
+    fetchById(id: any, table: any): any;
+    save(r: any, params?: any, options?: ApiRequestOptions): any;
+    delete(ids: any, table: any): any;
+}

package/types/_core/scripts/datasources/FetchResult.d.ts

@@ -0,0 +1,5 @@
+export interface FetchResult<R = any, I = any> {
+    records: R[];
+    count: number;
+    items?: I[];
+}

package/types/_core/scripts/datasources/MemoryDatasource.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="mithril" />
+import { Datasource } from "../common/Datasource";
+import { Table } from "../common/Table";
+import { Query } from "../services/api/Query";
+export interface MemoryDatasourceOptions {
+    filter?: any;
+}
+export declare class MemoryDatasource implements Datasource {
+    data: any[] | (() => any[]);
+    table?: Table;
+    options: MemoryDatasourceOptions;
+    constructor(data?: any[] | (() => any[]), table?: Table, options?: MemoryDatasourceOptions);
+    fetch(query: Query): _mithril.MithrilPromiseProperty<{
+        records: any;
+    }> & {
+        onchange: (v?: {
+            records: any;
+        }) => any;
+    };
+    save(r: any): _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+    fetchById(id: any): any;
+    destroy(): void;
+    private filterRecords;
+}

package/types/_core/scripts/datasources/TabularDatasource/TabularDatasource.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="mithril" />
+import { IApiAccessor } from "mdtServices/api/ApiAccessor";
+import { ApiRequestOptions } from "mdtServices/api/ApiRequestOptions";
+import { Query } from "mdtServices/api/Query";
+import { InitialFetchResponse } from "mdtServices/api/QueryResultHandler";
+declare class TabularDatasourceImpl {
+    private readonly TABULAR_SERVICE_URL;
+    private dataService;
+    private apiAccessor;
+    constructor();
+    setApiAccessor(apiAccessor: IApiAccessor): void;
+    fetch<T = InitialFetchResponse>(query: Query, tableName: string, options?: ApiRequestOptions): _mithril.MithrilPromise<import("mdtServices/api/QueryResultHandler").HandledResult<any, any>>;
+    private url;
+}
+export declare const TabularDatasource: TabularDatasourceImpl;
+export {};

package/types/_core/scripts/datasources/TabularDatasource/TabularDatasourceDataService.d.ts

@@ -0,0 +1,17 @@
+import { Query, QuerySorting } from "mdtServices/api/Query";
+import { InitialFetchResponse } from "mdtServices/api/QueryResultHandler";
+export interface TabularQuery extends Omit<Query, "count" | "sorting"> {
+    orderby?: QuerySorting[];
+}
+export declare class TabularDatasourceDataService {
+    private resultHandler;
+    private queryHandler;
+    constructor();
+    getPreparedQuery(query: Query): TabularQuery;
+    prepareFetchedData(fetchResult: InitialFetchResponse): import("mdtServices/api/QueryResultHandler").HandledResult<any, any>;
+}
+export declare class TabularQueryHandler {
+    prepareQueryForSending(query: Query): TabularQuery;
+    private renameSorting;
+    private renameCount;
+}

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

@@ -0,0 +1,35 @@
+import { PermissionLevel } from "./security/PermissionLevel";
+import { Table } from "./common/Table";
+import { ApiRequestOptions } from "./services/api/ApiRequestOptions";
+export declare class UnhandledServerError extends Error {
+    data: any;
+    constructor(data: any);
+}
+export declare class ServerError extends Error {
+    params: any;
+    data: any;
+    constructor(e: any, params?: any);
+}
+export declare class ConnectionError extends ServerError {
+    title: string;
+    constructor(args?: ApiRequestOptions);
+}
+export declare class LogicError extends Error {
+    title: any;
+    message: any;
+    args: any;
+    constructor(title: any, message: any, args?: any);
+}
+export declare class ControlError extends Error {
+    args?: any;
+    name: any;
+    constructor(message?: string, args?: any);
+}
+export declare function UnauthorizedError(): void;
+export declare function SecurityError(level: PermissionLevel, object: Table | string): void;
+export declare function DeferredError(e?: any): void;
+export declare class SchemaError extends LogicError {
+    msg: any;
+    constructor(msg: any);
+}
+export declare function showError(data: any, critical?: any): void;

package/types/_core/scripts/helpers/FieldValueFormatter.d.ts

@@ -0,0 +1 @@
+export declare function formatNumberByMask(value: number, mask: string): string;

package/types/_core/scripts/helpers/IUi.d.ts

@@ -0,0 +1 @@
+export declare type UiType = "success" | "danger" | "warning" | "info" | "primary" | "fatal";

package/types/_core/scripts/helpers/PositionCalculator.d.ts

@@ -0,0 +1,59 @@
+import { ComputePositionConfig } from "@floating-ui/core";
+interface FloatingElementOffset {
+    enabled: boolean;
+    size?: number;
+    mainAxisSize?: number;
+    crossAxisSize?: number;
+}
+interface FloatingElementShift {
+    enabled: boolean;
+    padding?: number;
+}
+interface FloatingElementFlip {
+    enabled: boolean;
+}
+interface FloatingElementArrow {
+    element: HTMLElement;
+}
+interface FloatingElementSize {
+    apply: (args: {
+        floating: DOMRect;
+        reference: DOMRect;
+    } & Pick<DOMRect, "height" | "width">) => void;
+    padding?: number;
+}
+interface ComputingBaseOptions {
+    offset?: FloatingElementOffset;
+    boundingShift?: FloatingElementShift;
+    flipElement?: FloatingElementFlip;
+    arrow?: FloatingElementArrow;
+    size?: FloatingElementSize;
+    placement?: "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
+}
+declare type VirtualElementBoundingRect = () => Omit<DOMRect, "toJSON">;
+export interface ComputingOptionsWithVirtualElReference extends ComputingBaseOptions {
+    boundingClientRect: VirtualElementBoundingRect;
+    contextElement?: Element;
+}
+declare type ComputingOptionsWithCursorHTMLElReference = ComputingBaseOptions;
+interface ElementPosition {
+    x: number;
+    y: number;
+}
+interface FloatingElementPosition extends ElementPosition {
+    additionalElementsData?: FloatingElementAdditionalElement;
+}
+interface FloatingElementAdditionalElement {
+    arrow: ElementPosition;
+}
+export declare function computeElementPositionByElement(floatingEl: HTMLElement, referenceElement: Element, options: ComputingOptionsWithCursorHTMLElReference): Promise<FloatingElementPosition>;
+export declare function computeElementPositionByVirtualEl(floatingEl: HTMLElement, options: ComputingOptionsWithVirtualElReference): Promise<FloatingElementPosition>;
+export declare class FloatingUILibOptionsBuilder {
+    getLibOptions(options: ComputingBaseOptions): Partial<ComputePositionConfig>;
+    private appendFlipMiddleware;
+    private appendShiftMiddleware;
+    private appendOffsetMiddleware;
+    private appendArrowMiddleware;
+    private appendSizeMiddleware;
+}
+export {};

package/types/_core/scripts/helpers/debug.d.ts

@@ -0,0 +1,6 @@
+export declare const debug: {
+    ms: (x: any) => string;
+    perf: (x: any, fn: any) => any;
+    mPerf: (viewProto: any) => void;
+    redraws: (n: any) => void;
+};

package/types/_core/scripts/helpers/extend.d.ts

@@ -0,0 +1,66 @@
+declare global {
+    export interface RegExpConstructor {
+        escape(str: string): string;
+    }
+    interface Array<T> {
+        first<Y>(predicate: (item: T, index?: number) => Y): Y;
+        find(predicate: (item: T) => boolean): T;
+        findIndex(predicate: (item: T, index?: number) => boolean): number;
+        last(): T;
+        remove(T: any): void;
+        includes(item: T): boolean;
+        priorited?: any;
+        move(item: T, offset: number): void;
+        getUnique(): any;
+        delete(item: T): void;
+        groupBy(fn: (item: any) => any): any[];
+        fill(any?: any): any[];
+    }
+    interface Number {
+        format(n?: any, x?: any): any;
+    }
+    interface NumberConstructor {
+        isInteger(n: number): boolean;
+    }
+    interface Function {
+        throttle(interval?: number, options?: {
+            trailing?: boolean;
+        }): any;
+        debounce(interval?: number, options?: {
+            leading?: boolean;
+        }): any;
+        times(count: number): void;
+        once(): void;
+        readonly name: string;
+    }
+    interface Date {
+        toDateTimeString(): string;
+        format(s?: string): string;
+    }
+    interface Object {
+        /**
+         * Returns an array of key/values of the enumerable properties of an object
+         * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+         */
+        entries<T>(o: {
+            [s: string]: T;
+        } | ArrayLike<T>): [string, T][];
+    }
+}
+export declare const _dateParse: (s: string) => number;
+export declare const _dateRegex: RegExp;
+export declare const _timeRegex: RegExp;
+export declare const _dateRegexps: {
+    dmy: RegExp;
+    my: RegExp;
+    y: RegExp;
+};
+export declare const getDateValuesFromStr: (v: string) => number[];
+export declare function deleteFromArray<T = any>(array: T[], item: T): void;
+export declare function deleteFromArrayByCondition<T = any>(array: T[], condition: (item: T) => boolean): void;
+export declare function lastOfArray<T = any>(array: T[]): T;
+export declare function allSettled<T = any>(promises: Promise<T>[]): Promise<Array<{
+    status: string;
+    value?: T;
+    reason?: any;
+}>>;

package/types/_core/scripts/helpers/formatOptions.d.ts

@@ -0,0 +1,6 @@
+export interface FormatOptions {
+    type?: string;
+    title?: string;
+    empty?: string;
+    mask?: string;
+}

package/types/_core/scripts/helpers/formattedText.d.ts

@@ -0,0 +1,9 @@
+declare type FormattedTextType = "text" | "markdown";
+export declare type FormattedText = string | {
+    text: string;
+    type: FormattedTextType;
+};
+export declare function getTextContent(text: FormattedText): string;
+export declare function getFormattedTextType(text: FormattedText): FormattedTextType;
+export declare function getTranslatedFormattedText(text: FormattedText, translateFn: (text: string) => string): FormattedText;
+export {};

package/types/_core/scripts/helpers/notification/ConsoleNotifier.d.ts

@@ -0,0 +1,4 @@
+import { Notifier, NotifierOptions } from "../types";
+export declare class ConsoleNotifier implements Notifier {
+    notify(title: string, options?: NotifierOptions): void;
+}

package/types/_core/scripts/helpers/notification/PopupNotifier.d.ts

@@ -0,0 +1,10 @@
+import { Notifier, NotifierOptions } from "../types";
+interface PopupNotifierOptions {
+    duration?: number;
+}
+export declare class PopupNotifier implements Notifier {
+    private settings;
+    constructor(settings?: PopupNotifierOptions);
+    notify(title: string, options: NotifierOptions): void;
+}
+export {};

package/types/_core/scripts/helpers/o2m.d.ts

@@ -0,0 +1,45 @@
+import { Field } from "../common/Field";
+import { Record } from "../common/Record";
+import { Table } from "../common/Table";
+import { IFilter } from "../services/IFilter";
+import { PickRecordOptions } from "../views/pickRecordModal";
+import { FieldCtrl } from "../views/form/field";
+import { FormCtrl, FormOptions } from "../views/form/form";
+import { ModalOptions } from "mdtScripts/views/containers/modal";
+export interface O2MPickOptions {
+    filter?: IFilter | (() => IFilter);
+    picked?: Function;
+    pick?: Function;
+    formOptions?: FormOptions;
+    pickOptions?: PickRecordOptions;
+    readonly?: boolean;
+    pickField?: Field;
+    modalOptions?: ModalOptions;
+}
+export interface O2MDetailsOptions {
+    record?: Record;
+    table?: Table;
+    field?: Field;
+    saved?: Function;
+    m2mField?: Field;
+    o2mField?: Field;
+    o2mFieldRecord?: any;
+    deleteAction?: any;
+    readonly?: boolean;
+    formOptions?: FormOptions;
+    modalOptions?: ModalOptions;
+    closeContainer?: Function;
+}
+export declare class O2M {
+    static pick(fieldCtrl: FieldCtrl, options?: O2MPickOptions): void;
+    static prepareLayout(layoutCtrl: any, form: FormCtrl, o2mField: Field): void;
+    static details(options: O2MDetailsOptions): void;
+}
+export interface O2MFormColCtx {
+    form: FormCtrl;
+    field: Field;
+}
+export declare class HideFieldFormColTransformer {
+    ctx: O2MFormColCtx;
+    constructor(ctx: O2MFormColCtx);
+}

package/types/_core/scripts/helpers/polyfills.d.ts

@@ -0,0 +1,16 @@
+export declare let a: any;
+declare global {
+    interface Math {
+        sign(x: number): number;
+    }
+    interface String {
+        startsWith(str: string, pos?: number): boolean;
+        endsWith(str: string, pos?: number): boolean;
+    }
+    interface Navigator {
+        /**
+         * @deprecated
+         */
+        msSaveOrOpenBlob(blob: Blob, defaultName?: string, retVal?: boolean): boolean;
+    }
+}

package/types/_core/scripts/helpers/removeMarkdown.d.ts

@@ -0,0 +1 @@
+export declare function removeMarkdown(md: any, options?: any): any;

package/types/_core/scripts/helpers/textScript/createScript.d.ts

@@ -0,0 +1 @@
+export declare function createScript(args: string[], script: string): Function;