import * as i0 from '@angular/core';
import { InjectionToken, TemplateRef, Type, ElementRef, AfterContentInit, QueryList, AfterViewInit, ComponentRef, DestroyRef, ChangeDetectorRef, Injector, OnInit, OnDestroy, OnChanges, Provider } from '@angular/core';
import * as i11 from '@fundamental-ngx/cdk/utils';
import { DynamicComponentConfig, Nullable, TemplateDirective, DynamicComponentContainer, CssClassBuilder, RtlService, HasElementRef, FocusTrapService } from '@fundamental-ngx/cdk/utils';
import { ContentDensityMode } from '@fundamental-ngx/core/content-density';
import { Subject, Observable, Subscription } from 'rxjs';
import * as i1 from '@fundamental-ngx/core/scrollbar';
import * as i12 from '@fundamental-ngx/core/bar';
import { ButtonBarComponent } from '@fundamental-ngx/core/bar';
import { Overlay, OverlayContainer } from '@angular/cdk/overlay';
import { AnimationEvent, AnimationTriggerMetadata } from '@angular/animations';
import { CdkPortalOutlet, CdkPortalOutletAttachedRef } from '@angular/cdk/portal';
import { Router } from '@angular/router';
import * as i13 from '@fundamental-ngx/core/title';

/**
 * Represents the positioning of the dialog on the screen.
 */
declare class DialogPosition {
    /** Value of the dialog's top position. */
    top?: string | number;
    /** Value of the dialog's bottom position. */
    bottom?: string | number;
    /** Value of the dialog's left position. */
    left?: string | number;
    /** Value of the dialog's right position. */
    right?: string | number;
}

declare class DialogConfigBase<T> implements DynamicComponentConfig {
    /** Id for the dialog component. If omitted, a unique one is generated. */
    id?: string;
    /** Width of the dialog. */
    width?: string | number;
    /** Height of the dialog. */
    height?: string | number;
    /** Minimum width of the dialog. */
    minWidth?: string | number;
    /** Minimum height of the dialog. */
    minHeight?: string | number;
    /** Maximum width of the dialog. */
    maxWidth?: string | number;
    /** Maximum height of the dialog. */
    maxHeight?: string | number;
    /** Position of the dialog. */
    position?: DialogPosition;
    /** Aria Modal for the dialog component element */
    ariaModal?: boolean;
    /** Aria label for the dialog component element. */
    ariaLabel?: Nullable<string>;
    /** Id of the element that labels the dialog. */
    ariaLabelledBy?: Nullable<string>;
    /** Id of the element that describes the dialog. */
    ariaDescribedBy?: Nullable<string>;
    /** Whether the dialog should have a backdrop. */
    hasBackdrop?: boolean;
    /** Whether clicking on the backdrop should close the dialog. Only works if hasBackdrop is true. */
    backdropClickCloseable?: boolean;
    /** Global classes to apply to the backdrop. */
    backdropClass?: string;
    /** Classes to apply to the `fd-dialog-container`  */
    containerClass?: string;
    /** Global classes to apply to the dialog panel. */
    dialogPanelClass?: string;
    /** Whether the escape key should close the dialog. */
    escKeyCloseable?: boolean;
    /** Whether the dialog should be focus trapped. */
    focusTrapped?: boolean;
    /** The container that the dialog is appended to. By default, it is appended to the body. */
    container?: HTMLElement | 'body';
    /** Data to pass along to the content through the DialogRef. */
    data?: T;
    /** Whether the dialog should be displayed in mobile mode. */
    mobile?: boolean;
    /** Whether the dialog in mobile mode should have outer space. */
    mobileOuterSpacing?: boolean;
    /** Whether the dialog should have vertical padding. */
    verticalPadding?: boolean;
    /** Whether the dialog should have horizontal padding. */
    horizontalPadding?: boolean;
    /** Whether to completely disable dialog body paddings. */
    disablePaddings?: boolean;
    /** Whether the dialog is a Settings dialog. */
    settings?: boolean;
    /** Workaround for IE11, as `flex-grow: 1` on dialog body won't work when 'min-height' for dialog set
     * There is another way to get dialog of wanted height by setting `min-height` for dialog body.
     */
    bodyMinHeight?: string;
    /** Whether the dialog should have responsive horizontal padding changing with Dialogs window width.
     * max-width: 599px                         - .fd-dialog__content--s
     * min-width: 600px and max-width: 1023px   - .fd-dialog__content--m
     * min-width: 1024px and max-width: 1439px  - .fd-dialog__content--l
     * min-width: 1440px                        - .fd-dialog__content--xl
     * */
    responsivePadding?: boolean;
    /** Whether to close the dialog on router navigation start. */
    closeOnNavigation?: boolean;
    /** Content density mode for the dialog. */
    contentDensity?: ContentDensityMode;
}

