import * as i0 from '@angular/core';
import { InjectionToken, OnInit, EnvironmentProviders, Provider, TemplateRef, AfterViewInit, Injector } from '@angular/core';
import { LuTranslation } from '@lucca-front/ng/core';
import { AutoFocusTarget, DialogConfig, DialogRef } from '@angular/cdk/dialog';
import { ComponentType } from '@angular/cdk/overlay';
import { Observable, Subscription } from 'rxjs';
import { Route, CanDeactivateFn, DeprecatedGuard, Router, ActivatedRoute } from '@angular/router';

declare class DialogContentComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContentComponent, "lu-dialog-content", never, {}, {}, never, ["*"], true, never>;
}

declare class DialogFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFooterComponent, "lu-dialog-footer", never, {}, {}, never, ["*"], true, never>;
}

declare const LU_DIALOG_HEADER_TRANSLATIONS: InjectionToken<LuTranslation<LuDialogHeaderTranslations>>;
interface LuDialogHeaderTranslations {
    close: string;
}
declare const luDialogHeaderTranslations: LuTranslation<LuDialogHeaderTranslations>;

declare class DialogHeaderAction {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderAction, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogHeaderAction, "[dialogHeaderAction]", never, {}, {}, never, never, true, never>;
}
declare class DialogHeaderComponent implements OnInit {
    #private;
    intl: LuDialogHeaderTranslations;
    dismissible: boolean;
    close(): void;
    optionalAction: i0.Signal<DialogHeaderAction>;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "lu-dialog-header", never, {}, {}, ["optionalAction"], ["[dialogHeaderAction]", "*"], true, never>;
}

declare function configureLuDialog(): EnvironmentProviders;
declare function provideLuDialog(): Provider;

declare const ɵdialogData: unique symbol;
declare const ɵdialogResult: unique symbol;
type ɵDialogDataFlag = {
    [ɵdialogData]: unknown;
};
type ɵDialogResultFlag<R> = {
    [ɵdialogResult]: R;
};
type LuDialogData<T> = {
    [K in keyof T]: T[K] extends ɵDialogDataFlag ? Omit<T[K], typeof ɵdialogData> : never;
}[keyof T];
type DialogRefProps<C> = {
    [K in keyof C]: C[K] extends ɵDialogResultFlag<unknown> ? K : never;
}[keyof C] & keyof C;
type LuDialogResult<C> = DialogRefProps<C> extends never ? void : C[DialogRefProps<C>] extends ɵDialogResultFlag<infer T> ? T : void;
interface BaseLuDialogConfig<C, TData = LuDialogData<C>> {
    /**
     * The component or template to put inside the dialog container
     */
    content: ComponentType<C> | TemplateRef<C>;
    /**
     * Data to pass to the component, will be required if the component used `injectDialogData` in a field, specifying the data that's needed.
     */
    data: TData;
    /**
     * Should we put a backdrop? Defaults to true
     */
    modal?: boolean;
    /**
     * Is this dialog a blocking popup that cannot be dismissed ?
     *
     * Defaults to false, setting this to true will also remove the close button in the header
     * if you're using `lu-dialog-header`.
     */
    alert?: boolean;
    /**
     * Can be used if you don't have a header or aren't using the default one, to set an aria-label
     * instead of aria-labelledby on the dialog container
     */
    ariaLabel?: string;
    /**
     * Autofocus target
     *
     * Defaults to the close button from the header, first-input is added by us to focus the first available input
     * or the first input that is contained inside a node that has the `.luDialog-autofocus` class
     */
    autoFocus?: AutoFocusTarget | 'first-input' | string;
    /**
     * This provides a way to override any of the configuration parameters expected by cdk's `Dialog.open` method.
     *
     * WARNING: this will take full authority and override with your values no matter what's computed by LuDialogService,
     * use with caution.
     */
    cdkConfigOverride?: DialogConfig<C>;
    /**
     * A hook function to determine if the current dialog can be closed or not, if provided.
     *
     * @param comp the instance of the component that's inside the dialog box.
     */
    canClose?: (comp: C) => boolean | Observable<boolean>;
    /**
     * Determine if the current dialog can be close by a click on backdrop or escape key
     */
    canCloseWithBackdrop?: boolean;
    /**
     * The size of the panel used for the dialog
     */
    size?: 'XS' | 'S' | 'M' | 'L' | 'XL' | 'fitContent' | `maxContent` | 'fullScreen';
    /**
     * Should it be a modal (default), a drawer? a drawer from bottom?
     */
    mode?: 'default' | 'drawer' | 'drawer-from-bottom';
    /**
     * Classes to add to the panel
     */
    panelClasses?: string[];
}
type LuDialogConfig<T, TData = LuDialogData<T>> = [TData] extends [never] ? Omit<BaseLuDialogConfig<T, TData>, 'data'> : BaseLuDialogConfig<T, TData>;

declare const DISMISSED_VALUE: {};
declare class LuDialogRef<C = unknown, TData = LuDialogData<C>> {
    readonly cdkRef: DialogRef<LuDialogResult<C> | typeof DISMISSED_VALUE, C>;
    readonly config: LuDialogConfig<C, TData>;
    /**
     * Instance of the component that's inside the dialog
     */
    get instance(): C;
    /**
     * Subscription to the detachments of the dialog
     * This is used to close the dialog when it is detached
     */
    detachSubscription: Subscription | null;
    /**
     * Emits when the dialog is closed
     *
     * Emits either the output of result$ or undefined depending on how it has been closed
     */
    closed$: Observable<LuDialogResult<C> | undefined>;
    /**
     * Emits void when the dialog is dismissed
     */
    dismissed$: Observable<void>;
    /**
     * Emits the result if it has a value that's not DISMISSED_VALUE
     */
    result$: Observable<LuDialogResult<C>>;
    constructor(cdkRef: DialogRef<LuDialogResult<C> | typeof DISMISSED_VALUE, C>, config: LuDialogConfig<C, TData>);
    dismiss(): void;
    close(res: LuDialogResult<C>): void;
}
type LuDialogSelfRef<R> = {
    dismiss(): void;
    close(res: R): void;
};

