import { Action } from '@ngrx/store';
import { ComponentType } from '@angular/cdk/portal';
import { MatDialogConfig } from '@angular/material';
import { IWithIdentifier } from '@digitaix/types';
export declare enum DialogActionTypes {
    OpenDialogWithViewContainer = "[Dialog] Open Dialog With View Container",
    OpenDialog = "[Dialog] Open Dialog",
    CloseDialog = "[Dialog] Close Dialog",
    DialogClosed = "[Dialog] Dialog Closed",
    OpenConfirmationDialog = "[Dialog] Open Confirmation Dialog",
    ConfirmationDialogClosed = "[Dialog] Confirmation Dialog Closed",
    OpenDialogWithActionResult = "[Dialog] OpenDialogWithActionResult"
}
export declare type WithComponentRef<P> = P & {
    componentRef: ComponentType<any>;
};
export interface SimpleDialogContext<D> {
    getTitle?: (row: D) => string;
    [key: string]: any;
}
export interface DialogContextWithDocumentId<D> extends SimpleDialogContext<D> {
    getTitle?: (row: D) => string;
    collectionPath: string;
    documentId: string;
    formId?: string;
}
export interface DialogContextWithDocument<D> extends SimpleDialogContext<D> {
    getTitle?: (row: D) => string;
    document: D;
    formId?: string;
}
export interface DialogContextWithTableId<D, R extends IWithIdentifier> extends SimpleDialogContext<D> {
    tableId: string;
    row: R;
    collectionPath: string;
    formId?: string;
}
export declare type DialogContext<D, R extends IWithIdentifier> = SimpleDialogContext<D> | DialogContextWithDocumentId<D> | DialogContextWithTableId<D, R> | DialogContextWithDocument<D>;
export interface CloseIfDefinition<A extends Action = Action> {
    actionType: string;
    filter?: (action: A) => boolean;
}
export declare type WithCloseIf<P, A extends Action = Action> = {
    /**
     * close the dialog if a action with a defined action-type
     * is dispatch. An optional filter allows further filtering
     */
    closeIf?: CloseIfDefinition<A>;
} & P;
export interface OpenDialogPayloadWithComponentRef<Data> {
    /**
     * componentRef Type of the component to load into the dialog.
     */
    componentRef: ComponentType<any>;
    /**
     * config Extra configuration options.
     */
    config?: MatDialogConfig<Data>;
}
export interface OpenDialogPayloadWithTableId<D, R extends IWithIdentifier> {
    config: MatDialogConfig<DialogContextWithTableId<D, R>>;
}
export declare type OpenDialogWithViewContainerPayload<D, A extends Action = Action, R extends IWithIdentifier = IWithIdentifier> = WithCloseIf<OpenDialogPayloadWithComponentRef<DialogContext<D, R>> | OpenDialogPayloadWithTableId<D, R>>;
export declare type OpenDialogPayload<D, A extends Action = Action> = WithCloseIf<OpenDialogPayloadWithComponentRef<D>, A>;
export declare function isDialogContextWithTableId<D, R extends IWithIdentifier = IWithIdentifier>(context: DialogContext<D, R>): context is DialogContextWithTableId<D, R>;
export declare function isDialogContextWithDocumentId<D, R extends IWithIdentifier = IWithIdentifier>(context: DialogContext<D, R>): context is DialogContextWithDocumentId<D>;
export declare function isDialogContextWithDocument<D, R extends IWithIdentifier = IWithIdentifier>(context: DialogContext<D, R>): context is DialogContextWithDocument<D>;
export declare class OpenDialog<D, A extends Action = Action> implements Action {
    payload: OpenDialogPayload<D, A>;
    tracer?: string;
    readonly type = DialogActionTypes.OpenDialog;
    constructor(payload: OpenDialogPayload<D, A>, tracer?: string);
}
export declare class OpenDialogWithActionResult<D, A extends Action = Action> implements Action {
    payload: OpenDialogPayload<D, A>;
    tracer?: string;
    readonly type = DialogActionTypes.OpenDialogWithActionResult;
    constructor(payload: OpenDialogPayload<D, A>, tracer?: string);
}
/**
 * Opens a modal dialog containing the given component.
 * @param componentOrTemplateRef Type of the component to load into the dialog,
 *     or a TemplateRef to instantiate as the dialog content.
 * @param config Extra configuration options.
 * @param tracer a unique string to trace the dialog. If a tracer is set a DialogClosed
 *     Action with the dialog result will be dispatch after the dialog closed
 */
export declare class OpenDialogWithViewContainer<D, A extends Action = Action> implements Action {
    payload: OpenDialogWithViewContainerPayload<D, A>;
    tracer?: string;
    readonly type = DialogActionTypes.OpenDialogWithViewContainer;
    constructor(payload: OpenDialogWithViewContainerPayload<D, A>, tracer?: string);
}
/**
 * Closed a model dialog
 * @param tracer a unique string to trace a dialog
 */
export declare class CloseDialog implements Action {
    tracer: string;
    readonly type = DialogActionTypes.CloseDialog;
    constructor(tracer: string);
}
/**
 * Dispatch after a model dialog is closed
 * @param result of the closed dialog
 * @param tracer a unique string to trace a dialog
 */
export declare class DialogClosed<T = any> implements Action {
    result: T | null;
    tracer: string;
    readonly type = DialogActionTypes.DialogClosed;
    constructor(result: T | null, tracer: string);
}
export interface ConfirmationDialogContext<YesResult, NoResult> {
    message?: string;
    title?: string;
    yesResult?: YesResult;
    noResult?: NoResult;
}
export declare class OpenConfirmationDialog<YesResult, NoResult> implements Action {
    tracer: string;
    context?: ConfirmationDialogContext<YesResult, NoResult>;
    config?: MatDialogConfig<any>;
    readonly type = DialogActionTypes.OpenConfirmationDialog;
    constructor(tracer: string, context?: ConfirmationDialogContext<YesResult, NoResult>, config?: MatDialogConfig<any>);
}
export declare type DialogActions<D, YesResult, NoResult> = OpenDialogWithViewContainer<D> | CloseDialog | OpenConfirmationDialog<YesResult, NoResult> | DialogClosed;