mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/services/FormManager.d.ts

@@ -0,0 +1,27 @@
+import { Field } from "../common/Field";
+import { Table } from "../common/Table";
+import { ApiService } from "./api/ApiService";
+import { FormLayout } from "../views/form/Layout";
+import { ApiRequestOptions } from "./api/ApiRequestOptions";
+export declare class FormManager {
+    api: ApiService;
+    events: {
+        create: any[];
+        itemCreated: any[];
+    };
+    createEmpty(): {
+        rows: {
+            cols: any[];
+        }[];
+    };
+    create(t: Table, key?: any): any;
+    createItem: (f: Field) => {
+        width: number;
+        type: string;
+        options: {
+            field: string;
+        };
+    };
+    save(t: Table, layout: FormLayout, layoutCode: string): any;
+    get(t: Table, key: string, layoutCode: string, reqOptions?: ApiRequestOptions): any;
+}

package/types/_core/scripts/services/FormManagerCommands.d.ts

@@ -0,0 +1,3 @@
+export declare class FormManagerCommands {
+    static init(): void;
+}

package/types/_core/scripts/services/FormService.d.ts

@@ -0,0 +1,7 @@
+import { ExtendableMixinEvents, ExtendableMixin } from "./Extendable";
+import { FormCtrl } from "_core/scripts/views/form/form";
+export declare class FormService extends ExtendableMixin<{}, ExtendableMixinEvents> {
+    constructor();
+    initForm(form: FormCtrl): void;
+    created(form: any, extConfig: any): void;
+}

package/types/_core/scripts/services/FuzzysortManager.d.ts

@@ -0,0 +1,7 @@
+export interface FuzzysortSearchOptions {
+    keys: string[];
+}
+export declare class FuzzysortManager {
+    static search<I>(source: string, target: I[], options?: FuzzysortSearchOptions): Fuzzysort.KeysResults<I>;
+    static highlight(target: Fuzzysort.Result, highlightOpen?: string, highlightClose?: string): string;
+}

package/types/_core/scripts/services/GlobalVarManager.d.ts

@@ -0,0 +1,17 @@
+import { ApiService } from "./api/ApiService";
+import { SchemaManager } from "./SchemaManager";
+export declare const MDTGlobalVars: {
+    quickFilterSelectAll: string;
+    mdtListAggregate: string;
+    fileDownloadTimeLimit: string;
+    sidebarActionsPanel: string;
+};
+declare class GlobalVarClass {
+    private settings;
+    inited: any;
+    init(api: ApiService, schema: SchemaManager): void;
+    getValue(code: string, defaultValue?: any): any;
+}
+export declare const GlobalVarManager: GlobalVarClass;
+export declare function sideActionsPanelEnabled(): any;
+export {};

package/types/_core/scripts/services/HotkeyManager.d.ts

@@ -0,0 +1,4 @@
+export declare class HotkeyManager {
+    static keyJoinWith: string;
+    static eventToString(e: any): string;
+}

