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

package/dist/@types/entities/components/ui/widgets/EntityPanelFactory.d.ts

@@ -0,0 +1,65 @@
+import * as React from 'react';
+import { EntityPanelComponent } from '../EntityPanelComponent';
+import { EntityPresenterComponent, SelectEntityListener } from '../../presenter/EntityPresenterComponent';
+import { PanelToolbarButton } from '../../../../widgets/panel/panel/title/PanelTitleToolbarWidget';
+import { BatchStore } from '../../../../stores/batch/BatchStore';
+import { ComboBoxStore2 } from '../../../../stores/combo2/ComboBoxStore2';
+import { ReactorPanelFactory } from '../../../../stores/workspace/react-workspaces/ReactorPanelFactory';
+import { ReactorPanelModel } from '../../../../stores/workspace/react-workspaces/ReactorPanelModel';
+import { RenderTitleBarEvent, WorkspaceModelFactoryEvent, WorkspaceModelListener } from '@projectstorm/react-workspaces-core';
+import { Btn } from '../../../../definitions/common';
+import { System } from '../../../../core/System';
+import { AbstractPresenterContext } from '../../presenter/AbstractPresenterContext';
+export interface EntityPanelModelListener<T extends any = any> extends WorkspaceModelListener, SelectEntityListener<T> {
+    contextGenerated: (context: AbstractPresenterContext<T>) => any;
+}
+export declare class EntityPanelModel<T extends any = any> extends ReactorPanelModel<EntityPanelModelListener<T>> {
+    protected factory: EntityPanelFactory<T>;
+    accessor presenter: string;
+    accessor presenterContext: AbstractPresenterContext<T>;
+    accessor comboBoxStore: ComboBoxStore2;
+    constructor(factory: EntityPanelFactory<T>);
+    setPresenter(key: string): void;
+    getPresenter(): EntityPresenterComponent<T>;
+    selectEntity(entity: T): Promise<void>;
+    get component(): EntityPanelComponent<any>;
+    get definition(): import("../../../EntityDefinition").EntityDefinition<any>;
+    isLoading(): boolean;
+    getElements(): any[];
+    toArray(): {
+        uiState: import("../../presenter/AbstractPresenterContext").SerializedPresenterContext<{}, {}>;
+        presenter: string;
+        _encoded: {};
+        id: string;
+        expandVertical: boolean;
+        expandHorizontal: boolean;
+        type: string;
+        width: number;
+        height: number;
+    };
+    fromArray(payload: ReturnType<this['toArray']>, engine: any): void;
+}
+export declare class EntityPanelFactory<T> extends ReactorPanelFactory<EntityPanelModel<T>> {
+    component: EntityPanelComponent;
+    accessor comboBoxStore: ComboBoxStore2;
+    accessor batchStore: BatchStore;
+    accessor system: System;
+    constructor(component: EntityPanelComponent);
+    matchesModel(newModel: EntityPanelModel<T>, existingModel: EntityPanelModel<T>): boolean;
+    getAdditionalButtons(event: RenderTitleBarEvent<EntityPanelModel<T>>): Btn[];
+    getPresenterSelectionContext(event: WorkspaceModelFactoryEvent<EntityPanelModel>): {
+        name: string;
+        tracking: boolean;
+        onChange: (event2: any) => Promise<void>;
+    };
+    getDescriberSelectionContext(event: WorkspaceModelFactoryEvent<EntityPanelModel>): {
+        name: string;
+        tracking: boolean;
+        onChange: (event2: any) => Promise<void>;
+    };
+    getSelectAllButton(event: WorkspaceModelFactoryEvent<EntityPanelModel>): PanelToolbarButton | null;
+    getSettingButtons(event: WorkspaceModelFactoryEvent<EntityPanelModel>): PanelToolbarButton[];
+    generateToolbar(event: WorkspaceModelFactoryEvent<EntityPanelModel>): React.JSX.Element;
+    protected _generateModel(): EntityPanelModel<T>;
+    protected generatePanelContent(event: WorkspaceModelFactoryEvent<EntityPanelModel<T>>): React.JSX.Element;
+}

