mdt-client 31.3.39 → 31.3.41

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

@@ -0,0 +1,24 @@
+import { ViewElement } from "../../../helpers/types";
+import { PanelToolbarOptions } from "../panelToolbar/panelToolbarOptions";
+import { PanelTitleOptions } from "../panelTitle/panelTitleOptions";
+export interface ResizablePanelOptions {
+    content: ResizablePanelContent;
+    onCreated?: (el: HTMLElement, onUnload: (handler: () => void) => void) => void;
+}
+export declare type OnPanelResize = () => void;
+export interface ResizablePanelContent {
+    view: () => ViewElement;
+    onResize?: OnPanelResize;
+    title?: PanelTitleOptions;
+    toolbar?: PanelToolbarOptions;
+    topZone?: PanelTopZone;
+    className?: string;
+    focusOptions?: ResizablePanelFocusOptions;
+}
+export interface PanelTopZone {
+    view: () => ViewElement;
+}
+export declare type ResizablePanelOnFocus = (focusedByUser: boolean) => void;
+export interface ResizablePanelFocusOptions {
+    onFocus?: ResizablePanelOnFocus;
+}

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

@@ -0,0 +1,22 @@
+import { MithrilVirtualElementKey } from "../../helpers/types";
+import { ResizablePanelContent } from "./resizablePanel/resizablePanelOptions";
+export declare type PanelsDirection = "row" | "column";
+export declare type PanelSizeFactor = number;
+export interface PanelWithSizeFactor {
+    /**
+     * Размер панели в долях. Все панели по-умолчанию имеют размер 1. Если, например, задать 2, то панель будет больше остальных в два раза.
+     * @default 1
+     */
+    size?: PanelSizeFactor;
+}
+export interface ResizablePanelsItemContent extends ResizablePanelContent, PanelWithSizeFactor {
+}
+export interface ResizablePanelsContentItem extends ResizablePanelsItemContent {
+    key: MithrilVirtualElementKey;
+}
+export interface ResizablePanelsOptions {
+    direction: PanelsDirection;
+    content: ResizablePanelsContentItem[];
+    resizerSize?: number;
+    highlightFocusedPanel?: boolean;
+}

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

@@ -0,0 +1,16 @@
+/// <reference types="../../../../mithril" />
+import { ViewElement } from "mdtScripts/helpers/types";
+import { IconOptions } from "../icon/iconOptions";
+export interface TextWithIconOptions {
+    icon?: BeforeTextIconOptions;
+    textContent: TextContentOptions;
+}
+export interface BeforeTextIconOptions {
+    name: string;
+    options?: IconOptions;
+}
+export interface TextContentOptions {
+    text: ViewElement | string[];
+    className?: string;
+    attrs?: _mithril.MithrilAttributes;
+}

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

@@ -0,0 +1,40 @@
+import { Valued, ViewElement } from "../../helpers/types";
+import { PanelTitleOptions } from "../resizablePanels/panelTitle/panelTitleOptions";
+import { PanelSizeFactor, ResizablePanelsItemContent } from "../resizablePanels/resizablePanelsOptions";
+export interface ToggleablePanel {
+    title: PanelTitleOptions;
+    content: ResizablePanelsItemContent;
+    isShown: boolean;
+    toggleButtonOptions?: ToggleablePanelToggleButtonOptions;
+}
+interface ToggleablePanelToggleButtonOptions {
+    title?: Valued<string>;
+}
+export interface ToggleablePanelsToolbarOptions {
+    className?: string;
+    leftZone?: ToolbarZone;
+    rightZone?: ToolbarZone;
+}
+interface ToolbarZone {
+    view: () => ViewElement;
+}
+export declare type ToggleablePanelsRowDirection = "vertical" | "horizontal";
+export interface ToggleableRotatablePanelsOptions {
+    /**
+     * @default "horizontal"
+     */
+    rowDirection?: ToggleablePanelsRowDirection;
+}
+export interface ToggleablePanelsOptions extends ToggleableRotatablePanelsOptions {
+    highlightFocusedPanel?: boolean;
+    panels: PanelsGrid<ToggleablePanel>;
+    toolbar?: ToggleablePanelsToolbarOptions;
+    resizerSize?: number;
+}
+export interface PanelsGrid<T> {
+    rows: {
+        cols: T[];
+        size?: PanelSizeFactor;
+    }[];
+}
+export {};

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

