import * as i0 from '@angular/core';
import { EventEmitter, OnDestroy, OnInit, ElementRef, ViewContainerRef, Type, EnvironmentInjector, NgZone } from '@angular/core';
import { Observable, Subject, BehaviorSubject } from 'rxjs';
import { AnimationEvent } from '@angular/animations';
import { NavigationExtras, Router } from '@angular/router';
import { SkyCoreAdapterService, SkyAppWindowRef, SkyDynamicComponentService, SkyDynamicComponentLegacyService } from '@skyux/core';

/**
 * Handler for notifying the flyout when it is appropriate to close the flyout. This will be returned from the flyout instance's `beforeClose` observable.
 */
declare class SkyFlyoutBeforeCloseHandler {
    /**
     * Function which should be called to close the flyout. This should be called once any intervening actions have completed.
     */
    readonly closeFlyout: () => void;
    constructor(closeFlyoutFunction: () => void);
}

/**
 * Arguments used when closing a flyout programmatically.
 */
interface SkyFlyoutCloseArgs {
    /**
     * Whether the `SkyFlyoutBeforeCloseHandler` is ignored when closing a flyout.
     */
    ignoreBeforeClose?: boolean;
}

/**
 * @internal
 */
declare enum SkyFlyoutMessageType {
    Open = 0,
    Close = 1,
    EnableIteratorNextButton = 2,
    EnableIteratorPreviousButton = 3,
    DisableIteratorNextButton = 4,
    DisableIteratorPreviousButton = 5
}

/**
 * @internal
 */
interface SkyFlyoutMessage {
    type: SkyFlyoutMessageType;
    data?: {
        ignoreBeforeClose?: boolean;
    };
}

/**
 * Represents a single displayed flyout.
 */
declare class SkyFlyoutInstance<T> {
    #private;
    /**
     * An event that the flyout instance emits when it is about to close.
     * If a subscription exists for this event,
     * the flyout does not close until the subscriber calls the handler's `closeModal` method.
     */
    get beforeClose(): Observable<SkyFlyoutBeforeCloseHandler>;
    /**
     * An event that the flyout instance emits when it closes.
     */
    closed: EventEmitter<void>;
    /**
     * The instance of the component to display in the flyout.
     */
    componentInstance: T;
    /**
     * Used to communicate with the host component.
     * @internal
     */
    get hostController(): Subject<SkyFlyoutMessage>;
    /**
     * A `boolean` value that returns `true` if the flyout is open.
     * @default true
     */
    isOpen: boolean;
    /**
     * An event that the flyout instance emits when users click the next iterator button.
     */
    get iteratorNextButtonClick(): EventEmitter<void>;
    /**
     * An event that the flyout instance emits when users click the previous iterator button.
     */
    get iteratorPreviousButtonClick(): EventEmitter<void>;
    /**
     * Disables the next iterator button.
     * @default false
     */
    set iteratorNextButtonDisabled(newValue: boolean);
    get iteratorNextButtonDisabled(): boolean;
    /**
     * Disables the previous iterator button.
     * @default false
     */
    set iteratorPreviousButtonDisabled(newValue: boolean);
    get iteratorPreviousButtonDisabled(): boolean;
    constructor(componentInstance?: T);
    /**
     * Closes the flyout instance and emits its `closed` event.
     * @param args Arguments used when closing the flyout.
     */
    close(args?: SkyFlyoutCloseArgs): void;
}

interface SkyFlyoutAction {
    /**
     * The button's label.
     */
    label?: string;
    /**
     * The callback function to execute when the button is clicked.
     */
    callback?: () => void;
    /**
     * Whether to close the flyout after the button is clicked.
     */
    closeAfterInvoking?: boolean;
}

interface SkyFlyoutPermalink {
    /**
     * The text label for the permalink button.
     */
    label?: string;
    /**
     * The object that represents the
     * [Angular application route](https://angular.dev/api/router/Router#navigate).
     * The object includes two properties that are mapped to Angular's
     * `Router.navigate(commands, extras?)` method.
     */
    route?: {
        commands: any[];
        extras?: NavigationExtras;
    };
    /**
     * The external URL for the permalink.
     */
    url?: string;
}

