import * as i0 from '@angular/core';
import { ChangeDetectionStrategy, OnDestroy, DoCheck, ViewContainerRef, ElementRef, Renderer2, Type, Injector, ApplicationRef, ComponentRef, Provider, InjectionToken } from '@angular/core';
import { ILuPopupConfig, ALuPopupRef, ILuPopupRef, ILuPopupRefFactory } from '@lucca-front/ng/popup';
import * as _lucca_front_ng_modal from '@lucca-front/ng/modal';
import { Observable, ReplaySubject, Subject } from 'rxjs';
import { ComponentType } from '@angular/cdk/portal';
import { LuDialogSize, LuDialogService } from '@lucca-front/ng/dialog';
import * as i1 from '@angular/cdk/overlay';
import { Overlay, ComponentType as ComponentType$1 } from '@angular/cdk/overlay';
import * as i2 from '@angular/cdk/dialog';
import { LuTranslation } from '@lucca-front/ng/core';

type LuModalMode = 'modal' | 'sidepanel';
interface LuModalClasses {
    panel: string;
    panelContainer: string;
    panelInner: string;
    overlayPane?: string;
}
declare const luModalClasses: Record<LuModalMode, LuModalClasses>;
type LuModalModeWithPosition = {
    mode?: 'modal';
    position: undefined | 'center';
} | {
    mode: 'sidepanel';
    position: 'left' | 'right';
};
type LuModalConfig = ILuPopupConfig & LuModalModeWithPosition & {
    changeDetection: ChangeDetectionStrategy;
};

declare const luDefaultModalConfig: LuModalConfig;
declare const luDefaultSidepanelConfig: LuModalConfig;

interface ILuModalContent<T = unknown> {
    title: string | Observable<string>;
    submitAction?: () => T | Observable<T>;
    submitLabel?: string | Observable<string>;
    submitPalette?: string;
    submitDisabled?: boolean | Observable<boolean>;
    submitCounter?: number | Observable<number>;
    cancelLabel?: string | Observable<string>;
}
type LuModalContentResult<T extends ILuModalContent> = T extends ILuModalContent<infer R> & {
    submitAction: unknown;
} ? R : never;

interface ILuModalRef<D = unknown, R = unknown> extends ILuPopupRef<D, R> {
    mode: LuModalMode;
    modalClasses: LuModalClasses;
    resize(size: LuDialogSize): void;
}
interface IModalRefFactory {
    forge<T extends ILuModalContent, C extends LuModalConfig, D>(component: ComponentType<T>, config: C): ILuModalRef<D, LuModalContentResult<T>>;
}
declare abstract class ALuModalRef<T extends ILuModalContent = ILuModalContent, D = unknown, R = unknown, C extends LuModalConfig = LuModalConfig> extends ALuPopupRef<T, D, R, C> implements ILuModalRef<D, R> {
    get mode(): LuModalMode;
    get modalClasses(): LuModalClasses;
    resize(size: LuDialogSize): void;
}