package/types/_core/scripts/services/IFilter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Фильтр
+ *
+ * @default { "op": "eq", "p1": "", "p2": "" }
+ */
+export declare type IFilter = IFilterItem | IFilterGroup | IFilterIn;
+/** Группировка фильтров */
+export interface IFilterGroup {
+    op: "and" | "or";
+    groups: IFilter[];
+    not?: boolean;
+}
+/** Фильтр */
+export interface IFilterItem {
+    op: "eq" | "ne" | "gt" | "ge" | "lt" | "le" | "startsWith" | "endsWith" | "contains" | "fulltext" | "equalTemplate";
+    /** Поле, по которому происходит фильтрация */
+    p1: string;
+    /** Значение фильтра */
+    p2: string | number | Date;
+    not?: boolean;
+    cast?: "date";
+}
+/** Фильтр */
+export interface IFilterIn extends Omit<IFilterItem, "op" | "p2"> {
+    op: "in";
+    p2: {
+        table: string;
+        field: string;
+        filter?: IFilter;
+        args?: any;
+    } | string[];
+}
+export interface FilterSetterOptions {
+    fireEvents?: boolean;
+}
+export interface FilterConstructor {
+    new (): Filter;
+    and(...groups: any[]): IFilterGroup;
+    or(...groups: any[]): IFilterGroup;
+    eq(p1: any, p2: any): IFilterItem;
+    ne(p1: any, p2: any): IFilterItem;
+    gt(p1: any, p2: any): IFilterItem;
+    ge(p1: any, p2: any): IFilterItem;
+    lt(p1: any, p2: any): IFilterItem;
+    le(p1: any, p2: any): IFilterItem;
+    startsWith(p1: any, p2: any): IFilterItem;
+    endsWith(p1: any, p2: any): IFilterItem;
+    contains(p1: any, p2: any): IFilterItem;
+    fulltext(p1: any, p2: any): IFilterItem;
+    not(f: any): IFilterItem;
+    in(p1: any, ar: any): IFilterIn;
+    queryIn(field: any, table: any, subField: any, filter: any, args?: any): IFilterIn;
+    cast(filter: any, cast: any): IFilter;
+    equalTemplate(p1: any, p2: any): any;
+}
+export declare class Filter {
+    static empty: IFilter;
+    static isEmptyFilter(filter: IFilter): boolean;
+    static mergeFilters(orig: IFilter, filter: IFilter): IFilter;
+    static and(...groups: any[]): IFilterGroup;
+    static or(...groups: any[]): IFilterGroup;
+    static eq(p1: any, p2: any): IFilterItem;
+    static ne(p1: any, p2: any): IFilterItem;
+    static gt(p1: any, p2: any): IFilterItem;
+    static ge(p1: any, p2: any): IFilterItem;
+    static lt(p1: any, p2: any): IFilterItem;
+    static le(p1: any, p2: any): IFilterItem;
+    static startsWith(p1: any, p2: any): IFilterItem;
+    static endsWith(p1: any, p2: any): IFilterItem;
+    static contains(p1: any, p2: any): IFilterItem;
+    static fulltext(p1: any, p2: any): IFilterItem;
+    static not(f: any): IFilterItem;
+    static in(p1: any, ar: any): IFilterIn;
+    static queryIn(field: any, table: any, subField: any, filter: any, args?: any): IFilterIn;
+    static cast(filter: any, cast: any): IFilter;
+    static equalTemplate(p1: any, p2: any): IFilter;
+}

package/types/_core/scripts/services/LayoutRecordManager.d.ts

@@ -0,0 +1,6 @@
+import { Table } from "mdtScripts/common/Table";
+export interface LayoutRecord {
+    code: string;
+}
+export declare function findLayoutRecord<T extends LayoutRecord = LayoutRecord>(fetchResult: T[], tableCode: string, layoutCode: string): T;
+export declare function getFormLayoutCodeByType(table: Table, layoutCode: string): string;

package/types/_core/scripts/services/ListManagerCommands.d.ts

@@ -0,0 +1,3 @@
+export declare class ListManagerCommands {
+    static init(): void;
+}

package/types/_core/scripts/services/ListService.d.ts

@@ -0,0 +1,21 @@
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+import { ExtendableMixinEvents, ExtendableMixin } from "./Extendable";
+import { ApiService } from "./api/ApiService";
+import { ApiRequestOptions } from "./api/ApiRequestOptions";
+export declare class ListService extends ExtendableMixin<{}, ExtendableMixinEvents> {
+    api: ApiService;
+    constructor();
+    get(tableCode: string, code?: string, requestOptions?: ApiRequestOptions): any;
+    saveLayout(list: ListCtrl): any;
+    createLayout(tableCode: string): {
+        $new: boolean;
+        $table: import("../common/Table").Table;
+        id_object: number;
+        columns: {
+            fieldPath: string;
+            $new: boolean;
+            $table: import("../common/Table").Table;
+        }[];
+    };
+    create(list: any, extConfig: any): void;
+}

package/types/_core/scripts/services/ModuleData.d.ts