package/dist/@types/entities/components/ui/widgets/EntityPanelWidget.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { EntityPanelModel } from './EntityPanelFactory';
+export interface EntityPanelWidgetProps {
+    model: EntityPanelModel;
+}
+export declare const EntityPanelWidget: React.FC<EntityPanelWidgetProps>;

package/dist/@types/entities-reactor/ReactorEntities.d.ts

@@ -0,0 +1,7 @@
+export declare enum ReactorEntities {
+    ACTION = "action",
+    PANEL = "panel"
+}
+export declare enum ReactorEntityCategories {
+    CORE = "Core"
+}

package/dist/@types/entities-reactor/actions/ActionEntityDefinition.d.ts

@@ -0,0 +1,7 @@
+import { EntityDefinition } from '../../entities/EntityDefinition';
+import { Action } from '../../actions';
+export declare class ActionEntityDefinition extends EntityDefinition<Action> {
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: Action): string;
+}

package/dist/@types/entities-reactor/actions/ActionEntityEncoder.d.ts

@@ -0,0 +1,9 @@
+import { EntityEncoderComponent } from '../../entities/components/encoder/EntityEncoderComponent';
+import { Action } from '../../actions';
+export interface EncodedAction {
+    action: string;
+}
+export declare class ActionEntityEncoder extends EntityEncoderComponent<Action, EncodedAction> {
+    doDecode(entity: EncodedAction): Promise<Action>;
+    doEncode(entity: Action): EncodedAction;
+}

package/dist/@types/entities-reactor/actions/ActionEntityHandler.d.ts

@@ -0,0 +1,7 @@
+import { EntityHandlerComponent, OpenEntityEvent } from '../../entities/components/handler/EntityHandlerComponent';
+import { Action } from '../../actions';
+import { ComboBoxItem } from '../../stores';
+export declare class ActionEntityHandler extends EntityHandlerComponent<Action> {
+    openEntity(event: OpenEntityEvent<Action>): Promise<boolean | void>;
+    getDescription(entity: Action): Omit<ComboBoxItem, 'key'>;
+}

package/dist/@types/entities-reactor/actions/ActionSearchEngineComponent.d.ts

@@ -0,0 +1,22 @@
+import { SimpleEntitySearchEngineComponent } from '../../entities/components/search/SimpleEntitySearchEngineComponent';
+import { CMDPalletGenerateResultWidgetEvent, CMDPalletSearchEngine, CommandPalletSearchEngineOptions } from '../../cmd-pallet/CMDPalletSearchEngine';
+import { CMDPalletEntitySearchEngine, CMDPalletEntitySearchEngineEntry, CMDPalletEntitySearchEngineOptions } from '../../cmd-pallet/CMDPalletEntitySearchEngine';
+import { Action } from '../../actions';
+import * as React from 'react';
+import { EntitySearchResultEntry } from '../../entities/components/search/EntitySearchEngineComponent';
+export declare class ActionSearchEngineComponent extends SimpleEntitySearchEngineComponent<Action> {
+    constructor();
+    getCmdPaletteSearchEngine(options?: Omit<CommandPalletSearchEngineOptions, 'displayName'>): CMDPalletSearchEngine;
+}
+export declare class CmdPaletteActionSearchEngine extends CMDPalletEntitySearchEngine<Action> {
+    protected component: ActionSearchEngineComponent;
+    constructor(options: CMDPalletEntitySearchEngineOptions<Action>, component: ActionSearchEngineComponent);
+    handleSelection(entry: CMDPalletEntitySearchEngineEntry<Action>): Promise<any>;
+    getWidget(entry: EntitySearchResultEntry<Action>, event: CMDPalletGenerateResultWidgetEvent): React.JSX.Element;
+}
+export interface ActionCmdPaletteEntryWidgetProps {
+    entry: EntitySearchResultEntry<Action>;
+    event: CMDPalletGenerateResultWidgetEvent;
+    component: ActionSearchEngineComponent;
+}
+export declare const ActionCmdPaletteEntryWidget: React.FC<ActionCmdPaletteEntryWidgetProps>;