declare abstract class ALuModalPanelComponent<T extends ILuModalContent> implements OnDestroy, DoCheck {
    protected _ref: ALuModalRef<T>;
    protected _containerRef: ViewContainerRef;
    protected _componentInstance: ILuModalContent;
    protected doCheck$: ReplaySubject<void>;
    intl: _lucca_front_ng_modal.ILuModalLabel;
    protected title$: Observable<string>;
    protected submitLabel$: Observable<string>;
    protected cancelLabel$: Observable<string>;
    protected submitCounter$: Observable<number>;
    protected submitDisabled$: Observable<boolean>;
    protected hasSubmitCounter$: Observable<boolean>;
    protected closeLabel: string;
    get isSubmitHidden(): boolean;
    get submitPalette(): string;
    submitClass$: Subject<unknown>;
    error$: Subject<unknown>;
    readonly modalId: number;
    private _subs;
    modalClasses: LuModalClasses;
    constructor(_ref: ALuModalRef<T>, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2);
    ngDoCheck(): void;
    attachInnerComponent(componentType: Type<T>, injector: Injector): i0.ComponentRef<T>;
    ngOnDestroy(): void;
    dismiss(): void;
    submit(): void;
    private listenComponentValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<ALuModalPanelComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuModalPanelComponent<any>, never, never, {}, {}, never, never, true, never>;
}
declare class LuModalPanelComponent<T extends ILuModalContent = ILuModalContent> extends ALuModalPanelComponent<T> {
    constructor(_ref: ALuModalRef<T>, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalPanelComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuModalPanelComponent<any>, "lu-modal-panel", never, {}, {}, never, never, true, never>;
}
declare class LuModalPanelComponentDefaultCD<T extends ILuModalContent = ILuModalContent> extends ALuModalPanelComponent<T> {
    constructor(_ref: ALuModalRef<T>, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2);
    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalPanelComponentDefaultCD<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuModalPanelComponentDefaultCD<any>, "lu-modal-panel-default", never, {}, {}, never, never, true, never>;
}

declare class LuModalRef<T extends ILuModalContent = ILuModalContent, D = unknown, R = unknown, C extends LuModalConfig = LuModalConfig> extends ALuModalRef<T, D, R, C> implements ILuModalRef<D, R> {
    protected _overlay: Overlay;
    protected _injector: Injector;
    protected _component: ComponentType$1<T>;
    protected _config: C;
    protected _applicationRef: ApplicationRef;
    protected _containerRef: ComponentRef<ALuModalPanelComponent<T>>;
    constructor(_overlay: Overlay, _injector: Injector, _component: ComponentType$1<T>, _config: C, _applicationRef: ApplicationRef);
    protected _openPopup(data?: D): void;
    protected _closePopup(): void;
    protected _getOverlayPanelClasses(): string[];
}
declare class LuModalRefFactory implements ILuPopupRefFactory<ILuModalContent, LuModalConfig> {
    protected _overlay: Overlay;
    protected _injector: Injector;
    protected _applicationRef: ApplicationRef;
    constructor(_overlay: Overlay, _injector: Injector);
    forge<T extends ILuModalContent, C extends LuModalConfig, D, R>(component: ComponentType$1<T>, config: C): LuModalRef<T, D, R, LuModalConfig>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalRefFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuModalRefFactory>;
}

/**
 * Provide LuModal.
 * Note that OverlayModule should be imported in one of the EnvironmentInjectors (AppModule, lazy-loaded route) using `providers: [importProvidersFrom(OverlayModule)]`.
 */
declare function provideLuModal(): Provider[];
/**
 * @deprecated use `OverlayModule, DialogModule` imports && provide `provideLuModal(), LuDialogService` instead
 */
declare class LuModalModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuModalModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuModalModule, never, [typeof i1.OverlayModule, typeof i2.DialogModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuModalModule>;
}

declare class LuModal {
    protected _factory: _lucca_front_ng_modal.IModalRefFactory;
    protected _config: LuModalConfig;
    protected luDialogService: LuDialogService;
    open<T extends ILuModalContent, D>(component: ComponentType<T>, data?: D, config?: Partial<LuModalConfig>): ILuModalRef<D, LuModalContentResult<T>>;
    legacyOpen<T extends ILuModalContent, D>(component: ComponentType<T>, data?: D, config?: Partial<LuModalConfig>): ILuModalRef<D, LuModalContentResult<T>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuModal, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuModal>;
}

/** Injection token that can be used to access the data that was passed in to a dialog. */
declare const LU_MODAL_DATA: InjectionToken<unknown>;
declare const LU_MODAL_CONFIG: InjectionToken<LuModalConfig>;
declare const LU_MODAL_REF_FACTORY: InjectionToken<IModalRefFactory>;

declare const LU_MODAL_TRANSLATIONS: InjectionToken<LuTranslation<ILuModalLabel>>;
interface ILuModalLabel {
    submit: string;
    cancel: string;
    close: string;
}
declare const luModalTranslations: LuTranslation<ILuModalLabel>;

declare function setAriaHiddenOnApplicationRoot(applicationRef: ApplicationRef, hidden: boolean): void;

export { ALuModalPanelComponent, ALuModalRef, LU_MODAL_CONFIG, LU_MODAL_DATA, LU_MODAL_REF_FACTORY, LU_MODAL_TRANSLATIONS, LuModal, LuModalModule, LuModalPanelComponent, LuModalPanelComponentDefaultCD, LuModalRefFactory, luDefaultModalConfig, luDefaultSidepanelConfig, luModalClasses, luModalTranslations, provideLuModal, setAriaHiddenOnApplicationRoot };
export type { ILuModalContent, ILuModalLabel, ILuModalRef, IModalRefFactory, LuModalClasses, LuModalConfig, LuModalContentResult, LuModalMode };