import * as i0 from '@angular/core';
import { InjectionToken, Signal, TemplateRef, Type, ElementRef, Injector, AfterViewInit, ComponentRef, DestroyRef, ChangeDetectorRef, OnDestroy, OnInit, OnChanges, Provider } from '@angular/core';
import * as i11 from '@fundamental-ngx/cdk/utils';
import { DynamicComponentConfig, TemplateDirective, DynamicComponentContainer, CssClassBuilder, RtlService, HasElementRef, FocusTrapService, Nullable } from '@fundamental-ngx/cdk/utils';
import { ContentDensityMode } from '@fundamental-ngx/core/content-density';
import { Observable, Subject } 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;
}

/** Dimension value that can be a numeric pixel value or string with units */
type DimensionValue = string | number;
declare class DialogConfigBase<T> implements DynamicComponentConfig {
    /**
     * Id for the dialog component.
     */
    id?: string;
    /**
     * Width of the dialog.
     * Accepts numeric values (interpreted as pixels) or string values with units.
     * @example '500px', 500, '50%', '50vw'
     */
    width?: DimensionValue;
    /**
     * Height of the dialog.
     * Accepts numeric values (interpreted as pixels) or string values with units.
     * @example '600px', 600, '80vh'
     */
    height?: DimensionValue;
    /**
     * Minimum width of the dialog.
     * Accepts numeric values (interpreted as pixels) or string values with units.
     * @example '400px', 400, '30%'
     */
    minWidth?: DimensionValue;
    /**
     * Minimum height of the dialog.
     * Accepts numeric values (interpreted as pixels) or string values with units.
     * @example '300px', 300, '40vh'
     */
    minHeight?: DimensionValue;
    /**
     * Maximum width of the dialog.
     * Accepts numeric values (interpreted as pixels) or string values with units.
     * @example '1200px', 1200, '90vw'
     */
    maxWidth?: DimensionValue;
    /**
     * Maximum height of the dialog.
     * Accepts numeric values (interpreted as pixels) or string values with units.
     * @example '800px', 800, '95vh'
     */
    maxHeight?: DimensionValue;
    /**
     * Position of the dialog within the viewport.
     * Allows precise placement using top, bottom, left, and right coordinates.
     */
    position?: DialogPosition;
    /**
     * Aria Modal for the dialog component element.
     * @default false
     */
    ariaModal?: boolean;
    /**
     * Aria label for the dialog component element.
     * Provides an accessible name when no visible title is present.
     */
    ariaLabel?: string | undefined | null;
    /**
     * Id of the element that labels the dialog.
     * References an element (typically a heading) that serves as the dialog's title.
     */
    ariaLabelledBy?: string | undefined | null;
    /**
     * Id of the element that describes the dialog.
     * References an element that provides additional context about the dialog.
     */
    ariaDescribedBy?: string | undefined | null;
    /**
     * Whether the dialog should have a backdrop (overlay).
     * The backdrop appears behind the dialog and typically dims the background content.
     * @default true
     */
    hasBackdrop?: boolean;
    /**
     * Whether clicking on the backdrop should close the dialog.
     * Only works if hasBackdrop is true.
     * @default false
     */
    backdropClickCloseable?: boolean;
    /**
     * Global classes to apply to the backdrop element.
     * Useful for custom backdrop styling or animations.
     * @example 'custom-backdrop dark-backdrop'
     */
    backdropClass?: string;
    /**
     * Classes to apply to the `fd-dialog-container` element.
     * The container wraps the entire dialog structure.
     * @example 'custom-container compact-dialog'
     */
    containerClass?: string;
    /**
     * Global classes to apply to the dialog panel element.
     * The panel is the main dialog content area.
     * @example 'custom-panel elevated-dialog'
     */
    dialogPanelClass?: string;
    /**
     * Whether the escape key should close the dialog.
     * When true, pressing ESC will dismiss the dialog.
     * @default true
     */
    escKeyCloseable?: boolean;
    /**
     * Whether the dialog should be focus trapped.
     * When true, keyboard focus is constrained within the dialog for accessibility.
     * Users cannot tab to elements outside the dialog while it's open.
     * @default true
     */
    focusTrapped?: boolean;
    /**
     * The container that the dialog is appended to.
     * Can be a specific HTMLElement or 'body' for document body.
     * @default 'body'
     */
    container?: HTMLElement | 'body';
    /**
     * Data to pass along to the content through the DialogRef.
     * This data is accessible in the dialog component via the DialogRef.
     */
    data?: T;
    /**
     * Whether the dialog should be displayed in mobile mode.
     * Mobile mode adapts the dialog layout for smaller screens.
     */
    mobile?: boolean;
    /**
     * Whether the dialog in mobile mode should have outer space.
     * Adds margin around the dialog in mobile view.
     */
    mobileOuterSpacing?: boolean;
    /**
     * Whether the dialog should have vertical padding (top and bottom).
     * @default true
     */
    verticalPadding?: boolean;
    /**
     * Whether the dialog should have horizontal padding (left and right).
     * @default true
     */
    horizontalPadding?: boolean;
    /**
     * Whether to completely disable all dialog body paddings.
     * When true, overrides verticalPadding and horizontalPadding settings.
     * @default false
     */
    disablePaddings?: boolean;
    /**
     * Whether the dialog is a Settings dialog.
     * Applies specific styling appropriate for settings/configuration dialogs.
     */
    settings?: boolean;
    /**
     * Minimum height for the dialog body.
     * Workaround for older browsers where `flex-grow: 1` on dialog body doesn't work
     * when 'min-height' is set on the dialog container.
     * @example '400px', '50vh'
     */
    bodyMinHeight?: string;
    /**
     * Whether the dialog should have responsive horizontal padding that changes with dialog width.
     * Padding classes are applied based on dialog width breakpoints:
     * - 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
     * @default false
     */
    responsivePadding?: boolean;
    /**
     * Whether to close the dialog when Angular router navigation starts.
     * Useful to automatically clean up dialogs when user navigates away.
     * @default true
     */
    closeOnNavigation?: boolean;
    /**
     * Content density mode for the dialog.
     * Controls spacing and sizing of dialog elements.
     * @example 'compact', 'cozy', 'comfortable'
     */
    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>>;
}

