import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import * as i0 from '@angular/core';
import { Type, AfterContentInit, AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef } from '@angular/core';
import { ConfigurableFocusTrapFactory } from '@angular/cdk/a11y';
import * as i2 from '@angular/cdk/portal';
import { ComponentPortal } from '@angular/cdk/portal';
import * as i1 from '@daffodil/design';
import { DaffOpenable, DaffOpenableDirective, DaffFocusStackService } from '@daffodil/design';
import * as i3 from '@angular/cdk/overlay';
import { Overlay } from '@angular/cdk/overlay';
import * as i1$1 from '@angular/common';
import * as i4 from '@daffodil/design/button';
import * as i5 from '@fortawesome/angular-fontawesome';
import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';

/**
 * Reference to modal instance.
 */
interface DaffModalRef<T> {
    /**
     * The component instance inside the modal.
     */
    instance: T;
    /**
     * Closes the modal.
     */
    close(): void;
    /**
     * Emits when the modal close animation completes.
     */
    afterClosed: Observable<boolean>;
}

type DaffModalVerticalPosition = 'top' | 'center';
interface DaffModalPosition {
    /**
     * The vertical position of the modal. Can be 'top' or 'center'.
     */
    vertical?: DaffModalVerticalPosition;
    /**
     * Optional offset from the top edge. Defaults to `10rem`.
     */
    offsetTop?: string;
}
interface DaffModalConfiguration {
    /**
     * A hook for what to do when the backdrop behind a
     * DaffModalComponent is interacted with.
     */
    onBackdropClicked?: () => void;
    /** Sets the `aria-labelledby` property on the modal. */
    ariaLabelledBy?: string;
    /**
     * The position of the modal. If not provided, defaults to centered horizontally and vertically.
     * Horizontal position is always center.
     *
     * @example
     * ```ts
     * // Center (default)
     * { vertical: 'center' }
     *
     * // Top with offset
     * { vertical: 'top', offsetTop: '2rem' }
     * ```
     */
    position?: DaffModalPosition;
}

declare class DaffModalService {
    private overlay;
    private _modals;
    constructor(overlay: Overlay);
    private defaultConfiguration;
    private _attachModal;
    private _attachModalContent;
    private _createPositionStrategy;
    private _createOverlayRef;
    private _removeModal;
    private _closeAllModals;
    open<T>(component: Type<T>, configuration?: Partial<DaffModalConfiguration>): DaffModalRef<T>;
    close(component: DaffModalComponent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DaffModalService>;
}

declare class DaffModalComponent implements AfterContentInit, AfterViewInit, OnDestroy, DaffOpenable {
    private modalService;
    private _focusTrapFactory;
    private elementRef;
    private openDirective;
    private _focusStack;
    private changeDetector;
    /**
     * @docs-private
     */
    readonly closing: i0.WritableSignal<boolean>;
    private _ariaLabelledBy;
    /**
     * @docs-private
     *
     * By default, the `aria-labelledby` of the modal is set to the `id` of the modal title.
     */
    get ariaLabelledBy(): string;
    set ariaLabelledBy(value: string);
    /**
     * @docs-private
     *
     * The CDK Portal outlet used to portal content into the modal.
     */
    private _portalOutlet;
    /**
     * Private subject for closed animation completion events.
     */
    private _closedAnimationCompleted;
    /**
     * Observable that emits when the close animation is completed.
     */
    readonly closedAnimationCompleted$: rxjs.Observable<boolean>;
    /**
     * @docs-private
     */
    onEscape(): void;
    private _focusTrap;
    constructor(modalService: DaffModalService, _focusTrapFactory: ConfigurableFocusTrapFactory, elementRef: ElementRef<HTMLElement>, openDirective: DaffOpenableDirective, _focusStack: DaffFocusStackService, changeDetector: ChangeDetectorRef);
    /**
     * @docs-private
     */
    ngAfterContentInit(): void;
    /**
     * @docs-private
     */
    ngAfterViewInit(): void;
    /**
     * @docs-private
     *
     * Helper method to attach portable content to modal.
     */
    attachContent(portal: ComponentPortal<any>): any;
    /**
     * Tracks the open state of the modal.
     */
    get open(): i0.ModelSignal<boolean>;
    /**
     * @docs-private
     *
     * Reveals the modal.
     */
    reveal(): void;
    /**
     * @docs-private
     *
     * Hides the modal.
     */
    hide(): void;
    /**
     * @docs-private
     *
     * Toggles the visibility of the modal.
     */
    toggle(): void;
    /**
     * @docs-private
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DaffModalComponent, "daff-modal", never, {}, {}, never, never, true, [{ directive: typeof i1.DaffOpenableDirective; inputs: {}; outputs: { "toggled": "toggled"; }; }]>;
}

declare class DaffModalHeaderComponent {
    faXmark: _fortawesome_fontawesome_common_types.IconDefinition;
    /**
     * Whether or not a modal is dismissible.
     */
    dismissible: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DaffModalHeaderComponent, "daff-modal-header", never, { "dismissible": { "alias": "dismissible"; "required": false; }; }, {}, never, ["[daffModalTitle]"], true, never>;
}

/**
 * Title of a modal.
 */
declare class DaffModalTitleDirective {
    private modal;
    /**
     * @docs-private
     */
    _id: string;
    constructor(modal: DaffModalComponent);
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalTitleDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DaffModalTitleDirective, "[daffModalTitle]", never, {}, {}, never, never, true, never>;
}

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

declare class DaffModalActionsComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DaffModalActionsComponent, "daff-modal-actions", never, {}, {}, never, ["*"], true, never>;
}

/**
 * The DaffModalCloseDirective is a helper directive that passes a click
 * event to the button it's used with to close a modal. It needs to be
 * implemented with the `<button>` HTML element to work. This helps to
 * reduce code duplication.
 */
declare class DaffModalCloseDirective {
    private modalService;
    private modal;
    constructor(modalService: DaffModalService, modal: DaffModalComponent);
    /**
     * @docs-private
     */
    onClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalCloseDirective, [null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DaffModalCloseDirective, "button[daffModalClose]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated in favor of {@link DAFF_MODAL_COMPONENTS}. Deprecated in version 0.78.0. Will be removed in version 1.0.0.
 */
declare class DaffModalModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffModalModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffModalModule, never, [typeof i1$1.CommonModule, typeof i2.PortalModule, typeof i3.OverlayModule, typeof i4.DaffButtonModule, typeof i5.FontAwesomeModule, typeof DaffModalComponent, typeof DaffModalHeaderComponent, typeof DaffModalTitleDirective, typeof DaffModalContentComponent, typeof DaffModalActionsComponent, typeof DaffModalCloseDirective], [typeof DaffModalComponent, typeof DaffModalHeaderComponent, typeof DaffModalTitleDirective, typeof DaffModalContentComponent, typeof DaffModalActionsComponent, typeof DaffModalCloseDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DaffModalModule>;
}

/**
 * @docs-private
 */
declare const DAFF_MODAL_COMPONENTS: readonly [typeof DaffModalHeaderComponent, typeof DaffModalTitleDirective, typeof DaffModalContentComponent, typeof DaffModalActionsComponent, typeof DaffModalCloseDirective];

export { DAFF_MODAL_COMPONENTS, DaffModalActionsComponent, DaffModalCloseDirective, DaffModalComponent, DaffModalContentComponent, DaffModalHeaderComponent, DaffModalModule, DaffModalService, DaffModalTitleDirective };
export type { DaffModalRef };