import { SqlExpression } from 'druid-query-toolkit';
import type { ExpressionMeta } from './models';
import type { Parameter, ParameterDefinitions, ParameterTypes, TypedParameter } from './parameter';
import type { ParametersToParams, VisualModule, VisualModuleContext, VisualModuleInstance } from './visual-module';
type ParameterOverrides<Type extends keyof ParameterTypes> = {
    [K in Exclude<keyof TypedParameter<Type>, 'type'>]?: Partial<TypedParameter<Type>[K]>;
};
export interface VisualModuleOverrides<P extends ParameterDefinitions> {
    parameters?: {
        [Name in keyof P]?: ParameterOverrides<P[Name]['type']>;
    };
    parameterOrder?: (keyof P)[];
    table?: string;
    where?: SqlExpression | string;
    having?: SqlExpression | string;
    onUpdate?(updateEvent: UpdateEvent<ParametersToParams<P>>, context: VisualModuleContext<ParametersToParams<P>>): void;
}
export interface RegisteredVisualModule {
    moduleName: string;
    parameters?: ParameterDefinitions;
    parameterOrder?: string[];
    (context: VisualModuleContext<Record<string, unknown>>): VisualModuleInstance<Record<string, unknown>>;
}
export interface UpdateEvent<Params> {
    params: Params;
    table: SqlExpression;
    where: SqlExpression;
    having?: SqlExpression;
}
export interface ModuleState {
    params: Record<string, unknown>;
    table: SqlExpression | undefined;
    where: SqlExpression | undefined;
    having?: SqlExpression | undefined;
}
export type TransferValue = [type: Parameter['type'], value: unknown];
export interface HostState {
    table: SqlExpression;
    columns?: ExpressionMeta[];
    where: SqlExpression;
    having?: SqlExpression;
    transferState: Record<string, TransferValue>;
    visualModules?: Record<string, RegisteredVisualModule | undefined>;
    visualModuleState: Record<string, ModuleState | undefined>;
    getModuleParams<P extends ParameterDefinitions>(moduleName: string): ParametersToParams<P>;
    getUpdateEvent<P extends ParameterDefinitions>(moduleName: string): UpdateEvent<ParametersToParams<P>>;
    registerModule<P extends ParameterDefinitions>(name: string, module: VisualModule<P>, overrides?: VisualModuleOverrides<P>): void;
    removeModule(name: string): void;
    setModuleParams<P extends Record<string, unknown>>(moduleName: string, params: Partial<P> | ((prev: P | undefined) => Partial<P>)): void;
    setModuleTable(moduleName: string, table: SqlExpression | undefined): void;
    setModuleWhere(moduleName: string, where: SqlExpression | undefined): void;
    setModuleHaving(moduleName: string, having: SqlExpression | undefined): void;
}
export interface StateStorage {
    getItem: (name: string) => any | null;
    setItem: (name: string, value: any) => void;
    removeItem: (name: string) => void;
}
export interface HostStorePersistOptions {
    name?: string;
    storage: 'localstorage' | 'sessionstorage' | 'url' | StateStorage;
}
export interface HostStoreOptions {
    persist?: HostStorePersistOptions;
    table: SqlExpression;
    where?: SqlExpression | string;
    having?: SqlExpression | string;
}
export declare function createHostStore(options: HostStoreOptions): import("zustand").StoreApi<HostState>;
export {};
//# sourceMappingURL=host-store.d.ts.map