@yesilyazilim/web.spa 1.0.31

package/types.d.ts

@@ -0,0 +1,1173 @@
+export interface ComponentOptions {
+    elementName: string;
+    classes?: string[];
+    styles?: Partial<CSSStyleDeclaration>;
+    extends?: string;
+}
+export function Component(componentOptions: ComponentOptions): ClassDecorator;
+export function Prop(): PropertyDecorator;
+export enum CommandTypes {
+    Command = 0,
+    Tool = 1,
+    Select = 2,
+    Custom = 3
+}
+export enum SystemEvents {
+    ApplicationStart = "ApplicationStart",
+    ApplicationShow = "ApplicationShow",
+    ApplicationHide = "ApplicationHide",
+    ApplicationEnd = "ApplicationEnd",
+    PageNavigated = "PageNavigated",
+    CommandStart = "CommandStart",
+    CommandCancel = "CommandCancel",
+    PanelResizeStart = "PanelResizeStart",
+    PanelResizeEnd = "PanelResizeEnd",
+    UserLogin = "UserLogin",
+    UserLogout = "UserLogout",
+    TokenRefresh = "TokenRefresh"
+}
+export enum FrameworkPages {
+    App = "AppPage",
+    Admin = "AdminPage"
+}
+export enum FrameworkCommandTargets {
+    Ribbon = "ribbon",
+    UserMenu = "user-menu"
+}
+export enum StartupJobTypes {
+    PreLoad = 0,
+    PostLoad = 1
+}
+export enum ServiceTypes {
+    Scoped = 0,
+    Singleton = 1,
+    Transient = 2
+}
+export enum PanelPos {
+    Center = 0,
+    Left = 1,
+    Right = 2,
+    Bottom = 3
+}
+export const IconClass: {
+    search: string;
+    save: string;
+    query: string;
+    add: string;
+    new: string;
+    delete: string;
+    edit: string;
+    cancel: string;
+    chevron_down: string;
+    chevron_up: string;
+    chevron_left: string;
+    chevron_right: string;
+    caret_up: string;
+    caret_down: string;
+    caret_left: string;
+    caret_right: string;
+    caret_up_fill: string;
+    caret_down_fill: string;
+    caret_left_fill: string;
+    caret_right_fill: string;
+    X: string;
+    error: string;
+    warning: string;
+    info: string;
+    success: string;
+    dots: string;
+    dots_v: string;
+    logout: string;
+    settings: string;
+    world: string;
+    alert: string;
+    hand: string;
+    zoom_in: string;
+    zoom_out: string;
+    alarm: string;
+    cursor: string;
+    key: string;
+    layers: string;
+    person: string;
+    people: string;
+    pin: string;
+};
+export type DebounceOptions<Result> = {
+    isImmediate?: boolean;
+    maxWait?: number;
+    callback?: (data: Result) => void;
+};
+export interface DebouncedFunction<Args extends unknown[], F extends (...args: Args) => unknown> {
+    (this: ThisParameterType<F>, ...args: Args & Parameters<F>): Promise<ReturnType<F>>;
+    cancel: (reason?: unknown) => void;
+}
+export function debounce<Args extends unknown[], F extends (...args: Args) => unknown>(func: F, waitMilliseconds?: number, options?: DebounceOptions<ReturnType<F>>): DebouncedFunction<Args, F>;
+export type EventListener<TData extends AnObject = {}, TResult = void> = (data?: TData) => TResult;
+export class Eventer<TData = any, TResult = void> {
+    debounceMs: number;
+    constructor(debounceMs?: number);
+    register(listener: EventListener<TData, TResult>): void;
+    unregister(listener: EventListener<TData, TResult>): void;
+    raise(data: TData): Promise<TResult[]>;
+}
+export type DomEventName = keyof HTMLElementEventMap;
+export type DomEventData = HTMLElementEventMap[DomEventName];
+export class DomEventAction extends Eventer<DomEventData, void> {
+    constructor(target: HTMLElement, eventName: DomEventName);
+}
+export type LookupValue = string | number;
+export type AnObject = {
+    [key: string]: any;
+};
+export type Constructable<T extends AnObject = {}> = {
+    new (...args: any[]): T;
+};
+export type ClassType<T extends AnObject = {}> = Function & Constructable<T>;
+export type CreatorFunc = () => unknown;
+export type LookupLoaderFunction = () => Promise<ILookup[]>;
+export type Action<R = void, P = void> = (p?: P) => R;
+export type AsyncAction<R = void, P = void> = Action<Promise<R>, P>;
+export type OpResult<T = void> = {
+    success: boolean;
+    message?: string;
+    data?: T;
+};
+export type AsyncOpResult<T = void> = Promise<OpResult<T>>;
+export type Operation<T = void> = Action<OpResult<T>>;
+export type AsyncOperation<T = void> = Action<AsyncOpResult<T>>;
+export interface ILookup {
+    key?: LookupValue;
+    title: string;
+}
+export type Keyed<T> = T & {
+    key: string;
+};
+export type IdValue<T> = {
+    id: number;
+    value: T;
+};
+export type SelfParent<T> = T & {
+    children?: SelfParent<T>[];
+};
+export interface IOrderable {
+    order?: number;
+}
+export type PropChangeInfo = {
+    name: string;
+    newValue: any;
+    oldValue?: any;
+};
+export interface IObservable {
+    readonly onPropChanged: Eventer<PropChangeInfo, void>;
+    raisePropChanged(info: PropChangeInfo): void;
+}
+export type LookupFunc = (context: any) => Promise<Array<ILookup>>;
+export type ISimpleArray<T> = Iterable<T> & ArrayLike<T>;
+declare class DevLoggerClass {
+    constructor();
+    set enable(value: boolean);
+    get enable(): boolean;
+    log(...data: any[]): void;
+}
+export const DevLogger: DevLoggerClass;
+export interface IButtonInfo {
+    text?: string;
+    tootip?: string;
+    iconClass?: string;
+}
+export interface IBag<T> {
+    bag: T;
+}
+export type IKeyedButtonInfo = Keyed<IButtonInfo>;
+export type BaggedButtonElement = HTMLButtonElement & IBag<IButtonInfo>;
+export type MenuItem = SelfParent<IKeyedButtonInfo>;
+export type ButtonClickAction = (info: IButtonInfo) => void;
+export type Orientation = 'horizonal' | 'vertical';
+export type Alignment = 'start' | 'center' | 'end';
+export type RibbonItemType = 'Button' | 'DropDownButton' | 'RadioButton' | 'Select' | 'Custom';
+export type FormInputType = 'hidden' | 'readonly' | 'text' | 'textarea' | 'int' | 'double' | 'date' | 'datetime-local' | 'boolean' | 'password' | 'color' | HTMLElement;
+export type DisplayClasses = 'danger' | 'warning' | 'success' | 'info';
+export type ButtonListProperties = {
+    orientation?: Orientation;
+    align?: Alignment;
+    gap?: string;
+};
+export type MenuProperties = {
+    align?: Alignment;
+    gap?: string;
+};
+export type OptionMenuProperties = MenuProperties & {
+    iconClass?: string;
+};
+export type CustomOption = HTMLOptionElement & {
+    originalValue: LookupValue;
+};
+export interface IValidationRule {
+    getError(value: any): string;
+}
+export interface IFormInput {
+    key: string;
+    title: string;
+    input: FormInputType;
+    readonlyInput?: HTMLElement;
+    rules?: IValidationRule[];
+    getter?: (inputElm: HTMLElement) => any;
+    setter?: (inputElm: HTMLElement, value: any) => void;
+}
+export interface IRibbonTab extends IOrderable {
+    key: string;
+    text: string;
+    groups: IRibbonGroup[];
+    onDemand?: boolean;
+    color?: string;
+}
+export interface IRibbonGroup extends IOrderable {
+    key: string;
+    text: string;
+    items: IRibbonItem[];
+}
+export interface IRibbonItem extends IOrderable {
+    type: RibbonItemType;
+    key: string;
+}
+export interface IRibbonCmd extends IKeyedButtonInfo {
+    action: () => void;
+    active?: boolean;
+}
+export interface IRibbonItemButton extends IRibbonItem, IRibbonCmd {
+    type: 'Button';
+    size: 'small' | 'big';
+}
+export interface IRibbonItemDropDown extends IRibbonItem {
+    type: 'DropDownButton';
+    mainButton: IRibbonCmd;
+    children: IRibbonCmd[];
+}
+export interface IRibbonItemRadioButton extends IRibbonItem {
+    type: 'RadioButton';
+    buttons: IRibbonCmd[];
+}
+export interface IRibbonItemSelect extends IRibbonItem {
+    type: 'Select';
+    title: string;
+    items: ILookup[];
+    action: (key: string) => void;
+}
+export interface IRibbonItemCustom extends IRibbonItem {
+    type: 'Custom';
+    title: string;
+    element: HTMLElement;
+}
+export type TreeItemActionInfo = IKeyedButtonInfo | HTMLInputElement;
+export interface ITreeItem extends IOrderable {
+    id: string;
+    title: string;
+    checked?: boolean;
+    hidden?: boolean;
+    passive?: boolean;
+    actions?: TreeItemActionInfo[];
+    children?: ISimpleArray<ITreeItem>;
+    onAction?: (id: string) => void;
+    propsChanged?: Eventer<{
+        key: string;
+        value: any;
+    }, void>;
+    actionPropChanged?: Eventer<{
+        action: TreeItemActionInfo;
+        key: string;
+        value: any;
+    }, void>;
+    displayClass?: DisplayClasses;
+    icon?: HTMLElement;
+}
+export type TreeViewProperties = {
+    hideCheck?: boolean;
+    selectable?: boolean;
+    expanded?: boolean;
+};
+export type MessageBoxStyles = '' | 'error' | 'info' | 'warning' | 'success';
+export class IndeterminateProgress extends HTMLElement {
+    constructor(attachMode?: 'bottom' | 'top' | null);
+    start(): void;
+    stop(): void;
+}
+export type ObserverFunc = (object: object, key: string, newValue: any, oldValue: any) => void;
+export class System {
+    static observe(object: object, key: string, observer: ObserverFunc): void;
+    static isString(value: any): value is string;
+    static isNumber(value: any): value is number;
+    static isFunction(value: any): value is Function;
+    static isDate(value: any): value is Date;
+    static isHtmlElement(value: any): value is HTMLElement;
+    static isNullOrUndefined(value: any): boolean;
+    static isEmpty(value: any): boolean;
+    static toString(value: number | string, defaultValue?: string): string;
+    static toNumber(value: string, defaultValue?: number | null): number | null;
+    static getExecuterInfo(): string;
+    static epoch2Date(epoch: number): Date | null;
+    static epoch2DateStr(epoch: number, skipTime?: boolean): string;
+    static sortFnc(a: IOrderable, b: IOrderable): number;
+    static sort(arr: IOrderable[]): void;
+    static assignDefault<T extends AnObject>(properties: T, defaultProps: Required<T>): Required<T>;
+}
+export class MessageDisplay extends HTMLElement {
+    constructor(type: MessageBoxStyles, message: string | HTMLElement);
+    setMessage(message: string | HTMLElement): void;
+}
+export class Spinner extends HTMLElement {
+    constructor(message?: string);
+    setMessage(message: string): void;
+}
+export interface IDomItem {
+    tag: keyof HTMLElementTagNameMap;
+    styles?: Partial<CSSStyleDeclaration>;
+    attrs?: Record<string, string>;
+    children?: Array<IDomItem | HTMLElement>;
+}
+export class ELF {
+    static create<K extends keyof HTMLElementTagNameMap>(tag: K, styles?: Partial<CSSStyleDeclaration>, attrs?: Partial<HTMLElementTagNameMap[K]>, children?: Array<HTMLElement | string>): HTMLElementTagNameMap[K];
+    static build(item: IDomItem): HTMLElement;
+    static button(text?: string, tooltip?: string, btnClasses?: string, iconClass?: string, action?: (ev?: PointerEvent, btn?: HTMLButtonElement) => void): HTMLButtonElement;
+    static Buttons: {
+        fromButtonInfo: (info: IButtonInfo, classes?: string, action?: (ev?: PointerEvent, btn?: BaggedButtonElement) => void) => BaggedButtonElement;
+        search: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        save: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        query: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        add: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        delete: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        edit: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        cancel: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, text?: string, tooltip?: string) => HTMLButtonElement;
+        mini: (action: (ev?: PointerEvent, btn?: HTMLButtonElement) => void, iconClass: string, tooltip?: string) => HTMLButtonElement;
+    };
+    static div(classes?: string, ...children: Array<HTMLElement | string>): HTMLDivElement;
+    static dialog(classes?: string, ...children: Array<HTMLElement | string>): HTMLDialogElement;
+    static span(text?: string, classes?: string): HTMLSpanElement;
+    static ul(attrs?: Record<string, string>, styles?: Partial<CSSStyleDeclaration>): HTMLUListElement;
+    static li(attrs?: Record<string, string>, styles?: Partial<CSSStyleDeclaration>): HTMLLIElement;
+    static label(label: string, classes?: string): HTMLLabelElement;
+    static closeButton(): HTMLAnchorElement;
+    static input(type: 'hidden' | 'text' | 'number' | 'date' | 'checkbox' | 'textarea' | 'password' | 'time' | 'datetime-local' | 'month' | 'color' | 'range', value?: string): HTMLInputElement;
+    static textarea(value?: string): HTMLTextAreaElement;
+    static switch(): HTMLInputElement;
+    static icon(className: string): HTMLElement;
+    static h(num: 1 | 2 | 3 | 4 | 5 | 6, text: string, className?: string): HTMLHeadingElement;
+    static p(text: string, className?: string): HTMLParagraphElement;
+    static option(text: string, value?: LookupValue): HTMLOptionElement;
+    static select(): HTMLSelectElement;
+    static selectWithOptions(...values: string[]): HTMLSelectElement;
+    static selectWithLookup(...lookups: ILookup[]): HTMLSelectElement;
+    static setClasses<T extends HTMLElement>(elm: T, ...arr: string[]): T;
+    static setStyles<T extends HTMLElement>(elm: T, styles?: Partial<CSSStyleDeclaration>): T;
+    static setAttributes<T extends HTMLElement>(elm: T, attrs: Record<string, string>): T;
+    static switchClassesIf<T extends HTMLElement>(elm: T, condition: boolean, trueClass: string, falseClass?: string): T;
+    static nextElementId(prefix?: string): string;
+    static showHideSpinnerAt(elm: HTMLElement, show: boolean, message?: string): void;
+    static showHideWorkingAt(elm: HTMLElement, show: boolean, attachMode?: 'bottom' | 'top'): void;
+    static getSpinnerAt(elm: HTMLElement): Spinner;
+    static showHideMessageDisplayAt(elm: HTMLElement, show: boolean, style?: MessageBoxStyles, message?: string | HTMLElement): void;
+}
+export abstract class BaseElement extends HTMLElement implements IObservable {
+    eid: number;
+    canClose(): Promise<boolean>;
+    protected onConnected?(): void;
+    protected onDisconnected?(): void;
+    onPanelResize?(start: boolean): void;
+    readonly onPropChanged: Eventer<PropChangeInfo, void>;
+    constructor();
+    raisePropChanged(info: PropChangeInfo): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    set bag(value: any);
+    get bag(): any;
+    grapFocus(child: HTMLElement): void;
+    get isBusy(): boolean;
+    setBusy(value: boolean, message?: string): void;
+    set visible(v: boolean);
+    removeAllChildNodes(): void;
+    isExist(): boolean;
+}
+export abstract class BaseFormElement extends BaseElement {
+    abstract check(): boolean;
+    abstract getData(): any;
+    abstract isReadonly: boolean;
+}
+export type TabItem = {
+    name: string;
+    header: string;
+    content: HTMLElement;
+    closable: boolean;
+    hidden?: boolean;
+    draggable?: boolean;
+    color?: string;
+} & IOrderable;
+export interface ITabContainer {
+    tabsChanged: Eventer<TabsChangedData, void>;
+    addTab(ti: TabItem): any;
+    containsTab(name: string): boolean;
+    removeTabAsync(name: string): Promise<boolean>;
+    activateTab(indexOrName: number | string): boolean;
+    showHideTab(indexOrName: number | string, show: boolean): any;
+    getActiveTabItem(): TabItem | null;
+}
+export type TabsChangedData = {
+    type: 'add' | 'remove' | 'activated' | 'deactivated';
+    tab: TabItem;
+};
+export class TabContainer extends BaseElement implements ITabContainer {
+    tabs: Tab[];
+    headers: TabHeader[];
+    tabsChanged: Eventer<TabsChangedData, void>;
+    onTabItemDragStarted: Eventer<TabItem>;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    addTab(ti: TabItem): void;
+    containsTab(name: string): boolean;
+    removeTabAsync(name: string): Promise<boolean>;
+    activateTab(indexOrName: number | string): boolean;
+    getActiveTabItem(): TabItem | null;
+    showHideTab(indexOrName: string | number, show: boolean): boolean;
+    disableTab(indexOrName: string | number, disable: boolean): boolean;
+    moveTo(name: string, other: TabContainer, activate?: boolean): boolean;
+    warnChildrenResize(start: boolean): void;
+}
+declare class Tab extends BaseElement {
+    item: TabItem;
+    name: string;
+    constructor(item: TabItem);
+    setActive(active: boolean): void;
+}
+declare class TabHeader extends BaseElement {
+    constructor(tabContainer: TabContainer, tab: Tab);
+    setActive(active: boolean): void;
+}
+export interface ServiceConfig {
+    type?: ServiceTypes;
+    creator?: CreatorFunc | any;
+}
+export interface IUserInfo<T = void> {
+    key: string;
+    title: string;
+    auths: string[];
+    props?: T;
+}
+export interface ILoginInfo {
+    token: string;
+    expires: number;
+    user: IUserInfo;
+}
+export interface ILoginComponent extends BaseElement {
+    onLogined: Eventer<ILoginInfo, any>;
+}
+export type AuthLocalProperties = {
+    type: 'Local';
+    autoLogin: boolean;
+    createLoginComponent: () => ILoginComponent;
+};
+export type AuthCookieProperties = {
+    type: 'Cookie';
+    logoutUrl: string;
+    loginInfoUrl: string;
+};
+export type AuthProperties = AuthLocalProperties | AuthCookieProperties;
+export type AppMenuItemGroupInfo = {
+    key: string;
+    title: string;
+    order: number;
+};
+export type AppMenuTabInfo = {
+    key: string;
+    title: string;
+    items: AppMenuItemGroupInfo[];
+    order: number;
+    onDemand?: boolean;
+    color?: string;
+};
+export type AppMenuProperties = {
+    defaultTool: string;
+    tabs: AppMenuTabInfo[];
+};
+export type ApplicationProperties = {
+    title: string;
+    hostElement: HTMLElement;
+    auth: AuthProperties;
+    ribbon: AppMenuProperties;
+    apiEndPoint: string;
+    logoUrl: string;
+    defaultPage: string;
+};
+export interface PageProperties {
+    key: string;
+    title: string;
+    auth?: string;
+    iconClass?: string;
+}
+export interface PagePartProperties {
+    key: string;
+    page: string;
+    title: string;
+    auth?: string;
+}
+type BaseCommandProperties = {
+    type: CommandTypes;
+    container: 'ribbon' | string;
+    key: string;
+    title: string;
+    group: string;
+    order?: number;
+    auth?: string;
+    preload?: boolean;
+};
+export type ActionCommandProperties = BaseCommandProperties & {
+    type: CommandTypes.Command | CommandTypes.Tool;
+    iconClass: string;
+};
+export type SelectCommandProperties = BaseCommandProperties & {
+    type: CommandTypes.Select;
+    selectItems?: ILookup[];
+};
+export type CustomCommandProperties = BaseCommandProperties & {
+    type: CommandTypes.Custom;
+    customElementCreator?: () => HTMLElement;
+};
+export type CommandProperties = ActionCommandProperties | SelectCommandProperties | CustomCommandProperties;
+export interface ICommand {
+    start(childKey?: string, param?: any): void;
+    enabled: boolean;
+    active: boolean;
+}
+export interface ITool extends ICommand {
+    cancel(): boolean;
+}
+export type StartupJobProperties = {
+    type: StartupJobTypes;
+    title: string;
+    required: boolean;
+    errorMessage?: string;
+    order?: number;
+};
+export interface IAppStartupJob {
+    name: string;
+    run(): Promise<boolean>;
+}
+export type PageNavigatedEventArgs = {
+    pageKey: string;
+    pageTitle: string;
+    fromPageKey: string;
+};
+export interface IMainPanel {
+    openItem(pos: PanelPos, item: TabItem): any;
+    closeItemAsync(name: string): Promise<boolean>;
+    onResizeStatusChanged(start: boolean, pos: PanelPos, affecteds: PanelPos[]): void;
+}
+export type FormFactoryProperties = {
+    type: string;
+    order: number;
+};
+export interface IFormFactory {
+    name: string;
+    createForm(row: AnObject, serviceKey: string, tableKey: string, targetType?: string): AsyncOpResult<HTMLElement>;
+}
+export interface ICommandDisplayer {
+    setActive(key: string, value: boolean): any;
+    setDisabled(key: string, value: boolean): any;
+    isExist(): boolean;
+}
+export abstract class BasePage extends BaseElement {
+    constructor();
+    canClose(): Promise<boolean>;
+    pageProps: PageProperties;
+    abstract OnShow(): void;
+    abstract OnHide(): void;
+}
+export abstract class BasePagePart extends BaseElement {
+    constructor();
+    canClose(): Promise<boolean>;
+    abstract OnShow(): void;
+    abstract OnHide(): void;
+}
+export type PagePartItem = {
+    pagePart: BasePagePart;
+    props: PagePartProperties;
+};
+export class LazyInstance<T> {
+    constructor(_constructor: ClassType<T>);
+    get instance(): T;
+    get newInstance(): T;
+    get isCreated(): boolean;
+    reset(): void;
+}
+export class LasyInstanceMap<T, L extends LazyInstance<T>> {
+    registerLazy(key: string, li: L): void;
+    has(key: string): boolean;
+    getLazy(key: string): L;
+    get allItems(): L[];
+    resetInstances(): void;
+}
+export class LazyCommand extends LazyInstance<ICommand> {
+    config: CommandProperties;
+    constructor(_constructor: ClassType<ICommand>, config: CommandProperties);
+}
+export class PageLazy extends LazyInstance<BasePage> {
+    props: PageProperties;
+    constructor(ctor: ClassType<BasePage>, props: PageProperties);
+}
+export class PagePartLazy extends LazyInstance<BasePagePart> {
+    props: PagePartProperties;
+    constructor(ctor: ClassType<BasePagePart>, props: PagePartProperties);
+}
+export class StartupJobLazy extends LazyInstance<IAppStartupJob> {
+    config: StartupJobProperties;
+    constructor(classType: ClassType<IAppStartupJob>, config: StartupJobProperties);
+}
+export class FormFactoryLazy extends LazyInstance<IFormFactory> {
+    key: string;
+    constructor(classType: ClassType<IFormFactory>, key: string);
+}
+export class ServiceItem {
+    serviceType: ServiceTypes;
+    constructor(_type: ClassType | string, config: ServiceConfig);
+    getInstance(): any;
+    onScopeChanged(): void;
+}
+declare class ServicePooler {
+    register(type: ClassType, config: ServiceConfig): void;
+    registerKeyed(key: string, type: ServiceTypes, service: AnObject | (() => any)): void;
+    get<T>(type: any): T;
+    find<T>(type: any): T | null;
+    get scopeActive(): boolean;
+    set scopeActive(value: boolean);
+}
+export const ServicePool: ServicePooler;
+export function Inject(): PropertyDecorator;
+export function Service(config?: ServiceConfig): ClassDecorator;
+export function ServiceKeyed(key: string, type: ServiceTypes): ClassDecorator;
+export class EventService {
+    constructor();
+    listen<TData, TResult>(eventName: string, listener: EventListener<TData, TResult>, debunceMs?: number): void;
+    forgot<TData, TResult>(eventName: string, listener: EventListener<TData, TResult>): void;
+    raise<TData, TResult>(eventName: string, data: TData): Promise<TResult[]>;
+}
+declare class TokenManagerClass {
+    refreshing: boolean;
+    refreshMin: number;
+    get isExpired(): boolean;
+    get needRefresh(): boolean;
+    get isValid(): boolean;
+    get headerValue(): string;
+    setToken(token: string, expiresAtSec: number): boolean;
+    clearToken(): void;
+}
+export const TokenManager: TokenManagerClass;
+declare class StoreObj {
+    eventService: EventService;
+    constructor();
+    set<T>(key: string, value: T, keep?: boolean): void;
+    get<T>(key: string): T | null;
+    _initLocal(): void;
+}
+export const Store: StoreObj;
+export function getAppProperties(): ApplicationProperties;
+export class AuthService {
+    eventService: EventService;
+    constructor();
+    startAsync(): Promise<boolean>;
+    onSuccessLogin(loginInfo: ILoginInfo): void;
+    get isLogined(): boolean;
+    get currentUser(): IUserInfo | null;
+    hasAuth(auth: string): boolean;
+    refreshToken(token: string, expires: number): void;
+    logOut(): void;
+    getHeaderUserDisplayText(): string;
+}
+export interface IWindow {
+    close(): any;
+}
+export class DialogWindow {
+    static DialogHost: HTMLElement;
+    static ShowAsync(title: string, content: HTMLElement): Promise<void>;
+}
+export interface INofityItem {
+    hide(): void;
+}
+export type NotifyProperties = {
+    title: string;
+    message?: string | HTMLElement;
+    iconClass?: string;
+    autoHideMs?: number;
+    preventHideOnClick?: boolean;
+    type?: '' | 'error' | 'info' | 'warning' | 'success';
+    onClose?: Action;
+};
+export class Notify {
+    static container: HTMLDivElement;
+    static Error(title: string, message?: string, replace?: INofityItem): INofityItem;
+    static Success(title: string, message?: string, replace?: INofityItem): INofityItem;
+    static Warning(title: string, message?: string, replace?: INofityItem): INofityItem;
+    static Info(title: string, message?: string, replace?: INofityItem): INofityItem;
+    static Show(properties: NotifyProperties, replace?: INofityItem): INofityItem;
+    static Wait(title: string, message?: string, replace?: INofityItem): INofityItem;
+}
+export abstract class PartContainerPage extends BasePage {
+    leftMenu: HTMLDivElement;
+    partSide: HTMLDivElement;
+    partContainer: HTMLDivElement;
+    activePart: BasePagePart;
+    authService: AuthService;
+    constructor(title: string);
+    loadParts(items: PagePartItem[]): void;
+    _onMenuClicked(item: PagePartItem, menuItem: HTMLDivElement): void;
+}
+export class NavigationService {
+    authService: AuthService;
+    eventService: EventService;
+    init(pageContainerElement: HTMLElement, headerActionsContainer: HTMLDivElement): void;
+    goto(key: string): Promise<boolean>;
+    getUserPagesForNav(): PageProperties[];
+    get headerActionsContainer(): HTMLDivElement;
+    getDefaultPage(): string;
+}
+export function Command(cmdProps: CommandProperties): ClassDecorator;
+export function Page(properties: PageProperties): ClassDecorator;
+export function PagePart(properties: PagePartProperties): ClassDecorator;
+export function StartupJob(key: string, properties: StartupJobProperties): ClassDecorator;
+export function FormFactory(key: string): ClassDecorator;
+export class CommandService {
+    eventService: EventService;
+    authService: AuthService;
+    constructor();
+    startCommand(key: string, childKey: string, param?: any): boolean;
+    startDefault(): void;
+    getCommandsFor(container: string, displayer: ICommandDisplayer): CommandProperties[];
+}
+type EventKeysType = HTMLElementEventMap & {
+    "change": Event;
+};
+export class ButtonRadioChangedEvent extends CustomEvent<{
+    key: string;
+}> {
+    constructor(key: string);
+}
+export class ButtonRadio<T extends IKeyedButtonInfo = IKeyedButtonInfo> extends BaseElement {
+    addEventListener<K extends keyof EventKeysType>(type: K, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    constructor(items: T[], cssClass?: string);
+    get value(): string;
+    set value(val: string);
+}
+export class ButtonList extends BaseElement {
+    constructor(properties: ButtonListProperties);
+}
+export class Dropdown extends BaseElement {
+    constructor(content: HTMLElement);
+    toggle(): void;
+    get visible(): boolean;
+    set visible(value: boolean);
+}
+export class DropdownButton extends BaseElement {
+    constructor(main: IKeyedButtonInfo, children: IKeyedButtonInfo[], clickAction: (info: IKeyedButtonInfo) => void);
+}
+export class RibbonMenu extends BaseElement implements ICommandDisplayer {
+    constructor();
+    addRibbonTab(tab: IRibbonTab): void;
+    removeRibbonTab(name: string): void;
+    findElement(key: string): HTMLElement;
+    activateFirstTab(): void;
+    setActive(key: string, value: boolean): void;
+    setDisabled(key: string, value: boolean): void;
+}
+export class Application {
+    constructor();
+    start(body: HTMLElement): Promise<boolean>;
+    openPanel(item: TabItem, pos: PanelPos): void;
+    movePanel(name: string, pos: PanelPos): void;
+}
+declare global {
+    interface Array<T> {
+        removeAt(index: number): boolean;
+        remove(item: T): boolean;
+    }
+    interface HTMLElement {
+        setClasses(...value: string[]): HTMLElement;
+        setStyles(styles?: Partial<CSSStyleDeclaration>): HTMLElement;
+        setAttributes(attrs: Record<string, string>): HTMLElement;
+        appendChildren(...elements: HTMLElement[]): void;
+        clearChildren(): void;
+        showhide(visible: boolean): void;
+        get active(): boolean;
+        set active(value: boolean);
+        get disabled(): boolean;
+        set disabled(value: boolean);
+    }
+    interface String {
+        format(...params: string[]): string;
+    }
+    interface Date {
+        toStr(skipTime?: boolean): string;
+    }
+}
+export type ListChangeInfo<T> = {
+    added?: T[];
+    removed?: T[];
+    replaced?: {
+        old: T;
+        new: T;
+    };
+    sorted?: boolean;
+};
+export class List<T> implements ISimpleArray<T> {
+    readonly [n: number]: T;
+    get length(): number;
+    readonly changeEvent: Eventer<ListChangeInfo<T>, void>;
+    constructor(...arr: T[]);
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    add(item: T): void;
+    addMany(...items: T[]): void;
+    getAt(inx: number): T | null;
+    setAt(inx: number, item: T): boolean;
+    remove(item: T): boolean;
+    removeMany(...items: T[]): boolean;
+    removeAt(inx: number): boolean;
+    clear(): void;
+    indexOf(item: T): number;
+    contains(item: T): boolean;
+    find(predicate: (value: T) => boolean): T;
+    filter(predicate: (value: T) => boolean): T[];
+    map<U>(callbackfn: (value: T) => U): U[];
+    forEach(callbackfn: (value: T) => void): void;
+    sort(callbackfn: (a: T, b: T) => number): void;
+    toArray(): T[];
+}
+export type ListItemInx<T> = IdValue<T> & {
+    inx: number;
+};
+export type IndexedListChangeInfo<T> = {
+    added?: ListItemInx<T>[];
+    removed?: ListItemInx<T>[];
+    replaced?: {
+        old: ListItemInx<T>;
+        new: ListItemInx<T>;
+    };
+    sorted?: boolean;
+};
+export class IndexedList<T> implements ISimpleArray<T> {
+    readonly [n: number]: T;
+    get length(): number;
+    readonly changeEvent: Eventer<IndexedListChangeInfo<T>, void>;
+    constructor(...arr: T[]);
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    add(item: T): number;
+    addMany(...items: T[]): IdValue<T>[];
+    getById(id: number): ListItemInx<T> | null;
+    getValueById(id: number): T | null;
+    setById(id: number, value: T): boolean;
+    removeById(id: number): boolean;
+    removeManyById(...ids: number[]): boolean;
+    clear(): void;
+    idsOf(value: T): number[];
+    contains(value: T): boolean;
+    find(predicate: (value: T) => boolean): T | null;
+    filter(predicate: (value: T) => boolean): T[];
+    map<U>(callbackfn: (value: T) => U): U[];
+    forEach(callbackfn: (value: T) => void): void;
+    forEachItem(callbackfn: (value: ListItemInx<T>) => void): void;
+    sort(callbackfn: (a: T, b: T) => number): void;
+    toArray(): T[];
+}
+export abstract class Observable implements IObservable {
+    readonly onPropChanged: Eventer<PropChangeInfo, void>;
+    raisePropChanged(info: PropChangeInfo): void;
+}
+export function Observe(): PropertyDecorator;
+export function MakePropObservable(target: Object, propertyKey: string | symbol): void;
+export abstract class ReactiveElement<TState extends object> extends BaseElement {
+    readonly state: TState;
+    constructor(state: TState);
+    bindToUi<TElm extends HTMLElement, KState extends Extract<keyof TState, string>, KElm extends Extract<keyof TElm, string>>(stateProperty: KState, targetElm: TElm, targetProperty: KElm): void;
+}
+export type AccordionItem = {
+    header: string;
+    content: string | HTMLElement;
+};
+export type AccordionProps = {
+    items: AccordionItem[];
+    connected: boolean;
+};
+export class Accordion extends BaseElement {
+    protected _item: AccordionItem;
+    protected _isOpen: boolean;
+    protected _header: HTMLElement;
+    protected _content: HTMLElement;
+    constructor(_item: AccordionItem);
+    get isOpen(): boolean;
+    get item(): AccordionItem;
+    toggle(): void;
+}
+export class AccordionContainer extends BaseElement {
+    constructor(prop: AccordionProps);
+}
+export type CardProperties = {
+    imageUrl?: string;
+    title?: string;
+    content: HTMLElement | string;
+};
+export class Card extends BaseElement {
+    constructor(_props: CardProperties);
+    _buildUi(): void;
+}
+export interface ListComponentProperties<T> {
+    source: IndexedList<T>;
+    itemFactory: (item: T) => HTMLElement;
+    filterFnc?: (txt: string, item: T) => boolean;
+    conditionFunc?: (item: T) => boolean;
+    selectable?: boolean;
+}
+export class ListComponent<T> extends BaseElement {
+    SelectedIdChanged: Eventer<number>;
+    constructor(props: ListComponentProperties<T>);
+    getElementForId(itemId: number): HTMLElement;
+    get selectedId(): number;
+    set selectedId(id: number);
+}
+export class ListComponentHelper {
+    static CreateStringListComponent(source: IndexedList<string>, selectable?: boolean): ListComponent<string>;
+}
+export type CheckListProperties = {
+    items: ILookup[] | LookupLoaderFunction;
+    selecteds?: LookupValue[];
+};
+export class CheckList extends BaseElement {
+    constructor(properties: CheckListProperties);
+    get value(): LookupValue[];
+    set value(val: LookupValue[]);
+}
+export class Menu extends BaseElement implements ICommandDisplayer {
+    ItemClicked: Eventer<MenuItem>;
+    constructor(properties: MenuProperties, _isDrop?: boolean);
+    setActive(key: string, value: boolean): void;
+    setDisabled(key: string, value: boolean): void;
+    set items(items: MenuItem[]);
+    setItemHidden(hidden: boolean, key: string): void;
+    findItemByKey(key: string): HTMLElement;
+}
+export type ContextMenuProperties = {
+    target: HTMLElement;
+    items?: IKeyedButtonInfo[] | AsyncAction<IKeyedButtonInfo[]>;
+    auto?: boolean;
+};
+export class ContextMenu implements ICommandDisplayer {
+    ItemClicked: Eventer<IKeyedButtonInfo>;
+    constructor(props: ContextMenuProperties);
+    setItems(items: AsyncAction<IKeyedButtonInfo[]> | IKeyedButtonInfo[]): void;
+    setActive(key: string, value: boolean): void;
+    setDisabled(key: string, value: boolean): void;
+    isExist(): boolean;
+    showAt(x: number, y: number): Promise<boolean>;
+    hide(): void;
+}
+export type HtmlElementLike = HTMLElement | ((...params: any[]) => HTMLElement);
+export class ConditionalElement extends BaseElement {
+    constructor(observingItem: IObservable, observingProp: string, trueElement: HtmlElementLike, falseElement?: HtmlElementLike);
+}
+export class TreeView extends BaseElement {
+    ItemActionClicked: Eventer<{
+        item: ITreeItem;
+        actionId: string;
+    }, void>;
+    ItemCheckChanged: Eventer<{
+        item: ITreeItem;
+        checked: boolean;
+    }, void>;
+    props: Required<TreeViewProperties>;
+    constructor(_source: IndexedList<ITreeItem>, properties?: TreeViewProperties);
+    onChildAction(item: ITreeItem, actionId: string): void;
+    onChildCheckChanged(item: ITreeItem, checked: boolean): void;
+    getCheckedItems(): ITreeItem[];
+    setCheckItems(ids: string[]): void;
+}
+export class DropdownTree extends BaseElement {
+    get treeView(): TreeView;
+    constructor(source: IndexedList<ITreeItem>);
+    getCheckedItems(): ITreeItem[];
+    setCheckedIds(ids: string[]): void;
+}
+export class Empty extends BaseElement {
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+export type FlexProperies = {
+    direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
+    gap?: string;
+    wrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    itemPosH?: 'flex-start' | 'flex-end' | 'center' | 'stretch';
+    itemPosV?: 'flex-start' | 'flex-end' | 'center' | 'stretch';
+    contentPosH?: 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'space-around' | 'space-between' | 'space-evenly';
+    contentPosV?: 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'space-around' | 'space-between' | 'space-evenly';
+};
+export class Flex extends HTMLDivElement {
+    constructor(prop: FlexProperies, ...children: HTMLElement[]);
+    set visible(v: boolean);
+    static GetCenteredHV(): Flex;
+    static GetCenteredH(): Flex;
+    static GetCenteredV(): Flex;
+}
+export class Form extends BaseFormElement {
+    isReadonly: boolean;
+    constructor(isReadonly?: boolean);
+    setData(inputs: IFormInput[], model?: any): void;
+    check(): boolean;
+    clearErrors(): void;
+    getData(): any;
+}
+export type GridProperies = {
+    cols?: string;
+    rows?: string;
+    gap?: string;
+    itemPosH?: 'start' | 'end' | 'center' | 'stretch';
+    itemPosV?: 'start' | 'end' | 'center' | 'stretch';
+    contentPosH?: 'start' | 'end' | 'center' | 'stretch' | 'space-around' | 'space-between' | 'space-evenly';
+    contentPosV?: 'start' | 'end' | 'center' | 'stretch' | 'space-around' | 'space-between' | 'space-evenly';
+};
+export class Grid extends HTMLDivElement {
+    constructor(prop: GridProperies, ...children: HTMLElement[]);
+    set visible(v: boolean);
+}
+export class GroupBox extends BaseElement {
+    constructor(caption: string, ...elements: HTMLElement[]);
+    addChild<T extends Node>(node: T): T;
+    deleteChild<T extends Node>(node: T): T;
+    get body(): HTMLDivElement;
+    get caption(): string;
+    set caption(value: string);
+}
+export type MessageBoxButtonTypes = 'Ok' | 'OkCancel' | 'YesNo';
+export type MessageBoxProperties = {
+    content: string | BaseFormElement | HTMLElement;
+    title?: string;
+    buttons?: MessageBoxButtonTypes;
+    style?: MessageBoxStyles;
+    okText?: string;
+    cancelText?: string;
+};
+export type MessageBoxResult = {
+    ok: boolean;
+    data?: any;
+};
+export class MessageBox {
+    static activeDialog: HTMLDialogElement | null;
+    static Error(message: string, title?: string): Promise<void>;
+    static Success(message: string, title?: string): Promise<void>;
+    static Warning(message: string, title?: string): Promise<void>;
+    static Info(message: string, title?: string): Promise<void>;
+    static ShowOk(message: string, title?: string): Promise<void>;
+    static Yesno(message: string, title?: string, style?: MessageBoxStyles): Promise<boolean>;
+    static InputText(title: string, type?: 'text' | 'textarea'): Promise<string>;
+    static ShowAsync(props: MessageBoxProperties): Promise<MessageBoxResult | null>;
+}
+export class OptionsMenu extends BaseElement implements ICommandDisplayer {
+    ItemClicked: Eventer<IKeyedButtonInfo>;
+    menu: Menu;
+    constructor(props: OptionMenuProperties);
+    set items(items: MenuItem[]);
+    setActive(key: string, value: boolean): void;
+    setDisabled(key: string, value: boolean): void;
+}
+export type RadialMenuOptions = {
+    items: IKeyedButtonInfo[] | AsyncAction<IKeyedButtonInfo[]>;
+    autoOpen: boolean;
+    size?: number;
+};
+export class RadialMenu extends BaseElement {
+    ItemClicked: Eventer<IKeyedButtonInfo>;
+    constructor(props: RadialMenuOptions);
+    showAt(x: number, y: number): Promise<boolean>;
+    hide(): void;
+    protected onConnected(): void;
+    _onMouseUp: () => void;
+    _onMouseMove: (e: MouseEvent) => void;
+}
+export class TagInput extends BaseElement {
+    constructor(type?: 'number' | 'text');
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    get value(): string;
+    set value(val: string);
+    addValue(val: string, silent?: boolean): void;
+    triggerChanged(): void;
+}
+export class Toolbar extends ButtonList implements ICommandDisplayer {
+    ItemClicked: Eventer<IKeyedButtonInfo>;
+    constructor(orientation: Orientation);
+    setActive(key: string, value: boolean): void;
+    setDisabled(key: string, value: boolean): void;
+    set items(items: IKeyedButtonInfo[]);
+    get items(): IKeyedButtonInfo[];
+}
+export class RequiredRule implements IValidationRule {
+    constructor();
+    getError(value: any): string;
+}
+export class MinLengthRule implements IValidationRule {
+    len: number;
+    constructor(len: number);
+    getError(value: string): string;
+}
+export class MaxLengthRule implements IValidationRule {
+    len: number;
+    constructor(len: number);
+    getError(value: string): string;
+}
+export class RegexpRule implements IValidationRule {
+    pattern: string;
+    constructor(pattern: string);
+    getError(value: string): string;
+}
+export class MinValueRule implements IValidationRule {
+    min: number;
+    constructor(min: number);
+    getError(value: number): string;
+}
+export class MaxValueRule implements IValidationRule {
+    max: number;
+    constructor(max: number);
+    getError(value: number): string;
+}
+export class MinDateRule implements IValidationRule {
+    min: string;
+    constructor(min: string);
+    getError(value: string): string;
+}
+export class MaxDateRule implements IValidationRule {
+    max: string;
+    constructor(max: string);
+    getError(value: string): string;
+}
+export class FormUtils {
+    static createOptionEmpty(title?: string, value?: string): CustomOption;
+    static createOptionFromLookup(lookup: ILookup): CustomOption;
+    static generateFormInputForSelect(field: string, title: string, list: ILookup[]): IFormInput;
+    static generateFormInputForSelectSecondary(field: string, title: string, primary: IFormInput, loaderFunc: (parentVal: LookupValue) => Promise<ILookup[]>): IFormInput;
+    static generateFormInputForCheckList(field: string, title: string, cp: CheckListProperties): IFormInput;
+    static generateFormInputForSelectFunc(field: string, title: string, lookupFnc: LookupFunc, context: any): IFormInput;
+}
+export abstract class AppStartup {
+    run(props: ApplicationProperties): Promise<void>;
+    abstract onReady(): void;
+}
+export abstract class BaseCommand implements ICommand {
+    protected _enabled: boolean;
+    protected _active: boolean;
+    abstract start(childKey?: string, param?: any): void;
+    get enabled(): boolean;
+    get active(): boolean;
+    set enabled(value: boolean);
+    set active(value: boolean);
+}
+export abstract class BaseTool extends BaseCommand implements ITool {
+    abstract cancel(): boolean;
+}
+export class FormService {
+    createFormAsync(item: AnObject, factoryKey: string, serviceKey: string, tableKey: string, targetType?: string): AsyncOpResult<HTMLElement>;
+}
+
+//# sourceMappingURL=types.d.ts.map