@@ -0,0 +1,8 @@
+import { RecordId } from "../common/Record";
+import { Record } from "../common/Record";
+export interface ModuleData extends Record {
+    Code: string;
+    ID_Package?: RecordId;
+    Icon?: string;
+    Title?: string;
+}

package/types/_core/scripts/services/ModuleService.d.ts

@@ -0,0 +1,12 @@
+import { ModuleData } from "./ModuleData";
+export declare class ModuleServiceClass {
+    inited: any;
+    initDeps: any[];
+    private def;
+    private moduleData;
+    constructor();
+    init(): void;
+    getData(): ModuleData[];
+    getModuleData(code: string): ModuleData;
+}
+export declare const ModuleService: ModuleServiceClass;

package/types/_core/scripts/services/NavigationControlManager.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="mithril" />
+import { NavigationNode } from "../common/NavigationNode";
+import { Record } from "../common/Record";
+import { ListExtConfig } from "../common/list/ListExt";
+import { FormOptions, FormCtrl } from "../views/form/form";
+import { ListCtrl } from "../views/list/ListCtrl";
+import { ListOptions } from "../views/list/ListOptions";
+import { Button } from "_core/scripts/helpers/ui/el";
+export declare class NavigationControlManager {
+    private creators;
+    controls: {
+        [key: number]: PageControl;
+    };
+    controlTemplates: {
+        [key: number]: PageControlTemplate;
+    };
+    inited: _mithril.MithrilPromise<Object>;
+    constructor();
+    createTemplate(node: NavigationNode, defaultTemplate: any): {};
+    getControlManager(node: NavigationNode): PageControlCreator;
+    createControl(node: NavigationNode): any;
+    registerControlCreator(creator: PageControlCreator): void;
+    private fetchControlTemplates;
+    private registerDefaultControls;
+    static createListControl(node: NavigationNode, settings: ListPageSettings): ListCtrl;
+    static OPEN_ID_PARAM: string;
+    static OpenFormExtender(): ListExtConfig;
+    static GetCopyLinkButton(recordId: any): Button;
+    prepareNavigationForm(form: FormCtrl): void;
+}
+export declare class FullPageForm {
+    content: any;
+    constructor(form: FormCtrl);
+}
+export interface PageControl extends Record {
+    Code: string;
+    Title: string;
+    Help: string;
+}
+export interface PageControlTemplate extends Record {
+    Title: string;
+    Template: string;
+}
+export interface PageControlCreator {
+    code: string;
+    settingsJsonSchema?: string;
+    createControl: (node: NavigationNode, settings: any) => any;
+    /** if true navigation node will be shown without ID_Object */
+    isContent?: boolean;
+    /** template in case if id_ControlTemplate is empty */
+    defaultTemplate?: () => any;
+}
+export interface ListPageSettings {
+    options?: ListOptions;
+    extConfig?: ListExtConfig;
+}
+export interface FormPageSettings {
+    id: number;
+    options: FormOptions;
+    extConfig: any;
+}

