import * as i2 from '@sbb-esta/angular/dialog';
import { SbbDialogContainer, SbbDialogRole, SbbDialogRef, SbbDialogClose, SbbDialog, _SbbDialogTitleBase, _SbbDialogBase } from '@sbb-esta/angular/dialog';
export { SbbDialogRole } from '@sbb-esta/angular/dialog';
import * as i0 from '@angular/core';
import { OnDestroy, ViewContainerRef, Injector, OnInit, OnChanges, SimpleChanges, InjectionToken, TemplateRef } from '@angular/core';
import * as i1 from '@angular/cdk/dialog';
import { DialogRef } from '@angular/cdk/dialog';
import * as i2$1 from '@angular/cdk/overlay';
import { ScrollStrategy } from '@angular/cdk/overlay';
import * as i1$1 from '@angular/cdk/portal';
import { ComponentType } from '@angular/cdk/portal';
import * as i1$2 from '@sbb-esta/angular/core';
import * as i3 from '@sbb-esta/angular/icon';
import { AnimationEvent, AnimationTriggerMetadata } from '@angular/animations';
import { Subject } from 'rxjs';

/**
 * Internal component that wraps user-provided lightbox content.
 * @docs-private
 */
declare class SbbLightboxContainer extends SbbDialogContainer implements OnDestroy {
    private _viewportRuler;
    /** Callback, invoked whenever an animation on the host completes. */
    _onAnimationDone({ toState, totalTime }: AnimationEvent): void;
    /** Callback, invoked when an animation on the host starts. */
    _onAnimationStart({ toState, totalTime }: AnimationEvent): void;
    /** Starts the dialog exit animation. */
    _startExitAnimation(): void;
    private _destroyed;
    constructor(...args: unknown[]);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightboxContainer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SbbLightboxContainer, "sbb-lightbox-container", never, {}, {}, never, never, true, never>;
}

/**
 * Configuration for opening a modal dialog with the SbbLightbox service.
 */
declare class SbbLightboxConfig<D = any> {
    /**
     * Where the attached component should live in Angular's *logical* component tree.
     * This affects what is available for injection and the change detection order for the
     * component instantiated inside of the lightbox. This does not affect where the lightbox
     * content will be rendered.
     */
    viewContainerRef?: ViewContainerRef;
    /**
     * Injector used for the instantiation of the component to be attached. If provided,
     * takes precedence over the injector indirectly provided by `ViewContainerRef`.
     */
    injector?: Injector;
    /** ID for the lightbox. If omitted, a unique one will be generated. */
    id?: string;
    /** The ARIA role of the dialog element. */
    role?: SbbDialogRole;
    /** Custom class for the overlay pane. */
    panelClass?: string | string[];
    /** Whether the user can use escape or clicking on the backdrop to close the modal. */
    disableClose?: boolean;
    /** Data being injected into the child component. */
    data?: D | null;
    /** ID of the element that describes the dialog. */
    ariaDescribedBy?: string | null;
    /** ID of the element that labels the dialog. */
    ariaLabelledBy?: string | null;
    /** Aria label to assign to the dialog element. */
    ariaLabel?: string | null;
    /** Whether this is a modal dialog. Used to set the `aria-modal` attribute. */
    ariaModal?: boolean;
    /** Whether the dialog should focus the first focusable element on open. */
    autoFocus?: boolean;
    /**
     * Whether the dialog should restore focus to the
     * previously-focused element, after it's closed.
     */
    restoreFocus?: boolean;
    /** Scroll strategy to be used for the dialog. */
    scrollStrategy?: ScrollStrategy;
    /**
     * Whether the dialog should close when the user goes backwards/forwards in history.
     * Note that this usually doesn't include clicking on links (unless the user is using
     * the `HashLocationStrategy`).
     */
    closeOnNavigation?: boolean;
    /** Duration of the enter animation. Has to be a valid CSS value (e.g. 100ms). */
    enterAnimationDuration?: string;
    /** Duration of the exit animation. Has to be a valid CSS value (e.g. 50ms). */
    exitAnimationDuration?: string;
}

/**
 * Reference to a dialog opened via the SbbLightbox service.
 */
declare class SbbLightboxRef<T, R = any> extends SbbDialogRef<T, R> {
    /**
     * Observable that emits when closing the lightbox is requested when close is disabled.
     */
    readonly closeRequest: Subject<void>;
    constructor(ref: DialogRef<R, T>, config: SbbLightboxConfig, containerInstance: SbbDialogContainer);
    /**
     * Not supported for lightbox.
     * @docs-private
     */
    updatePosition(): this;
    /**
     * Not supported for lightbox.
     * @docs-private
     */
    updateSize(): this;
}

/**
 * Button that will close the current lightbox.
 */