@@ -0,0 +1,6 @@
+export interface ActivationListAdapterOptions {
+    /**
+     * Отображать деактивированные записи
+     */
+    showDeactivatedCells?: boolean;
+}

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

@@ -0,0 +1,21 @@
+import { FieldPath } from "mdtScripts/helpers/types";
+import { BaseQuery } from "mdtServices/api/BaseQuery";
+import { IFilter } from "mdtServices/IFilter";
+/**
+ * @defaultSnippets [[{ "label": "Настройка по умолчанию", "body": { "query": { "filter": { "op": "eq", "p1": "$1", "p2": "$2" } }}}]
+ */
+export interface ToolbarAutopickOptions {
+    query: {
+        filter: IFilter;
+    };
+}
+export interface ToolbarFieldFilterListExtenderOptions {
+    /** Путь до поля по которому будет фильтроваться список */
+    fieldPath: FieldPath;
+    /** Наименование кнопки в тулбаре */
+    title?: string;
+    /** Дополнительные настройки для запроса значений фильтра */
+    query?: Omit<BaseQuery, "select">;
+    /** Настройки автоматического выбора фильтра по заданному условию */
+    autopick?: ToolbarAutopickOptions;
+}

package/types/_core/scripts/data/periods/helpers/types.d.ts

@@ -0,0 +1,4 @@
+export declare enum PeriodBoundaryIcon {
+    BEGIN = "minus",
+    END = "plus"
+}

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/helpers/IUi.d.ts

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

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

