import { Result } from 'ts-results';
import { SanitizedMovexClient, MovexMasterContext } from 'movex-core-util';
import type { IObservable, MovexClient, NextStateGetter, ResourceIdentifier, CheckedState, AnyAction, ToCheckedAction, ToPrivateAction, ToPublicAction, MovexReducer } from 'movex-core-util';
import { DispatchedEventPayload, DispatchPublicFn } from './dispatch';
type ObservedItem<TState> = {
    subscribers: Record<MovexClient['id'], SanitizedMovexClient>;
    checkedState: CheckedState<TState>;
};
/**
 * This is the MovexResource running on the Client
 */
export declare class MovexResourceObservable<TState = any, TAction extends AnyAction = AnyAction> implements IObservable<ObservedItem<TState>> {
    private clientId;
    rid: ResourceIdentifier<string>;
    private reducer;
    /**
     * This flag informs that the resource (client) is in sync with the master.
     * It starts as false and it waits for at least one "sync" or "update" call.
     *
     * For now it never goes from true to false but that could be a valid use case in the future.
     */
    private isSynchedPromiseDelegate;
    private $item;
    private pubsy;
    private dispatcher;
    private unsubscribers;
    constructor(clientId: MovexClient['id'], rid: ResourceIdentifier<string>, reducer: MovexReducer<TState, TAction>, initialSubscribers?: Record<MovexClient['id'], SanitizedMovexClient>, initialCheckedState?: CheckedState<TState>);
    /**
     * This is the dispatch for this Movex Resource
     */
    dispatch(...args: Parameters<DispatchPublicFn<TAction>>): void;
    dispatchPrivate(privateAction: ToPrivateAction<TAction>, publicAction: ToPublicAction<TAction>): void;
    applyMultipleActions(actions: ToPublicAction<TAction>[]): ObservedItem<TState>;
    /**
     * Same as applyAction() except it fails on mismatching checksums
     *
     * @param actionOrActionTuple
     * @param expectedNextChecksum
     * @returns
     */
    reconciliateAction(checkedAction: ToCheckedAction<TAction>, masterContext: MovexMasterContext): Result<CheckedState<TState>, 'ChecksumMismatch'>;
    private getNextCheckedStateFromAction;
    private computeNextState;
    /**
     * Subscribe to State updates
     *
     * @param fn
     * @returns
     */
    onUpdate(fn: (p: {
        subscribers: Record<MovexClient['id'], SanitizedMovexClient>;
        checkedState: CheckedState<TState>;
    }) => void): () => void;
    onDispatched(fn: (event: DispatchedEventPayload<CheckedState<TState>, TAction>) => void): () => void;
    get(): ObservedItem<TState>;
    getCheckedState(): CheckedState<TState>;
    getUnwrappedState(): TState;
    /**
     * This needs to be called each time master emits an updated state.
     * The dispatch won't work without it being called at least once.
     *
     * @param nextStateGetter
     * @returns
     */
    syncState(nextStateGetter: NextStateGetter<CheckedState<TState>>): void;
    setUnsync(): void;
    /**
     * If set to false it doesn't wait for the master state to be synced
     * Good for tests at least. If not for anythign else, need to rethink it.
     *
     * @param flag
     */
    setMasterSyncing(flag: boolean): void;
    update(nextStateGetter: NextStateGetter<ObservedItem<TState>>): void;
    private updateCheckedState;
    updateUnwrappedState(nextStateGetter: NextStateGetter<TState>): void;
    updateSubscribers(nextStateGetter: NextStateGetter<ObservedItem<TState>['subscribers']>): void;
    applyStateTransformer(masterContext: MovexMasterContext): CheckedState<TState>;
    private applyStateTransformerToCheckedState;
    applyStateTransformerToCheckedStateAndUpdate(checkedState: CheckedState<TState>, masterContext: MovexMasterContext): CheckedState<TState>;
    destroy(): void;
}
export {};