declare function injectDialogData<TData>(): TData & ɵDialogDataFlag;
declare function injectDialogRef<R = void>(): LuDialogSelfRef<R> & ɵDialogResultFlag<R>;

declare class LuDialogService {
    #private;
    open<C, TData = LuDialogData<C>>(config: LuDialogConfig<C, NoInfer<TData>>): LuDialogRef<C, TData>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuDialogService>;
}

declare class DialogComponent implements AfterViewInit {
    #private;
    readonly dialogRef: LuDialogRef<unknown, never>;
    close(): void;
    dismiss(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "lu-dialog", never, {}, {}, never, ["*"], true, never>;
}

declare class DialogCloseDirective {
    #private;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogCloseDirective, "[luDialogClose]", never, {}, {}, never, never, true, never>;
}

declare class DialogDismissDirective {
    #private;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDismissDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDismissDirective, "[luDialogDismiss]", never, {}, {}, never, never, true, never>;
}

declare class DialogOpenDirective {
    #private;
    dialog: TemplateRef<void>;
    luDialogConfig: LuDialogConfig<unknown>;
    click(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogOpenDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogOpenDirective, "[luDialogOpen]", never, { "dialog": { "alias": "luDialogOpen"; "required": true; }; "luDialogConfig": { "alias": "luDialogConfig"; "required": false; }; }, {}, never, never, true, never>;
}

type Deferrable<T> = Promise<T> | Observable<T> | T;
declare function deferrableToPromise<T>(deferrable: Promise<T> | Observable<T> | T): Promise<T>;
declare function deferrableToObservable<T>(deferrable: Promise<T> | Observable<T> | T): Observable<T>;
declare const DIALOG_ROUTE_CONFIG: InjectionToken<DialogRouteConfig<unknown>>;
declare function createDialogRoute<C>(config: DialogRouteConfig<C>): Route;
type DialogFactoryResultOptions<C> = {
    path: string;
    dialogRouteConfig?: Partial<Omit<DialogRouteConfig<C>, 'path'>>;
} & (LuDialogData<C> extends never ? {
    dataFactory?: never;
} : {
    dataFactory: () => Deferrable<LuDialogData<C>>;
});
type DialogFactoryResult<C> = (options: DialogFactoryResultOptions<C>) => Route;
type DialogFactoryConfig<C> = Partial<{
    dialogConfig: Omit<LuDialogConfig<C>, 'data' | 'content'>;
    dialogRouteConfig: Partial<DialogRouteConfig<C>>;
}>;
declare function dialogRouteFactory<C>(component: ComponentType<C>, config?: DialogFactoryConfig<C>): DialogFactoryResult<C>;

type DialogRouteConfig<C> = {
    dialogConfigFactory: () => Deferrable<LuDialogConfig<C>>;
    /**
     * When the dialog is closed, this callback is called with the result of the dialog.
     * This callback is called within injection context, so you can inject services in it.
     */
    onClosed?: (res: LuDialogResult<C>) => unknown;
    /**
     * When the dialog is dismissed, this callback is called.
     * This callback is called within injection context, so you can inject services in it.
     */
    onDismissed?: () => unknown;
    /**
     * Override canDeactivate to have a stricter type
     */
    canDeactivate?: (CanDeactivateFn<C> | DeprecatedGuard)[];
} & Omit<Route, 'component' | 'canDeactivate'>;

declare const defaultOnClosedFn: <C>(router?: Router, route?: ActivatedRoute, config?: DialogRouteConfig<C>) => void;
declare class DialogRoutingComponent<C> implements OnInit {
    #private;
    readonly injector: Injector;
    readonly dialogConfig: i0.Signal<LuDialogConfig<C, LuDialogData<C>>>;
    readonly dialogTemplateContent: i0.Signal<TemplateRef<C>>;
    readonly dialogComponentContent: i0.Signal<ComponentType<C>>;
    protected readonly dialogTemplate: i0.Signal<TemplateRef<any>>;
    readonly customInjector: i0.DestroyableInjector;
    readonly componentInstance: i0.WritableSignal<C>;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogRoutingComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogRoutingComponent<any>, "lu-dialog-routing", never, {}, {}, never, never, true, never>;
}

export { DIALOG_ROUTE_CONFIG, DialogCloseDirective, DialogComponent, DialogContentComponent, DialogDismissDirective, DialogFooterComponent, DialogHeaderAction, DialogHeaderComponent, DialogOpenDirective, DialogRoutingComponent, LU_DIALOG_HEADER_TRANSLATIONS, LuDialogRef, LuDialogService, configureLuDialog, createDialogRoute, defaultOnClosedFn, deferrableToObservable, deferrableToPromise, dialogRouteFactory, injectDialogData, injectDialogRef, luDialogHeaderTranslations, provideLuDialog };
export type { Deferrable, DialogFactoryConfig, DialogFactoryResult, DialogFactoryResultOptions, DialogRouteConfig, LuDialogConfig, LuDialogData, LuDialogHeaderTranslations, LuDialogResult, LuDialogSelfRef, ɵDialogDataFlag, ɵDialogResultFlag };