declare class SbbLightboxClose extends SbbDialogClose implements OnInit, OnChanges {
    protected _dialogRef: SbbLightboxRef<any>;
    protected _dialog: SbbDialog;
    /** Aria label for the close button. */
    ariaLabel: string;
    /** Lightbox close input. */
    get lightboxResult(): any;
    set lightboxResult(value: any);
    _sbbLightboxClose: any;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightboxClose, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SbbLightboxClose, "[sbb-lightbox-close], [sbbLightboxClose]", ["sbbLightboxClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "lightboxResult": { "alias": "sbb-lightbox-close"; "required": false; }; "_sbbLightboxClose": { "alias": "sbbLightboxClose"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Title of a lightbox element. Stays fixed to the top of the lightbox when scrolling.
 */
declare class SbbLightboxTitle extends _SbbDialogTitleBase implements OnInit {
    protected _dialogRef: SbbLightboxRef<any>;
    protected _dialog: SbbDialog;
    /** Unique id for the lightbox title. If none is supplied, it will be auto-generated. */
    id: string;
    _lightBoxClose: SbbLightboxClose;
    /** Arial label for the close button. */
    closeAriaLabel: string;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightboxTitle, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SbbLightboxTitle, "sbb-lightbox-title, [sbb-lightbox-title], [sbbLightboxTitle]", ["sbbLightboxTitle"], { "id": { "alias": "id"; "required": false; }; "closeAriaLabel": { "alias": "closeAriaLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Scrollable content container of a lightbox.
 */
declare class SbbLightboxContent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightboxContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SbbLightboxContent, "[sbb-lightbox-content], sbb-lightbox-content, [sbbLightboxContent]", never, {}, {}, never, never, true, never>;
}
/**
 * Container for the bottom action buttons in a lightbox.
 * Stays fixed to the bottom when scrolling.
 */
declare class SbbLightboxActions {
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightboxActions, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SbbLightboxActions, "[sbb-lightbox-actions], sbb-lightbox-actions, [sbbLightboxActions]", never, {}, {}, never, never, true, never>;
}

declare class SbbLightboxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightboxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SbbLightboxModule, never, [typeof i1.DialogModule, typeof i2.SbbDialogModule, typeof i2$1.OverlayModule, typeof i1$1.PortalModule, typeof i1$2.SbbCommonModule, typeof i3.SbbIconModule, typeof SbbLightboxContainer, typeof SbbLightboxClose, typeof SbbLightboxTitle, typeof SbbLightboxActions, typeof SbbLightboxContent], [typeof SbbLightboxContainer, typeof SbbLightboxClose, typeof SbbLightboxTitle, typeof SbbLightboxContent, typeof SbbLightboxActions]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SbbLightboxModule>;
}

/** Injection token that can be used to access the data that was passed in to a dialog. */
declare const SBB_LIGHTBOX_DATA: InjectionToken<any>;
/** Injection token that can be used to specify default dialog options. */
declare const SBB_LIGHTBOX_DEFAULT_OPTIONS: InjectionToken<SbbLightboxConfig<any>>;
/** Injection token that determines the scroll handling while the dialog is open. */
declare const SBB_LIGHTBOX_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
/**
 * Service to open modal lightboxes.
 */
declare class SbbLightbox extends _SbbDialogBase<SbbLightboxContainer, SbbLightboxRef<any>> {
    protected _idPrefix: string;
    /** Keeps track of the currently-open lightboxes. */
    get openLightboxes(): SbbLightboxRef<any>[];
    constructor(...args: unknown[]);
    /**
     * Opens a modal lightbox containing the given template.
     * @param componentOrTemplateRef Component type or TemplateRef to instantiate as the lightbox content.
     * @param config Extra configuration options.
     * @returns Reference to the newly-opened lightbox.
     */
    open<T, D = any, R = any>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, config?: SbbLightboxConfig<D>): SbbLightboxRef<T, R>;
    /**
     * Finds an open lightbox by its id.
     * @param id ID to use when looking up the lightbox.
     * @alias getLightboxById
     */
    getDialogById(id: string): SbbLightboxRef<any> | undefined;
    /**
     * Finds an open lightbox by its id.
     * @param id ID to use when looking up the lightbox.
     */
    getLightboxById(id: string): SbbLightboxRef<any> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLightbox, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SbbLightbox>;
}

/**
 * Animations used by SbbLightbox.
 * @docs-private
 */
declare const sbbLightboxAnimations: {
    readonly lightboxContainer: AnimationTriggerMetadata;
};

export { SBB_LIGHTBOX_DATA, SBB_LIGHTBOX_DEFAULT_OPTIONS, SBB_LIGHTBOX_SCROLL_STRATEGY, SbbLightbox, SbbLightboxActions, SbbLightboxClose, SbbLightboxConfig, SbbLightboxContainer, SbbLightboxContent, SbbLightboxModule, SbbLightboxRef, SbbLightboxTitle, sbbLightboxAnimations };