package/dist/@types/entities-reactor/actions/ActionTreePresenter.d.ts

@@ -0,0 +1,11 @@
+import { EntityTreePresenterComponent } from '../../entities/components/presenter/types/tree/EntityTreePresenterComponent';
+import { Action } from '../../actions';
+import { EntityTreePresenterContext } from '../../entities/components/presenter/types/tree/presenter-contexts/EntityTreePresenterContext';
+import { ReactorTreeEntity } from '../../widgets';
+export declare class ActionTreePresenterContext extends EntityTreePresenterContext<Action> {
+    doGenerateTreeNode(entity: Action, options: any): ReactorTreeEntity;
+}
+export declare class ActionTreePresenter extends EntityTreePresenterComponent<Action> {
+    constructor();
+    protected _generateContext(): ActionTreePresenterContext;
+}

package/dist/@types/entities-reactor/panels/PanelEntityDefinition.d.ts

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '../../entities/EntityDefinition';
+import { ReactorPanelFactory } from '../../stores/workspace/react-workspaces/ReactorPanelFactory';
+import { WorkspaceStore } from '../../stores';
+export declare class PanelEntityDefinition extends EntityDefinition<ReactorPanelFactory> {
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: ReactorPanelFactory): string;
+}

package/dist/@types/env.d.ts

@@ -0,0 +1,10 @@
+type ENV = {
+    RELEASE: string;
+    USER_EMAIL: string;
+    USER_ID: string;
+    USER_NAME: string;
+    USER_ORG: string;
+    ADMIN_PORTAL_URL: string;
+};
+export declare const ENV: ENV;
+export {};

package/dist/@types/fonts.d.ts

@@ -0,0 +1,2 @@
+import 'balloon-css';
+import 'typeface-source-sans-pro';

package/dist/@types/forms/ColumnsFormModel.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { FormModel } from './FormModel';
+import { FormInput } from './FormInput';
+export declare enum ColumnsFormModelRenderMode {
+    TABLE = "table",
+    DIVISIONS = "divisions"
+}
+export interface ColumnsFormModelOptions {
+    columnWidths?: number[];
+    columnSpacing?: number;
+    mode?: ColumnsFormModelRenderMode;
+}
+export declare class ColumnsFormModel<T = {}> extends FormModel<T> {
+    protected options: ColumnsFormModelOptions;
+    columns: Map<FormInput, number>;
+    constructor(options?: ColumnsFormModelOptions);
+    getMode(): ColumnsFormModelRenderMode;
+    addInput<T extends FormInput>(input: T, column?: number): T;
+    render(): React.JSX.Element;
+}

package/dist/@types/forms/FormInput.d.ts