@@ -0,0 +1,23 @@
+export declare const regexIso8601DateOnly: RegExp;
+export declare function toISOString(date: Date, dateOnly?: boolean): string;
+export declare function toISO8601DateString(date: Date): ISO8601DateString;
+export declare function toUiDateString(date: Date): string;
+export declare function toTimeString(date: Date): string;
+export declare function toDateTimeNotZApiFormat(date: Date): string;
+export declare function dateTimeModelFromUiDateString(dateString: MdtDateStringFormat): DateTimeModel;
+export declare function dateFromUiDateString(dateString: MdtDateStringFormat): Date;
+export interface DateTimeModel {
+    day: number;
+    monthIndex: number;
+    year: number;
+    time?: {
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+}
+/**
+ * Строка с датой в формате "dd.mm.yyyy hh:mm:ss" или "dd.mm.yyyy"
+ */
+export declare type MdtDateStringFormat = string;
+export declare type ISO8601DateString = string;

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

@@ -0,0 +1 @@
+export declare function deleteFromArray<T = any>(array: T[], item: T): void;

package/types/_core/scripts/helpers/events/EventEmitter.d.ts

@@ -0,0 +1,12 @@
+import { AnyObject } from "../types";
+export interface EventEmitterSubscribeController<E> {
+    subscribe: <T extends keyof E>(code: T, listener: (args: E[T]) => unknown) => () => void;
+    unsubscribe: <T extends keyof E>(code: T, listener: (args: E[T]) => unknown) => void;
+}
+export declare class EventEmitter<E = Record<string, AnyObject>> {
+    private events;
+    subscribe<T extends keyof E>(code: T, listener: (args: E[T]) => unknown): () => void;
+    unsubscribe<T extends keyof E>(code: T, listener: (args: E[T]) => unknown): void;
+    emit<T extends keyof E>(code: T, args?: E[T]): void;
+    getSubscribeController(): EventEmitterSubscribeController<E>;
+}

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

@@ -0,0 +1,4 @@
+export declare const fireEvent: FireEventType;
+declare type FireEventType = (...args: any[]) => any;
+export declare function addDisposableEvent<T extends FireEventType = FireEventType>(event: Array<FireEventType>, callback: T): void;
+export {};

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

@@ -0,0 +1,16 @@
+import { MaskOptions } from "mdtScripts/components/baseFormControls/maskedInput/MaskFormatter.types";
+import { PeriodBoundaryIcon } from "mdtScripts/data/periods/helpers/types";
+export interface FormatOptions {
+    type?: string;
+    title?: string;
+    empty?: string;
+    /**
+     * @deprecated
+     */
+    mask?: string;
+    /**
+     * Настройки маски
+     */
+    maskOptions?: MaskOptions;
+    dateRangeIcon?: PeriodBoundaryIcon;
+}

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

@@ -0,0 +1,8 @@
+import { ViewElement } from "./types";
+export declare type FormattedTextType = "text" | "markdown" | "view";
+export declare type FormattedText = string | {
+    content: string | ViewElement[];
+    type: FormattedTextType;
+};
+export declare function getTextContent(text: FormattedText): string | ViewElement[];
+export declare function getFormattedTextType(text: FormattedText): FormattedTextType;

package/types/_core/scripts/helpers/pipeline/ImmutableArgPipeline.d.ts

@@ -0,0 +1,8 @@
+declare type Handler<A, R> = (args?: A, currentResult?: R) => R | undefined;
+export declare class ImmutableArgPipeline<A = unknown, R = unknown> {
+    private pipelines;
+    register(handler: Handler<A, R>): void;
+    execute(args: A, initialResult?: R): R;
+    getRegisterController(): (handler: Handler<A, R>) => void;
+}
+export {};

package/types/_core/scripts/helpers/pipeline/Pipeline.d.ts

@@ -0,0 +1,20 @@
+import { AnyError } from "../types";
+declare type Next<D> = (args?: D) => void;
+declare type Middleware<D> = (args: D, next: Next<D>) => void | Promise<void>;
+export declare class Pipeline<D = any> {
+    private middlewaresStorage;
+    constructor(middlewares?: Middleware<D>[]);
+    push(middleware: Middleware<D>): () => void;
+    remove(middleware: Middleware<D>): void;
+    execute(args: D, onComplete: (args: D) => void, onError?: (e: AnyError) => void): void;
+    executePromise(args: D): Promise<D>;
+}
+declare type MiddlewareSync<D> = (args: D) => D | undefined;
+export declare class PipelineSync<D = any> {
+    private middlewaresStorage;
+    constructor(middlewares?: MiddlewareSync<D>[]);
+    push(middleware: MiddlewareSync<D>): () => void;
+    remove(middleware: MiddlewareSync<D>): void;
+    execute(args: D): D;
+}
+export {};

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

@@ -0,0 +1,16 @@
+declare type RedrawEventHandler = () => void;
+export interface RedrawFn {
+    (x?: any): void;
+    events: {
+        after?: RedrawEventHandler[];
+        before?: RedrawEventHandler[];
+        beforeOnce: RedrawEventHandler[];
+        afterOnce: RedrawEventHandler[];
+    };
+}
+export declare const uiRedraw: {
+    redrawing: boolean;
+    animating: boolean;
+    redraw: RedrawFn;
+};
+export {};

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

@@ -0,0 +1,84 @@
+/// <reference types="../../../../mithril" />
+import { UiType } from "./IUi";
+export interface AnyObject {
+    [key: string]: any;
+}
+export declare type MithrilStyleAttribute = {
+    width?: CSSSizeUnit;
+} & AnyObject;
+export declare type MithrilContext<T = Record<string, unknown>> = T;
+declare type CSSSizeUnit = string;
+export declare type NotifierType = "log" | "error" | "warn" | "info" | "success";
+export declare type LabelType = "normal" | "heading" | "hidden" | "inline" | "embedded";
+export interface NotifierOptions {
+    type?: NotifierType;
+    msg?: MessageText;
+    icon?: string;
+}
+export interface Notifier {
+    notify(title: MessageText, options?: NotifierOptions): void;
+}
+export interface NotifierErrorOptions extends NotifierOptions {
+    error?: Error;
+}
+export interface ErrorNotifier extends Notifier {
+    notify(title: MessageText, options?: NotifierErrorOptions): void;
+}
+export declare type ViewElement = _mithril.MithrilVirtualElement | _mithril.MithrilVirtualElement[] | string;
+export declare type CommandEvent = Event | _mithril.MithrilEvent;
+export declare type InputChangeEvent = Event | _mithril.MithrilEvent;
+export declare type CSSClassName = string;
+export declare type CSSPositionUnit = string;
+export declare type MithrilControl = ViewControl | ContentControl;
+export interface ViewControl {
+    $view(): ViewElement | string;
+    [key: string]: any;
+}
+export declare type ViewControlConstructor<A extends Array<any> = any> = new (...A: A) => ViewControl;
+export interface ContentControl<C = any> {
+    content: C;
+    [key: string]: any;
+}
+export declare type Markdown = string;
+export declare type MessageText = Markdown | string;
+export declare type ColorStyle = UiType | "default";
+export declare type ButtonStyle = ColorStyle;
+export declare type ObjectCode = string;
+export declare type ObjectId = number;
+export declare type ObjectIdOrCode = ObjectCode | ObjectId;
+export declare type ObjectTitle = string;
+export declare type ObjectSchemaName = string;
+export declare type ObjectPhysicalName = string;
+export declare type ModuleId = number;
+export declare type ModuleCode = string;
+export declare type Valued<T> = T | (() => T);
+export declare type Timeout = ReturnType<typeof setTimeout>;
+export declare type MithrilAttributes = _mithril.MithrilAttributes & {
+    [name: string]: any;
+};
+export declare type MithrilVirtualElementKey = string | number;
+export declare type HTMLAnchorTarget = "_blank" | "_self" | "_parent" | "_top" | "framename";
+export declare type HTMLString = string;
+export declare type KeyboardKeyCode = string;
+export declare type AnyError = any;
+export declare type FieldPath = string;
+export declare type FieldId = number;
+export declare type FieldCode = string;
+export declare type FieldKind = "dfk" | "o2m" | "o2o" | "hist" | "dfk-list";
+export declare type LanguageCode = "ru" | "en";
+export declare type LanguageId = number;
+export declare type GConstructor<T = Record<string, unknown>, A extends Array<any> = any> = new (...args: A) => T;
+export declare type URLString = string;
+export declare type JSONString = string;
+export declare type JavaScriptCodeContent = string;
+export declare type DateString = string;
+export declare type RequestMethod = "POST" | "GET" | string;
+export declare enum BrandIcon {
+    primary = 0,
+    fatal = "skull",
+    danger = "hexagon-xmark",
+    warning = "triangle-exclamation",
+    success = "circle-check",
+    info = "circle-info"
+}
+export {};

package/types/_core/scripts/helpers/ui/elementModificators/focusableComponent.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="../../../../mithril" />
+import { KeyboardKeyCode } from "../../types";
+import { ComponentConfigParams } from "./modificatorsTypes";
+export declare function doesKeyPressed(keyCode: KeyboardKeyCode | KeyboardKeyCode[], e: KeyboardEvent): boolean;
+export declare function getFocusableComponentAttrs(): _mithril.MithrilAttributes;
+declare type KeyboardAction = (e: KeyboardEvent) => void;
+export interface KeyboardActions {
+    primary?: KeyboardAction;
+    secondary?: KeyboardAction;
+    clear?: KeyboardAction;
+    cancel?: KeyboardAction;
+}
+export declare function setKeyboardActions(actions: KeyboardActions, configParams: ComponentConfigParams): void;
+export {};

package/types/_core/scripts/helpers/ui/elementModificators/modificatorsTypes.d.ts

@@ -0,0 +1,4 @@
+export interface ComponentConfigParams {
+    el: HTMLElement;
+    inited: boolean;
+}

package/types/_core/scripts/helpers/ui/keyboardUtils/getKeySymbol.d.ts

@@ -0,0 +1,2 @@
+export declare type KeySymbolCode = "Cmd" | "Option" | "Alt" | "Shift" | "Ctrl" | "Enter" | "Left" | "Right" | "Up" | "Down";
+export declare function getKeySymbol(key: KeySymbolCode): string;

package/types/_core/scripts/helpers/ui/keyboardUtils/keyboardUtils.d.ts

@@ -0,0 +1,23 @@
+/** KeyboardEvent.code */
+export declare type KeyboardKeyCode = string;
+/** KeyboardEvent.key */
+export declare type KeyboardKeyValue = string;
+/** KeyboardEvent.key, приведенный к числу */
+export declare type KeyboardNumberKeyValue = number;
+interface EventModifierKeys {
+    shift: boolean;
+    meta: boolean;
+    alt: boolean;
+    ctrl: boolean;
+}
+export declare type EventModifierKey = keyof EventModifierKeys;
+export declare function checkKeydownModifiers(e: KeyboardEvent, pressedModifierKeys?: EventModifierKey[]): boolean;
+interface KeydownEventKeyCheckingOptions {
+    requiredModifiers?: EventModifierKey[];
+    /** @default true */
+    checkModifiers?: boolean;
+}
+export declare function checkKeydownEventKeys(e: KeyboardEvent, keyCode: KeyboardKeyCode, options?: KeydownEventKeyCheckingOptions): boolean;
+/** Получить код клавиши с цифрой */
+export declare function getKeyCodeOfNumberKey(numberKeyValue: KeyboardNumberKeyValue): KeyboardKeyCode;
+export {};

package/types/_core/scripts/helpers/ui/keyboardUtils/osByUserAgent.d.ts

@@ -0,0 +1 @@
+export declare function osByUserAgent(userAgent: string): string;

package/types/_core/scripts/helpers/utils/classNames.d.ts

@@ -0,0 +1,20 @@
+import { CSSClassName } from "../types";
+declare type ClassNamesSimpleArg = CSSClassName | number | Record<CSSClassName, any> | undefined;
+/**
+ * Тип для параметров функций classNames и mClassNames.
+ * Функции принимают любое количество аргументов, которые могут быть строкой, объектом или массивом.
+ *
+ * @example
+ * classNames('foo', 'bar'); // => 'foo bar'
+ * classNames('foo', { bar: true }); // => 'foo bar'
+ * classNames({ 'foo-bar': true }); // => 'foo-bar'
+ * classNames({ 'foo-bar': false }); // => ''
+ * classNames({ foo: true }, { bar: true }); // => 'foo bar'
+ * classNames({ foo: true, bar: true }); // => 'foo bar'
+ * classNames('foo', { bar: true, duck: false }, 'baz', { quux: true }); // => 'foo bar baz quux'
+ * classNames(null, false, 'bar', undefined, 0, { baz: null }, ''); // => 'bar'
+ */
+export declare type ClassNamesArg = ClassNamesSimpleArg | ClassNamesSimpleArg[];
+export declare function classNames(...args: ClassNamesArg[]): string;
+export declare function mClassNames(...args: ClassNamesArg[]): string;
+export {};

package/types/_core/scripts/helpers/utils/keyStorage/KeyStorage.d.ts

@@ -0,0 +1,6 @@
+export interface KeyStorage<T> {
+    get(): T;
+    set(value: T): void;
+    clear(): void;
+}
+export declare type KeyStorageInvalidateKey = number | string;

package/types/_core/scripts/helpers/utils/memoization/memoize.d.ts

@@ -0,0 +1,18 @@
+export declare class Memoize<A extends any[] = any[], R = any> {
+    private calculate;
+    private store;
+    constructor(calculate: (...args: A) => R);
+    exec(args: A): R;
+}
+export declare class MemoizeStore {
+    private store;
+    exec<A extends any[] = any[], R = any>(key: string, calculate: (...args: A) => R, args: A): R;
+    clearKey(key: string): void;
+}
+export declare class MultiMemoize<A extends any[] = any[], R = any> {
+    private calculate;
+    private store;
+    constructor(calculate: (...args: A) => R);
+    exec(...args: A): R;
+    clear(): void;
+}

package/types/_core/scripts/helpers/utils/object.d.ts

@@ -0,0 +1,4 @@
+export declare function hasOwnProperty(object: Record<never, unknown>, name: string): boolean;
+export declare function shallowCopy<T>(obj: T): T;
+export declare function copyWithIgnore<T, K extends keyof T = null>(obj: T, ignore: K[]): Omit<T, K>;
+export declare function shallowEqual(objA: Record<never, unknown>, objB: Record<never, unknown>): boolean;

package/types/_core/scripts/helpers/utils/stringifyControlSize.d.ts

@@ -0,0 +1,3 @@
+import { ControlSize } from "../../views/controls/Control";
+export declare type ComponentSize = "small" | "normal" | "large";
+export declare function stringifyControlSize(size: ControlSize): ComponentSize;

package/types/_core/scripts/helpers/utils/valued/getValued.d.ts

@@ -0,0 +1,18 @@
+declare type ValuedParams<F> = F extends (...args: infer A) => unknown ? A : never;
+declare type ValuedExtract<F> = F extends (...args: any[]) => infer R ? R : F;
+/**
+ * @example
+const o = {
+    a1: getValued(123), // number
+    a2: getValued(() => 123), // number
+    a3: getValued(() => "str"), // string
+    a4: getValued((s: string) => `str:${s}`, "one"), // string
+    a5: getValued((s: string, n: number) => `str:${s}${n.toString()}`, "one", 123), // string
+    a6: getValued((s: string, n: string) => ({ name: s, value: n }), "one", "v"), // { name: string; value: string; }
+    a7: getValued((s: string, n: string) => ({ name: s, value: n }), "one", 123), // Error
+    a8: getValued("str", "one", 123), // Error
+    a9: getValued((s?: string, n?: string) => ({ name: s, value: n }), "one") // { name: string; value: string; }
+};
+ */
+export declare function getValued<F>(main: F, ...args: ValuedParams<F>): ValuedExtract<F>;
+export {};

package/types/_core/scripts/helpers/zone/IZone.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="../../../../mithril" />
+import { MithrilControl } from "../types";
+export interface IZone {
+    remove(content: MithrilControl): void;
+    push(content: MithrilControl): void;
+    render(): _mithril.MithrilVirtualElement[];
+}

package/types/_core/scripts/security/PermissionLevel.d.ts

@@ -0,0 +1,40 @@
+import { IFilterGroup } from "../services/IFilter";
+import { MdtField } from "../common/MdtField";
+import { MdtObject } from "../common/MdtObject";
+import { Record } from "../common/Record";
+export declare enum PermissionLevel {
+    None = 0,
+    Read = 1,
+    Write = 2,
+    Delete = 4,
+    Add = 8,
+    Execute = 16,
+    Filter = 32,
+    All = 255
+}
+/** Example: "Read, Write, Delete, Add" */
+export declare type PermissionLevelString = string;
+export interface PrincipalPermission extends Record {
+    ID_Permission?: number;
+    ID_Permission$?: Permission;
+    ID_Object?: number;
+    ID_Object$?: MdtObject;
+    ID_Field?: number;
+    ID_Field$?: MdtField;
+    LevelGrant?: PermissionLevel;
+    LevelDeny?: PermissionLevel;
+    Filter?: IFilterGroup;
+}
+export interface Permission extends Record {
+    id?: number;
+    Code: string;
+    LevelMask: PermissionLevel;
+    ID_Parent: number;
+    FlagObject: boolean;
+    FlagField: boolean;
+}
+export declare class PrincipalTypes {
+    static User: string;
+    static Group: string;
+    static Role: string;
+}

package/types/_core/scripts/security/User.d.ts

@@ -0,0 +1,19 @@
+import { ApiV1 } from "mdtServices/api/ApiAccessor/apiV1Types";
+export interface User {
+    $id: number;
+    id: any;
+    permissions: ApiV1.Response.User.Permissions;
+    login: string;
+    fullName: string;
+    email?: string;
+    identityName: string;
+    isAdmin: boolean;
+    isAnonymous: boolean;
+    roles: string[];
+    languageId: number;
+    languageCode: string;
+    isImpersonated: boolean;
+}
+export declare type UserPermissionType = ApiV1.Response.User.UserPermissionType;
+export declare type ObjectPermission = ApiV1.Response.User.ObjectPermission;
+export declare type CommonPermissionData = ApiV1.Response.User.CommonPermissonData;

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

@@ -0,0 +1,6 @@
+import { Hotkey } from "./commands/CommandManager";
+export declare class HotkeyManager {
+    static keyJoinWith: string;
+    static eventToString(e: any): string;
+    static modifyHotkeys(hotkeys: Hotkey[]): Hotkey[];
+}