package/types/_core/scripts/services/NavigationManager.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="mithril" />
+import { NavigationNode, NavigationTopNode } from "../common/NavigationNode";
+interface NavigationManagerHooks {
+    getTopNode?: () => NavigationTopNode;
+}
+export declare class NavigationManager {
+    private api;
+    events: {
+        inited: any[];
+        navigated: any[];
+        fetchNodes: any[];
+        updated: any[];
+    };
+    node: _mithril.MithrilPromiseProperty<NavigationNode>;
+    private currentPath;
+    nodes: _mithril.MithrilPromise<NavigationNode[]>;
+    inited: _mithril.MithrilPromise<Object>;
+    systemNodes: {
+        [key: string]: NavigationNode;
+    };
+    private _hooks;
+    setHook(code: keyof NavigationManagerHooks, hook: any): void;
+    pathNodes(node?: NavigationNode): NavigationNode[];
+    path(node: NavigationNode): string;
+    update(): void;
+    refreshNodeState(): void;
+    addNode(node: NavigationNode, position?: number, parent?: NavigationNode): NavigationNode;
+    addSystemNode(node: NavigationNode, parentNodeKey?: string, parentNode?: NavigationNode): NavigationNode;
+    prepare(ns: NavigationNode[], p: any): void;
+    findNodeByPath(path: any): NavigationNode;
+    private findChildNode;
+    findNode(condition: (node: NavigationNode) => boolean, nodes?: any): any;
+    findNodes(condition: (node: NavigationNode) => boolean, nodes?: NavigationNode[]): NavigationNode[];
+    navigated(path: string): NavigationNode;
+    setIsContentCheck(fn: (node: NavigationNode) => boolean): void;
+    private _isContent;
+    private isContentNode;
+    findNotEmpty(node: NavigationNode): NavigationNode;
+    getFullUrl(node?: NavigationNode, params?: any): string;
+    nodeIcon(node: any): any;
+    static useFastNav: boolean;
+    fastNavKey: string;
+    fastNav: any;
+    saveFastNav(topNodeCode: string, path: string): void;
+    getFastNavPath(topNodeCode: string): any;
+    /**
+     * Определение верхнего узла
+     * Используется для поиска узлов с автообновлением
+     */
+    private getTopNode;
+    private setAutorefresh;
+    private isRefreshNode;
+    private cleanAutoRefresh;
+    private refreshTimeouts;
+    private refreshPending;
+    private runAutorefresh;
+    static pathToNode(node: NavigationNode): string;
+    constructor();
+}
+export {};

package/types/_core/scripts/services/NavigationManagerCommands.d.ts

@@ -0,0 +1,5 @@
+export declare class NavigationManagerCommands {
+    private static groupCode;
+    static init(): void;
+    static openCurrentCommand(): void;
+}

package/types/_core/scripts/services/NotificationService.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="mithril" />
+import { Button } from "../helpers/ui/el";
+import { AlertOptions } from "../views/controls/Alert";
+export interface Notification {
+    title: string;
+    text: string;
+    icon?: string;
+    type?: "default" | "info" | "success" | "warning" | "danger";
+    id?: number;
+    time?: Date;
+    actions?: Button[];
+}
+export declare class NotificationService {
+    list: Notification[];
+    events: {
+        added: any[];
+    };
+    private id;
+    viewed: _mithril.MithrilProperty<boolean>;
+    constructor();
+    add(msg: Notification, options: AlertOptions): void;
+}

package/types/_core/scripts/services/OneToManyRecordManager.d.ts

@@ -0,0 +1,8 @@
+import { Record } from "mdtScripts/common/Record";
+import { Table } from "mdtScripts/common/Table";
+import { CreateRecordOptions } from "./RecordManager";
+export declare class OneToManyRecordManager {
+    static createRecord(table: Table, options?: CreateRecordOptions): Record;
+    static updateRecord(table: Table, record: Record): Record;
+    static isRecord(value: any): boolean;
+}

package/types/_core/scripts/services/QuerySelectService.d.ts

@@ -0,0 +1,7 @@
+declare class QuerySelectServiceClass {
+    isSelectFieldAggregatedWithAlias(fieldName: string): boolean;
+    getAggregatedFieldAlias(fieldName: string): string;
+    getAggregatedFieldName(fieldName: string): string;
+}
+export declare const QuerySelectService: QuerySelectServiceClass;
+export {};