@@ -0,0 +1,64 @@
+import { BaseListener, BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+import * as React from 'react';
+export interface FormInputOptions<T = any> {
+    label: string;
+    name?: string;
+    required?: boolean;
+    desc?: string;
+    /**
+     * Expressed as markdown
+     */
+    tooltip?: string;
+    value?: T;
+    visible?: boolean;
+    disabled?: boolean;
+}
+export interface FormInputRenderOptions {
+    inline: boolean;
+}
+export interface FormInputListener<T = any> extends BaseListener {
+    valueChanged: (event: {
+        prev_value: T;
+        current_value: T;
+    }) => any;
+    errorChanged: (event: {
+        error: string | null;
+    }) => any;
+    removed: () => any;
+    visibilityChanged: () => any;
+    optionsUpdated: () => any;
+}
+export type SimplifiedFormInputType<T> = FormInput<{
+    VALUE: T;
+    OPTIONS: FormInputOptions<T>;
+    LISTENER: FormInputListener<T>;
+}>;
+export interface FormInputGenerics {
+    OPTIONS: FormInputOptions;
+    LISTENER: FormInputListener;
+    VALUE: any;
+}
+export declare abstract class FormInput<T extends FormInputGenerics = FormInputGenerics> extends BaseObserver<T['LISTENER']> {
+    value: T['VALUE'];
+    private _error;
+    options: T['OPTIONS'];
+    constructor(options: T['OPTIONS']);
+    update(options: Partial<Omit<T['OPTIONS'], 'name' | 'value'>>): void;
+    get valid(): boolean;
+    protected setError(error?: string): void;
+    get error(): string;
+    get visible(): boolean;
+    get label(): string;
+    validate(): void;
+    dispose(): void;
+    remove(): void;
+    setValue(value: T['VALUE']): void;
+    get name(): string;
+    renderInputWidget(options: FormInputRenderOptions): React.JSX.Element;
+    abstract renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}
+export interface FormInputWidgetProps {
+    input: FormInput;
+    children: () => React.JSX.Element;
+}
+export declare const FormInputWidget: React.FC<FormInputWidgetProps>;

package/dist/@types/forms/FormModel.d.ts

@@ -0,0 +1,26 @@
+import { FormInput } from './FormInput';
+import * as React from 'react';
+import { BaseListener, BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+export interface FormEvent {
+    input: FormInput;
+}
+export interface FormModelListener extends BaseListener {
+    valueChanged: (event: FormEvent) => any;
+    errorsChanged: (event: FormEvent) => any;
+}
+export interface RenderOptions {
+    spacing?: number;
+}
+export declare class FormModel<T = {}> extends BaseObserver<FormModelListener> {
+    protected _inputs: Set<FormInput>;
+    constructor();
+    addInput<T extends FormInput>(input: T): T;
+    get inputs(): FormInput<import("./FormInput").FormInputGenerics>[];
+    getVisibleInputs(): FormInput<import("./FormInput").FormInputGenerics>[];
+    setValues(values: Partial<T>): void;
+    getInput<T extends FormInput>(name: string): T;
+    errors(): T;
+    value(): T;
+    isValid(): boolean;
+    render(options?: RenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/controls/BooleanInput.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { FormInputOptions, FormInputRenderOptions } from '../FormInput';
+import { ControlInput, ControlInputGenerics } from './ControlInput';
+export interface BooleanInputOptions extends FormInputOptions {
+    renderWithLabel?: boolean;
+}
+export declare class BooleanInput extends ControlInput<{
+    OPTIONS: BooleanInputOptions;
+} & ControlInputGenerics<boolean>> {
+    constructor(options: BooleanInputOptions);
+    renderInputWidget(options: FormInputRenderOptions): React.JSX.Element;
+}
+export interface BooleanInputWrapperWidgetProps {
+    input: BooleanInput;
+}
+export declare const BooleanInputWrapperWidget: React.FC<BooleanInputWrapperWidgetProps>;

package/dist/@types/forms/controls/ControlInput.d.ts

@@ -0,0 +1,15 @@
+import { FormInput, FormInputGenerics, FormInputListener, FormInputRenderOptions } from '../FormInput';
+import { AbstractValueControl } from '../../controls/AbstractValueControl';
+export interface ControlInputInputListener<T> extends FormInputListener<T> {
+}
+export interface ControlInputGenerics<T = any> extends FormInputGenerics {
+    LISTENER: ControlInputInputListener<T>;
+    VALUE: T;
+}
+export declare class ControlInput<G extends ControlInputGenerics> extends FormInput<G> {
+    control: AbstractValueControl<G['VALUE']>;
+    private valueChangingFromControl;
+    constructor(options: G['OPTIONS'], control: AbstractValueControl<G['VALUE']>);
+    setValue(value: G['VALUE']): void;
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/controls/DateInput.d.ts

@@ -0,0 +1,14 @@
+import { FormInputOptions } from '../FormInput';
+import { ControlInput, ControlInputGenerics } from './ControlInput';
+import { DateTimePickerType } from '../../widgets/forms/dates/DateTimePickerWidget';
+import { IReactionDisposer } from 'mobx';
+export interface DateInputOptions extends FormInputOptions {
+    type: DateTimePickerType;
+}
+export declare class DateInput extends ControlInput<{
+    OPTIONS: DateInputOptions;
+} & ControlInputGenerics<Date>> {
+    reactionDisposer: IReactionDisposer;
+    constructor(options: DateInputOptions);
+    dispose(): void;
+}

package/dist/@types/forms/controls/EntityInput.d.ts

@@ -0,0 +1,12 @@
+import { FormInputOptions } from '../FormInput';
+import { ControlInput, ControlInputGenerics } from './ControlInput';
+export interface EntityInputOptions extends FormInputOptions {
+    entityType: string;
+    value: any;
+    parent?: any;
+}
+export declare class EntityInput extends ControlInput<{
+    OPTIONS: EntityInputOptions;
+} & ControlInputGenerics> {
+    constructor(options: EntityInputOptions);
+}

package/dist/@types/forms/controls/FileInput.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { ControlInput, ControlInputGenerics } from './ControlInput';
+import { FormInputOptions, FormInputRenderOptions } from '../FormInput';
+import { DialogStore } from '../../stores';
+export interface FileInputOptions extends FormInputOptions<File> {
+    allowPaste?: boolean;
+}
+export declare class FileInput extends ControlInput<ControlInputGenerics<File> & {
+    OPTIONS: FileInputOptions;
+}> {
+    accessor dialogStore: DialogStore;
+    constructor(options: FileInputOptions);
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/controls/ImageInput.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { FormInput, FormInputGenerics, FormInputRenderOptions } from '../FormInput';
+import { ImageMedia, MediaEngine } from '../../media-engine';
+interface ImageInputG extends FormInputGenerics {
+    VALUE: ImageMedia;
+}
+export declare class ImageInput extends FormInput<ImageInputG> {
+    accessor mediaEngine: MediaEngine;
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}
+export {};

package/dist/@types/forms/controls/NumberInput.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { FormInput, FormInputGenerics, FormInputOptions, FormInputRenderOptions } from '../FormInput';
+export interface NumberInputOptions extends FormInputOptions<number> {
+    validator?: (value: string) => boolean | string;
+    min?: number;
+    max?: number;
+}
+export declare class NumberInput extends FormInput<{
+    OPTIONS: NumberInputOptions;
+    VALUE: number;
+} & FormInputGenerics> {
+    locked: boolean;
+    accessor interemediateValue: string;
+    constructor(options: NumberInputOptions);
+    validate(): void;
+    setValue(value: number | null): void;
+    setIntermediate(value: string): void;
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/controls/ProviderInput.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { FormInput, FormInputGenerics, FormInputOptions, FormInputRenderOptions } from '../FormInput';
+export interface ProviderInputOptions extends FormInputOptions {
+    entityType: string;
+    value: any;
+}
+/**
+ * @deprecated
+ */
+export declare class ProviderInput extends FormInput<{
+    VALUE: any;
+    OPTIONS: ProviderInputOptions;
+} & FormInputGenerics> {
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/controls/SelectInput.d.ts

@@ -0,0 +1,15 @@
+import { FormInputOptions } from '../FormInput';
+import { ControlInput, ControlInputGenerics } from './ControlInput';
+export interface SelectInputOptions<T extends string = string> extends FormInputOptions {
+    options: Record<T, string>;
+    tooltip?: string;
+}
+export declare class SelectInput<T extends string = string> extends ControlInput<{
+    OPTIONS: SelectInputOptions<T>;
+} & ControlInputGenerics<T>> {
+    constructor(options: SelectInputOptions<T>);
+    getOptions(): {
+        key: string;
+        label: any;
+    }[];
+}

package/dist/@types/forms/controls/collection/ArrayInput.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { FormInput, FormInputGenerics, FormInputListener, FormInputOptions, FormInputRenderOptions } from '../../FormInput';
+export interface ArrayInputOptions<T> extends FormInputOptions<T[]> {
+    generate: () => FormInput;
+}
+export interface ArrayInputListener extends FormInputListener {
+    loadingChanged: () => any;
+}
+export interface ArrayInputGenerics<T> extends FormInputGenerics {
+    VALUE: T[];
+    OPTIONS: ArrayInputOptions<T>;
+    LISTENER: ArrayInputListener;
+}
+export declare class ArrayInput<T> extends FormInput<ArrayInputGenerics<T>> {
+    entries: Map<string, FormInput>;
+    entryListeners: Set<() => any>;
+    loading: boolean;
+    constructor(options: ArrayInputOptions<T>);
+    setLoading(loading?: boolean): void;
+    setValue(values: ArrayInputGenerics<T>['VALUE']): void;
+    protected updateValue(): void;
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}
+export interface ArrayInputWidgetProps {
+    input: ArrayInput<any>;
+}
+export declare const ArrayInputWidget: React.FC<ArrayInputWidgetProps>;

package/dist/@types/forms/controls/collection/ArraySetInput.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import { FormInput, FormInputGenerics, FormInputListener, FormInputOptions, FormInputRenderOptions } from '../../FormInput';
+import { ComboBoxItem } from '../../../stores/combo/ComboBoxDirectives';
+import { Btn } from '../../../definitions/common';
+export interface ArraySetInputOptions<T> extends FormInputOptions<{
+    [key: string]: T;
+}> {
+    generate: (key: string) => FormInput;
+    entries: ComboBoxItem[];
+    addbutton?: Partial<Btn>;
+    layout?: {
+        scrollLength: number;
+    };
+}
+export interface ArraySetInputListener extends FormInputListener {
+    loadingChanged: () => any;
+}
+export interface ArraySetInputGenerics<T> extends FormInputGenerics {
+    VALUE: {
+        [key: string]: T;
+    };
+    OPTIONS: ArraySetInputOptions<T>;
+    LISTENER: ArraySetInputListener;
+}
+export declare class ArraySetInput<T> extends FormInput<ArraySetInputGenerics<T>> {
+    entries: Map<string, FormInput>;
+    entryListeners: Map<string, () => any>;
+    loading: boolean;
+    constructor(options: ArraySetInputOptions<T>);
+    setLoading(loading?: boolean): void;
+    setValue(value: ArraySetInputGenerics<T>['VALUE']): void;
+    protected updateValue(): void;
+    availableEntries(): ComboBoxItem[];
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}
+export interface ArraySetInputWidgetProps {
+    input: ArraySetInput<any>;
+}
+export declare const ArraySetInputWidget: React.FC<ArraySetInputWidgetProps>;
+export declare const ArraySetInputEntryWidget: React.FC<React.PropsWithChildren<{
+    label: string;
+    input: FormInput;
+    remove: () => any;
+}>>;

package/dist/@types/forms/controls/collection/GroupInput.d.ts

@@ -0,0 +1,30 @@
+import { FormInput, FormInputGenerics, FormInputOptions, FormInputRenderOptions, SimplifiedFormInputType } from '../../FormInput';
+import * as React from 'react';
+export interface GroupInputOptions<T extends {}> extends FormInputOptions<T> {
+    inputs?: FormInput[];
+    layout?: {
+        horizontal: boolean;
+        border: boolean;
+    };
+}
+export interface GroupInputGenerics<T> extends FormInputGenerics {
+    OPTIONS: GroupInputOptions<T>;
+    VALUE: T;
+}
+export declare class GroupInput<T = {}> extends FormInput<GroupInputGenerics<T>> {
+    disposeListeners: () => any;
+    private setValueLock;
+    inputs: FormInput[];
+    constructor(options: GroupInputOptions<T>);
+    protected setInputs(inputs: FormInput[]): void;
+    getInput<T extends FormInput>(input: string): T;
+    getInput<K extends keyof T, C extends SimplifiedFormInputType<T[K]>>(input: K): C;
+    setValue(value: GroupInputGenerics<T>['VALUE']): void;
+    dispose(): void;
+    renderInputWidget(options: FormInputRenderOptions): React.JSX.Element;
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}
+export interface GroupWidgetProps {
+    input: GroupInput<any>;
+}
+export declare const GroupWidget: React.FC<GroupWidgetProps>;

package/dist/@types/forms/controls/text/AbstractTextInput.d.ts

@@ -0,0 +1,11 @@
+import { FormInput, FormInputGenerics, FormInputOptions } from '../../FormInput';
+export interface AbstractTextInputOptions extends FormInputOptions<string> {
+    validator?: (value: string) => boolean | string;
+}
+export interface TextInputFormGenerics extends FormInputGenerics {
+    OPTIONS: AbstractTextInputOptions;
+    VALUE: string;
+}
+export declare abstract class AbstractTextInput<Generics extends TextInputFormGenerics = TextInputFormGenerics> extends FormInput<Generics> {
+    setValue(value: string | null): void;
+}

package/dist/@types/forms/controls/text/TextAreaInput.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { FormInputRenderOptions } from '../../FormInput';
+import { AbstractTextInput } from './AbstractTextInput';
+export declare class TextAreaInput extends AbstractTextInput {
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/controls/text/TextInput.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { FormInputRenderOptions } from '../../FormInput';
+import { AbstractTextInput, AbstractTextInputOptions, TextInputFormGenerics } from './AbstractTextInput';
+export declare enum TextInputType {
+    TEXT = "text",
+    PASSWORD = "password"
+}
+export interface TextInputOptions extends AbstractTextInputOptions {
+    inputType?: TextInputType;
+}
+export declare class TextInput extends AbstractTextInput<{
+    OPTIONS: TextInputOptions;
+} & TextInputFormGenerics> {
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

package/dist/@types/forms/index.d.ts

@@ -0,0 +1,16 @@
+export * from './ColumnsFormModel';
+export * from './controls/BooleanInput';
+export * from './controls/collection/ArrayInput';
+export * from './controls/collection/ArraySetInput';
+export * from './controls/collection/GroupInput';
+export * from './controls/DateInput';
+export * from './controls/EntityInput';
+export * from './controls/FileInput';
+export * from './controls/ImageInput';
+export * from './controls/NumberInput';
+export * from './controls/ProviderInput';
+export * from './controls/SelectInput';
+export * from './controls/text/TextAreaInput';
+export * from './controls/text/TextInput';
+export * from './FormInput';
+export * from './FormModel';

package/dist/@types/hooks/useButton.d.ts

@@ -0,0 +1,23 @@
+import { Btn } from '../definitions/common';
+import { MousePosition } from '../layers/combo/SmartPositionWidget';
+import { ButtonComponentSelection } from '../stores/guide/selections/common';
+import { ReactorIcon } from '../widgets/icons/IconWidget';
+export interface UseButtonProps {
+    btn: Btn;
+    forwardRef?: React.RefObject<HTMLDivElement>;
+}
+export declare const useButton: (props: UseButtonProps) => {
+    border: string;
+    attention: import("..").ComponentSelection<ButtonComponentSelection, import("..").ComponentSelectionListener>;
+    onClick: (event: MousePosition) => Promise<void>;
+    loading: boolean;
+    disabled: boolean;
+    tooltip: string;
+    icon: {
+        icon: ReactorIcon;
+        spin: boolean;
+        color?: string;
+    };
+    ref: import("react").RefObject<any>;
+    validationResult: import("../actions/validators/ActionValidator").ValidationResult;
+};

package/dist/@types/hooks/useCopyButton.d.ts

@@ -0,0 +1,5 @@
+import { Btn } from '../definitions/common';
+export interface UseCopyButtonProps {
+    value: string;
+}
+export declare const useCopyButton: (props: UseCopyButtonProps) => Partial<Btn>;

package/dist/@types/hooks/useDisplayDateOptions.d.ts

@@ -0,0 +1,2 @@
+import { DateDisplayWidgetProps } from '../widgets';
+export declare const useDisplayDateOptions: () => Omit<DateDisplayWidgetProps, "date">;

package/dist/@types/hooks/useForceUpdate.d.ts

@@ -0,0 +1,3 @@
+export declare function useForceUpdate(): (props?: {
+    defer?: boolean;
+}) => void;