/**
 * Specifies the configuration options to set up a flyout.
 */
interface SkyFlyoutConfig {
    /**
     * The HTML element ID of the element that describes
     * the flyout. This sets the flyout's `aria-describedby` attribute
     * to provide a text equivalent for screen readers [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
     * The description typically includes text on the flyout but not on items that users
     * interact with, such as buttons and forms.
     * For more information about the `aria-describedby` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-describedby).
     */
    ariaDescribedBy?: string;
    /**
     * The ARIA label for the flyout. This sets the flyouts's `aria-label` attribute to provide a text equivalent for screen readers
     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
     * If the flyout includes a visible label, use `ariaLabelledBy` instead.
     * For more information about the `aria-label` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-label).
     */
    ariaLabel?: string;
    /**
     * The HTML element ID of the element that labels
     * the flyout. This sets the flyout's `aria-labelledby` attribute to provide a text equivalent for screen readers
     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).
     * If the flyout does not include a visible label, use `ariaLabel` instead.
     * For more information about the `aria-labelledby` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-labelledby).
     */
    ariaLabelledBy?: string;
    /**
     * The ARIA role for the flyout
     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility)
     * by indicating how the flyout functions and what it controls. For information about how
     * an ARIA role indicates what an item represents on a web page,
     * see the [WAI-ARIA roles model](https://www.w3.org/WAI/PF/aria/#roles).
     * @default dialog
     * @deprecated Since version `5.1.0`. Consumers should use the default `dialog` role to ensure a
     * proper accessibility implementation.
     */
    ariaRole?: string;
    /**
     * The default width of the flyout container. If you do not provide a width,
     * the flyout defaults to half the width of its container.
     */
    defaultWidth?: number;
    /**
     * The minimum resize width of the flyout container.
     * @default 320
     */
    minWidth?: number;
    /**
     * The maximum resize width of the flyout container.
     * @default defaultWidth
     */
    maxWidth?: number;
    /**
     * Displays a permalink button in the flyout header that navigates users to the URL
     * (or application route) representative of the flyout's contents.
     */
    permalink?: SkyFlyoutPermalink;
    /**
     * Displays a configurable button in the flyout header.
     */
    primaryAction?: SkyFlyoutAction;
    /**
     * The array of custom providers to pass to the component's constructor.
     */
    providers?: any[];
    /**
     * Whether to display iterator buttons in the flyout header
     * to access the next and previous records in a record set.
     * @default false
     */
    showIterator?: boolean;
    /**
     * Disables the previous iterator button in the flyout header that accesses
     * the previous record in a record set.
     * @default false
     */
    iteratorPreviousButtonDisabled?: boolean;
    /**
     * Disables the next iterator button in the flyout header that accesses the next record
     * in a record set.
     * @default false
     */
    iteratorNextButtonDisabled?: boolean;
    /**
     * The unique key for the UI Config Service to retrieve stored settings from a database.
     * The UI Config Service saves configuration settings for users to preserve the width of
     * the flyout. For more information about the UI Config Service,
     * see [the sticky settings documentation](https://developer.blackbaud.com/skyux/learn/develop/sticky-settings).
     */
    settingsKey?: string;
}

/**
 * Type to represent the flyout configuration after default values have been applied.
 * @internal
 */
interface SkyFlyoutConfigInternal extends SkyFlyoutConfig {
    /**
     * The default width of the flyout container. If you do not provide a width,
     * the flyout defaults to half the width of its container.
     */
    defaultWidth: number;
    /**
     * The minimum resize width of the flyout container.
     * @default 320
     */
    minWidth: number;
    /**
     * The maximum resize width of the flyout container.
     * @default defaultWidth
     */
    maxWidth: number;
    /**
     * The array of custom providers to pass to the component's constructor.
     */
    providers: any[];
}

/**
 * @internal
 */