package/types/_core/scripts/services/RecordManager.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="mithril" />
+import { AnyObject, ViewElement } from "mdtScripts/helpers/types";
+import { ActionItem } from "mdtScripts/helpers/ui/el";
+import { LayoutColumn } from "mdtScripts/views/list/ListCtrl";
+import { SchemaManager } from "_core/scripts/services/SchemaManager";
+import { Field } from "../common/Field";
+import { Record } from "../common/Record";
+import { Table } from "../common/Table";
+import { ApiRequestOptions } from "./api/ApiRequestOptions";
+import { QuerySorting } from "./api/Query";
+export declare type SearchOperation = "startsWith" | "contains";
+export interface RecordManagerSearchByDefaultFieldOptions {
+    fields?: any;
+    getTitle?: (r: Record, f?: Field) => string | _mithril.MithrilVirtualElement;
+    additionalText?: (r: Record) => string;
+    itemClass?: (item: any) => any;
+    itemTooltip?: (item: any) => any;
+    presetItems?: any;
+    searchOperation?: SearchOperation;
+    queryOptions?: ApiRequestOptions;
+    select?: any;
+    sorting?: QuerySorting[];
+    filter?: any;
+    top?: number;
+    zone?: {
+        right: (r: Record) => ViewElement;
+    };
+}
+export declare class RecordManager {
+    schemaManager: SchemaManager;
+    displayValue(record: Record, field?: Field, options?: {
+        emptyText?: string;
+        format?: boolean;
+        title?: string;
+    }): any;
+    static title(rec: any, table: Table): any;
+    displayValueByPath(record: Record, path: string, table?: Table | string): any;
+    valueByPath(record: Record, path: string, table?: Table | string): any;
+    private _onValuePrepare;
+    onValuePrepare(callback: any): () => void;
+    valueByField(record: Record, field: Field): any;
+    fetchRecordDisplayValue(table: Table, id: any, full?: boolean, paths?: any[], requestOptions?: ApiRequestOptions): any;
+    fetchDisplayValue(field: any, val: any, requestOptions?: ApiRequestOptions): any;
+    clone(rec: any): any;
+    new(table: any, props?: any): any;
+    /** @deprecated use RecordManager.newId */
+    newId(): number;
+    /** @deprecated use RecordManager.isNewId */
+    isNewId(id: any): boolean;
+    static newId(): number;
+    static isNewId(id: any): boolean;
+    /**
+     * Creates record with default values
+     */
+    static createRecord(table: Table, options?: CreateRecordOptions): Record;
+    static getDefaultValues(table: Table): {};
+    convertCamel(obj: any, toCamel: any): any;
+    _fillFk(records: any, fkField: any, select: any, requestOptions?: ApiRequestOptions): any;
+    _fillO2M(records: any, table: any, o2mField: any, select: any, requestOptions?: ApiRequestOptions): any;
+    _checkFill(record: any, path: any): boolean;
+    fillRefs(table: any, records: any, paths: any, requestOptions?: ApiRequestOptions): _mithril.MithrilPromise<unknown>;
+    searchByDefaultField(table: Table, text?: string, options?: RecordManagerSearchByDefaultFieldOptions): Promise<ActionItem[]>;
+    createM2MRecord(field: Field, parentRecord: Record, refRecord: Record, options?: {
+        m2mField?: Field;
+    }): Record;
+    fetchM2MValue(field: Field, recordId: number, options?: any, requestOptions?: ApiRequestOptions): any;
+    clearO2MValue(record: any, field: Field): any[];
+    private flagDestroy;
+    destroy(record: any): void;
+    isDestroyed(record: any): boolean;
+    displayId(record: Record): string;
+    private getSortOrder;
+    sort: (a: any, b: any) => number;
+    newRecord(data: any, table?: string): any;
+    private getFormatRecordExp;
+    formatRecordPaths(formatStr: string): string[];
+    formatRecord(record: Record, formatStr: string): string;
+    static ensureFilled(rows: any, table: Table, field: Field, paths?: any[]): void;
+    static prepareForSave(record: any): any;
+    static prepareRecord(record: any, table: Table): void;
+    static getRefObjectData(record: any, column: LayoutColumn, field: string): any;
+}
+export declare class IdedValue {
+    id: any;
+    title: string;
+    constructor(id: any, title: string);
+}
+export interface CreateRecordOptions {
+    /** Проставлять значения по-умолчанию из схемы. По-умолчанию `true` */
+    defaultValues?: boolean;
+    data?: AnyObject;
+}

