import { ITransactionOperation } from './Transactions';
import { Observable } from 'rxjs';
export interface IWizardStepSource<T, Params> {
    load(params: Params): Promise<T>;
}
export declare class WizardStepSource<T, Params> implements IWizardStepSource<T, Params> {
    private readonly inner;
    constructor(inner: (params: Params) => Promise<T>);
    load(params: Params): Promise<T>;
}
export interface UpdateWizardState {
    property: string;
    value: any;
    previous: any;
}
export interface IWizardStep<Params = any> {
    reset(): void;
    resetState(params: Params): Promise<void>;
    buildOperation(wizard: IWizard): ITransactionOperation;
    isDirty(): boolean;
    changes$: Observable<UpdateWizardState[]>;
    initialized$: Observable<boolean>;
    key: string;
}
export interface WizardStepOptions<Model, Params> {
    key: string;
    source: IWizardStepSource<Model, Params>;
    defaultValue: Model;
    operation: IWizardOperation<Model, Params>;
}
export interface IWizardOperationContext<Model, Params> {
    values: Partial<Model>;
    changes: UpdateWizardState[];
    current: Model;
    wizard: IWizard;
    params: Params;
}
export interface IWizardOperation<Model, Params> {
    execute(context: IWizardOperationContext<Model, Params>): Promise<void>;
}
export declare class WizardStep<Model extends object = any, Params = any> implements IWizardStep<Params> {
    private readonly options;
    private readonly current;
    private readonly initialized;
    private readonly previous;
    constructor(options: WizardStepOptions<Model, Params>);
    get key(): string;
    get changes$(): Observable<UpdateWizardState[]>;
    get initialized$(): Observable<boolean>;
    get model(): Model;
    get previousModel(): Model | undefined;
    rollbackToPrevious(): void;
    save(value: Model): void;
    resetState(params: Params): Promise<void>;
    buildOperation(wizard: IWizard): ITransactionOperation;
    isDirty(): boolean;
    resolveChanges(): UpdateWizardState[];
    createPatchModel(): Partial<Model>;
    reset(): void;
}
export interface IWizard {
    steps: IWizardStep[];
}
export declare class Wizard<State, Params> implements IWizard {
    readonly steps: IWizardStep<Params>[];
    private readonly current;
    private readonly isStarted;
    private readonly params;
    constructor(steps: IWizardStep<Params>[]);
    start(params: Params): Promise<void>;
    selectStep(key: keyof State): void;
    findStep(key: keyof State): IWizardStep<Params> | undefined;
    get params$(): Observable<Params | undefined>;
    get current$(): Observable<IWizardStep<Params> | undefined>;
    get initialized$(): Observable<boolean>;
    get isStarted$(): Observable<boolean>;
    commit(): Promise<void>;
    commitStep(key: keyof State): Promise<void>;
    resetAll(): void;
    updateParams(params: Params): void;
    save(): Promise<void>;
}
export declare function diffState<T extends object>(a: T, b: T): UpdateWizardState[];
declare type CreateWizardExpression<State, Params> = {
    [Property in keyof State]: WizardStepOptions<State[Property], Params>;
} & {
    onStart?: (params: Params) => Promise<void>;
};
export declare function createWizard<State, Params>(expression: CreateWizardExpression<State, Params>): Wizard<State, Params>;
export {};