/**
 * Configuration for opening a dialog with the DialogService.
 */

declare const DIALOG_DEFAULT_CONFIG: InjectionToken<DialogConfig<any>>;
type ExtendedDialogConfig<TAdditionalProperties extends Record<string, any> = Record<string, any>> = DialogConfig & TAdditionalProperties;
declare class DialogConfig<T = any> extends DialogConfigBase<T> {
    /** Whether the dialog should be draggable. */
    draggable?: boolean;
    /** Whether the dialog should be resizable. */
    resizable?: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogConfig<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogConfig<any>>;
}

declare enum FD_DIALOG_DISMISS_REASON {
    ESCAPE = "escape",
    BACKDROP = "backdrop",
    NAVIGATION_CHANGE = "navigation change"
}
declare class DialogRefBase<T, P = any> {
    /** @hidden */
    _endClose$: Subject<void>;
    /**
     * Observable that is triggered when the dialog is closed.
     * On close a *result* is passed back. On dismiss, an *error* is returned instead.
     */
    afterClosed: Observable<P | undefined>;
    /** Observable that is triggered when the modal view is initialised. */
    afterLoaded: Observable<boolean>;
    /** Data passed from the calling component to the content.*/
    data: T;
    /** @hidden */
    protected readonly _afterClosed: Subject<P | undefined>;
    /** @hidden */
    protected readonly _afterLoaded: Subject<boolean>;
    /** @hidden */
    constructor();
    /**
     * Closes the dialog and emits the result to the afterClosed observable.
     * @param result Value passed back to the observable as a result.
     */
    close(result?: P): void;
    /**
     * Dismisses the dialog and passes the argument to the afterClosed observable as an error.
     * @param reason Value passed back to the observable as an error.
     */
    dismiss(reason?: FD_DIALOG_DISMISS_REASON | any): void;
    /** Function that is called after the view of modal is initialised. */
    loaded(): void;
}

interface DialogRefLoadingConfiguration {
    isLoading: boolean;
    loadingLabel?: string;
    loadingContent?: string | TemplateRef<any> | Type<any>;
}
/**
 * Reference to a dialog component
 * It can be injected into the content component through the constructor.
 * For a template, it is declared as part of the implicit context, see examples.
 */