package/types/_core/scripts/services/SchemaManager.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="mithril" />
+import { Field } from "../common/Field";
+import { Table } from "../common/Table";
+import { ApiDatasource } from "../datasources/ApiDatasource";
+import { ApiService } from "./api/ApiService";
+import { RecordId } from "mdtScripts/common/Record";
+export declare type FieldType = "number" | "boolean" | "string" | "date" | "time";
+export declare class SchemaManager {
+    api: ApiService;
+    datasource: ApiDatasource;
+    inited: _mithril.MithrilPromise<SchemaManager>;
+    events: {
+        inited: any[];
+    };
+    tables: Table[];
+    tableMap: {
+        [code: string]: Table;
+    };
+    static systemFields: string[];
+    static allAggregationTypes: AggregationType[];
+    constructor();
+    static isField(field: Field): boolean;
+    static isOne2One(field: Field): boolean;
+    static isHistory(field: Field): boolean;
+    static isDynamicFK(field: Field): boolean;
+    getDFKFields(table: Table | string | number): Field[];
+    static isOne2Many(field: Field): boolean;
+    static isDateField(field: Field): boolean;
+    static validateDateStrByMinMax(dateInStr: string): boolean;
+    static validateDateByMinMax(date: Date): boolean;
+    static isFkPath(path: string): boolean;
+    static isSimplePath(path: string, ignoreSimpleFk?: boolean): boolean;
+    static isRequiredField(field: Field): boolean;
+    static copyTable(table: Table): Table;
+    static isHierarchyTable(table: Table): boolean;
+    static sortFieldCode: string;
+    setupAutoRefresh(): void;
+    refresh(forceRefresh?: boolean): void;
+    private addTable;
+    init(): void;
+    add(t: Table | Table[]): void;
+    prepare(t: Table, tables?: Table[]): Table;
+    prepareField(t: Table, f: Field): void;
+    createSystemObject(objParams: Table): Table;
+    addField(t: Table, f: Field): Field;
+    removeField(t: Table, f: Field): void;
+    cleanCode(code: string, replaceAnySchema?: boolean): string;
+    private getFromTableMapById;
+    get(idOrCode: string | number, check?: boolean): Table;
+    defaultField(t: Table | string): Field;
+    field(t: Table, code: string, check?: boolean): Field;
+    fieldById(t: Table, id: number): Field;
+    fieldTitle(field: Field): any;
+    _table(t: string | number | Table, check?: boolean): Table;
+    cleanPath(path: string): string;
+    pathFields(t: Table | string | number, path: string, check?: boolean, options?: {
+        onError?: (err: string) => void;
+    }): Field[];
+    fieldsToPath(fields: Field[]): string;
+    isPathRefToDefault(path: string): boolean;
+    pathFieldsFull(t: Table | string | number, path: string, check?: boolean): Field[];
+    fieldByPath(t: Table | string | number, path: string, check?: boolean): Field;
+    typeValueByPath(t: Table | string, path: string, check?: boolean): string;
+    one2ManyField(t: Table, refTable: any, check?: boolean): Field;
+    valuePathFull(t: Table | string, path: string, splitter?: string): string;
+    displayFieldPath(field: Field): string;
+    displayPathFields(field: Field): any[];
+    private pathOnlyRefs;
+    lastRefFieldInPath(table: Table | string, path: string, splitter?: string): Field;
+    lastTableInPath(table: Table | string, path: string, splitter?: string): Table;
+    lastRefIdPath(table: Table | string, path: string, splitter?: string): string;
+    removeSystemFields(fields: Field[]): Field[];
+    appendPath(...paths: string[]): string;
+    isSimpleType(type: string): boolean;
+    superType(type: string): FieldType;
+    isDateType(type: string): boolean;
+    isTimeType(type: string): boolean;
+    findO2MField(field: Field, check?: boolean): Field;
+    findM2MField(field: Field, check?: boolean): Field;
+    findField(field: any): Field;
+    isCustom(table: Table): boolean;
+    override(table: Table, override: Table): Table;
+    objectAbbr(object: any): string;
+    fixO2MPath(table: any, code: any): any;
+    static messages: {
+        tableNotFound: string;
+        fieldNotFound: string;
+        fieldNotFk: string;
+    };
+    /**
+     * Tables with useless inner information for user.
+     * For example: user no need to know about fields in status.Status (Icon, LabelStyle, flags etc.)
+     */
+    isPropTable: (table: Table | string | number) => boolean;
+    propTableShowFormOverrides: (sourceTable: Table, record: any, refFields: Field[]) => {
+        table: Table;
+        ids: RecordId[] | RecordId;
+    };
+    aggregationTypes(table: Table | string | number, path: string): AggregationType[];
+    shouldFormatAggregation(param: AggregationType): boolean;
+    getStyleFieldPath(field: Field): string;
+    getIconFieldPath(field: Field): string;
+    getFieldKind(fieldItem: Record<string, any>): string;
+    updateSchema(): any;
+    private getItemKind;
+}
+export declare type AggregationType = "sum" | "avg" | "count" | "distinct" | "max" | "min";
+export declare enum MdtObjectTypes {
+    Function = "F",
+    Procedure = "P",
+    View = "V",
+    Table = "T"
+}
+export declare type TableArg = Table | string | number;