/**
 * Enumeration of reasons why a dialog was dismissed.
 * Used to identify the cause of dialog closure without explicit user action.
 */
declare enum FD_DIALOG_DISMISS_REASON {
    /** Dialog dismissed by pressing the Escape key */
    ESCAPE = "escape",
    /** Dialog dismissed by clicking on the backdrop/overlay */
    BACKDROP = "backdrop",
    /** Dialog dismissed due to router navigation */
    NAVIGATION_CHANGE = "navigation change",
    /** Dialog dismissed because the service was destroyed */
    SERVICE_DESTROYED = "service destroyed"
}
/**
 * Represents the current lifecycle status of a dialog.
 * - `pending`: Dialog created but not yet loaded/initialized
 * - `loaded`: Dialog view has been loaded and initialized
 * - `closed`: Dialog closed normally with a result
 * - `dismissed`: Dialog dismissed without a result (via ESC, backdrop click, etc.)
 */
type DialogStatus = 'pending' | 'loaded' | 'closed' | 'dismissed';
/**
 * Result object returned when a dialog is closed or dismissed.
 * Contains the final status and any associated data or reason.
 * @template P - The type of result value returned when dialog is closed
 */
interface DialogCloseResult<P> {
    /** Whether the dialog was closed normally or dismissed */
    status: 'closed' | 'dismissed';
    /** Optional result value when dialog was closed normally */
    value?: P;
    /** Optional reason when dialog was dismissed */
    reason?: FD_DIALOG_DISMISS_REASON | any;
}
declare class DialogRefBase<T, P = any> {
    /**
     * Data passed from the calling component to the dialog content.
     * Accessible within the dialog component via the DialogRef instance.
     */
    data: T;
    /**
     * Observable that emits when the dialog is closed.
     * Emits the result value on normal close, or errors with the dismiss reason.
     * @deprecated Use signal-based API instead: `status()`, `closeResult()`, or `isOpen()`
     */
    afterClosed: Observable<P | undefined>;
    /**
     * Observable that emits when the dialog view is initialized and loaded.
     * @deprecated Use signal-based API instead: `isLoaded()`
     */
    afterLoaded: Observable<boolean>;
    /**
     * Readonly signal containing the current lifecycle status of the dialog.
     * Possible values: 'pending', 'loaded', 'closed', 'dismissed'
     */
    readonly status: Signal<DialogStatus>;
    /**
     * Readonly signal containing the result of dialog closure.
     * Returns null while dialog is open, contains result object after close/dismiss.
     */
    readonly closeResult: Signal<DialogCloseResult<P> | null>;
    /**
     * Computed signal indicating whether the dialog has been loaded and initialized.
     * Returns true once the dialog view has finished loading.
     */
    readonly isLoaded: Signal<boolean>;
    /**
     * Computed signal indicating whether the dialog has been closed or dismissed.
     * Returns true if status is 'closed' or 'dismissed'.
     */
    readonly isClosed: Signal<boolean>;
    /**
     * Computed signal indicating whether the dialog is currently open and active.
     * Returns true if dialog is loaded but not yet closed/dismissed.
     */
    readonly isOpen: Signal<boolean>;
    /**
     * @hidden
     * Subject that signals the end of dialog lifecycle.
     * Completes when dialog is closed or dismissed.
     * Used by dialog container components to track lifecycle.
     */
    _endClose$: Subject<void>;
    /**
     * @hidden
     * Internal subject for backward-compatible afterClosed observable.
     */
    protected readonly afterClosedSubject: Subject<P | undefined>;
    /**
     * @hidden
     * Internal subject for backward-compatible afterLoaded observable.
     */
    protected readonly afterLoadedSubject: Subject<boolean>;
    /** @hidden Internal signal tracking dialog lifecycle status */
    private readonly _statusSignal;
    /** @hidden Internal signal storing the result of dialog closure */
    private readonly _closeResultSignal;
    /** @hidden */
    constructor();
    /**
     * Closes the dialog normally and returns a result value.
     * Updates signal state and emits to observables for backward compatibility.
     * @param result - Optional result value to return to the caller
     */
    close(result?: P): void;
    /**
     * Dismisses the dialog without a result, typically due to user cancellation.
     * Updates signal state and emits error to observables for backward compatibility.
     * @param reason - Optional reason for dismissal (ESC key, backdrop click, etc.)
     */
    dismiss(reason?: FD_DIALOG_DISMISS_REASON | any): void;
    /**
     * Marks the dialog as loaded and initialized.
     * Called internally after the dialog view has been created and rendered.
     * Updates signal state and emits to observables for backward compatibility.
     * @internal
     */
    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 {
    /**
     * @hidden
     * Signal-based query for custom footer templates.
     * Templates are identified by their fdkTemplate name attribute.
     */
    readonly customTemplates: i0.Signal<readonly TemplateDirective[]>;
    /**
     * @hidden
     * Signal-based query for button bar components.
     */
    readonly buttons: i0.Signal<readonly ButtonBarComponent[]>;
    /**
     * @hidden
     * Signal containing the custom footer template, if provided.
     * Returns the TemplateRef when a template with name='footer' is projected.
     * This template uses the predefined Bar layout.
     */
    readonly footerTemplate: i0.Signal<TemplateRef<any> | undefined>;
    /**
     * @hidden
     * Signal containing the custom footer template without predefined Bar, if provided.
     * Returns the TemplateRef when a template with name='customFooter' is projected.
     * This template gives full control to the user without any predefined layout.
     */
    readonly customFooterTemplate: i0.Signal<TemplateRef<any> | undefined>;
    /** @hidden */
    protected readonly injector: Injector;
    /**
     * @hidden
     * Sets up an effect to add a CSS class to button elements when buttons change.
     * Must be called within an injection context or will use runInInjectionContext.
     * @param className - The CSS class name to add to each button element
     */
    protected _listenForButtonChanges(className: string): void;
    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 AfterViewInit {
    /** @hidden */
    dialogConfig: DialogConfig<any>;
    /** @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 {
    /**
     * @hidden
     * Signal-based query for custom header/subheader templates.
     * Templates are identified by their fdkTemplate name attribute.
     */
    readonly customTemplates: i0.Signal<readonly TemplateDirective[]>;
    /**
     * @hidden
     * Signal containing the custom header template, if provided.
     * Returns the TemplateRef when a template with name='header' is projected.
     */
    readonly headerTemplate: i0.Signal<TemplateRef<any> | undefined>;
    /**
     * @hidden
     * Signal containing the custom subheader template, if provided.
     * Returns the TemplateRef when a template with name='subheader' is projected.
     */
    readonly subHeaderTemplate: i0.Signal<TemplateRef<any> | undefined>;
    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 {
    /** @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 mutable dialogs signal */
    readonly dialogsSignal: i0.WritableSignal<ComponentRef<T>[]>;
    /**
     * Readonly signal containing all currently open dialog component references.
     * Use this to observe the list of active dialogs.
     */
    readonly dialogs: i0.Signal<ComponentRef<T>[]>;
    /**
     * Computed signal indicating whether any dialogs are currently open.
     * Useful for conditional logic based on dialog presence.
     */
    readonly hasOpenDialogs: i0.Signal<boolean>;
    /** Computed: count of open dialogs */
    readonly openDialogCount: i0.Signal<number>;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden */
    constructor();
    /** Dismisses all currently open dialogs. */
    dismissAll(reason?: FD_DIALOG_DISMISS_REASON | string): void;
    /** @hidden Extends configuration using default values */
    protected _applyDefaultConfig(config: DialogConfig, defaultConfig: DialogConfig): DialogConfig;
    /** @hidden Register a dialog and setup auto-cleanup */
    protected _registerDialog(dialog: ComponentRef<T>): void;
    /** @hidden Destroy existing dialog */
    protected _destroyDialog(dialog: ComponentRef<T>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogBaseService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogBaseService<any>>;
}

/**
 * Base class for dialog content configuration.
 * Defines common properties for dialog titles, content, buttons, and accessibility attributes.
 */
declare class DialogContentBase<ContentType = unknown> {
    /**
     * Unique identifier for the dialog title element.
     */
    titleId?: string;
    /**
     * Text content for the dialog title.
     * Displayed in the dialog header.
     */
    title?: string;
    /**
     * Semantic heading level for the dialog title.
     * Determines which HTML heading tag (h1-h6) to use for proper document outline.
     * @default 1
     * @example 2 // renders as <h2>
     */
    titleHeadingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
    /**
     * Main content to be displayed in the dialog body.
     * Can be a template, component, or any custom content type.
     */
    content?: ContentType;
    /**
     * Unique identifier for the dialog content/body element.
     */
    contentId?: string;
    /**
     * Aria Modal attribute for the dialog component element.
     * When true, indicates the dialog is modal and content outside is inert.
     * @default false
     */
    ariaModal?: boolean;
    /**
     * ARIA label for the dialog component element.
     * Provides an accessible name when no visible title is present.
     */
    ariaLabel?: string | null | undefined;
    /**
     * ID of the element that labels the dialog.
     * References an element (typically the title) that serves as the dialog's accessible name.
     */
    ariaLabelledBy?: string | null | undefined;
    /**
     * ID of the element that describes the dialog.
     * References an element that provides additional context about the dialog's purpose.
     */
    ariaDescribedBy?: string | null | undefined;
    /**
     * Label text for the approve/confirm button.
     * If provided, displays a primary action button in the dialog footer.
     */
    approveButton?: string;
    /**
     * Unique identifier for the approve button element.
     */
    approveButtonId?: string;
    /**
     * Callback function executed when the approve button is clicked.
     * Use this to handle the primary action of the dialog.
     */
    approveButtonCallback?: () => void;
    /**
     * ARIA label for the approve button element.
     * Provides an accessible name for screen readers, especially when the button text is not descriptive.
     */
    approveButtonAriaLabel?: string;
    /**
     * Label text for the cancel/dismiss button.
     * If provided, displays a secondary action button in the dialog footer.
     */
    cancelButton?: string;
    /**
     * Unique identifier for the cancel button element.
     */
    cancelButtonId?: string;
    /**
     * Callback function executed when the cancel button is clicked.
     * Use this to handle cancellation or dismissal logic.
     */
    cancelButtonCallback?: () => void;
    /**
     * Callback function executed when the close button (X icon) is clicked.
     * Typically used to dismiss the dialog without taking action.
     */
    closeButtonCallback?: () => void;
    /**
     * Callback function executed when the full screen toggle button is clicked.
     * Use this to handle expanding or minimizing the dialog to full screen.
     */
    fullScreenButtonCallback?: () => void;
    /**
     * Title/tooltip text for the close button.
     * Displayed on hover to provide context for the close action.
     */
    closeButtonTitle?: string;
    /**
     * ARIA label for the close button element.
     * Provides an accessible name for screen readers.
     */
    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 OnDestroy, HasElementRef {
    /** @hidden Reference to dialog window element*/
    abstract dialogWindow: ElementRef;
    /** @hidden */
    abstract get _ref(): D;
    /** @hidden */
    abstract get _config(): DialogConfigBase<any>;
    /** @hidden */
    readonly _focusTrapService: FocusTrapService;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly _router: Router;
    /** @hidden */
    protected readonly _rtlService: RtlService | null;
    /** @hidden */
    protected readonly _injector: Injector;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /** @hidden RTL direction computed from service */
    protected readonly dir: i0.Signal<"rtl" | "ltr">;
    /** @hidden Dialog padding sizes - signal for reactive updates */
    protected readonly dialogPaddingSize: i0.WritableSignal<DialogSize | undefined>;
    /** @hidden Focus trap ID - used by child classes to pause/unpause */
    protected _focusTrapId: string | undefined;
    /** @hidden Dialog width - tracked via ResizeObserver */
    private readonly _dialogWidth;
    /** @hidden ResizeObserver for dialog element */
    private _resizeObserver?;
    /**
     * @hidden
     * Used to mute errors of focus trap during unit tests (jsdom incompatibility).
     */
    private readonly _focusTrapError;
    /** @hidden */
    constructor();
    /** @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 */
    ngOnDestroy(): void;
    /**
     * @deprecated Use reactive ResizeObserver instead. This method is kept for backward compatibility
     * but is no longer needed as padding updates happen automatically via signals.
     * @hidden Determine dialog padding size based on dialogs window width
     */
    adjustResponsivePadding(): void;
    /** @hidden Setup focus trap - called from constructor via afterNextRender */
    protected setupFocusTrap(): void;
    /**
     * @hidden
     * Apply all style configurations to dialog element (position and dimensions).
     * Combines position and size styling in one method for better organization.
     */
    protected applyStyles(): void;
    /**
     * @hidden
     * Sets up ResizeObserver to track dialog element size changes.
     */
    protected setupResizeObserver(): void;
    /** @hidden Listen on NavigationStart event and dismiss the dialog */
    private _listenAndCloseOnNavigation;
    /** @hidden Deactivate focus trap on destroy */
    private _deactivateFocusTrap;
    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 { DialogCloseResult, DialogContainer, DialogContentType, DialogRefLoadingConfiguration, DialogStatus, DialogTemplateDirectiveContext, ExtendedDialogConfig };