declare class DialogRef<T = any, P = any> extends DialogRefBase<T, P> implements DialogRefLoadingConfiguration {
    /** @hidden */
    private readonly _onHide;
    /** @hidden */
    private readonly _onLoading;
    /** @hidden */
    private readonly _fullScreen;
    /** Observable that is triggered whenever the dialog should be visually hidden or visible.*/
    onHide: Observable<boolean>;
    /** Observable that is triggered whenever the dialog should be displayed in loading state.*/
    onLoading: Observable<boolean>;
    /** Observable that is triggered whenever the full-screen state being changed. */
    fullScreen: Observable<boolean>;
    /** Value used to determine if dialog window should be hidden or visible. */
    isLoading: boolean;
    /** Text, that is rendered in loading state */
    loadingLabel?: string;
    /** Content, that is rendered in loading state before busy indicator */
    loadingContent?: DialogRefLoadingConfiguration['loadingContent'];
    /**
     * Visually hides the dialog.
     * @param isHidden Value used to determine if dialog window should be hidden or visible.
     */
    hide(isHidden: boolean): void;
    /**
     * Displays the dialog in loading state.
     * @param loadingData Value used to determine if dialog window should be displayed in loading state.
     */
    loading(loadingData: boolean | DialogRefLoadingConfiguration): void;
    /**
     * Toggles full-screen mode of the Dialog.
     */
    toggleFullScreen(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogRef<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogRef<any, any>>;
}

/**
 * Applies fundamental layout and styling to the contents of a dialog body.
 *
 * ```html
 * <fd-dialog-body>
 *     <!-- Content -->
 * </fd-dialog-body>
 * ```
 */
declare class DialogBodyComponent {
    readonly elementRef: ElementRef;
    dialogConfig: DialogConfig;
    dialogRef: DialogRef;
    /**
     * property to remove the horizontal and vertical paddings from the body
     * default is set to false
     */
    disablePaddings: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    constructor(elementRef: ElementRef, dialogConfig: DialogConfig, dialogRef: DialogRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBodyComponent, [null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogBodyComponent, "fd-dialog-body", never, { "disablePaddings": { "alias": "disablePaddings"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.ScrollbarDirective; inputs: {}; outputs: {}; }]>;
}

/**
 * Directive that applies fundamental dialog styling to a dialog close button.
 *
 * ```html
 * <button fd-dialog-close-button></button>
 * ```
 */
declare class DialogCloseButtonComponent {
    /** Displays dialog close button in mobile mode */
    mobile: i0.InputSignal<boolean>;
    /** add title dynamically to add a tooltip */
    title: i0.InputSignal<string | undefined>;
    /** add aria label dynamically to add to the button */
    ariaLabel: i0.InputSignal<string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogCloseButtonComponent, "[fd-dialog-close-button]", never, { "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare abstract class DialogFooterBase implements AfterContentInit {
    /** @hidden */
    customTemplates: QueryList<TemplateDirective>;
    /** @hidden */
    buttons: QueryList<ButtonBarComponent>;
    /** @hidden */
    footerTemplate: TemplateRef<any> | undefined;
    /** @hidden */
    customFooterTemplate: TemplateRef<any> | undefined;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    protected _listenForButtonChanges(className: string): void;
    /** @hidden Assign custom templates */
    private _assignCustomTemplates;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFooterBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogFooterBase, never, never, {}, {}, ["customTemplates", "buttons"], never, true, never>;
}

declare const DialogButtonClass = "fd-dialog__decisive-button";
/**
 * Building block of the dialog used to create dialog button.
 *
 * ```html
 * <fd-dialog-footer><!--Content--></fd-dialog-footer>
 *
 * Complex footer:
 * <fd-dialog-footer>
 *     <ng-template fdkTemplate="footer"><!--Content--></ng-template>
 * </fd-dialog-footer>
 * ```
 * */
declare class DialogFooterComponent extends DialogFooterBase implements AfterContentInit, AfterViewInit {
    /** @hidden */
    dialogConfig: DialogConfig<any>;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFooterComponent, "fd-dialog-footer", never, {}, {}, never, ["*"], true, never>;
}

declare abstract class DialogHeaderBase implements AfterContentInit {
    /** @hidden */
    customTemplates: QueryList<TemplateDirective>;
    /** @hidden */
    headerTemplate: TemplateRef<any>;
    /** @hidden */
    subHeaderTemplate: TemplateRef<any>;
    /** @hidden */
    private readonly _changeDetectorRef;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden Assign custom templates */
    private _assignCustomTemplates;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderBase, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogHeaderBase, never, never, {}, {}, ["customTemplates"], never, true, never>;
}

/**
 * Applies fundamental layout and styling to the contents of a dialog header.
 *
 * ```html
 * <fd-dialog-header>
 *     <h1 fd-title>Title</h1>
 *     <button fd-dialog-close-button></button>
 * </fd-dialog-header>
 * ```
 */
declare class DialogHeaderComponent extends DialogHeaderBase implements AfterContentInit {
    /** @hidden */
    dialogConfig: DialogConfig<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "fd-dialog-header", never, {}, {}, never, ["[fd-title]", "[fd-dialog-full-screen-toggler-button]", "[fd-dialog-close-button]"], true, never>;
}

interface DialogContainer<T> {
    ref: DialogRefBase<T>;
}

/** Service used to dynamically generate a dialog. */
declare abstract class DialogBaseService<T extends DialogContainer<any>> {
    abstract open<D>(content: unknown, config: DialogConfigBase<D>): DialogRefBase<D>;
    /** @hidden Collection of existing dialog references */
    protected _dialogs: ComponentRef<T>[];
    /** @hidden */
    protected _destroyRef: DestroyRef;
    /**
     * Status of the dialog service.
     * Returns true if there are open dialogs, false otherwise.
     */
    hasOpenDialogs(): boolean;
    /** Dismisses all currently open dialogs. */
    dismissAll(reason?: any): void;
    /** @hidden Extends configuration using default values*/
    protected _applyDefaultConfig(config: DialogConfig, defaultConfig: DialogConfig): DialogConfig;
    /** @hidden Destroy existing dialog */
    protected _destroyDialog(dialog: ComponentRef<T>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBaseService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogBaseService<any>>;
}

declare class DialogContentBase<ContentType = unknown> {
    /** Dialog Title id */
    titleId?: string;
    /** Dialog Title */
    title?: string;
    /** Dialog Title Heading Level. Default is 1 */
    titleHeadingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
    /** Dialog Body */
    content?: ContentType;
    /** Dialog Body Id */
    contentId?: string;
    /** Aria Modal for the dialog component element */
    ariaModal?: boolean;
    /** Aria label for the dialog component element. */
    ariaLabel?: Nullable<string>;
    /** Aria labelby for the dialog component element. */
    ariaLabelledBy?: Nullable<string>;
    /** Aria DescribedBy for the dialog component element.. */
    ariaDescribedBy?: Nullable<string>;
    /** Approve Button Label */
    approveButton?: string;
    /** Approve Button Id */
    approveButtonId?: string;
    /** Approve Button Click Callback */
    approveButtonCallback?: () => void;
    /** Aria label for the dialog approve button element. */
    approveButtonAriaLabel?: string;
    /** Cancel Button Label */
    cancelButton?: string;
    /** Cancel Button Id */
    cancelButtonId?: string;
    /** Cancel Button Click Callback */
    cancelButtonCallback?: () => void;
    /** Close Button Callback */
    closeButtonCallback?: () => void;
    /** Full screen Button Click callback */
    fullScreenButtonCallback?: () => void;
    /** close button title */
    closeButtonTitle?: string;
    /** Aria labelby for the dialog close button element. */
    closeButtonAriaLabel?: string;
}

declare class DialogDefaultContent extends DialogContentBase<TemplateRef<any>> {
    /** Subheader Body */
    subHeader?: TemplateRef<any>;
    /** Whether to allow dialog to be opened in full screen mode. */
    allowFullScreen?: boolean;
    /** Full screen button text when dialog is not in full-screen mode. */
    fullScreenExpandButtonText?: string;
    /** Full screen button text when dialog is in full-screen mode. */
    fullScreenMinifyButtonText?: string;
}

type DialogContentType = TemplateRef<any> | Type<any> | DialogDefaultContent;

/** Dialog container where the dialog content is embedded. */
declare class DialogContainerComponent extends DynamicComponentContainer<DialogContentType> implements DialogContainer<any>, AfterViewInit, CssClassBuilder {
    dialogConfig: DialogConfig;
    ref: DialogRef;
    private _destroyRef;
    protected readonly _cdr: ChangeDetectorRef;
    /** Custom classes */
    set class(userClass: string);
    /** @hidden */
    portalOutlet: CdkPortalOutlet;
    /** The state of the Dialog animations. */
    protected get _animationState(): string;
    /** @hidden */
    private _class;
    /** @hidden */
    private _animationStateSignal;
    /** @hidden */
    constructor(dialogConfig: DialogConfig, ref: DialogRef, _destroyRef: DestroyRef, elementRef: ElementRef, _cdr: ChangeDetectorRef, injector: Injector);
    /** @hidden */
    buildComponentCssClass(): string[];
    /** Handle end of animations, updating the state of the Message Toast. */
    onAnimationEnd(event: AnimationEvent): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    protected _attached(event: CdkPortalOutletAttachedRef): void;
    /** @hidden Load received content */
    protected _loadContent(): void;
    /** @hidden Returns context for embedded template */
    private _templateContext;
    /** @hidden Load Dialog component from passed object */
    private _createFromDefaultDialog;
    /**
     * @hidden
     * We need to wait until animation plays, and then send signal to the service to destroy the component.
     */
    private _listenOnClose;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContainerComponent, "fd-dialog-container", never, { "class": { "alias": "class"; "required": false; }; }, {}, never, never, true, never>;
}

/** Service used to create a dialog. */
declare class DialogService extends DialogBaseService<DialogContainerComponent> {
    private _defaultConfig;
    private _rtlService;
    private _injector;
    private readonly _overlay;
    /** @hidden */
    private platformId;
    /** @hidden */
    private readonly htmlElement?;
    /** @hidden */
    constructor(_defaultConfig: DialogConfig, _rtlService: RtlService, _injector: Injector, _overlay: Overlay);
    /**
     * Opens a dialog component with provided content.
     * @param content Content of the dialog component.
     * @param dialogConfig Configuration of the dialog component.
     * @param parentInjector Parent injector instance.
     */
    open<T = any>(content: DialogContentType, dialogConfig?: DialogConfig<T>, parentInjector?: Injector): DialogRef<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, [{ optional: true; }, { optional: true; }, null, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

/** @hidden Describes available dialog padding sizes */
type DialogSize = 'sm' | 'md' | 'lg' | 'xl';

declare abstract class DialogBase<T = any, D extends DialogRefBase<T> = DialogRefBase<T>> implements OnInit, AfterViewInit, OnDestroy, HasElementRef {
    /** @hidden Reference to dialog window element*/
    abstract dialogWindow: ElementRef;
    /**
     * @hidden
     */
    _dir: string;
    /** @hidden Dialog padding sizes */
    dialogPaddingSize: DialogSize;
    /** @hidden */
    readonly _focusTrapService: FocusTrapService;
    /** @hidden */
    readonly _changeDetectorRef: ChangeDetectorRef;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly _router: Router;
    /** @hidden */
    protected readonly _rtlService: RtlService | null;
    /** @hidden */
    protected _focusTrapId: string;
    /** @hidden */
    protected _subscriptions: Subscription;
    /** @hidden */
    abstract get _ref(): D;
    /** @hidden */
    abstract get _config(): DialogConfigBase<any>;
    /**
     * @hidden
     * Used to mute errors of focus trap during unit tests (jsdom incompatibility).
     */
    private readonly _focusTrapError;
    /** @hidden */
    private readonly _zone;
    /** @hidden Listen and close dialog on Escape key */
    closeDialogEsc(event: KeyboardEvent): void;
    /** @hidden Listen and close dialog on Backdrop click */
    closeDialog(target: EventTarget | null): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden Determine dialog padding size based on dialogs window width */
    adjustResponsivePadding(): void;
    /** @hidden Listen on NavigationStart event and dismiss the dialog */
    private _listenAndCloseOnNavigation;
    /** @hidden Trap focus inside dialog window */
    private _trapFocus;
    /** @hidden */
    private _deactivateFocusTrap;
    /** @hidden Set dialog window position */
    private _setPosition;
    /** @hidden Set dialog window width and height */
    private _setWidthHeight;
    /** @hidden Listen on window resize and adjust padding */
    private _listenOnWindowResize;
    /** @hidden */
    private _onMicrotaskEmpty;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBase<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogBase<any, any>, never, never, {}, {}, never, never, true, never>;
}

declare class DialogTitleDirective implements AfterViewInit {
    dialogConfig: DialogConfig;
    /** Title ID attribute, generated automatically if not provided */
    id: i0.InputSignal<string>;
    /** @hidden */
    constructor(dialogConfig: DialogConfig);
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTitleDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogTitleDirective, "[fd-dialog-title]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Dialog component.
 *
 * ```html
 * <fd-dialog>
 *      <fd-dialog-header></fd-dialog-header>
 *      <fd-dialog-body></fd-dialog-body>
 *      <fd-dialog-footer></fd-dialog-footer>
 * </fd-dialog>
 * ```
 */
declare class DialogComponent extends DialogBase<DialogRef> implements OnInit, OnChanges, AfterViewInit, OnDestroy, CssClassBuilder {
    dialogConfig: DialogConfig;
    private _dialogRef;
    /** Custom classes */
    set class(userClass: string);
    /** DialogRef - should be used for Template based Dialog implementation */
    set embeddedDialogRef(value: DialogRef);
    get embeddedDialogRef(): DialogRef;
    /** DialogConfig - should be used for Template based Dialog implementation */
    set embeddedDialogConfig(value: DialogConfig);
    /** @hidden */
    dialogWindow: ElementRef;
    /** @hidden If dialog sub-components didn't receive DialogConfig from Injector, DialogConfig is passed from parent.
     * This is necessary when dialog has been passed as TemplateRef and created as EmbeddedView.
     * In such case parent injector of DialogComponent is the component that DECLARED the TemplateRef.
     **/
    set dialogHeaderConfig(component: DialogHeaderComponent);
    /** @hidden */
    set dialogBodyConfig(component: DialogBodyComponent);
    /** @hidden */
    set dialogFooterConfig(component: DialogFooterComponent);
    /** @hidden */
    set dialogTitle(component: DialogTitleDirective);
    /** @hidden Whenever dialog should be visible */
    showDialogWindow: boolean;
    /** @hidden Whenever dialog is dragged */
    isDragged: boolean;
    /**
     * @hidden
     * Whether the Dialog in full-screen mode.
     */
    _fullScreen: boolean;
    /** @hidden */
    private _class;
    /** @hidden */
    private _onHidden;
    /** @hidden */
    constructor(dialogConfig: DialogConfig, _dialogRef: DialogRef);
    /** @hidden */
    get _config(): DialogConfig;
    /** @hidden */
    get _ref(): DialogRef;
    /** @hidden */
    buildComponentCssClass(): string[];
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _listenOnFullScreen;
    /** @hidden Listen on Dialog visibility */
    private _listenOnHidden;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, [{ optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "fd-dialog", never, { "class": { "alias": "class"; "required": false; }; "embeddedDialogRef": { "alias": "dialogRef"; "required": false; }; "embeddedDialogConfig": { "alias": "dialogConfig"; "required": false; }; }, {}, ["dialogHeaderConfig", "dialogBodyConfig", "dialogFooterConfig", "dialogTitle"], ["fd-dialog-header", "fd-dialog-body", "fd-dialog-footer"], true, never>;
}

/** Dialog component used to create the dialog in object based approach */
declare class DialogDefaultComponent implements AfterViewInit {
    private _changeDetectorRef;
    _dialogConfig: DialogConfig;
    /** @hidden */
    _defaultDialogContent: Nullable<DialogDefaultContent>;
    /** @hidden */
    _defaultDialogConfiguration: DialogConfig;
    /**
     * dialog title id
     * if not set, a default value is provided
     */
    dialogTitleId: string;
    /**
     * dialog content id
     * if not set, a default value is provided
     */
    dialogContentId: string;
    /** @hidden */
    constructor(_changeDetectorRef: ChangeDetectorRef, _dialogConfig: DialogConfig);
    /** @hidden
     * TODO: Inspect why DialogDefaultComponents needs change detection re-run to render adjusted content (dialog header title)
     * */
    ngAfterViewInit(): void;
    /** Whether there is a approve button, or cancel button text */
    _showFooter(): boolean;
    /** @hidden */
    _closeButtonClicked(): void;
    /** @hidden */
    _approveButtonClicked(): void;
    /** @hidden */
    _cancelButtonClicked(): void;
    /** @hidden */
    _fullScreenButtonClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDefaultComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogDefaultComponent, "fd-dialog-default", never, {}, {}, never, never, true, never>;
}

declare class DialogFullScreenTogglerButtonComponent implements OnInit {
    /** Displays dialog close button in mobile mode */
    mobile: i0.InputSignal<boolean>;
    /** DialogRef direct reference. Used with template-based dialogs. */
    dialogRef: i0.InputSignal<Nullable<DialogRef<any, any>>>;
    /** add title dynamically to add a tooltip */
    title: i0.InputSignal<string | undefined>;
    /** @hidden */
    _fullscreen$: i0.WritableSignal<boolean>;
    /** @hidden */
    private readonly _ref;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFullScreenTogglerButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFullScreenTogglerButtonComponent, "[fd-dialog-full-screen-toggler-button]", never, { "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "dialogRef": { "alias": "dialogRef"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface DialogTemplateDirectiveContext<T = DialogConfig<any>, U = T extends DialogConfig<infer P> ? P : any> {
    $implicit: DialogRef<U>;
    dialogConfig: T;
}
declare class DialogTemplateDirective<T = DialogConfig<any>> {
    /** Custom dialog config model. */
    fdDialogTemplateConfig: i0.InputSignal<T | undefined>;
    /** @hidden */
    readonly templateRef: TemplateRef<any>;
    /** @hidden */
    static ngTemplateContextGuard<T extends null>(dir: DialogTemplateDirective<T>, ctx: DialogTemplateDirectiveContext<DialogConfig<any>>): ctx is DialogTemplateDirectiveContext<DialogConfig<any>>;
    /** @hidden */
    static ngTemplateContextGuard<T = DialogConfig<any>>(dir: DialogTemplateDirective<T>, ctx: DialogTemplateDirectiveContext<T>): ctx is DialogTemplateDirectiveContext<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogTemplateDirective<any>, "[fdDialogTemplate]", never, { "fdDialogTemplateConfig": { "alias": "fdDialogTemplateConfig"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use following imports instead:
 * `DialogComponent`,
 * `DialogBodyComponent`,
 * `DialogFooterComponent`,
 * `DialogHeaderComponent`,
 * `DialogCloseButtonComponent`,
 * `DialogTitleDirective`,
 * `DialogFullScreenTogglerButtonComponent`
 *
 * in order to provide dialog service, use `provideDialogService()`
 */
declare class DialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, never, [typeof DialogComponent, typeof DialogBodyComponent, typeof DialogFooterComponent, typeof DialogHeaderComponent, typeof DialogDefaultComponent, typeof DialogContainerComponent, typeof DialogCloseButtonComponent, typeof DialogTitleDirective, typeof DialogFullScreenTogglerButtonComponent, typeof DialogTemplateDirective, typeof i11.TemplateModule, typeof i12.BarComponent, typeof i12.BarLeftDirective, typeof i12.BarMiddleDirective, typeof i12.BarRightDirective, typeof i12.BarElementDirective, typeof i12.ButtonBarComponent, typeof i13.TitleComponent], [typeof DialogComponent, typeof DialogBodyComponent, typeof DialogFooterComponent, typeof DialogHeaderComponent, typeof DialogDefaultComponent, typeof DialogContainerComponent, typeof DialogCloseButtonComponent, typeof DialogTitleDirective, typeof DialogFullScreenTogglerButtonComponent, typeof DialogTemplateDirective, typeof i11.TemplateModule, typeof i12.BarComponent, typeof i12.BarLeftDirective, typeof i12.BarMiddleDirective, typeof i12.BarRightDirective, typeof i12.BarElementDirective, typeof i12.ButtonBarComponent, typeof i13.TitleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
}

declare const dialogFade: AnimationTriggerMetadata;

declare const FD_DIALOG_BODY_COMPONENT: InjectionToken<unknown>;
declare const FD_DIALOG_FOCUS_TRAP_ERROR: InjectionToken<boolean>;

declare class DialogOverlayContainer extends OverlayContainer {
    /**
     * This method returns the overlay container element. It will lazily
     * create the element the first time it is called to facilitate using
     * the container in non-browser environments.
     * @returns the container element
     */
    getContainerElement(): HTMLElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogOverlayContainer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogOverlayContainer>;
}

/**
 * Provides necessary services for dialog functionality to properly work.
 * @returns Array of Providers.
 */
declare function provideDialogService(): Provider[];

export { DIALOG_DEFAULT_CONFIG, DialogBase, DialogBaseService, DialogBodyComponent, DialogButtonClass, DialogCloseButtonComponent, DialogComponent, DialogConfig, DialogConfigBase, DialogContainerComponent, DialogContentBase, DialogDefaultComponent, DialogDefaultContent, DialogFooterBase, DialogFooterComponent, DialogFullScreenTogglerButtonComponent, DialogHeaderBase, DialogHeaderComponent, DialogModule, DialogOverlayContainer, DialogPosition, DialogRef, DialogRefBase, DialogService, DialogTemplateDirective, DialogTitleDirective, FD_DIALOG_BODY_COMPONENT, FD_DIALOG_DISMISS_REASON, FD_DIALOG_FOCUS_TRAP_ERROR, dialogFade, provideDialogService };
export type { DialogContainer, DialogContentType, DialogRefLoadingConfiguration, DialogTemplateDirectiveContext, ExtendedDialogConfig };