package/types/_core/scripts/services/SchemaManagerCommands.d.ts

@@ -0,0 +1,3 @@
+export declare class SchemaManagerCommands {
+    static init(): void;
+}

package/types/_core/scripts/services/SearchByDeafultFieldHelper.d.ts

@@ -0,0 +1,12 @@
+import { IFilter } from "./IFilter";
+import { RecordManagerSearchByDefaultFieldOptions, SearchOperation } from "./RecordManager";
+import { Table } from "mdtScripts/common/Table";
+import { ActionItem } from "mdtScripts/helpers/ui/el";
+import { ListCtrl } from "mdtScripts/views/list/ListCtrl";
+export declare class SearchByDefaultFieldHelper {
+    static getTextFilter(paths: string[], text?: string, searchOperation?: SearchOperation): import("./IFilter").IFilterGroup;
+    static setFilterByDefaultField(list: ListCtrl, filter: IFilter): void;
+    static search(table: Table, text?: string, options?: RecordManagerSearchByDefaultFieldOptions): Promise<ActionItem[]>;
+    private static rowToDropDownItem;
+    private static getDefaultFieldPath;
+}

package/types/_core/scripts/services/SecurityManager.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="mithril" />
+import { PermissionLevel } from "../security/PermissionLevel";
+import { Field } from "../common/Field";
+import { Table } from "../common/Table";
+interface ObjectPermission {
+    level: PermissionLevel;
+    fields?: {
+        [fieldId: number]: ObjectPermission;
+    };
+}
+export declare class SecurityManager {
+    user: _mithril.MithrilPromise<import("../security/User").User>;
+    inited: _mithril.MithrilPromise<import("../security/User").User>;
+    customChecks: ((record: any, table: Table, level: PermissionLevel, permission: any, options: RecordPermissionsOptions) => PermissionLevel)[];
+    get(table: Table | string, permission?: string): ObjectPermission;
+    table(table: Table | string, level: PermissionLevel, permission?: string, check?: boolean): number;
+    field(field: Field, level: PermissionLevel, permission?: string): number;
+    recordPermission(record: any, level: PermissionLevel, parentLevel: PermissionLevel, field?: Field, onlyRecordPermission?: boolean): number;
+    record(record: any, table: Table, level: PermissionLevel, permission?: string, options?: RecordPermissionsOptions): number;
+    isInRole(role: any): boolean;
+    isInRoles(roles: string[], and?: boolean, not?: boolean): boolean;
+    hasPermission(permission: string): boolean;
+    private getLocaleCode;
+    getCurrentLocale(): any;
+    checkRoles(rolesList: string[], userRoles: string[], and?: boolean, not?: boolean): boolean;
+    hasObjectPermission(object: string | Table, level: PermissionLevel): boolean;
+}
+interface RecordPermissionsOptions {
+    customChecks?: boolean;
+    field?: Field;
+}
+export {};

package/types/_core/scripts/services/SettingsManager.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="mithril" />
+export interface SystemSettings {
+    maxRequestLength: number;
+    languageId: number;
+    languageTable: string;
+}
+export declare class SettingsManager {
+    private api;
+    inited: _mithril.MithrilPromise<void>;
+    settings: SystemSettings;
+    constructor();
+}