import { JSX } from 'react';

interface IMountable<TMountPayload = unknown, TUnmountPayload = unknown> {
    mount(payload?: TMountPayload): void;
    unmount(payload?: TUnmountPayload): void;
}

declare abstract class Observer<TPayload = unknown> {
    abstract onNotified(payload: TPayload): void;
}

declare class Publisher<TPayload = unknown, TObserver extends Observer<TPayload> = Observer<TPayload>> {
    private __observers;
    constructor();
    get observersList(): TObserver[];
    notify(payload: TPayload): void;
    subscribe(observer: TObserver): void;
    unsubscribe(observer: TObserver): void;
    removeAllObservers(): void;
    protected _getListOfObservers(_: TPayload): TObserver[];
}

interface IStateObserverPayload<TStateObject extends object, TKey extends keyof TStateObject = keyof TStateObject> {
    key: TKey;
    value: TStateObject[TKey];
}
type StateObserverNotifyFunction<TStateObject extends object, TKey extends keyof TStateObject = keyof TStateObject> = (value: TStateObject[TKey]) => void;
declare class StateObserver<TStateObject extends object, TKey extends keyof TStateObject = keyof TStateObject> extends Observer<IStateObserverPayload<TStateObject, TKey>> {
    private __key;
    private __executeFunction;
    get key(): TKey;
    constructor(key: TKey, executeFunction: StateObserverNotifyFunction<TStateObject, TKey>);
    onNotified(payload: IStateObserverPayload<TStateObject, TKey>): void;
}
declare class StatePublisher<TStateObject extends object> extends Publisher<IStateObserverPayload<TStateObject>, StateObserver<TStateObject>> {
    protected _getListOfObservers(payload: IStateObserverPayload<TStateObject, keyof TStateObject>): StateObserver<TStateObject>[];
}

type ValueFactory<TStateObject, TKey extends keyof TStateObject> = (value: TStateObject[TKey]) => TStateObject[TKey];
declare abstract class AbstractState<TStateObject extends object> implements IMountable {
    private __stateObject;
    private __publisher;
    constructor(initialStateObject: TStateObject);
    protected get stateObject(): TStateObject;
    mount(): void;
    unmount(): void;
    getSnapshot<TKey extends keyof TStateObject>(key: TKey): TStateObject[TKey];
    subscribe<TKey extends keyof TStateObject>(key: TKey, callback: StateObserverNotifyFunction<TStateObject, TKey>): () => void;
    removeAllObservers(): void;
    protected updateStateObject<TKey extends keyof TStateObject>(key: TKey, value: TStateObject[TKey]): void;
    protected updateStateObject<TKey extends keyof TStateObject>(key: TKey, value: ValueFactory<TStateObject, TKey>): void;
}

declare const useSyncState: <TStateObject extends object = object, TState extends AbstractState<TStateObject> = AbstractState<TStateObject>>(state: TState) => <TKey extends keyof TStateObject>(key: TKey) => TStateObject[TKey];

interface IWidgetViewProps<TStateObject extends object, TState extends AbstractState<TStateObject>> extends IMountable {
    state: TState;
}
interface IWidgetCreatePayload<TStateObject extends object, TState extends AbstractState<TStateObject>> {
    state: TState;
}
declare abstract class Widget<TStateObject extends object, TState extends AbstractState<TStateObject>, TWidgetViewProps extends IWidgetViewProps<TStateObject, TState> = IWidgetViewProps<TStateObject, TState>> {
    protected _state: TState;
    constructor(payload: IWidgetCreatePayload<TStateObject, TState>);
    render(): JSX.Element | null;
    protected _mount(): void;
    protected _unmount(): void;
    private __componentMount;
    private __componentUnmount;
    protected _getWidgetViewProps(): TWidgetViewProps;
    protected abstract _getWidget(props: TWidgetViewProps): JSX.Element;
}

declare const useWidgetRegister: (props: IMountable) => void;

export { AbstractState, type IMountable, type IWidgetViewProps, Observer, Publisher, StateObserver, type StateObserverNotifyFunction, StatePublisher, Widget, useSyncState, useWidgetRegister };