declare class SkyFlyoutComponent implements OnDestroy, OnInit {
    #private;
    config: SkyFlyoutConfigInternal;
    enableTrapFocus: boolean;
    enableTrapFocusAutoCapture: boolean;
    flyoutId: string;
    flyoutState: string;
    isOpen: boolean;
    isOpening: boolean;
    flyoutWidth: number;
    instanceReady: boolean;
    isDragging: boolean;
    isFullscreen: boolean;
    resizeKeyControlActive: boolean;
    get messageStream(): Subject<SkyFlyoutMessage>;
    permalink: SkyFlyoutPermalink;
    permalinkLabel: string;
    primaryAction: SkyFlyoutAction;
    primaryActionLabel: string;
    /**
     * @internal
     */
    widthStep: number;
    /**
     * @internal
     */
    flyoutRef: ElementRef | undefined;
    target: ViewContainerRef | undefined;
    flyoutHeader: ElementRef | undefined;
    protected zIndex$: BehaviorSubject<number>;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    onWindowResize(event: Event): void;
    attach<T>(component: Type<T>, config?: SkyFlyoutConfig, environmentInjector?: EnvironmentInjector): SkyFlyoutInstance<T>;
    close(): void;
    invokePrimaryAction(): boolean;
    getAnimationState(): string;
    animationDone(event: AnimationEvent): void;
    onHeaderGrabHandleMouseDown(event: MouseEvent): void;
    onHeaderGrabHandleKeyDown(event: KeyboardEvent): void;
    onResizeHandleKeyDown(event: KeyboardEvent): void;
    onResizeHandleMouseDown(event: MouseEvent): void;
    onMouseMove(event: MouseEvent): void;
    onHandleRelease(): void;
    onIteratorPreviousButtonClick(): void;
    onIteratorNextButtonClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SkyFlyoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SkyFlyoutComponent, "sky-flyout", never, {}, {}, never, never, true, never>;
}

declare class SkyFlyoutModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SkyFlyoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyFlyoutModule, never, [typeof SkyFlyoutComponent], [typeof SkyFlyoutComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SkyFlyoutModule>;
}

/**
 * Launches flyouts and provides a common look and feel.
 * This service dynamically generates the flyout component and appends it directly to the
 * document's `body` element. The `SkyFlyoutInstance` class watches for and triggers flyout events.
 */
declare class SkyFlyoutService implements OnDestroy {
    #private;
    private static host;
    constructor(coreAdapter: SkyCoreAdapterService, windowRef: SkyAppWindowRef, dynamicComponentService: SkyDynamicComponentService, router: Router, ngZone: NgZone);
    ngOnDestroy(): void;
    /**
     * Closes the flyout. This method also removes the flyout's HTML elements from the DOM.
     * @param args Arguments used when closing the flyout.
     */
    close(args?: SkyFlyoutCloseArgs): void;
    /**
     * Opens a flyout and displays the specified component.
     * @param component Specifies the component to render.
     * @param config Specifies the flyout configuration passed to the specified component's constructor.
     */
    open<T>(component: Type<T>, config?: SkyFlyoutConfig): SkyFlyoutInstance<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SkyFlyoutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SkyFlyoutService>;
}
/**
 * Launches flyouts and provides a common look and feel.
 * This service dynamically generates the flyout component and appends it directly to the
 * document's `body` element. The `SkyFlyoutInstance` class watches for and triggers flyout events.
 * @internal
 * @deprecated Use `SkyFlyoutService` to open a standalone component instead.
 */
declare class SkyFlyoutLegacyService extends SkyFlyoutService {
    constructor(coreAdapter: SkyCoreAdapterService, windowRef: SkyAppWindowRef, dynamicComponentService: SkyDynamicComponentLegacyService, router: Router, ngZone: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<SkyFlyoutLegacyService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SkyFlyoutLegacyService>;
}

export { SkyFlyoutBeforeCloseHandler, SkyFlyoutInstance, SkyFlyoutLegacyService, SkyFlyoutMessageType, SkyFlyoutModule, SkyFlyoutService, SkyFlyoutComponent as λ1 };
export type { SkyFlyoutAction, SkyFlyoutCloseArgs, SkyFlyoutConfig, SkyFlyoutMessage, SkyFlyoutPermalink };