import { ConvertActionHelpers } from "./action";
import { GetContainer } from "./container";
import { NyaxContext } from "./context";
import { Effects } from "./effect";
import { Reducers } from "./reducer";
import { ConvertGetters, Selectors } from "./selector";
import { ConvertState, InitialState } from "./state";
import { Nyax } from "./store";
import { Subscriptions } from "./subscription";
import { Resolved, UnionToIntersection } from "./util";
export interface Model<TDependencies = unknown, TInitialState = {}, TSelectors = {}, TReducers = {}, TEffects = {}, TSubscriptions = {}> {
    initialState(): TInitialState;
    selectors(): TSelectors;
    reducers(): TReducers;
    effects(): TEffects;
    subscriptions(): TSubscriptions;
    dependencies: TDependencies;
    state: ConvertState<ReturnType<this["initialState"]>>;
    getters: ConvertGetters<ReturnType<this["selectors"]>>;
    actions: ConvertActionHelpers<ReturnType<this["reducers"]>, ReturnType<this["effects"]>>;
    namespace: string;
    key: string | undefined;
    getContainer: GetContainer;
    nyax: Nyax;
}
export declare type ModelClass<TDependencies = unknown, TInitialState = {}, TSelectors = {}, TReducers = {}, TEffects = {}, TSubscriptions = {}> = new (...args: any[]) => Model<TDependencies, TInitialState, TSelectors, TReducers, TEffects, TSubscriptions>;
export interface NamespacedModelClass<TDependencies = unknown, TInitialState = {}, TSelectors = {}, TReducers = {}, TEffects = {}, TSubscriptions = {}, TDynamic = boolean> extends ModelClass<TDependencies, TInitialState, TSelectors, TReducers, TEffects, TSubscriptions> {
    namespace: string;
    isDynamic: TDynamic;
}
export declare type ModelPropertyKey = "initialState" | "selectors" | "reducers" | "effects" | "subscriptions";
export declare type ExtractModelProperty<TModelClass extends ModelClass, TPropertyKey extends ModelPropertyKey> = ReturnType<InstanceType<TModelClass>[TPropertyKey]>;
export declare type ExtractModelDependencies<TModelClass extends ModelClass> = InstanceType<TModelClass>["dependencies"];
export declare type MergeModelsProperty<TModelClasses extends ModelClass[], TPropertyKey extends ModelPropertyKey> = Resolved<UnionToIntersection<{
    [K in keyof TModelClasses & number]: ExtractModelProperty<TModelClasses[K], TPropertyKey>;
}[number]>>;
export declare type MergeSubModelsProperty<TSubModelClasses extends Record<string, ModelClass>, TPropertyKey extends ModelPropertyKey> = Resolved<{
    [K in keyof TSubModelClasses]: ExtractModelProperty<TSubModelClasses[K], TPropertyKey>;
}>;
export declare type MergeModelsDependencies<TModelClasses extends ModelClass[]> = UnionToIntersection<{
    [K in keyof TModelClasses & number]: InstanceType<TModelClasses[K]>["dependencies"];
}[number]>;
export declare type MergeSubModelsDependencies<TSubModelClasses extends Record<string, ModelClass>> = UnionToIntersection<{
    [K in keyof TSubModelClasses]: InstanceType<TSubModelClasses[K]>["dependencies"];
}[keyof TSubModelClasses]>;
export declare class ModelBase<TDependencies = unknown> implements Model<TDependencies, {}, {}, {}, {}, {}> {
    protected readonly __nyax_container: {
        nyax: Nyax;
        namespace: string;
        key: string | undefined;
        state: any;
        getters: any;
        actions: any;
    };
    initialState(): any;
    selectors(): any;
    reducers(): any;
    effects(): any;
    subscriptions(): any;
    constructor(__nyax_container: {
        nyax: Nyax;
        namespace: string;
        key: string | undefined;
        state: any;
        getters: any;
        actions: any;
    });
    get state(): any;
    get getters(): any;
    get actions(): any;
    get dependencies(): any;
    get namespace(): any;
    get key(): any;
    get getContainer(): any;
    get nyax(): any;
}
export declare function mergeModelClasses<TModelClasses extends ModelClass[] | [ModelClass]>(...modelClasses: TModelClasses): ModelClass<MergeModelsDependencies<TModelClasses>, MergeModelsProperty<TModelClasses, "initialState">, MergeModelsProperty<TModelClasses, "selectors">, MergeModelsProperty<TModelClasses, "reducers">, MergeModelsProperty<TModelClasses, "effects">, MergeModelsProperty<TModelClasses, "subscriptions">>;
export declare function mergeSubModelClasses<TSubModelClasses extends Record<string, ModelClass>>(subModelClasses: TSubModelClasses): ModelClass<MergeSubModelsDependencies<TSubModelClasses>, MergeSubModelsProperty<TSubModelClasses, "initialState">, MergeSubModelsProperty<TSubModelClasses, "selectors">, MergeSubModelsProperty<TSubModelClasses, "reducers">, MergeSubModelsProperty<TSubModelClasses, "effects">, MergeSubModelsProperty<TSubModelClasses, "subscriptions">>;
export declare function createBaseModelClass<TDependencies>(): ModelClass<TDependencies, {}, {}, {}, {}, {}>;
export declare function defineModel<TDependencies, TInitialState extends InitialState, TSelectors extends Selectors, TReducers extends Reducers, TEffects extends Effects, TSubscriptions extends Subscriptions, TDynamic extends boolean = false>(namespace: string, modelClass: ModelClass<TDependencies, TInitialState, TSelectors, TReducers, TEffects, TSubscriptions>, isDynamic?: TDynamic): NamespacedModelClass<TDependencies, TInitialState, TSelectors, TReducers, TEffects, TSubscriptions, TDynamic>;
export declare type RegisterModelClasses = (...modelClasses: NamespacedModelClass[]) => void;
export declare function createRegisterModelClasses(nyaxContext: NyaxContext): RegisterModelClasses;