import { Bloc } from "./bloc";
import { TemplateResult } from "../template";
import { OtherBlocSearchCriteria } from "./blocs-provider";
import { BaseBlocsHTMLElement } from '../base';
export interface BuildWhenFunction<S> {
    (previousState: S, newState: S): boolean;
}
export interface BlocBuilderConfig<S> {
    buildWhen?: BuildWhenFunction<S>;
    otherSearchCriteria?: OtherBlocSearchCriteria;
    blocs_map?: Record<string, Bloc<any>>;
}
export declare abstract class BlocBuilder<B extends Bloc<S>, S> extends BaseBlocsHTMLElement {
    private _bloc;
    private _subscriptionId;
    private _prevState;
    protected nameOfBlocToSearch: string;
    get blocName(): string;
    static stateChangeBuildWhenFunction<S>(preState: S, newState: S): boolean;
    private _blocBuilderConfig;
    get blocbuilderconfig(): BlocBuilderConfig<S>;
    set blocbuilderconfig(bConfig: BlocBuilderConfig<S>);
    /**
     *
     * @param nameOfBlocToSearch Either provide this or provide bloc attribute
     * @param configs
     */
    constructor(nameOfBlocToSearch?: string, configs?: BlocBuilderConfig<S>);
    get bloc(): B | undefined;
    get state(): S | undefined;
    protected connectedCallback(): void;
    getBloc<B extends Bloc<any>>(bn: string): B | undefined;
    _initialize(): void;
    disconnectedCallback(): void;
    _build(state: S): void;
    abstract builder(state: S): TemplateResult | undefined;
}
export declare abstract class MultiBlocsReactiveWidget<S> extends BaseBlocsHTMLElement {
    protected config: {
        blocs_map: Record<string, Bloc<any>>;
        subscribed_blocs: string[];
    };
    protected found_blocs: Record<string, Bloc<any>>;
    protected state?: S;
    protected subscribed_states: Record<string, any>;
    private listener_ids;
    get blocsMap(): Record<string, Bloc<any>>;
    getBloc<B extends Bloc<any>>(blocName: string): B;
    constructor(config: {
        blocs_map: Record<string, Bloc<any>>;
        subscribed_blocs: string[];
    });
    connectedCallback(): void;
    disconnectedCallback(): void;
    abstract convertSubscribedStatesToReactiveState(subscribed_states?: Record<string, any>): S | undefined;
    protected build_when(prev_state?: S, new_state?: S): boolean;
    abstract build(state?: S): TemplateResult | undefined;
    protected _build(): void;
}