@lakutata/core/build/base/abstracts/Module.d.ts

Lakutata Framework Core

import { BaseObject } from '../BaseObject';
import { Container } from '../Container';
import { Component } from './Component';
import { IComponentsConfig } from '../../interfaces/IComponentsConfig';
import { IModulesConfig } from '../../interfaces/IModulesConfig';
import { TPluginsConfig } from '../../types/TPluginsConfig';
import { Plugin } from '../Plugin';
import { IConstructor } from '../../interfaces/IConstructor';
import { TWorkflowsConfig } from '../../types/TWorkflowsConfig';
import { ThreadManager } from '../thread/ThreadManager';
import { Thread } from '../thread/Thread';
import { IThreadConstructor } from '../../interfaces/IThreadConstructor';
import { ProcessManager } from '../process/ProcessManager';
import { Process } from '../process/Process';
import { IProcessConstructor } from '../../interfaces/IProcessConstructor';
import { TThreadsConfig } from '../../types/TThreadsConfig';
import { TProcessesConfig } from '../../types/TProcessesConfig';
export declare abstract class Module extends BaseObject {
    private readonly eventEmitter;
    readonly id: string | IConstructor<Module>;
    protected readonly container: Container;
    protected readonly threadManager: ThreadManager;
    protected readonly processManager: ProcessManager;
    protected readonly onComponentsLoaded: (module: ThisType<this>) => void | Promise<void>;
    protected readonly onModulesLoaded: (module: ThisType<this>) => void | Promise<void>;
    protected abstract initialize(): Promise<void> | void;
    constructor();
    protected readonly workflows: TWorkflowsConfig;
    protected readonly plugins: TPluginsConfig;
    protected readonly components: IComponentsConfig;
    protected readonly modules: IModulesConfig;
    protected readonly threads: TThreadsConfig;
    protected readonly processes: TProcessesConfig;
    protected bindPlugins(): void;
    protected bindComponents(): void;
    protected bindModules(): void;
    protected bindThreads(): Promise<void>;
    protected bindProcesses(): Promise<void>;
    get Plugins(): {
        bind: <TPlugin extends Plugin = Plugin>(pluginConstructor: IConstructor<TPlugin>, identifier: string, config: object) => void;
        get: <T extends Plugin = Plugin>(name: string) => T;
        has: (name: string) => boolean;
    };
    get Objects(): {
        bind: <TObject extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject>, config?: {
            [key: string]: any;
        } | undefined) => void;
        get: <TObject_1 extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject_1>) => TObject_1;
        has: <TObject_2 extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject_2>) => boolean;
        unbind: <TObject_3 extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject_3>) => void;
    };
    get Components(): {
        [key: string]: any;
        get: <T extends Component = Component>(name: string) => T;
        has: (name: string) => boolean;
    };
    get Modules(): {
        get: <T extends Module = Module>(name: string) => T;
        has: (name: string) => boolean;
    };
    get Threads(): {
        bind: <T extends Thread = Thread>(threadConstructor: IThreadConstructor<T>) => Promise<boolean>;
        get: <T_1 extends Thread = Thread>(threadConstructor: IThreadConstructor<T_1>) => T_1;
        has: <T_2 extends Thread = Thread>(threadConstructor: IThreadConstructor<T_2>) => boolean;
        destroy: <T_3 extends Thread = Thread>(threadConstructor: IThreadConstructor<T_3>) => Promise<void>;
    };
    get Processes(): {
        bind: <T extends Process = Process>(processConstructor: IProcessConstructor<T>) => Promise<boolean>;
        get: <T_1 extends Process = Process>(processConstructor: IProcessConstructor<T_1>) => T_1;
        has: <T_2 extends Process = Process>(processConstructor: IProcessConstructor<T_2>) => boolean;
        destroy: <T_3 extends Process = Process>(processConstructor: IProcessConstructor<T_3>) => Promise<void>;
    };
    on(event: 'ready', listener: (instance: this) => void): this;
    on(event: 'loaded', listener: (id: string, identifier: string, constructor: IConstructor<Module> | IConstructor<Component>, loadTime: number, type: 'module' | 'component') => void): this;
    on(event: string | symbol, listener: (...args: any[]) => void): this;
    once(event: 'ready', listener: (instance: this) => void): this;
    once(event: 'loaded', listener: (id: string, identifier: string, constructor: IConstructor<Module> | IConstructor<Component>, loadTime: number, type: 'module' | 'component') => void): this;
    once(event: string | symbol, listener: (...args: any[]) => void): this;
    off(event: string): void;
    off(event: string | symbol, listener: (...args: any[]) => void): this;
    emit(event: string | symbol, ...args: any[]): boolean;
    bind<TObject extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject>, config?: {
        [key: string]: any;
    }): void;
    get<TObject extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject>): TObject;
    unbind<TObject extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject>): void;
    has<TObject extends BaseObject = BaseObject>(objectConstructor: IConstructor<TObject>): boolean;
}