@journeyapps-labs/reactor-mod 0.0.0-dev-20250801180850

package/dist/@types/actions/validators/ActionValidator.d.ts

@@ -0,0 +1,36 @@
+import { BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+export declare enum PassiveActionValidationState {
+    ALLOWED = "allowed",
+    /**
+     * Show in the UI but disable
+     */
+    DISABLED = "disabled",
+    /**
+     * Hide from the UI completely
+     */
+    DISALLOWED = "disallowed"
+}
+export declare enum ValidationDisabledReason {
+    PLAN_LIMITS = "plan_limits",
+    PLAN_SETTING = "plan_setting",
+    AUTH = "auth"
+}
+export interface ValidationResultAllowed {
+    type: PassiveActionValidationState.ALLOWED;
+}
+export interface ValidationResultDisallowed {
+    type: PassiveActionValidationState.DISALLOWED;
+}
+export interface ValidationResultDisabled {
+    type: PassiveActionValidationState.DISABLED;
+    reason?: ValidationDisabledReason;
+}
+export type ValidationResult = ValidationResultAllowed | ValidationResultDisallowed | ValidationResultDisabled;
+export interface ActionValidatorListener {
+    validationInProgress: () => any;
+}
+export declare abstract class ActionValidator extends BaseObserver<ActionValidatorListener> {
+    accessor busy: boolean;
+    constructor();
+    abstract validate(): ValidationResult;
+}

package/dist/@types/actions/validators/ActionValidatorContext.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '../Action';
+import { PassiveActionValidationState, ValidationResult } from './ActionValidator';
+export interface Validator {
+    validate(): ValidationResult;
+}
+export declare class ActionValidatorContext implements Validator {
+    protected action: Action;
+    constructor(action: Action);
+    get busy(): boolean;
+    get validators(): import("./ActionValidator").ActionValidator[];
+    validate(): import("./ActionValidator").ValidationResultDisabled | {
+        type: PassiveActionValidationState;
+    };
+    validatePassively(): PassiveActionValidationState;
+}

package/dist/@types/actions/validators/InlineActionValidator.d.ts

@@ -0,0 +1,9 @@
+import { ActionValidator, PassiveActionValidationState, ValidationResult } from './ActionValidator';
+/**
+ * @deprecated use InlineActionValidator2
+ */
+export declare class InlineActionValidator extends ActionValidator {
+    protected validateFn: () => PassiveActionValidationState;
+    constructor(validateFn: () => PassiveActionValidationState);
+    validate(): ValidationResult;
+}

package/dist/@types/actions/validators/InlineActionValidator2.d.ts

@@ -0,0 +1,6 @@
+import { ActionValidator, ValidationResult } from './ActionValidator';
+export declare class InlineActionValidator2 extends ActionValidator {
+    protected validateFn: () => ValidationResult;
+    constructor(validateFn: () => ValidationResult);
+    validate(): ValidationResult;
+}

package/dist/@types/cmd-pallet/CMDPalletEntitySearchEngine.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { CMDPalletGenerateResultWidgetEvent, CMDPalletSearchEngine, CMDPalletSearchEngineResult, CommandPalletSearchEngineOptions, CommandPalletSearchResultEntry } from './CMDPalletSearchEngine';
+import { EntityDefinition, EntitySearchEngineComponent, EntitySearchResultEntry } from '../index';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface CMDPalletEntitySearchEngineOptions<E> extends Omit<CommandPalletSearchEngineOptions, 'displayName'> {
+    component: EntitySearchEngineComponent<E>;
+    priority?: number;
+}
+export type CMDPalletEntitySearchEngineEntry<E> = EntitySearchResultEntry<E> & CommandPalletSearchResultEntry;
+export declare class CMDPalletEntitySearchEngine<E> extends CMDPalletSearchEngine<CMDPalletEntitySearchEngineEntry<E>> {
+    private options2;
+    constructor(options2: CMDPalletEntitySearchEngineOptions<E>);
+    getWidget(entry: EntitySearchResultEntry<E>, event: CMDPalletGenerateResultWidgetEvent): React.JSX.Element;
+    doSearch(event: SearchEvent): CMDPalletSearchEngineResult<CMDPalletEntitySearchEngineEntry<E>>;
+    handleSelection(entry: CMDPalletEntitySearchEngineEntry<E>): Promise<any>;
+}
+export interface CommandPalletEntryWidgetWrappedProps {
+    entry: EntitySearchResultEntry;
+    event: CMDPalletGenerateResultWidgetEvent;
+    definition: EntityDefinition;
+    disabled?: boolean;
+}
+export declare const CommandPalletEntryWidgetWrapped: React.FC<React.PropsWithChildren<CommandPalletEntryWidgetWrappedProps>>;

package/dist/@types/cmd-pallet/CMDPalletPreferencesSearchEngine.d.ts

@@ -0,0 +1,15 @@
+import { CMDPalletSearchEngine, CMDPalletSearchEngineResult, CommandPalletSearchResultEntry, PrefsStore } from '../stores';
+import { BooleanSetting, MousePosition } from '../index';
+import { ThemeStore } from '../stores/themes/ThemeStore';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface CMDPalletPreferenceSearchEntry extends CommandPalletSearchResultEntry {
+    preference: BooleanSetting;
+}
+export declare class CMDPalletPreferencesSearchEngine extends CMDPalletSearchEngine<CMDPalletPreferenceSearchEntry> {
+    protected preferencesStore: PrefsStore;
+    protected themeStore: ThemeStore;
+    constructor(preferencesStore: PrefsStore, themeStore: ThemeStore);
+    doSearch(event: SearchEvent): CMDPalletSearchEngineResult<CMDPalletPreferenceSearchEntry>;
+    handleEnter(entry: CMDPalletPreferenceSearchEntry): Promise<boolean>;
+    handleSelection(entry: CMDPalletPreferenceSearchEntry, event: MousePosition): Promise<boolean>;
+}

package/dist/@types/cmd-pallet/CMDPalletProviderSearchEngine.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { CMDPalletGenerateResultWidgetEvent, CMDPalletSearchEngine, CMDPalletSearchEngineResult, CommandPalletSearchResultEntry } from './CMDPalletSearchEngine';
+import { Provider, ProviderSearchResultSerialized, SerializedEntity, ThemeStore } from '../index';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface ProviderSearchEngineOptions<E extends SerializedEntity> {
+    provider: Provider<any, E>;
+    themeStore: ThemeStore;
+    limit?: number;
+}
+export interface ProviderSearchResultEntry<E extends SerializedEntity> extends CommandPalletSearchResultEntry {
+    serialized: E;
+}
+export declare class CMDPalletProviderSearchEngine<E extends SerializedEntity = SerializedEntity> extends CMDPalletSearchEngine<ProviderSearchResultEntry<E>> {
+    protected options2: ProviderSearchEngineOptions<E>;
+    constructor(options2: ProviderSearchEngineOptions<E>);
+    getWidget(entry: ProviderSearchResultSerialized<any, E>, event: CMDPalletGenerateResultWidgetEvent): React.JSX.Element;
+    doSearch(event: SearchEvent): CMDPalletSearchEngineResult<ProviderSearchResultEntry<E>>;
+    handleSelection(entry: ProviderSearchResultEntry<E>): Promise<boolean>;
+}

package/dist/@types/cmd-pallet/CMDPalletSearchEngine.d.ts

@@ -0,0 +1,40 @@
+import { MouseEvent } from 'react';
+import { MousePosition } from '../widgets';
+import { Btn } from '../definitions/common';
+import { SearchEngineInterface, SearchEvent, SearchResult, SearchResultEntry } from '@journeyapps-labs/lib-reactor-search';
+export interface CMDPalletGenerateResultWidgetEvent {
+    key: string;
+    selected: boolean;
+    mouseEntered: () => any;
+    mouseClicked: (event: MouseEvent) => any;
+    ref: React.RefObject<HTMLDivElement>;
+}
+export interface CommandPalletSearchResultEntry extends SearchResultEntry {
+    getWidget: (event: CMDPalletGenerateResultWidgetEvent) => React.JSX.Element;
+    engine: CMDPalletSearchEngine;
+    immediatelyClose?: boolean;
+}
+export interface CMDPalletSearchEngineResultOptions {
+    showMore?: () => any;
+    showMoreText?: string;
+    buttons?: Btn[];
+}
+export declare class CMDPalletSearchEngineResult<T extends CommandPalletSearchResultEntry = CommandPalletSearchResultEntry> extends SearchResult<T> {
+    engine: CMDPalletSearchEngine;
+    options: CMDPalletSearchEngineResultOptions;
+    constructor(engine: CMDPalletSearchEngine<T>, options?: CMDPalletSearchEngineResultOptions);
+    getLimitedResults(): T[];
+}
+export interface CommandPalletSearchEngineOptions {
+    displayName: string;
+    limit?: number | false;
+    priority?: number;
+}
+export declare abstract class CMDPalletSearchEngine<T extends CommandPalletSearchResultEntry = CommandPalletSearchResultEntry> implements SearchEngineInterface<T> {
+    options: CommandPalletSearchEngineOptions;
+    id: string;
+    constructor(options: CommandPalletSearchEngineOptions);
+    abstract doSearch(event: SearchEvent): CMDPalletSearchEngineResult<T>;
+    handleEnter(entry: T, position: MousePosition): Promise<boolean>;
+    abstract handleSelection(entry: T, position: MousePosition): Promise<boolean>;
+}

package/dist/@types/controls/AbstractControl.d.ts

@@ -0,0 +1,15 @@
+import { ComboBoxItem } from '../stores/combo/ComboBoxDirectives';
+import { Btn } from '../definitions/common';
+import { LayoutContext, LayoutContextSize } from '../layout';
+export interface RepresentAsComboBoxItemsEvent {
+    label?: string;
+}
+export interface RepresentAsControlOptions {
+    context?: LayoutContext;
+    size?: LayoutContextSize;
+}
+export interface AbstractControl {
+    representAsBtn(): Btn;
+    representAsControl(options?: RepresentAsControlOptions): React.JSX.Element;
+    representAsComboBoxItems(options?: RepresentAsComboBoxItemsEvent): ComboBoxItem[];
+}

package/dist/@types/controls/AbstractValueControl.d.ts

@@ -0,0 +1,22 @@
+import { BaseListener, BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+import { ComboBoxItem } from '../stores/combo/ComboBoxDirectives';
+import { Btn } from '../definitions/common';
+import { AbstractControl, RepresentAsComboBoxItemsEvent, RepresentAsControlOptions } from './AbstractControl';
+export interface AbstractValueControlListener<Value> extends BaseListener {
+    valueChanged: (value: Value) => any;
+    optionsUpdated?: () => any;
+}
+export interface AbstractValueControlOptions<Value> {
+    initialValue: Value;
+}
+export declare abstract class AbstractValueControl<Value = any, Options extends AbstractValueControlOptions<Value> = AbstractValueControlOptions<Value>> extends BaseObserver<AbstractValueControlListener<Value>> implements AbstractControl {
+    protected options: Options;
+    protected accessor _value: Value;
+    constructor(options: Options);
+    updateOptions(options: Partial<Omit<Options, 'initialValue'>>): void;
+    abstract representAsBtn(): Btn;
+    abstract representAsControl(options?: RepresentAsControlOptions): React.JSX.Element;
+    abstract representAsComboBoxItems(options?: RepresentAsComboBoxItemsEvent): ComboBoxItem[];
+    get value(): Value;
+    set value(value: Value);
+}

package/dist/@types/controls/ActionButtonControl.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { ButtonControl } from './ButtonControl';
+import { RepresentAsControlOptions } from './AbstractControl';
+import { Action } from '../actions/Action';
+import { ValidationResult } from '../actions/validators/ActionValidator';
+import { Btn } from '../definitions/common';
+export type EventType<T> = T extends Action<infer TResult> ? TResult['EVENT'] : never;
+export type E = EventType<Action>;
+export interface ActionButtonControlOptions<T extends Action> {
+    action: T;
+    getEventData?: () => Partial<EventType<T>>;
+}
+export declare class ActionButtonControl<T extends Action> extends ButtonControl {
+    protected options2: ActionButtonControlOptions<T>;
+    constructor(options2: ActionButtonControlOptions<T>);
+    representAsBtn(): Btn;
+    representAsControl(options: RepresentAsControlOptions): React.JSX.Element;
+}
+export interface ActionButtonWidgetProps<T extends Action> {
+    action: T;
+    render: (result: ValidationResult) => React.JSX.Element;
+}
+export declare const ActionButtonWidget: <T extends Action>(props: ActionButtonWidgetProps<T>) => React.JSX.Element;

package/dist/@types/controls/BooleanControl.d.ts

@@ -0,0 +1,23 @@
+import { RepresentAsComboBoxItemsEvent } from './AbstractControl';
+import { ComboBoxItem } from '../stores/combo/ComboBoxDirectives';
+import * as React from 'react';
+import { Btn } from '../definitions/common';
+import { AbstractValueControl } from './AbstractValueControl';
+export interface RepresentAsCheckboxOptions {
+    label?: string;
+    disabled?: boolean;
+}
+export declare class BooleanControl extends AbstractValueControl<boolean> {
+    representAsComboBoxItems(event?: RepresentAsComboBoxItemsEvent): ComboBoxItem[];
+    toggle(): void;
+    representAsControl(): React.JSX.Element;
+    representAsCheckbox(options?: RepresentAsCheckboxOptions): React.JSX.Element;
+    representAsBtn(): Btn;
+}
+export interface BooleanControlWidgetProps {
+    control: BooleanControl;
+    checkbox?: boolean;
+    label?: string;
+    disabled?: boolean;
+}
+export declare const BooleanControlWidget: React.FC<BooleanControlWidgetProps>;

package/dist/@types/controls/ButtonControl.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { AbstractControl, RepresentAsComboBoxItemsEvent, RepresentAsControlOptions } from './AbstractControl';
+import { ComboBoxItem } from '../stores/combo/ComboBoxDirectives';
+import { Btn } from '../definitions/common';
+export interface ButtonControlOptions {
+    btn: Btn | (() => Btn);
+}
+export declare class ButtonControl implements AbstractControl {
+    protected options: ButtonControlOptions;
+    constructor(options: ButtonControlOptions);
+    representAsBtn(): Btn;
+    representAsComboBoxItems(options: RepresentAsComboBoxItemsEvent | undefined): ComboBoxItem[];
+    representAsControl(options: RepresentAsControlOptions): React.JSX.Element;
+}

package/dist/@types/controls/DateControl.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { AbstractValueControl, AbstractValueControlOptions } from './AbstractValueControl';
+import { Btn } from '../definitions/common';
+import { RepresentAsComboBoxItemsEvent, RepresentAsControlOptions } from './AbstractControl';
+import { DateTimePickerType } from '../widgets/forms/dates/DateTimePickerWidget';
+import { ComboBoxItem } from '../stores/index';
+import { ReactorIcon } from '../widgets/index';
+export interface DateControlOptions extends AbstractValueControlOptions<Date> {
+    type: DateTimePickerType;
+}
+export declare class DateControl extends AbstractValueControl<Date, DateControlOptions> {
+    accessor valid: boolean;
+    constructor(options: DateControlOptions);
+    representAsBtn(): Btn;
+    get label(): "Input a time" | "Select a date";
+    get icon(): ReactorIcon;
+    getDateFromDialog(): Promise<Date | null>;
+    representAsComboBoxItems(options: RepresentAsComboBoxItemsEvent | undefined): ComboBoxItem[];
+    representAsControl(options?: RepresentAsControlOptions): React.JSX.Element;
+    get dateControlType(): DateTimePickerType;
+}
+export interface DateControlWidgetProps {
+    control: DateControl;
+}
+export declare const DateControlWidget: React.FC<DateControlWidgetProps>;

package/dist/@types/controls/EntityControl.d.ts

@@ -0,0 +1,23 @@
+import { RepresentAsComboBoxItemsEvent } from './AbstractControl';
+import { ComboBoxItem } from '../stores';
+import { System } from '../core/System';
+import * as React from 'react';
+import { Btn } from '../definitions/common';
+import { AbstractValueControl, AbstractValueControlOptions } from './AbstractValueControl';
+export interface EntityControlOptions<Entity extends any> extends AbstractValueControlOptions<Entity> {
+    entityType: string;
+    parent?: any;
+}
+export declare class EntityControl<Entity = any> extends AbstractValueControl<Entity, EntityControlOptions<Entity>> {
+    accessor system: System;
+    get entityType(): string;
+    get definition(): import("..").EntityDefinition<Entity>;
+    get parent(): any;
+    representAsComboBoxItems(options?: RepresentAsComboBoxItemsEvent): ComboBoxItem[];
+    representAsControl(): React.JSX.Element;
+    representAsBtn(): Btn;
+}
+export interface EntityControlWidgetProps {
+    control: EntityControl;
+}
+export declare const EntityControlWidget: React.FC<EntityControlWidgetProps>;

package/dist/@types/controls/FileControl.d.ts

@@ -0,0 +1,16 @@
+import { RepresentAsComboBoxItemsEvent } from './AbstractControl';
+import { ComboBoxItem } from '../stores';
+import * as React from 'react';
+import { Btn } from '../definitions/common';
+import { ThemeStore } from '../stores/themes/ThemeStore';
+import { AbstractValueControl } from './AbstractValueControl';
+export declare class FileControl extends AbstractValueControl<File> {
+    accessor themeStore: ThemeStore;
+    representAsComboBoxItems(options?: RepresentAsComboBoxItemsEvent): ComboBoxItem[];
+    representAsControl(): React.JSX.Element;
+    representAsBtn(): Btn;
+}
+export interface FileControlWidgetProps {
+    control: FileControl;
+}
+export declare const FileControlWidget: React.FC<FileControlWidgetProps>;

package/dist/@types/controls/SetControl.d.ts

@@ -0,0 +1,34 @@
+import { RepresentAsComboBoxItemsEvent } from './AbstractControl';
+import { ComboBoxItem } from '../stores';
+import * as React from 'react';
+import { ComboBoxStore2 } from '../stores/combo2/ComboBoxStore2';
+import { Btn } from '../definitions/common';
+import { ThemeStore } from '../stores/themes/ThemeStore';
+import { AbstractValueControl, AbstractValueControlOptions } from './AbstractValueControl';
+import { ReactorIcon } from '../widgets/icons/IconWidget';
+import { MousePosition } from '../layers/combo/SmartPositionWidget';
+export interface SetControlOption<T extends string> {
+    key: T;
+    label: string;
+    icon?: ReactorIcon;
+}
+export interface SetControlOptions<T extends string> extends AbstractValueControlOptions<T> {
+    options: SetControlOption<T>[];
+    disabled?: boolean;
+    tooltip?: string;
+}
+export declare class SetControl<T extends string = string> extends AbstractValueControl<T, SetControlOptions<T>> {
+    accessor comboBoxStore: ComboBoxStore2;
+    accessor themeStore: ThemeStore;
+    get tooltip(): string;
+    get disabled(): boolean;
+    representAsComboBoxItems(options?: RepresentAsComboBoxItemsEvent): ComboBoxItem[];
+    select(event: MousePosition): void;
+    getSelectedOption(): SetControlOption<T>;
+    representAsControl(): React.JSX.Element;
+    representAsBtn(): Btn;
+}
+export interface SetControlWidgetProps {
+    control: SetControl;
+}
+export declare const SetControlWidget: React.FC<SetControlWidgetProps>;

package/dist/@types/core/AbstractReactorModule.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@journeyapps-labs/lib-ioc';
+export interface AbstractReactorModuleOptions {
+    name: string;
+}
+export declare abstract class AbstractReactorModule {
+    options: AbstractReactorModuleOptions;
+    constructor(options: AbstractReactorModuleOptions);
+    abstract register(ioc: Container): any;
+    abstract init(ioc: Container): Promise<any>;
+}

package/dist/@types/core/ReactorKernel.d.ts

@@ -0,0 +1,11 @@
+import { AbstractReactorModule } from './AbstractReactorModule';
+import { Logger } from '@journeyapps-labs/lib-reactor-utils';
+export declare class ReactorKernel {
+    logger: Logger;
+    modules: AbstractReactorModule[];
+    constructor();
+    registerModule(module: AbstractReactorModule): void;
+    boot(): Promise<void>;
+    render(): Promise<void>;
+    protected init(): Promise<void>;
+}

package/dist/@types/core/System.d.ts

@@ -0,0 +1,87 @@
+import { Action, ActionEvent, ActionListener, ActionSource } from '../actions/Action';
+import { EntityAction } from '../actions/parameterized/EntityAction';
+import { Provider, SerializedEntity } from '../providers/Provider';
+import { Tracer } from './Tracer';
+import { ParameterizedAction } from '../actions/parameterized/ParameterizedAction';
+import { SystemInterface, SystemListener } from './SystemInterface';
+import { EntityDefinition } from '../entities/EntityDefinition';
+import { BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+import { EncodedEntity } from '../entities/components/encoder/EntityEncoderComponent';
+import { AbstractStore } from '../stores';
+import { ComboBoxStore2 } from '../stores/combo2/ComboBoxStore2';
+import { MousePosition } from '../layers/combo/SmartPositionWidget';
+import { Newable } from '@journeyapps-labs/lib-ioc';
+export interface BaseActionSelectionParameters {
+    event?: MousePosition;
+    source: ActionSource;
+    exclude?: string[];
+    additional?: ParameterizedAction[];
+}
+export interface SerializedActionSelectionParameters extends BaseActionSelectionParameters {
+    /**
+     * Target entity
+     */
+    serializedEntity: SerializedEntity;
+}
+export interface DeserializedActionSelectionParameters extends BaseActionSelectionParameters {
+    /**
+     * Target entity
+     */
+    entity: any;
+    type: string;
+}
+type StartEntityActionSelectionParameters = SerializedActionSelectionParameters | DeserializedActionSelectionParameters;
+export interface BroadcastEvent {
+    event: ActionEvent;
+    action: string;
+}
+export declare class System extends BaseObserver<SystemListener> implements SystemInterface {
+    accessor actions: {
+        [name: string]: Action;
+    };
+    accessor ideName: string;
+    providers: {
+        [type: string]: Provider;
+    };
+    definitions: Map<string, EntityDefinition>;
+    actionListeners: Map<string, () => any>;
+    broadcastChannel: BroadcastChannel;
+    tracer: Tracer;
+    stores: Set<AbstractStore>;
+    accessor comboBoxStore2: ComboBoxStore2;
+    constructor();
+    addStore<T extends AbstractStore>(symbol: Newable<T>, store: T): void;
+    unbindStore<T extends AbstractStore>(symbol: Newable<T>): void;
+    getStores(): AbstractStore[];
+    getEntityDefinitions(): EntityDefinition<any>[];
+    registerDefinition(definition: EntityDefinition): void;
+    getDefinition<T>(type: string): EntityDefinition<T> | null;
+    getDefinitionForEntity<T>(entity: any): EntityDefinition<T> | null;
+    decodeEntity<T>(entity: EncodedEntity): Promise<T>;
+    encodeEntity(entity: any, throws?: boolean): EncodedEntity<{}>;
+    configureTracer(tracer: Tracer): void;
+    broadcast(action: Action, event: ActionEvent): void;
+    startEntityActionSelection(options: StartEntityActionSelectionParameters): Promise<void>;
+    /**
+     * @deprecated
+     */
+    registerProvider(provider: Provider): void;
+    /**
+     * @deprecated
+     */
+    getProvider<P extends Provider>(type: string): P;
+    getActions(): Action<Partial<import("../actions/Action").ActionGenerics>, import("../actions/Action").ActionGenerics & Partial<import("../actions/Action").ActionGenerics>, ActionListener<ActionEvent>>[];
+    unregisterAction(action: Action): void;
+    registerAction(action: Action): void;
+    getActionByID<T extends Action>(id: string): T;
+    getAction<T extends Action>(name: string): T;
+    getActionsForEntityDecoded<T>(options: {
+        entity: T;
+        type: string;
+    }): EntityAction<T>[];
+    /**
+     * @deprecated
+     */
+    getActionsForEntity<T>(entity: SerializedEntity): Promise<EntityAction<T>[]>;
+}
+export {};

package/dist/@types/core/SystemInterface.d.ts

@@ -0,0 +1,18 @@
+import { Action, ActionEvent } from '../actions/Action';
+import { Tracer } from './Tracer';
+import { Provider } from '../providers/Provider';
+import { BaseListener, BaseObserverInterface } from '@journeyapps-labs/lib-reactor-utils';
+export interface SystemListener extends BaseListener {
+    actionWillFire?: (event: {
+        action: Action;
+        event: Partial<ActionEvent>;
+    }) => Promise<any>;
+    actionFired?: (event: {
+        action: Action;
+        event: Partial<ActionEvent>;
+    }) => void;
+}
+export interface SystemInterface extends BaseObserverInterface<SystemListener> {
+    tracer: Tracer;
+    getProvider<P extends Provider>(type: string): P;
+}

package/dist/@types/core/Tracer.d.ts

@@ -0,0 +1,22 @@
+import { ActionEvent, ActionSource } from '../actions/Action';
+export interface UserAction {
+    success: boolean;
+    source: ActionSource;
+    action_id: string;
+    start_timestamp: string;
+    end_timestamp: string;
+    trace_id?: string;
+}
+export declare class ActionTrace {
+    tracer: Tracer;
+    event: ActionEvent;
+    timestamp: Date;
+    trace_id: string;
+    constructor(tracer: Tracer, event: ActionEvent);
+    setTraceID(id: string): void;
+    end(success: boolean): void;
+}
+export declare class Tracer {
+    logAction(action: UserAction): void;
+    createActionTrace(event: ActionEvent): ActionTrace;
+}

package/dist/@types/definitions/common.d.ts

@@ -0,0 +1,34 @@
+import { IconName } from '@fortawesome/fontawesome-svg-core';
+import { Validator } from '../actions/validators/ActionValidatorContext';
+import { MousePosition } from '../layers/combo/SmartPositionWidget';
+import { ReactorIcon } from '../widgets/icons/IconWidget';
+import { TooltipProps } from '../widgets/info/tooltips';
+export interface Panel {
+    name: string;
+    key: string;
+    icon?: IconName;
+}
+export declare const PanelCategory: {
+    readonly IDE: "IDE";
+    readonly MEDIA: "Media";
+};
+export type PanelCategory = typeof PanelCategory;
+export type ButtonActionLegacy = (event: MousePosition, loading?: (loading: boolean) => any) => any;
+export type ButtonActionNew = (event: MousePosition) => Promise<any>;
+export type ButtonAction = ButtonActionNew | ButtonActionLegacy;
+export interface Btn extends TooltipProps {
+    validator?: Validator;
+    icon?: ReactorIcon;
+    action?: ButtonAction;
+    tooltip?: string;
+    label?: string;
+    forwardRef?: React.RefObject<HTMLDivElement>;
+    highlight?: boolean;
+    submitButton?: boolean;
+    disabled?: boolean;
+}
+export interface User {
+    name: string;
+    email: string;
+    online: boolean;
+}

package/dist/@types/entities/EntityDefinition.d.ts

@@ -0,0 +1,73 @@
+import { EntityComboBoxItem, EntitySearchEngineComponent } from './components/search/EntitySearchEngineComponent';
+import { EncodedEntity, EntityEncoderComponent } from './components/encoder/EntityEncoderComponent';
+import { EntityDefinitionComponent } from './EntityDefinitionComponent';
+import { System } from '../core/System';
+import { MousePosition, ReactorIcon } from '../widgets';
+import * as _ from 'lodash';
+import { EntityPresenterComponent } from './components/presenter/EntityPresenterComponent';
+import { EntityHandlerComponent, OpenEntityEvent } from './components/handler/EntityHandlerComponent';
+import { EntityPanelComponent } from './components/ui/EntityPanelComponent';
+import { EntityDescriberComponent, EntityDescription } from './components/meta/EntityDescriberComponent';
+import { EntityDocsComponent } from './components/meta/EntityDocsComponent';
+import { ComboBoxStore2 } from '../stores/combo2/ComboBoxStore2';
+import { SimpleComboBoxDirectiveOptions } from '../stores/combo2/directives/SimpleComboBoxDirective';
+import { ComboBoxDirective } from '../stores/combo2/ComboBoxDirective';
+import { Action } from '../actions';
+import { DescendantEntityProviderComponent } from './components/exposer/DescendantEntityProviderComponent';
+import { ThemeStore } from '../stores/themes/ThemeStore';
+export interface EntityDefinitionOptions {
+    type: string;
+    label: string;
+    category: string;
+    icon: ReactorIcon;
+    iconColor: string;
+}
+export interface EntityPickOptions<T extends any = any> {
+    event?: MousePosition;
+    filter?: (entity: T) => boolean;
+    parent?: any;
+    autoSelectedIsolatedEntity?: boolean;
+}
+export declare abstract class EntityDefinition<T extends any = any> {
+    protected options: EntityDefinitionOptions;
+    components: Set<EntityDefinitionComponent>;
+    system: System;
+    accessor comboBoxStore: ComboBoxStore2;
+    accessor themeStore: ThemeStore;
+    private accessor preferredDescriber;
+    private additionalActionIds;
+    constructor(options: EntityDefinitionOptions);
+    setSystem(system: System): void;
+    registerComponent(component: EntityDefinitionComponent): void;
+    get category(): string;
+    get type(): string;
+    get label(): string;
+    get icon(): ReactorIcon;
+    get iconColorDefault(): string;
+    get iconColor(): string;
+    abstract getEntityUID(t: T): any;
+    abstract matchEntity(t: any): boolean;
+    resolveOneEntity(options?: EntityPickOptions<T>): Promise<T | null>;
+    getComboBoxDirective(options: EntityPickOptions<T>): ComboBoxDirective<EntityComboBoxItem<T>>;
+    getAsComboBoxItem(t: T): EntityComboBoxItem<T>;
+    describeEntity(t: T): EntityDescription;
+    showContextMenuForEntity(entity: T, event: MousePosition, options?: Pick<SimpleComboBoxDirectiveOptions, 'hideSearch'>): void;
+    getActionEventDataForEntity(entity: T, a: Action): {};
+    isActionAllowedForEntity(action: Action, entity: T): boolean;
+    getActionsForEntity(entity: T): Action[];
+    getPreferredDescriber(): EntityDescriberComponent<T>;
+    registerAdditionalAction(actionId: string): void;
+    getDocumenters: (() => EntityDocsComponent<T>[]) & _.MemoizedFunction;
+    getDescribers: (() => EntityDescriberComponent<T>[]) & _.MemoizedFunction;
+    getEncoders: (() => EntityEncoderComponent[]) & _.MemoizedFunction;
+    getSearchEngines: (() => EntitySearchEngineComponent<T>[]) & _.MemoizedFunction;
+    getPresenters: (() => EntityPresenterComponent[]) & _.MemoizedFunction;
+    getHandlers: (() => EntityHandlerComponent[]) & _.MemoizedFunction;
+    getPanelComponents: (() => EntityPanelComponent[]) & _.MemoizedFunction;
+    getExposers: (() => DescendantEntityProviderComponent<T, any>[]) & _.MemoizedFunction;
+    selectEntity(event: OpenEntityEvent<T>): Promise<any>;
+    isMultiSelectable(): boolean;
+    getEncoder: ((version?: number) => EntityEncoderComponent<T>) & _.MemoizedFunction;
+    encode(entity: T, throws?: boolean): EncodedEntity;
+    decode(entity: EncodedEntity): Promise<T>;
+}