import * as i1 from '@angular/cdk/overlay';
import { Overlay, OverlayRef, OverlayConfig, ComponentType as ComponentType$1 } from '@angular/cdk/overlay';
import * as i0 from '@angular/core';
import { Injector, ComponentRef, InjectionToken } from '@angular/core';
import { ComponentType } from '@angular/cdk/portal';
import { Observable, Subject, Subscription } from 'rxjs';
import * as _lucca_front_ng_popup from '@lucca-front/ng/popup';

interface ILuPopupConfig {
    position?: 'center' | 'top' | 'bottom' | 'left' | 'right';
    noBackdrop?: boolean;
    /** popup dismisses if `esc` is pressed or backdrop is clicked, set it to true if you want to prevent it but be aware that your popup might become unclosable */
    undismissable?: boolean;
    backdropClass?: string | string[];
    panelClass?: string | string[];
    size?: string;
}

declare const luDefaultPopupConfig: ILuPopupConfig;

interface ILuPopupRef<D = unknown, R = unknown> {
    onOpen: Observable<D>;
    onClose: Observable<R>;
    onDismiss: Observable<void>;
    onBackdropClick: Observable<void>;
    open(data: D): void;
    close(result: R): void;
    dismiss(): void;
}
interface ILuPopupRefFactory<TComponent = unknown, TConfig extends ILuPopupConfig = ILuPopupConfig> {
    forge<T extends TComponent, C extends TConfig, D, R>(component: ComponentType<T>, config: C): ILuPopupRef<D, R>;
}
declare abstract class ALuPopupRef<T = unknown, D = unknown, R = unknown, C extends ILuPopupConfig = ILuPopupConfig> implements ILuPopupRef<D, R> {
    protected _overlay: Overlay;
    protected _injector: Injector;
    protected _component: ComponentType<T>;
    protected _config: C;
    onOpen: Subject<D>;
    onClose: Subject<R>;
    onDismiss: Subject<void>;
    onBackdropClick: Subject<void>;
    protected _overlayRef: OverlayRef;
    protected _componentRef: ComponentRef<T>;
    protected _subs: Subscription;
    constructor(_overlay: Overlay, _injector: Injector, _component: ComponentType<T>, _config: C);
    open(data?: D): void;
    close(result?: R): void;
    dismiss(): void;
    /**
     *  This method creates the overlay from the provided popover's template and saves its
     *  OverlayRef so that it can be attached to the DOM when openPopover is called.
     */
    protected _createOverlay(): void;
    /**
     * This method builds the configuration object needed to create the overlay, the OverlayConfig.
     * @returns OverlayConfig
     */
    protected _getOverlayConfig(): OverlayConfig;
    protected _openPopup(data?: D): void;
    protected _getOverlayPanelClasses(): string[];
    protected _destroy(): void;
    protected _completeSubjects(): void;
    protected _destroyOverlay(): void;
    protected _closePopup(): void;
    protected _subToCloseEvents(): void;
    protected _subToEscapeKeydownEvent(): void;
    protected _subToBackdropClickEvent(): void;
    protected _cleanSubscription(): void;
}

declare class LuPopupRef<T = unknown, D = unknown, R = unknown> extends ALuPopupRef<T, D, R> {
    protected _overlay: Overlay;
    protected _injector: Injector;
    protected _component: ComponentType$1<T>;
    protected _config: ILuPopupConfig;
    constructor(_overlay: Overlay, _injector: Injector, _component: ComponentType$1<T>, _config: ILuPopupConfig);
}
declare class LuPopupRefFactory implements ILuPopupRefFactory {
    protected _overlay: Overlay;
    protected _injector: Injector;
    constructor(_overlay: Overlay, _injector: Injector);
    forge<T, D, R>(component: ComponentType$1<T>, config: ILuPopupConfig): LuPopupRef<T, D, R>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopupRefFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuPopupRefFactory>;
}

/**
 * @deprecated use `OverlayModule` imports && `LuPopup, { provide: LU_POPUP_CONFIG, useValue: luDefaultPopupConfig }, { provide: LU_POPUP_REF_FACTORY, useClass: LuPopupRefFactory }` providers instead
 */
declare class LuPopupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuPopupModule, never, [typeof i1.OverlayModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuPopupModule>;
}

declare class LuPopup {
    protected _factory: _lucca_front_ng_popup.ILuPopupRefFactory<unknown, ILuPopupConfig>;
    protected _config: ILuPopupConfig;
    open<T, D, R>(component: ComponentType$1<T>, data?: D, config?: Partial<ILuPopupConfig>): ILuPopupRef<D, R>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuPopup, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuPopup>;
}

declare const LU_POPUP_REF_FACTORY: InjectionToken<ILuPopupRefFactory<unknown, ILuPopupConfig>>;
/** Injection token that can be used to access the data that was passed in to a dialog. */
declare const LU_POPUP_DATA: InjectionToken<unknown>;
declare const LU_POPUP_CONFIG: InjectionToken<ILuPopupConfig>;

export { ALuPopupRef, LU_POPUP_CONFIG, LU_POPUP_DATA, LU_POPUP_REF_FACTORY, LuPopup, LuPopupModule, LuPopupRef, LuPopupRefFactory, luDefaultPopupConfig };
export type { ILuPopupConfig, ILuPopupRef, ILuPopupRefFactory };