@villedemontreal/angular-ui 19.0.1 → 20.0.0

package/index.d.ts

@@ -1,5 +1,2387 @@
+import * as i0 from '@angular/core';
+import { OnChanges, EventEmitter, SimpleChanges, OnDestroy, ElementRef, Renderer2, AfterContentInit, ChangeDetectorRef, AfterViewInit, ViewContainerRef, Injector, NgZone, ComponentRef, EmbeddedViewRef, InjectionToken, Type, TemplateRef, OnInit, QueryList, Optional } from '@angular/core';
+import * as i2 from '@angular/common';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i3 from '@angular/cdk/observers';
+import { ConfigurableFocusTrapFactory, FocusOrigin, InteractivityChecker, FocusMonitor, AriaLivePoliteness, LiveAnnouncer } from '@angular/cdk/a11y';
+import * as i5 from '@angular/cdk/portal';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, DomPortal, ComponentType as ComponentType$1 } from '@angular/cdk/portal';
+import { Direction } from '@angular/cdk/bidi';
+import * as i4 from '@angular/cdk/overlay';
+import { ScrollStrategy, OverlayRef, Overlay, OverlayContainer, ComponentType } from '@angular/cdk/overlay';
+import { Observable, Subject } from 'rxjs';
+import * as i4$1 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import { AnimationEvent } from '@angular/animations';
+import { Platform } from '@angular/cdk/platform';
+import { BreakpointObserver } from '@angular/cdk/layout';
+
 /**
- * Generated bundle index. Do not edit.
+ * Content of an alert, intended for use within `<bao-alert>`. This component is an optional
+ * convenience for use with other convenience elements, such as `<bao-alert-title>`; any custom
+ * content block element may be used in its place.
+ *
+ * BaoAlertContent provides no behaviors, instead serving as a purely visual treatment.
  */
-/// <amd-module name="@villedemontreal/angular-ui" />
-export * from './public-api';
+/**
+ * Title of an alert, intended for use within `<bao-alert>`. This component is an optional
+ * convenience for one variety of alert title; any custom title element may be used in its place.
+ *
+ * BaoAlertTitle provides no behaviors, instead serving as a purely visual treatment.
+ */
+declare class BaoAlertTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAlertTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoAlertTitle, "bao-alert-title", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Content of an alert, intended for use within `<bao-alert>`. This component is an optional
+ * convenience for use with other convenience elements, such as `<bao-alert-title>`; any custom
+ * content block element may be used in its place.
+ *
+ * BaoAlertContent provides no behaviors, instead serving as a purely visual treatment.
+ */
+declare class BaoAlertContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAlertContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoAlertContent, "bao-alert-content", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Bottom area of an alert that contains action buttons, intended for use within `<bao-alert>`.
+ * This component is an optional convenience for use with other convenience elements, such as
+ * `<bao-alert-content>`; any custom action block element may be used in its place.
+ *
+ * BaoAlertActions provides no behaviors, instead serving as a purely visual treatment.
+ */
+declare class BaoAlertActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAlertActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoAlertActions, "bao-alert-actions", ["baoAlertActions"], {}, {}, never, never, false, never>;
+}
+/**
+ * Link inside an alert message, intended for use within `<bao-alert>`.
+ * This component is an optional convenience for use with other convenience elements, such as
+ * `<bao-alert-content>`; any custom action block element may be used in its place.
+ *
+ * BaoAlertLink provides no behaviors, instead serving as a purely visual treatment.
+ */
+declare class BaoAlertLink {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAlertLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoAlertLink, "bao-alert-link", never, {}, {}, never, never, false, never>;
+}
+/**
+ * BAO alert component. Alerts should be used when the message concerns an
+ * external subject or a part of the page
+ *
+ * See https://zeroheight.com/575tugn0n/p/03c51f-messages-dalerte/t/80b47c
+ *
+ * BaoAlertComponent provides no behaviors, instead serving as a purely visual treatment.
+ */
+declare class BaoAlertComponent implements OnChanges {
+    /**
+     * Alert type
+     */
+    type: 'success' | 'danger' | 'warning' | 'emergency' | 'info';
+    dismissible: boolean;
+    alertTypeTitle?: string;
+    dismissibleButtonAriaLabel?: string;
+    dismiss: EventEmitter<any>;
+    iconType: string;
+    iconTitle: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    alertTypeIcon(value: string): any;
+    alertTitleIcon(value: string): any;
+    onDismissClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoAlertComponent, "bao-alert", never, { "type": { "alias": "type"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "alertTypeTitle": { "alias": "alertTypeTitle"; "required": false; }; "dismissibleButtonAriaLabel": { "alias": "dismissibleButtonAriaLabel"; "required": false; }; }, { "dismiss": "dismiss"; }, never, ["*"], false, never>;
+}
+
+declare const enum BaoColors {
+    ACTION = "action",
+    PRIMARY = "primary",
+    PRIMARY_REVERSED = "primary-reversed",
+    SECONDARY = "secondary",
+    TERTIARY = "tertiary",
+    INFORMATIVE = "informative",
+    NEGATIVE = "negative",
+    POSITIVE = "positive",
+    WARNING = "warning"
+}
+
+declare class BaoIconDictionary {
+    private document;
+    private domSanitizer;
+    constructor(document: any, domSanitizer: DomSanitizer);
+    getNamedSvgIcon(iconName: string): SVGElement;
+    private getRawIconStringFromIconName;
+    private svgElementFromString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoIconDictionary, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaoIconDictionary>;
+}
+
+/**
+ * Component to display an icon. It can be used in the following ways:
+ *
+ * - Specify the svgIcon input to load an SVG icon from a preset list of icons.
+ *   Examples:
+ *     `<bao-icon svgIcon="heart"></bao-icon>`
+ */
+declare class BaoIconComponent implements OnDestroy {
+    private elementRef;
+    private iconRegistry;
+    private renderer;
+    /** The color of the icon, if not specified the icon's parent current text color will be used */
+    color: BaoColors;
+    /**
+     * The size of the icon
+     */
+    size: 'medium' | 'small' | 'x-small' | 'xx-small';
+    private _svgIcon;
+    private _title;
+    private _titleId;
+    private _elementsWithExternalReferences?;
+    constructor(elementRef: ElementRef<HTMLElement>, iconRegistry: BaoIconDictionary, renderer: Renderer2);
+    /** Name of the icon in the SVG icon set. */
+    get svgIcon(): string;
+    /** Title that will be used as an aria-label for the icon */
+    get title(): string;
+    get hexColor(): string | void;
+    get titleId(): string;
+    set svgIcon(value: string);
+    set title(value: string);
+    ngOnDestroy(): void;
+    private setSvgElement;
+    private clearSvgElement;
+    private updateSvgIcon;
+    private addTitleToSVG;
+    private removeTitleAttributeFromHost;
+    private generateUniqueTitleId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoIconComponent, "bao-icon", ["baoIcon"], { "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BaoIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoIconModule, [typeof BaoIconComponent], [typeof i2.CommonModule], [typeof BaoIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoIconModule>;
+}
+
+declare class BaoButtonComponent implements AfterContentInit {
+    private elementRef;
+    private cdr;
+    /**
+     * The display type of the button
+     */
+    displayType: 'utility' | 'editorial';
+    /**
+     * The hierarchy level of the button
+     */
+    level: 'primary' | 'secondary' | 'tertiary';
+    /**
+     * The size of the button
+     */
+    size: 'large' | 'medium' | 'small';
+    /**
+     * Flag to set the button in loading state
+     */
+    loading: boolean;
+    /**
+     * Flag to set the button reversed color mode
+     */
+    reversed: boolean;
+    /**
+     * The aria-label of the loading spinner if it displayed alone
+     */
+    loadingSpinnerAriaLabel: string;
+    /**
+     * Allows the button to grow to the width of it's container
+     */
+    fullWidth: boolean;
+    /**
+     * If there is no text, some margin/padding will be different, i.e. for the spinner
+     */
+    noText: boolean;
+    /**
+     * If the icon is on the right of the label, the loading spinner will need to be on the right of the label
+     */
+    rightIcon: boolean;
+    constructor(elementRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    get nativeElement(): HTMLElement;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoButtonComponent, "button[bao-button]", never, { "displayType": { "alias": "displayType"; "required": false; }; "level": { "alias": "level"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "reversed": { "alias": "reversed"; "required": false; }; "loadingSpinnerAriaLabel": { "alias": "loadingSpinnerAriaLabel"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BaoButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoButtonModule, [typeof BaoButtonComponent], [typeof i2.CommonModule, typeof BaoIconModule], [typeof BaoButtonComponent, typeof BaoIconModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoButtonModule>;
+}
+
+declare class BaoAlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoAlertModule, [typeof BaoAlertTitle, typeof BaoAlertContent, typeof BaoAlertActions, typeof BaoAlertLink, typeof BaoAlertComponent], [typeof i2.CommonModule, typeof BaoIconModule, typeof BaoButtonModule], [typeof BaoAlertTitle, typeof BaoAlertContent, typeof BaoAlertActions, typeof BaoAlertLink, typeof BaoAlertComponent, typeof BaoIconModule, typeof BaoButtonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoAlertModule>;
+}
+
+declare class BaoAvatarContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAvatarContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoAvatarContent, "bao-avatar-content, [bao-avatar-content]", ["baoAvatarContent"], {}, {}, never, never, false, never>;
+}
+declare class BaoAvatarComponent implements AfterViewInit {
+    private renderer;
+    private elementRef;
+    /**
+     * Name of the profile to be used as title of the avatar.
+     */
+    profileName: string;
+    /**
+     * ID of the background color to be used if avatar's content is text.
+     */
+    color: 'background-color-1' | 'background-color-2' | 'background-color-3' | 'background-color-4' | 'background-color-5' | 'background-color-6' | 'background-color-7' | 'background-color-8' | 'background-color-9' | 'background-color-10';
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngAfterViewInit(): void;
+    private addIcon;
+    private setProfileName;
+    private formatInitials;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoAvatarComponent, "bao-avatar", never, { "profileName": { "alias": "profileName"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, ["bao-avatar-content, [bao-avatar-content]"], false, never>;
+}
+
+declare class BaoAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoAvatarModule, [typeof BaoAvatarComponent, typeof BaoAvatarContent], [typeof i2.CommonModule], [typeof BaoAvatarComponent, typeof BaoAvatarContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoAvatarModule>;
+}
+
+declare class BaoBadgeComponent {
+    type: '' | 'success' | 'danger' | 'warning' | 'info';
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoBadgeComponent, "bao-badge", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BaoBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoBadgeModule, [typeof BaoBadgeComponent], [typeof i2.CommonModule], [typeof BaoBadgeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoBadgeModule>;
+}
+
+/**
+ * A basic content container component that adds the styles of a BAO design card.
+ *
+ * While this component can be used alone, it also provides a number
+ * of preset styles for common card sections, including:
+ * * bao-card-body
+ * * bao-card-title
+ * * bao-card-bao-text-interface
+ * * More to come!
+ */
+declare class BaoCardComponent {
+    padding: 'normal' | 'large';
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoCardComponent, "bao-card, [bao-card], [baoCard]", never, { "padding": { "alias": "padding"; "required": false; }; }, {}, never, ["bao-card-header", "bao-card-content"], false, never>;
+}
+/**
+ * Header of a card, needed as it's used as a selector in the API.
+ */
+declare class BaoCardHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCardHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoCardHeader, "bao-card-header, [bao-card-header], [baoCardHeader]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Body of a card, needed as it's used as a selector in the API.
+ */
+declare class BaoCardContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCardContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoCardContent, "bao-card-content, [bao-card-content], [baoCardContent]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Title of a card, needed as it's used as a selector in the API.
+ */
+declare class BaoCardTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCardTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoCardTitle, "bao-card-title, [bao-card-title], [baoCardTitle]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Text of a card, needed as it's used as a selector in the API.
+ */
+declare class BaoCardTextInterface {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCardTextInterface, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoCardTextInterface, "bao-card-text-interface, [bao-card-text-interface], [baoCardTextInterface]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoCardModule, [typeof BaoCardComponent, typeof BaoCardContent, typeof BaoCardHeader, typeof BaoCardTextInterface, typeof BaoCardTitle], [typeof i2.CommonModule], [typeof BaoCardComponent, typeof BaoCardContent, typeof BaoCardHeader, typeof BaoCardTextInterface, typeof BaoCardTitle]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoCardModule>;
+}
+
+declare class BaoBreadcrumbComponent implements AfterViewInit {
+    private renderer;
+    private staticContainer;
+    constructor(renderer: Renderer2);
+    ngAfterViewInit(): void;
+    onContentChange(): void;
+    private setLastLinkAttribute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoBreadcrumbComponent, "bao-breadcrumb", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BaoBreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoBreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoBreadcrumbModule, [typeof BaoBreadcrumbComponent], [typeof i2.CommonModule, typeof i3.ObserversModule], [typeof BaoBreadcrumbComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoBreadcrumbModule>;
+}
+
+declare const FILTER_MODAL_WIDTH = "360px";
+declare enum eModalDesktopWidthSize {
+    SMALL = "bao-modal-sm",// 500px
+    MEDIUM = "bao-modal-md",// 800px
+    LARGE = "bao-modal-lg"
+}
+declare enum eModalVariant {
+    GLOBAL = "global",
+    FILTER = "filter"
+}
+declare enum eModalMobileWidthSize {
+    FULL = "bao-modal-mobil-full",// Full width on mobile screen
+    COMPACT = "bao-modal-mobil-compact"
+}
+interface BaoModalConfig {
+    size?: eModalDesktopWidthSize;
+    mobileSize?: eModalMobileWidthSize;
+    data?: unknown;
+    ariaLabelledBy?: string;
+    variant?: eModalVariant;
+    triggerElement?: ElementRef;
+}
+/** Options for where to set focus to automatically on dialog open */
+type AutoFocusTarget = 'dialog' | 'modal' | 'first-tabbable' | 'first-heading';
+/** Valid ARIA roles for a dialog element. */
+type ModalRole = 'dialog' | 'alertdialog';
+/** Possible overrides for a dialog's position. */
+interface ModalPosition {
+    /** Override for the dialog's top position. */
+    top?: string;
+    /** Override for the dialog's bottom position. */
+    bottom?: string;
+    /** Override for the dialog's left position. */
+    left?: string;
+    /** Override for the dialog's right position. */
+    right?: string;
+}
+/**
+ * Configuration for opening a modal dialog with the BaoModal service.
+ */
+declare class BaoModalInitialConfig<D = unknown> {
+    /**
+     * 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 dialog. This does not affect where the dialog
+     * 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 dialog. If omitted, a unique one will be generated. */
+    id?: string;
+    /** The ARIA role of the dialog element. */
+    role?: ModalRole;
+    /** Custom class for the overlay pane. */
+    panelClass?: string | string[];
+    /** Whether the dialog has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class for the backdrop. */
+    backdropClass?: string | string[];
+    /** Whether the user can use escape or clicking on the backdrop to close the modal. */
+    disableClose?: boolean;
+    /** Width of the dialog. */
+    width?: string;
+    /** Height of the dialog. */
+    height?: string;
+    /** Min-width of the dialog. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Min-height of the dialog. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-width of the dialog. If a number is provided, assumes pixel units. Defaults to 80vw. */
+    maxWidth?: number | string;
+    /** Max-height of the dialog. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Position overrides. */
+    position?: ModalPosition;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Layout direction for the dialog's content. */
+    direction?: Direction;
+    /** 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;
+    /** Modal variant (default or filter). */
+    variant?: eModalVariant;
+    /** Trigger element for connected positioning (used with filter variant). */
+    triggerElement?: ElementRef;
+    /**
+     * Where the dialog should focus on open.
+     */
+    autoFocus?: AutoFocusTarget;
+    /**
+     * Whether the dialog should restore focus to the
+     * previously-focused element, after it's closed.
+     */
+    restoreFocus?: boolean;
+    /** Whether to wait for the opening animation to finish before trapping focus. */
+    delayFocusTrap?: 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;
+}
+
+/** Event that captures the state of modal container animations. */
+interface DialogAnimationEvent {
+    state: 'opened' | 'opening' | 'closing' | 'closed';
+    totalTime: number;
+}
+/**
+ * Throws an exception for the case when a ComponentPortal is
+ * attached to a DomPortalOutlet without an origin.
+ * @docs-private
+ */
+declare function throwBaoModalContentAlreadyAttachedError(): void;
+/**
+ * Base class for the `BaoModalContainer`. The base class does not implement
+ * animations as these are left to implementers of the modal container.
+ */
+declare abstract class _BaoModalContainerBase extends BasePortalOutlet {
+    protected _elementRef: ElementRef;
+    protected _focusTrapFactory: ConfigurableFocusTrapFactory;
+    protected _changeDetectorRef: ChangeDetectorRef;
+    /** The modal configuration. */
+    _config: BaoModalInitialConfig;
+    private readonly _interactivityChecker;
+    private readonly _ngZone;
+    private _focusMonitor?;
+    /** The portal outlet inside of this container into which the modal content will be loaded. */
+    _portalOutlet: CdkPortalOutlet;
+    /** Emits when an animation state changes. */
+    _animationStateChanged: EventEmitter<DialogAnimationEvent>;
+    /**
+     * Type of interaction that led to the modal being closed. This is used to determine
+     * whether the focus style will be applied when returning focus to its original location
+     * after the modal is closed.
+     */
+    _closeInteractionType: FocusOrigin | null;
+    /** ID of the element that should be considered as the modal's label. */
+    _ariaLabelledBy: string | null;
+    /** ID for the container DOM element. */
+    _id: string;
+    protected _document: Document;
+    /** The class that traps and manages focus within the modal. */
+    private _focusTrap;
+    /** Element that was focused before the modal was opened. Save this to restore upon close. */
+    private _elementFocusedBeforeDialogWasOpened;
+    constructor(_elementRef: ElementRef, _focusTrapFactory: ConfigurableFocusTrapFactory, _changeDetectorRef: ChangeDetectorRef, _document: any, 
+    /** The modal configuration. */
+    _config: BaoModalInitialConfig, _interactivityChecker: InteractivityChecker, _ngZone: NgZone, _focusMonitor?: FocusMonitor);
+    /** Initializes the modal container with the attached content. */
+    _initializeWithAttachedContent(): void;
+    /**
+     * Attach a ComponentPortal as content to this modal container.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /**
+     * Attach a TemplatePortal as content to this modal container.
+     */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    /** Moves focus back into the modal if it was moved out. */
+    _recaptureFocus(): Promise<void>;
+    /**
+     * Moves the focus inside the focus trap. When autoFocus is not set to 'modal', if focus
+     * cannot be moved then focus will go to the modal container.
+     */
+    protected _trapFocus(): Promise<void>;
+    /** Restores focus to the element that was focused before the modal opened. */
+    protected _restoreFocus(): void;
+    /**
+     * Focuses the provided element. If the element is not focusable, it will add a tabIndex
+     * attribute to forcefully focus it. The attribute is removed after focus is moved.
+     */
+    private _forceFocus;
+    /**
+     * Focuses the first element that matches the given selector within the focus trap.
+     */
+    private _focusByCssSelector;
+    /** Sets up the focus trap. */
+    private _setupFocusTrap;
+    /** Captures the element that was focused before the modal was opened. */
+    private _capturePreviouslyFocusedElement;
+    /** Focuses the modal container. */
+    private _focusDialogContainer;
+    /** Returns whether focus is inside the modal. */
+    private _containsFocus;
+    /** Starts the modal exit animation. */
+    abstract _startExitAnimation(): void;
+    abstract _startOpenAnimation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_BaoModalContainerBase, [null, null, null, { optional: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_BaoModalContainerBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class BaoModalContainer extends _BaoModalContainerBase {
+    /** State of the modal animation. */
+    _state: 'void' | 'enter' | 'exit';
+    _startOpenAnimation(): void;
+    /** Starts the modal exit animation. */
+    _startExitAnimation(): void;
+    private _finishDialogOpen;
+    private _openAnimationDone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoModalContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoModalContainer, "bao-modal-container", never, {}, {}, never, never, false, never>;
+}
+
+/** Possible states of the lifecycle of a modal. */
+declare const enum BaoModalState {
+    OPEN = 0,
+    CLOSING = 1,
+    CLOSED = 2
+}
+/**
+ * Reference to a modal opened via the BaoModalService.
+ */
+declare class BaoModalRef<T, R = unknown> {
+    private _overlayRef;
+    _containerInstance: _BaoModalContainerBase;
+    /** Id of the modal. */
+    readonly id: string;
+    /** The instance of component opened into the modal. */
+    componentInstance: T;
+    /** Whether the user is allowed to close the modal. */
+    disableClose: boolean | undefined;
+    /** Subject for notifying the user that the modal has finished opening. */
+    private readonly _afterOpened;
+    /** Subject for notifying the user that the modal has finished closing. */
+    private readonly _afterClosed;
+    /** Subject for notifying the user that the modal has started closing. */
+    private readonly _beforeClosed;
+    /** Result to be passed to afterClosed. */
+    private _result;
+    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */
+    private _closeFallbackTimeout;
+    /** Current state of the modal. */
+    private _state;
+    constructor(_overlayRef: OverlayRef, _containerInstance: _BaoModalContainerBase, 
+    /** Id of the modal. */
+    id?: string);
+    /**
+     * Close the modal.
+     * @param modalResult Optional result to return to the modal opener.
+     */
+    close(modalResult?: R): void;
+    startOpenAnimation(): void;
+    /**
+     * Gets an observable that is notified when the modal is finished opening.
+     */
+    afterOpened(): Observable<void>;
+    /**
+     * Gets an observable that is notified when the modal is finished closing.
+     */
+    afterClosed(): Observable<R | undefined>;
+    /**
+     * Gets an observable that is notified when the modal has started closing.
+     */
+    beforeClosed(): Observable<R | undefined>;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick(): Observable<MouseEvent>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * Updates the dialog's position.
+     */
+    updatePosition(position?: ModalPosition): this;
+    /**
+     * Updates the modal's width and height.
+     */
+    updateSize(width?: string, height?: string): this;
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes: string | string[]): this;
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes: string | string[]): this;
+    /** Gets the current state of the modal's lifecycle. */
+    getState(): BaoModalState;
+    /**
+     * Finishes the modal close by updating the state of the modal
+     * and disposing the overlay.
+     */
+    private _finishModalClose;
+    /** Fetches the position strategy object from the overlay ref. */
+    private _getPositionStrategy;
+    /**
+     * Applies the position strategy to the overlay.
+     *
+     * This method sets the position of the modal based on the provided `position` configuration.
+     * It determines whether to apply the position to the vertical or horizontal axis based on the
+     * `axis` parameter.
+     *
+     * @param position The position configuration for the modal.
+     * @param strategy The position strategy to be applied.
+     * @param axis The axis to apply the position (`'horizontal' | 'vertical'`)
+     */
+    private applyPositionStrategy;
+}
+/**
+ * Closes the modal with the specified interaction type. This is currently not part of
+ * `BaoModalRef` as that would conflict with custom modal ref mocks provided in tests.
+ * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.
+ */
+declare function _closeModalVia<R>(ref: BaoModalRef<R>, interactionType: FocusOrigin, result?: R): void;
+
+/** Injection token that can be used to access the data that was passed in to a modal. */
+declare const BAO_MODAL_DATA: InjectionToken<unknown>;
+declare abstract class BaoModalBase<C extends _BaoModalContainerBase> implements OnDestroy {
+    private _overlay;
+    private _injector;
+    private _parentModal;
+    private _overlayContainer;
+    private _modalRefConstructor;
+    private _modalContainerType;
+    private _modalDataToken;
+    readonly afterAllClosed: Observable<void>;
+    private _openModalsAtThisLevel;
+    private readonly _afterAllClosedAtThisLevel;
+    private readonly _afterOpenedAtThisLevel;
+    private _ariaHiddenElements;
+    private _modalAnimatingOpen;
+    private _animationStateSubscriptions;
+    private _lastModalRef;
+    constructor(_overlay: Overlay, _injector: Injector, _parentModal: BaoModalBase<C> | undefined, _overlayContainer: OverlayContainer, _modalRefConstructor: Type<BaoModalRef<unknown>>, _modalContainerType: Type<C>, _modalDataToken: InjectionToken<unknown>);
+    /** Keeps track of the currently-open modals. */
+    get openModals(): BaoModalRef<unknown>[];
+    /** Stream that emits when a modal has been opened. */
+    get afterOpened(): Subject<BaoModalRef<unknown>>;
+    getAfterAllClosed(): Subject<void>;
+    /**
+     * Opens a modal modal containing the given template.
+     */
+    open<T>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, config?: BaoModalConfig): BaoModalRef<unknown>;
+    /**
+     * Closes all of the currently-open modals.
+     */
+    closeAll(): void;
+    /**
+     * Finds an open modal by its id.
+     */
+    getModalById(id: string): BaoModalRef<unknown> | undefined;
+    ngOnDestroy(): void;
+    /**
+     * Creates the overlay into which the modal will be loaded.
+     */
+    private _createOverlay;
+    /**
+     * Creates an overlay config from a modal config.
+     */
+    private _getOverlayConfig;
+    /**
+     * Attaches a modal container to a modal's already-created overlay.
+     */
+    private _attachModalContainer;
+    /**
+     * Attaches the user-provided component to the already-created modal container.
+     */
+    private _attachModalContent;
+    /**
+     * Creates a custom injector to be used inside the modal. This allows a component loaded inside
+     * of a modal to close itself and, optionally, to return a value.
+     */
+    private _createInjector;
+    /**
+     * Removes a modal from the array of open modals.
+     */
+    private _removeOpenModal;
+    /**
+     * Hides all of the content that isn't an overlay from assistive technology.
+     */
+    private _hideNonModalContentFromAssistiveTechnology;
+    /** Closes all of the modals in an array. */
+    private _closeModals;
+    /**
+     * Applies default options to the modal config.
+     */
+    private _applyConfigDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoModalBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoModalBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Service to open modal.
+ */
+declare class BaoModal extends BaoModalBase<BaoModalContainer> {
+    constructor(overlay: Overlay, injector: Injector, parentModal: BaoModal, overlayContainer: OverlayContainer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoModal, [null, null, { optional: true; skipSelf: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaoModal>;
+}
+
+/**
+ * Button that will close the current dialog.
+ */
+declare class BaoModalClose implements OnInit, OnChanges {
+    modalRef: BaoModalRef<unknown> | null;
+    private _elementRef;
+    private _dialog;
+    /** Screenreader label for the button. */
+    ariaLabel: string;
+    /** Default to "button" to prevents accidental form submits. */
+    type: 'submit' | 'button' | 'reset';
+    /** Dialog close input. */
+    dialogResult: unknown;
+    _baoModalClose: unknown;
+    constructor(modalRef: BaoModalRef<unknown> | null, _elementRef: ElementRef<HTMLElement>, _dialog: BaoModal);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _onButtonClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoModalClose, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoModalClose, "[bao-modal-close], [baoModalClose]", ["BaoModalClose"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "dialogResult": { "alias": "bao-modal-close"; "required": false; }; "_baoModalClose": { "alias": "baoModalClose"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class BaoModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoModalModule, [typeof BaoModalContainer, typeof BaoModalClose], [typeof i2.CommonModule, typeof i4.OverlayModule, typeof i5.PortalModule], [typeof BaoModalContainer, typeof BaoModalClose]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoModalModule>;
+}
+
+declare class BaoTagComponent implements AfterViewInit {
+    private renderer;
+    private elementRef;
+    /**
+     * The color of the tag.
+     */
+    type: 'neutral' | 'info' | 'positive' | 'alert' | 'negative';
+    /**
+     * The shade of the tags color.
+     */
+    variant: 'light' | 'strong';
+    /**
+     * The hidden text for screen readers.
+     */
+    hiddenText: string;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngAfterViewInit(): void;
+    private addHiddenText;
+    private addIconClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoTagComponent, "bao-tag, [bao-tag], [baoTag]", never, { "type": { "alias": "type"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "hiddenText": { "alias": "hiddenText"; "required": false; }; }, {}, never, ["bao-icon", "*"], false, never>;
+}
+
+declare class BaoTagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoTagModule, [typeof BaoTagComponent], [typeof i2.CommonModule], [typeof BaoTagComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoTagModule>;
+}
+
+/**
+ * A basic content container component that adds the styles of a BAO header-info
+ *
+ * While this component can be used alone, it also provides a number
+ * of preset styles for common header-info sections, including:
+ * - bao-header-info-title-group
+ * - bao-header-info-content
+ * - bao-header-info-title
+ * - bao-header-info-surtitle
+ * - bao-header-info-subtitle
+ */
+declare class BaoHeaderInfoComponent {
+    notch: '' | 'left' | 'center';
+    imageUrl: string;
+    brandBorder: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoHeaderInfoComponent, "bao-header-info", never, { "notch": { "alias": "notch"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "brandBorder": { "alias": "brandBorder"; "required": false; }; }, {}, never, ["bao-header-info-title-group", "*"], false, never>;
+}
+declare class BaoHeaderInfoTitleGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoTitleGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoHeaderInfoTitleGroupComponent, "bao-header-info-title-group", never, {}, {}, never, ["*", "bao-header-surtitle, [bao-header-surtitle], [baoHeaderSurtitle], \n  bao-header-title, [bao-header-title], [baoHeaderTitle],\n  bao-header-subtitle, [bao-header-subtitle], [baoHeaderSubtitle]"], false, never>;
+}
+declare class BaoHeaderInfoContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoHeaderInfoContent, "bao-header-info-content", never, {}, {}, never, never, false, never>;
+}
+declare class BaoHeaderInfoSurtitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoSurtitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoHeaderInfoSurtitle, "bao-header-info-surtitle, [bao-header-info-surtitle], [baoHeaderInfoSurtitle]", never, {}, {}, never, never, false, never>;
+}
+declare class BaoHeaderInfoSubtitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoSubtitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoHeaderInfoSubtitle, "bao-header-info-subtitle, [bao-header-info-subtitle], [baoHeaderInfoSubtitle]", never, {}, {}, never, never, false, never>;
+}
+declare class BaoHeaderInfoTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoHeaderInfoTitle, "bao-header-info-title, [bao-header-info-title], [baoHeaderInfoTitle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoHeaderInfoModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHeaderInfoModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoHeaderInfoModule, [typeof BaoHeaderInfoComponent, typeof BaoHeaderInfoContent, typeof BaoHeaderInfoTitleGroupComponent, typeof BaoHeaderInfoSubtitle, typeof BaoHeaderInfoSurtitle, typeof BaoHeaderInfoTitle], [typeof i2.CommonModule], [typeof BaoHeaderInfoComponent, typeof BaoHeaderInfoContent, typeof BaoHeaderInfoTitleGroupComponent, typeof BaoHeaderInfoSubtitle, typeof BaoHeaderInfoSurtitle, typeof BaoHeaderInfoTitle]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoHeaderInfoModule>;
+}
+
+declare class BaoListItem {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoListItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoListItem, "bao-list-item, [bao-list-item]", never, {}, {}, never, ["baoIconItemType, [baoIconItemType]", "*", "bao-tag, [bao-tag], baoIconTag, [baoIconTag]", "bao-button, [bao-button], bao-dropdown-menu, [bao-dropdown-menu]"], false, never>;
+}
+declare class BaoList {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoList, "bao-list, [bao-list]", never, {}, {}, never, never, false, never>;
+}
+declare class BaoNavList {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoNavList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoNavList, "bao-nav-list, [bao-nav-list]", never, {}, {}, never, never, false, never>;
+}
+declare class BaoListItemDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoListItemDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoListItemDescription, "bao-list-item-description, [bao-list-item-description]", never, {}, {}, never, never, false, never>;
+}
+declare class BaoListItemTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoListItemTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoListItemTitle, "bao-list-item-title, [bao-list-item-title]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoListModule, [typeof BaoListItem, typeof BaoList, typeof BaoNavList, typeof BaoListItemDescription, typeof BaoListItemTitle], [typeof i2.CommonModule], [typeof BaoListItem, typeof BaoList, typeof BaoNavList, typeof BaoListItemDescription, typeof BaoListItemTitle]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoListModule>;
+}
+
+declare class BaoErrorTextComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoErrorTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoErrorTextComponent, "bao-error, [bao-error]", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BaoGuidingTextComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoGuidingTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoGuidingTextComponent, "bao-guiding-text, [bao-guiding-text]", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BaoLabelTextComponent {
+    required: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoLabelTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoLabelTextComponent, "bao-label, [bao-label]", never, { "required": { "alias": "required"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BaoTitleTextComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTitleTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoTitleTextComponent, "bao-title-text, [bao-title-text]", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BaoCommonComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCommonComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoCommonComponentsModule, [typeof BaoErrorTextComponent, typeof BaoGuidingTextComponent, typeof BaoLabelTextComponent, typeof BaoTitleTextComponent], [typeof i2.CommonModule], [typeof BaoErrorTextComponent, typeof BaoGuidingTextComponent, typeof BaoLabelTextComponent, typeof BaoTitleTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoCommonComponentsModule>;
+}
+
+/**
+ * Checkbox state for aria-checked property
+ */
+declare const enum eCheckboxAriaState {
+    TRUE = "true",
+    FALSE = "false",
+    MIXED = "mixed"
+}
+declare class BaoCheckboxComponent implements ControlValueAccessor, AfterViewInit, OnInit, OnDestroy {
+    private elementRef;
+    private cdr;
+    private focusMonitor;
+    /**
+     * The checkbox ID. It is set dynamically with an unique ID by default
+     */
+    id: string;
+    /**
+     * The aria-label for web accessibility
+     */
+    ariaLabel?: string;
+    /**
+     * Whether the checkbox has a border and is considered as a card.
+     */
+    brandBorder: boolean;
+    /**
+     * Whether the checkbox is inline.
+     */
+    inline: boolean;
+    /**
+     * The name property of the checkbox
+     */
+    name?: string;
+    /**
+     * The visible state of the label
+     */
+    hiddenLabel: boolean;
+    /**
+     * Emitted object on change event
+     */
+    readonly change: EventEmitter<boolean>;
+    /**
+     * Inderminate value of the checkbox whenever
+     */
+    readonly indeterminateChange: EventEmitter<boolean>;
+    /**
+     * Reference to the input html element
+     */
+    private inputElement;
+    /**
+     * The aria-describedby id for web accessibilty
+     */
+    ariaDescribedby?: string;
+    /**
+     * The aria-labeledby id for web accessibilty
+     */
+    ariaLabelledby?: string;
+    /**
+     * The ID of the input html element
+     */
+    inputID: string;
+    private _disabled;
+    private _checked;
+    private _indeterminate;
+    private _uniqueId;
+    private _required;
+    constructor(elementRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef, focusMonitor: FocusMonitor);
+    /**
+     * Whether the checkbox is checked.  Default value : false
+     */
+    get checked(): boolean;
+    /**
+     * Whether the checkbox is disabled. Default value : false
+     */
+    get disabled(): boolean;
+    /**
+     * Whether the checkbox is required.  Default value : false
+     */
+    get required(): boolean;
+    /**
+     * Whether the checkbox is indeterminate.  Default value : false
+     */
+    get indeterminate(): boolean;
+    get nativeElement(): HTMLElement;
+    set checked(value: boolean);
+    set disabled(value: boolean);
+    set required(value: boolean);
+    set indeterminate(value: boolean);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    writeValue(value: any): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    setDisabledState(isDisabled: boolean): void;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /**
+     * Whenever there is change on the input html element
+     */
+    onInteractionEvent(event: Event): void;
+    /**
+     * Whenever there is click event triggered on the checkbox
+     */
+    onInputClick(event: Event): void;
+    /**
+     * Get the value for the aria-checked property (web accessibility)
+     */
+    getAriaState(): eCheckboxAriaState;
+    /**
+     * Emit new values whenever the checkbox object has change.
+     */
+    private emitChangeEvent;
+    /**
+     * Set the checked property on the input html element
+     */
+    private syncChecked;
+    /**
+     * Set the indeterminate property on the input html element
+     */
+    private syncIndeterminate;
+    /**
+     * Set the aria-describedby property to bao-checkbox-description
+     */
+    private setAriaDescribedByToDescription;
+    /**
+     * Set checked value
+     */
+    private toggle;
+    private onModelChange;
+    private onTouch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoCheckboxComponent, "bao-checkbox, [bao-checkbox]", never, { "id": { "alias": "id"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "brandBorder": { "alias": "brandBorder"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "name": { "alias": "name"; "required": false; }; "hiddenLabel": { "alias": "hiddenLabel"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, ["*", "bao-checkbox-description, [bao-checkbox-description], [baoCheckboxDescription]"], false, never>;
+}
+declare class BaoCheckBoxDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCheckBoxDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoCheckBoxDescription, "bao-checkbox-description, [bao-checkbox-description],  [baoCheckboxDescription]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoCheckboxGroupComponent implements AfterViewInit {
+    private cdr;
+    /**
+     * The checkbox group ID. It is set dynamically with an unique ID by default
+     */
+    id: string;
+    private staticContainer;
+    /**
+     * The aria-describedby id for web accessibilty
+     */
+    ariaDescribedby?: string;
+    private _uniqueId;
+    constructor(cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    onContentChange(): void;
+    /**
+     * Set the aria-describedby property to bao-guiding-text if available
+     */
+    private setAriaDescribedByToDescription;
+    private showAriaDescribedBy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCheckboxGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoCheckboxGroupComponent, "bao-checkbox-group, [bao-checkbox-group]", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*", "bao-error, [bao-error], bao-guiding-text, [bao-guiding-text]"], false, never>;
+}
+
+declare class BaoCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoCheckboxModule, [typeof BaoCheckboxComponent, typeof BaoCheckboxGroupComponent, typeof BaoCheckBoxDescription], [typeof i2.CommonModule, typeof BaoCommonComponentsModule, typeof i3.ObserversModule], [typeof BaoCheckboxComponent, typeof BaoCheckboxGroupComponent, typeof BaoCheckBoxDescription]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoCheckboxModule>;
+}
+
+/**
+ * We have to inject the radio button group and all its children to each child.
+ */
+declare const BAO_RADIO_GROUP: InjectionToken<BaoRadioButtonGroupComponent>;
+declare class BaoRadioButtonGroupComponent implements AfterContentInit, ControlValueAccessor, AfterViewInit {
+    private cdr;
+    /**
+     * The checkbox group ID. It is set dynamically with an unique ID by default
+     */
+    id: string;
+    /**
+     * Emit the value of the selected radio button
+     */
+    readonly change: EventEmitter<string>;
+    private staticContainer;
+    /**
+     * The aria-describedby for web accessibilty
+     */
+    ariaDescribedby: string | null;
+    private _radios;
+    private _value;
+    private _name;
+    private _selected;
+    private _isInitialized;
+    private _disabled;
+    private _required;
+    private _uniqueId;
+    constructor(cdr: ChangeDetectorRef);
+    /**
+     * Define the name property of all radio buttons. Default : null
+     */
+    get name(): string | null;
+    /**
+     * Define the value of the selected radio button. Default : null
+     */
+    get value(): string | null;
+    /**
+     * Define which radio button is selected. Default : null
+     */
+    get selected(): BaoRadioButtonComponent | null;
+    /**
+     * Whether the radio button groupd is disabled. Default : false
+     */
+    get disabled(): boolean;
+    /**
+     * Whether the radio button groupd is required. Default : false
+     */
+    get required(): boolean;
+    set name(value: string | null);
+    set value(newValue: string | null);
+    set selected(selected: BaoRadioButtonComponent | null);
+    set disabled(value: boolean);
+    set required(value: boolean);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    writeValue(value: string): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Implement ControlValueAccessor
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * onTouch() called from the button children
+     */
+    onGroupTouch(): void;
+    /**
+     * Update all radio button name
+     */
+    updateRadioButtonNames(): void;
+    /**
+     * Define which radio button is selected.
+     */
+    updateSelectedRadioFromValue(): void;
+    /**
+     * Update checked property on selected radio button
+     */
+    checkSelectedRadioButton(): void;
+    /**
+     * Emit the value of the new selected radio button
+     */
+    emitChangeEvent(): void;
+    /**
+     * Call markForCheck function on all radio buttons since one of the parent inputs could't have change meanwhile. Prevent change detection error.
+     */
+    markRadiosForCheck(): void;
+    onContentChange(): void;
+    onModelChange: (value: any) => void;
+    /**
+     * Set the aria-describedby property to bao-guiding-text if available
+     */
+    private setAriaDescribedByToDescription;
+    private showAriaDescribedBy;
+    private onTouch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoRadioButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoRadioButtonGroupComponent, "bao-radio-button-group, [bao-radio-button-group], [baoRadioButtonGroup]", ["baoRadioGroup"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, ["staticContainer"], ["*", "bao-error, [bao-error], bao-guiding-text, [bao-guiding-text]"], false, never>;
+}
+
+declare class BaoRadioButtonComponent implements AfterViewInit, OnInit, OnDestroy {
+    private elementRef;
+    private cdr;
+    private focusMonitor;
+    private radioDispatcher;
+    /**
+     * The radio button ID. It is set dynamically with an unique ID by default
+     */
+    id: string;
+    /**
+     * The aria-label for web accessibility
+     */
+    ariaLabel: string | null;
+    /**
+     * Whether the radio button has a border and is considered as a card.
+     */
+    brandBorder: boolean;
+    /**
+     * Whether the radio button is inline.
+     */
+    inline: boolean;
+    /**
+     * The name property of the radio button
+     */
+    name: string | null;
+    /**
+     * The visible state of the label
+     */
+    hiddenLabel: boolean;
+    /**
+     * Emitted boolean on change
+     */
+    readonly change: EventEmitter<string>;
+    /**
+     * Reference to the input html element
+     */
+    private inputElement;
+    /**
+     * The radio buttons group
+     */
+    radioGroup: BaoRadioButtonGroupComponent;
+    /**
+     * The aria-describedby id for web accessibilty
+     */
+    ariaDescribedby: string | null;
+    /**
+     * The aria-labeledby id for web accessibilty
+     */
+    ariaLabelledby: string | null;
+    /**
+     * The ID of the input html element
+     */
+    inputID: string;
+    private _checked;
+    private _disabled;
+    private _required;
+    private _value;
+    private _uniqueId;
+    constructor(radioGroup: BaoRadioButtonGroupComponent, elementRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef, focusMonitor: FocusMonitor, radioDispatcher: UniqueSelectionDispatcher);
+    /**
+     * Whether the radio button is checked. Default : false
+     */
+    get checked(): boolean;
+    /**
+     * Define the radio button value. Default : null
+     */
+    get value(): string;
+    /**
+     * Whether the radio button is disabled. Default : false
+     */
+    get disabled(): boolean;
+    /**
+     * Whether the radio button is required. Default : false
+     */
+    get required(): boolean;
+    get nativeElement(): HTMLElement;
+    set checked(value: boolean);
+    set value(value: string);
+    set disabled(value: boolean);
+    set required(value: boolean);
+    focus(options?: FocusOptions, origin?: FocusOrigin): void;
+    /**
+     * Method called from the parent as one of the parent input has changed. Prevent change detection error.
+     */
+    markForCheck(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Emit the new value from the selected radio-button and the parent
+     */
+    onInputInteraction(event: Event): void;
+    private emitChangeEvent;
+    private setDisabled;
+    /**
+     * Set the id property to bao-radio-button-description as a description to the input
+     */
+    private setAriaDescribedByToDescription;
+    /** Unregister function for radioDispatcher */
+    private _removeUniqueSelectionListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoRadioButtonComponent, [{ optional: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoRadioButtonComponent, "bao-radio-button, [bao-radio-button]", never, { "id": { "alias": "id"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "brandBorder": { "alias": "brandBorder"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "name": { "alias": "name"; "required": false; }; "hiddenLabel": { "alias": "hiddenLabel"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, never, ["*", "bao-radio-button-description, [bao-radio-button-description], [baoRadioButtonDescription]"], false, never>;
+}
+declare class BaoRadioDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoRadioDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoRadioDescription, "bao-radio-button-description, [bao-radio-button-description],  [baoRadioButtonDescription]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoRadioModule, [typeof BaoRadioButtonComponent, typeof BaoRadioDescription, typeof BaoRadioButtonGroupComponent], [typeof i2.CommonModule, typeof i4$1.FormsModule, typeof i4$1.ReactiveFormsModule, typeof BaoCommonComponentsModule, typeof BaoButtonModule, typeof i3.ObserversModule], [typeof BaoRadioButtonComponent, typeof BaoRadioDescription, typeof BaoRadioButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoRadioModule>;
+}
+
+declare const enum EDisplayMode {
+    COMPACT = "compact",
+    RESPONSIVE = "responsive"
+}
+
+declare class BaoSummaryComponent implements OnInit, AfterViewInit {
+    private elementRef;
+    /**
+     * Set display mode
+     * RESPONSIVE (viewport width <=> is 576px)
+     * COMPACT (viewport width < 576px)
+     */
+    displayMode: EDisplayMode;
+    /**
+     * Set value of unique ID for bao-label
+     */
+    id: string;
+    /**
+     * The aria-describebdy-error id for web accessibility
+     * only when error section appears
+     */
+    ariaDescribedbyError?: string;
+    /**
+     * The aria-describebdy-text id for web accessibility
+     * only when we have de guidance text
+     */
+    ariaDescribedbyGuidingText?: string;
+    /**
+     * The aria-labelledby id for web accessibility
+     */
+    ariaLabelledby?: string;
+    /**
+     * Initialize the ID for summary
+     */
+    private _uniqueId;
+    private attribues;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    setAriaDescribedByToDescription(): void;
+    private elementNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoSummaryComponent, "bao-summary, [bao-summary], [baoSummary]", never, { "displayMode": { "alias": "displayMode"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["bao-label", "bao-guiding-text, [bao-guiding-text]", "bao-title-text, [bao-title-text]", "bao-summary-description", "bao-list-summary, [bao-list-summary], [baoListSummary]", "button[bao-button]", "bao-error, [bao-error]"], false, never>;
+}
+declare class BaoSummaryDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSummaryDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoSummaryDescription, "bao-summary-description, [bao-summary-description], [baoSummaryDescription]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoListSummaryItem {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoListSummaryItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoListSummaryItem, "bao-list-summary-item, [bao-list-summary-item], [baoListSummaryItem]", never, {}, {}, never, ["*"], false, never>;
+}
+declare class BaoListSummary {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoListSummary, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoListSummary, "bao-list-summary, [bao-list-summary], [baoListSummary]", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class BaoSummaryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSummaryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoSummaryModule, [typeof BaoSummaryComponent, typeof BaoSummaryDescription, typeof BaoListSummary, typeof BaoListSummaryItem], [typeof i2.CommonModule, typeof BaoCommonComponentsModule], [typeof BaoSummaryComponent, typeof BaoSummaryDescription, typeof BaoListSummary, typeof BaoListSummaryItem]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoSummaryModule>;
+}
+
+declare class BaoTabHeader implements AfterViewInit {
+    private renderer;
+    private elementRef;
+    /**
+     * Emits its index when tab is clicked
+     */
+    onTabClick: EventEmitter<string>;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    onClick(el: HTMLElement): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTabHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoTabHeader, "bao-tab-header, [bao-tab-header]", ["baoTabHeader"], {}, { "onTabClick": "onTabClick"; }, never, never, false, never>;
+}
+declare class BaoTabPanel implements AfterViewInit {
+    private renderer;
+    private elementRef;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTabPanel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoTabPanel, "bao-panel, [bao-panel]", ["baoPanel"], {}, {}, never, never, false, never>;
+}
+declare class BaoTablistComponent implements AfterViewInit, AfterContentInit, OnDestroy {
+    private renderer;
+    private elementRef;
+    tabHeaders: QueryList<BaoTabHeader>;
+    /**
+     * Size of the tabs displayed
+     */
+    size: 'small' | 'medium' | 'large';
+    /**
+     * Optionnal value to be used as aria-label property on tablist component
+     */
+    ariaLabel: string;
+    /**
+     * Emits the index of the new active tab
+     */
+    activeTabChange: EventEmitter<string>;
+    /**
+     * Index of the tab that is currently active
+     */
+    private activeTabIndex;
+    /**
+     * Unique ID for every instance of BaoTablist component
+     */
+    private uniqueId;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    get tabs(): HTMLCollection;
+    leftKeyEvent(): void;
+    rightKeyEvent(): void;
+    /**
+     * Makes the focus visible on tab header when changing from mouse to keyboard navigation
+     */
+    tabKeyEvent(): void;
+    /**
+     * Makes the focus visible on tab header when changing from mouse to keyboard navigation
+     */
+    tabShiftKeyEvent(): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private setTablistAttributes;
+    private setInitialActiveTab;
+    private changeActiveTab;
+    /**
+     * Finds the next activable tab index when navigating with left and right arrow keys
+     * @param currentIndex Tab index which currently has focus
+     * @param isRight Whether the tab navigation is going in the right direction or not
+     * @returns Index of the new tab that will receive focus
+     */
+    private getNextActivableTabIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTablistComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoTablistComponent, "bao-tablist, [bao-tablist]", never, { "size": { "alias": "size"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "activeTabChange": "activeTabChange"; }, ["tabHeaders"], ["*"], false, never>;
+}
+declare class BaoTabsContainer implements AfterViewInit, AfterContentInit, OnDestroy {
+    private renderer;
+    private elementRef;
+    tablist: BaoTablistComponent;
+    private panelIdPrefix;
+    private tabIdPrefix;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get tabs(): HTMLCollection;
+    get panels(): NodeListOf<Element>;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private setInitialActivePanel;
+    private changeActivePanel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTabsContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoTabsContainer, "bao-tabs, [bao-tabs]", ["baoTabs"], {}, {}, ["tablist"], never, false, never>;
+}
+
+declare class BaoTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoTabsModule, [typeof BaoTabsContainer, typeof BaoTablistComponent, typeof BaoTabHeader, typeof BaoTabPanel], [typeof i2.CommonModule], [typeof BaoTabsContainer, typeof BaoTablistComponent, typeof BaoTabHeader, typeof BaoTabPanel]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoTabsModule>;
+}
+
+declare class BaoHyperlinkComponent implements AfterViewInit {
+    private renderer;
+    private elementRef;
+    /**
+     * Size of the link when it's in a list.
+     */
+    size?: 'extra-small' | 'small' | 'medium';
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngAfterViewInit(): void;
+    private addTabIndex;
+    private setIcon;
+    private addIconClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHyperlinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoHyperlinkComponent, "bao-hyperlink, [bao-hyperlink]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class BaoHyperlinkModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoHyperlinkModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoHyperlinkModule, [typeof BaoHyperlinkComponent], [typeof i2.CommonModule], [typeof BaoHyperlinkComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoHyperlinkModule>;
+}
+
+declare class BaoDropdownMenuService {
+    readonly itemClicked$: Observable<void>;
+    private readonly itemClickedSource;
+    constructor();
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaoDropdownMenuService>;
+}
+declare class BaoDropdownMenuItem implements AfterViewInit, OnChanges {
+    private renderer;
+    private elementRef;
+    private _parent;
+    private baoDropdownMenuService;
+    /**
+     * Is the list item disabled
+     */
+    disabled: boolean;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>, _parent: BaoDropdownMenuComponent, baoDropdownMenuService: BaoDropdownMenuService);
+    get nativeElement(): HTMLElement;
+    spaceKeyEvent(): void;
+    onClick(el: HTMLElement): void;
+    enterKeyEvent(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Regroups label and description in a new div to help with layout */
+    private addContentDiv;
+    private addPaddingClass;
+    private disableItem;
+    /**
+     * This method propagates a click event to menu item children with inputs (checkbox, radio button).
+     * It emits event to close menu if item does not contain an input.
+     */
+    private propagateClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoDropdownMenuItem, "bao-dropdown-menu-item, [bao-dropdown-menu-item]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+declare class BaoDropdownMenuComponent implements AfterViewInit {
+    private cdr;
+    private renderer;
+    private elementRef;
+    baoDropdownMenuService: BaoDropdownMenuService;
+    /**
+     * Fired when the dropdown-menu changes its 'isOpen' value
+     */
+    isOpenChange: EventEmitter<boolean>;
+    /**
+     * Fired when menu is closed by key event triggered from menu item
+     */
+    isClosedByKeyEvent: EventEmitter<any>;
+    /**
+     * Content of menu to be loaded inside Overlay
+     */
+    _menuContent: ElementRef<HTMLElement>;
+    /**
+     * All list items inside menu
+     */
+    _listItems: QueryList<BaoDropdownMenuItem>;
+    /**
+     * Unique identifier of the dropdown menu
+     */
+    readonly menuId: string;
+    /**
+     * Is the dropwdown menu currently open
+     */
+    private _isOpen;
+    /**
+     * Reference to portal which is attached to Overlay
+     */
+    private _menuPortal;
+    /**
+     * Index of currently active list item
+     */
+    private _activeItemIndex;
+    constructor(cdr: ChangeDetectorRef, renderer: Renderer2, elementRef: ElementRef<HTMLElement>, baoDropdownMenuService: BaoDropdownMenuService);
+    get isOpen(): boolean;
+    get activeItemIndex(): number;
+    get menuPortal(): DomPortal;
+    get nativeElement(): HTMLElement;
+    get service(): BaoDropdownMenuService;
+    set isOpen(isOpen: boolean);
+    set activeItemIndex(index: number);
+    upKeyEvent(): void;
+    downKeyEvent(): void;
+    /** Prevents focus to be lost when TAB has reached end of menu  */
+    tabKeyEvent(): void;
+    tabUpKeyEvent(): void;
+    /** Prevents focus to be lost when SHIFT + TAB has reached beginning of menu  */
+    shiftTabKeyEvent(event: KeyboardEvent): void;
+    ngAfterViewInit(): void;
+    open(): void;
+    close(): void;
+    focus(): void;
+    /** Move the aria-current attribute to new active page */
+    setNavigationAttribute(activePageElement: HTMLElement): void;
+    private focusNextItem;
+    /**
+     * Finds the next activable tab index when navigating with up and down arrow or TAB keys
+     * @param currentIndex List item index which currently has focus
+     * @param isDown Whether the navigation is going in the down direction or not
+     * @param isBackward If recursive function is going backward looking for last activable item in list
+     * @returns Index of the next item that will receive focus
+     */
+    private getNextActivableItemIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoDropdownMenuComponent, "bao-dropdown-menu", never, {}, { "isOpenChange": "isOpenChange"; "isClosedByKeyEvent": "isClosedByKeyEvent"; }, ["_listItems"], ["*"], false, never>;
+}
+/**
+ * Directive to be applied on element that will trigger the opening and closing of menu.
+ */
+declare class BaoDropdownMenuTrigger implements AfterViewInit, OnDestroy {
+    private renderer;
+    private elementRef;
+    private overlay;
+    menu: BaoDropdownMenuComponent | null;
+    private _overlayRef;
+    private _isMenuOpen;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>, overlay: Overlay);
+    get nativeElement(): HTMLElement;
+    escapeKeyEvent(): void;
+    onClick(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private toggleMenu;
+    private closeMenu;
+    private openMenu;
+    private createOverlay;
+    private getOverlayConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoDropdownMenuTrigger, "bao-dropdown-menu-trigger, [bao-dropdown-menu-trigger], [baoDropdownMenuTriggerFor]", never, { "menu": { "alias": "baoDropdownMenuTriggerFor"; "required": false; }; }, {}, never, never, false, never>;
+}
+/**
+ * Sections of list items in menu. Apply proper styling to section's title if there is one.
+ */
+declare class BaoDropdownMenuSection implements AfterViewInit {
+    private elementRef;
+    private renderer;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    get nativeElement(): HTMLElement;
+    ngAfterViewInit(): void;
+    private insertTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuSection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoDropdownMenuSection, "bao-dropdown-menu-section, [bao-dropdown-menu-section]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Label of a list item, add css class to apply proper styling.
+ */
+declare class BaoDropdownMenuItemLabel {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuItemLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoDropdownMenuItemLabel, "bao-dropdown-menu-item-label, [bao-dropdown-menu-item-label]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Description of a list item, add css class to apply proper styling.
+ */
+declare class BaoDropdownMenuItemDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuItemDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoDropdownMenuItemDescription, "bao-dropdown-menu-item-description, [bao-dropdown-menu-item-description]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Divider to separate sections.
+ */
+declare class BaoDropdownMenuDivider implements AfterContentInit {
+    private renderer;
+    private elementRef;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoDropdownMenuDivider, "bao-dropdown-menu-divider, [bao-dropdown-menu-divider]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoDropdownMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoDropdownMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoDropdownMenuModule, [typeof BaoDropdownMenuComponent, typeof BaoDropdownMenuTrigger, typeof BaoDropdownMenuItem, typeof BaoDropdownMenuSection, typeof BaoDropdownMenuItemLabel, typeof BaoDropdownMenuItemDescription, typeof BaoDropdownMenuDivider], [typeof i2.CommonModule, typeof i3.ObserversModule, typeof i4.OverlayModule, typeof i5.PortalModule], [typeof BaoDropdownMenuComponent, typeof BaoDropdownMenuTrigger, typeof BaoDropdownMenuItem, typeof BaoDropdownMenuSection, typeof BaoDropdownMenuItemLabel, typeof BaoDropdownMenuItemDescription, typeof BaoDropdownMenuDivider]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoDropdownMenuModule>;
+}
+
+/**
+ * To modify the labels and text displayed, create a new instance of BaoFileIntl and
+ * include it in a custom provider
+ */
+declare class BaoFileIntl {
+    /**
+     * Stream to emit from when labels are changed. Use this to notify components when the labels have
+     * changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    /** The label for button in dropzone */
+    dropzoneButtonLabel: string;
+    /** The default dropzone instructions */
+    defaultDropzoneInstructions: string;
+    /** Error message displayed when uploaded file is too large */
+    fileTooBigErrorMessage: string;
+    /** Error message displayed when uploaded file has an invalid type */
+    invalidFileTypeErrorMessage: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFileIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaoFileIntl>;
+}
+declare class BaoFileIntlEnglish extends BaoFileIntl {
+    /** The label for button in dropzone */
+    dropzoneButtonLabel: string;
+    /** The default dropzone instructions */
+    defaultDropzoneInstructions: string;
+    /** Error message displayed when uploaded file is too large */
+    fileTooBigErrorMessage: string;
+    /** Error message displayed when uploaded file has an invalid type */
+    invalidFileTypeErrorMessage: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFileIntlEnglish, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaoFileIntlEnglish>;
+}
+/** @docs-private */
+declare function BAO_FILE_INTL_PROVIDER_FACTORY(parentIntl: BaoFileIntl): BaoFileIntl;
+/** @docs-private */
+declare const BAO_FILE_INTL_PROVIDER: {
+    provide: typeof BaoFileIntl;
+    deps: Optional[][];
+    useFactory: typeof BAO_FILE_INTL_PROVIDER_FACTORY;
+};
+
+declare class BaoFileInputComponent implements AfterContentInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    intl: BaoFileIntl;
+    private elementRef;
+    private renderer;
+    private cdr;
+    /**
+     * Id of the file input field
+     */
+    inputId?: string;
+    /**
+     * Label of field to be displayed above
+     */
+    label: string;
+    /**
+     * Size of the file input label
+     */
+    size: 'small' | 'medium';
+    /**
+     * Maximum size accepted for uploaded files
+     */
+    maximalFileSize: number;
+    /**
+     * Accepted types of files
+     */
+    acceptedMIMETypes: string[];
+    /**
+     * Is field required
+     */
+    required?: boolean;
+    /**
+     * Is field disabled
+     */
+    disabled?: boolean;
+    /**
+     * File selected to be uploaded
+     */
+    uploadedFile: EventEmitter<File>;
+    /**
+     * List of files that have been uploaded so far
+     */
+    private _files;
+    /**
+     * Form errors when component is used in a form
+     */
+    private _errorForm;
+    /**
+     * Error texts
+     */
+    private _errorTexts;
+    /**
+     * File input that triggers uploading when clicked
+     */
+    private uploader;
+    private dropzoneElement;
+    insertDefaultInstructions: boolean;
+    isFileTooBig: boolean;
+    isFileTypeInvalid: boolean;
+    private _value;
+    private _intlChanges;
+    private _helperTextId;
+    constructor(intl: BaoFileIntl, elementRef: ElementRef<HTMLElement>, renderer: Renderer2, cdr: ChangeDetectorRef);
+    get nativeElement(): HTMLElement;
+    enterKeyEvent(): void;
+    tabKeyEvent(): void;
+    shiftTabKeyEvent(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Implements ControlValueAccessor interface
+     */
+    writeValue(obj: any): void;
+    /**
+     * Implements ControlValueAccessor interface
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Implements ControlValueAccessor interface
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Implements ControlValueAccessor interface
+     */
+    setDisabledState(isDisabled: boolean): void;
+    uploadFile(file: File): void;
+    /**
+     * Saves the registerOnChange function so the component can call it whenever it wants.
+     */
+    propagateChange: (_: any) => void;
+    /**
+     * Saves the registerOnTouched function so the component can call it whenever it wants.
+     */
+    propagateTouched: () => void;
+    private setValue;
+    private setDescribedByAttribute;
+    private setErrorTextsAttribute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFileInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoFileInputComponent, "bao-file-input, [bao-file-input]", never, { "inputId": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; "maximalFileSize": { "alias": "maximalFileSize"; "required": false; }; "acceptedMIMETypes": { "alias": "acceptedMIMETypes"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "uploadedFile": "uploadedFile"; }, ["_files", "_errorForm"], ["bao-guiding-text", "bao-file-dropzone-instructions", "bao-error", "*"], false, never>;
+}
+declare class BaoFileDropDirective {
+    fileDrop: EventEmitter<File>;
+    private _isDragOver;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    private preventAndStop;
+    private getDataTransfer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFileDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoFileDropDirective, "[baoFileDrop]", never, {}, { "fileDrop": "fileDrop"; }, never, never, false, never>;
+}
+declare class BaoFileDropzoneIntructions implements AfterContentInit {
+    private renderer;
+    private elementRef;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    get nativeElement(): HTMLElement;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFileDropzoneIntructions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoFileDropzoneIntructions, "bao-file-dropzone-instructions, [bao-file-dropzone-instructions]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoFilePreviewComponent {
+    private elementRef;
+    private renderer;
+    get file(): File;
+    /**
+     * Uploaded file to display in list.
+     */
+    set file(f: File);
+    /**
+     * Is file loading
+     */
+    isLoading: boolean;
+    /**
+     * True if projected content has no icon and file does not have a thumbnail.
+     */
+    insertGenericIcon: boolean;
+    thumbnailURL: string;
+    protected _file: File;
+    protected fileSize: string;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    private get nativeElement();
+    private setFileData;
+    private setIcon;
+    private getThumbnail;
+    private formatSize;
+    private getSizeAndUnit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFilePreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoFilePreviewComponent, "bao-file-preview, [bao-file-preview]", never, { "file": { "alias": "file"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, ["bao-icon", "button[bao-button]", "baoDropdownTriggerFor"], false, never>;
+}
+
+declare class BaoFileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoFileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoFileModule, [typeof BaoFileInputComponent, typeof BaoFileDropzoneIntructions, typeof BaoFileDropDirective, typeof BaoFilePreviewComponent], [typeof i2.CommonModule, typeof BaoDropdownMenuModule, typeof BaoCommonComponentsModule, typeof BaoIconModule, typeof BaoButtonModule], [typeof BaoFileInputComponent, typeof BaoFileDropzoneIntructions, typeof BaoFileDropDirective, typeof BaoFilePreviewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoFileModule>;
+}
+
+/** Injection token that can be used to access the data that was passed in to a snack bar. */
+declare const BAO_SNACK_BAR_DATA: InjectionToken<any>;
+/** Possible values for horizontalPosition on MatSnackBarConfig. */
+type BaoSnackBarHorizontalPosition = 'start' | 'center' | 'end' | 'left' | 'right';
+/** Possible values for verticalPosition on MatSnackBarConfig. */
+type BaoSnackBarVerticalPosition = 'top' | 'bottom';
+/** Possible types of toast to display the snack bar */
+type BaoSnackBarToastType = 'info' | 'success' | 'danger';
+/**
+ * Configuration used when opening a snack-bar.
+ */
+declare class BaoSnackBarConfig<D = any> {
+    /** The message to display in the snackbar. */
+    message: string;
+    /** The type of snackbar template to display. */
+    toastType?: BaoSnackBarToastType;
+    /**
+     * The attached action to the snack bar. If the name of the action matches an icon provided as part of
+     * angular-ui icon dictionnary an icon will be displayed instead of text.
+     * */
+    actionLabelOrIcon?: string;
+    /** Displays the close button when set to true */
+    showClose?: boolean;
+    /** The length of time in milliseconds to wait before automatically dismissing the snack bar. */
+    duration?: number;
+    /** The politeness level for the MatAriaLiveAnnouncer announcement. */
+    politeness?: AriaLivePoliteness;
+    /**
+     * Message to be announced by the LiveAnnouncer. When opening a snackbar without a custom
+     * component or template, the announcement message will default to the specified message.
+     */
+    announcementMessage?: string;
+    /**
+     * The view container that serves as the parent for the snackbar for the purposes of dependency
+     * injection. Note: this does not affect where the snackbar is inserted in the DOM.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /** Extra CSS classes to be added to the snack bar container. */
+    panelClass?: string | string[];
+    /** Text layout direction for the snack bar. */
+    direction?: Direction;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** The horizontal position to place the snack bar. */
+    horizontalPosition?: BaoSnackBarHorizontalPosition;
+    /** The vertical position to place the snack bar. */
+    verticalPosition?: BaoSnackBarVerticalPosition;
+}
+
+/**
+ * Internal interface for a snack bar container.
+ * @docs-private
+ */
+interface IBaoSnackBarContainer {
+    snackBarConfig: BaoSnackBarConfig;
+    _onAnnounce: Subject<any>;
+    _onExit: Subject<any>;
+    _onEnter: Subject<any>;
+    enter: () => void;
+    exit: () => Observable<void>;
+    attachTemplatePortal: <C>(portal: TemplatePortal<C>) => EmbeddedViewRef<C>;
+    attachComponentPortal: <T>(portal: ComponentPortal<T>) => ComponentRef<T>;
+}
+/**
+ * Internal component that wraps user-provided snack bar content.
+ * @docs-private
+ */
+declare class BaoSnackBarContainerComponent extends BasePortalOutlet implements OnDestroy, IBaoSnackBarContainer {
+    private _ngZone;
+    private _elementRef;
+    private _changeDetectorRef;
+    private _platform;
+    /** The snack bar configuration. */
+    snackBarConfig: BaoSnackBarConfig;
+    /** The portal outlet inside of this container into which the snack bar content will be loaded. */
+    _portalOutlet: CdkPortalOutlet;
+    private _document;
+    private _trackedModals;
+    /** Subject for notifying that the snack bar has announced to screen readers. */
+    readonly _onAnnounce: Subject<void>;
+    /** Subject for notifying that the snack bar has exited from view. */
+    readonly _onExit: Subject<void>;
+    /** Subject for notifying that the snack bar has finished entering the view. */
+    readonly _onEnter: Subject<void>;
+    /** The state of the snack bar animations. */
+    _animationState: string;
+    /** aria-live value for the live region. */
+    _live: AriaLivePoliteness;
+    /** The number of milliseconds to wait before announcing the snack bar's content. */
+    private readonly _announceDelay;
+    /** The timeout for announcing the snack bar's content. */
+    private _announceTimeoutId;
+    /** Whether the component has been destroyed. */
+    private _destroyed;
+    /**
+     * Role of the live region. This is only for Firefox as there is a known issue where Firefox +
+     * JAWS does not read out aria-live message.
+     */
+    _role?: 'status' | 'alert';
+    /** Unique ID of the aria-live element. */
+    readonly _liveElementId: string;
+    constructor(_ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, _platform: Platform, 
+    /** The snack bar configuration. */
+    snackBarConfig: BaoSnackBarConfig);
+    /** Attach a component portal as content to this snack bar container. */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /** Attach a template portal as content to this snack bar container. */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    /**
+     * Attaches a DOM portal to the snack bar container.
+     * @deprecated To be turned into a method.
+     * @breaking-change 10.0.0
+     */
+    attachDomPortal: (portal: DomPortal) => void;
+    /** Handle end of animations, updating the state of the snackbar. */
+    onAnimationEnd(event: AnimationEvent): void;
+    /** Begin animation of snack bar entrance into view. */
+    enter(): void;
+    /** Begin animation of the snack bar exiting from view. */
+    exit(): Observable<void>;
+    /** Makes sure the exit callbacks have been invoked when the element is destroyed. */
+    ngOnDestroy(): void;
+    /**
+     * Waits for the zone to settle before removing the element. Helps prevent
+     * errors where we end up removing an element which is in the middle of an animation.
+     */
+    private completeExit;
+    /** Applies the various positioning and user-configured CSS classes to the snack bar. */
+    private applySnackBarClasses;
+    /**
+     * Called after the portal contents have been attached. Can be
+     * used to modify the DOM once it's guaranteed to be in place.
+     */
+    protected _afterPortalAttached(): void;
+    /**
+     * Some browsers won't expose the accessibility node of the live element if there is an
+     * `aria-modal` and the live element is outside of it. This method works around the issue by
+     * pointing the `aria-owns` of all modals to the live element.
+     */
+    private _exposeToModals;
+    /** Clears the references to the live element from any modals it was added to. */
+    private _clearFromModals;
+    /** Asserts that no content is already attached to the container. */
+    private assertNotAttached;
+    /**
+     * Starts a timeout to move the snack bar content to the live region so screen readers will
+     * announce it.
+     */
+    private screenReaderAnnounce;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSnackBarContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoSnackBarContainerComponent, "bao-snack-bar-container", never, {}, {}, never, never, false, never>;
+}
+
+/** Event that is emitted when a snack bar is dismissed. */
+interface IBaoSnackBarDismiss {
+    /** Whether the snack bar was dismissed using the action button. */
+    dismissedByAction: boolean;
+}
+/**
+ * Reference to a snack bar dispatched from the snack bar service.
+ */
+declare class BaoSnackBarRef<T> {
+    private _overlayRef;
+    /** The instance of the component making up the content of the snack bar. */
+    instance: T;
+    /**
+     * The instance of the component making up the content of the snack bar.
+     * @docs-private
+     */
+    containerInstance: IBaoSnackBarContainer;
+    /** Subject for notifying the user that the snack bar has been dismissed. */
+    private readonly _afterDismissed;
+    /** Subject for notifying the user that the snack bar has opened and appeared. */
+    private readonly _afterOpened;
+    /** Subject for notifying the user that the snack bar action was called. */
+    private readonly _onAction;
+    /**
+     * Timeout ID for the duration setTimeout call. Used to clear the timeout if the snackbar is
+     * dismissed before the duration passes.
+     */
+    private _durationTimeoutId;
+    /** Whether the snack bar was dismissed using the action button. */
+    private _dismissedByAction;
+    constructor(containerInstance: IBaoSnackBarContainer, _overlayRef: OverlayRef);
+    /** Dismisses the snack bar. */
+    dismiss(): void;
+    /** Marks the snackbar action clicked. */
+    dismissWithAction(): void;
+    /** Dismisses the snack bar after some duration */
+    dismissAfter(duration: number): void;
+    /** Marks the snackbar as opened */
+    open(): void;
+    /** Gets an observable that is notified when the snack bar is finished closing. */
+    afterDismissed(): Observable<IBaoSnackBarDismiss>;
+    /** Gets an observable that is notified when the snack bar has opened and appeared. */
+    afterOpened(): Observable<void>;
+    /** Gets an observable that is notified when the snack bar action is called. */
+    onAction(): Observable<void>;
+    /** Cleans up the DOM after closing. */
+    private finishDismiss;
+}
+
+/**
+ * Interface for a simple snack bar component that has a message and a single action.
+ */
+interface ITextOnlySnackBar {
+    data: {
+        message: string;
+        toastType: BaoSnackBarToastType;
+        actionLabelOrIcon: string;
+        showClose: boolean;
+    };
+    snackBarRef: BaoSnackBarRef<ITextOnlySnackBar>;
+    action: () => void;
+    hasAction: boolean;
+}
+/**
+ * A component used to open as the default snack bar, matching material spec.
+ * This should only be used internally by the snack bar service.
+ */
+declare class BaoSimpleSnackBarComponent implements ITextOnlySnackBar {
+    snackBarRef: BaoSnackBarRef<BaoSimpleSnackBarComponent>;
+    showCloseTitle: string;
+    /** Data that was injected into the snack bar. */
+    data: {
+        message: string;
+        toastType: BaoSnackBarToastType;
+        actionLabelOrIcon: string;
+        showClose: boolean;
+    };
+    constructor(snackBarRef: BaoSnackBarRef<BaoSimpleSnackBarComponent>, data: any);
+    /** Returns the politeness */
+    get politeness(): string;
+    /** Returns the toast class */
+    get toastClass(): string;
+    /** Returns the toast icon */
+    get toastIcon(): string;
+    /** Returns the toast icon title */
+    get toastIconTitle(): string;
+    /** If the action button should be shown. */
+    get hasAction(): boolean;
+    /** If the action is an icon */
+    get isActionIcon(): boolean;
+    /** Performs the action on the snack bar. */
+    action(): void;
+    /** Closes the snack bar. */
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSimpleSnackBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoSimpleSnackBarComponent, "bao-simple-snack-bar", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaoSnackBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSnackBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoSnackBarModule, [typeof BaoSimpleSnackBarComponent, typeof BaoSnackBarContainerComponent], [typeof i2.CommonModule, typeof i4.OverlayModule, typeof i5.PortalModule, typeof BaoButtonModule, typeof BaoIconModule], [typeof BaoSimpleSnackBarComponent, typeof BaoSnackBarContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoSnackBarModule>;
+}
+
+/**
+ * This component is dynamically added to replace breadcrumb when System Header is viewed on tablet or mobile screens.
+ * Used internally by BaoSystemHeaderComponent only, not to be used by host application.
+ */
+declare class BaoBackNavigationComponent implements OnChanges {
+    private renderer;
+    private elementRef;
+    link: string;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoBackNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoBackNavigationComponent, "bao-back-navigation-component", never, { "link": { "alias": "link"; "required": false; }; }, {}, never, never, false, never>;
+}
+/**
+ * This directive is to mark the template where the BaoBackNavigationComponent should be dynamically inserted,
+ * when a Breadcrumb component needs to be replaced
+ */
+declare class BaoBackNavigationInsert {
+    viewContainerRef: ViewContainerRef;
+    constructor(viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoBackNavigationInsert, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoBackNavigationInsert, "[backNavigationInsert]", never, {}, {}, never, never, false, never>;
+}
+declare class BaoSystemHeaderComponent implements AfterViewInit, OnInit {
+    private cd;
+    private breakpointObserver;
+    private renderer;
+    private textContainer;
+    private backButtonInsert;
+    screenType: 'mobile' | 'tablet' | 'desktop';
+    constructor(cd: ChangeDetectorRef, breakpointObserver: BreakpointObserver, renderer: Renderer2);
+    get textContainerChildren(): Element[];
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private formatNavigation;
+    private applySizeClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSystemHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoSystemHeaderComponent, "bao-system-header", never, {}, {}, never, ["a", "bao-breadcrumb", "h1", "bao-tag", "span", "*"], false, never>;
+}
+
+declare class BaoSystemHeaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSystemHeaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoSystemHeaderModule, [typeof BaoSystemHeaderComponent, typeof BaoBackNavigationInsert, typeof BaoBackNavigationComponent], [typeof i2.CommonModule, typeof BaoIconModule], [typeof BaoSystemHeaderComponent, typeof BaoBackNavigationInsert, typeof BaoBackNavigationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoSystemHeaderModule>;
+}
+
+/**
+ * The BaoMessageBarContent directive is used within the <bao-message-bar>
+ * It ensures consistency in text formatting and spacing.
+ *
+ * This directive is purely visual and does not provide any additional behaviors.
+ */
+declare class BaoMessageBarContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoMessageBarContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaoMessageBarContent, "bao-message-content", never, {}, {}, never, never, false, never>;
+}
+declare class BaoMessageBarComponent implements OnChanges {
+    private elementRef;
+    type: 'info' | 'alert' | 'urgent' | 'neutral';
+    dismissible: boolean;
+    dismissibleButtonAriaLabel: string;
+    dismiss: EventEmitter<void>;
+    iconType: string;
+    iconTitle: string;
+    constructor(elementRef: ElementRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    onDismissClicked(): void;
+    private getIconType;
+    private getIconTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoMessageBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoMessageBarComponent, "bao-message-bar", never, { "type": { "alias": "type"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; "dismissibleButtonAriaLabel": { "alias": "dismissibleButtonAriaLabel"; "required": false; }; }, { "dismiss": "dismiss"; }, never, ["*"], false, never>;
+}
+
+declare class BaoMessageBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoMessageBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoMessageBarModule, [typeof BaoMessageBarComponent, typeof BaoMessageBarContent], [typeof i2.CommonModule, typeof BaoIconModule, typeof BaoButtonModule, typeof BaoHyperlinkModule], [typeof BaoMessageBarComponent, typeof BaoMessageBarContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoMessageBarModule>;
+}
+
+declare class BaoPaginationComponent implements OnChanges, OnInit {
+    private cdr;
+    /**
+     * The total number of items.
+     */
+    totalItems: number;
+    /**
+     * The number of items per page as selected.
+     */
+    itemsPerPage: number;
+    /**
+     * The current page number.
+     */
+    currentPage: number;
+    /**
+     * The different page size options.
+     */
+    pageSizeOptions: number[];
+    /**
+     * The label for the type of items that are displayed on the page
+     */
+    itemLabel: string;
+    /**
+     * If selector for number of items per page should be displayed or not
+     */
+    showItemsPerPageSelector: boolean;
+    /**
+     * EventEmitter that triggers when there is a page change and emits page number (index adjusted)
+     */
+    pageChanged: EventEmitter<number>;
+    /**
+     * EventEmitter that triggers when the number of items per page is changed.
+     */
+    itemsPerPageChanged: EventEmitter<number>;
+    /**
+     * Page number list to display
+     */
+    displayedPages: number[];
+    /**
+     * Max number of pages to display
+     */
+    private _maxPages;
+    /**
+     * Number of pages in total.
+     */
+    private _totalPages;
+    /**
+     * Position of first item being displayed on current page.
+     */
+    private _startItem;
+    /**
+     * Position of last item being displayed on current page.
+     */
+    private _endItem;
+    constructor(cdr: ChangeDetectorRef);
+    get totalPages(): number;
+    set totalPages(value: number);
+    get startItem(): number;
+    set startItem(value: number);
+    get endItem(): number;
+    set endItem(value: number);
+    get rangeLabel(): string;
+    /**
+     * Flag that indicates if a previous page exists for the current list
+     */
+    get hasPrevious(): boolean;
+    /**
+     * Flag that indicates if a next page exists for the current list
+     */
+    get hasNext(): boolean;
+    ngOnInit(): void;
+    /**
+     * Update list of displayed pages when current page is changed.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Navigate to specific page
+     */
+    goTo(page: number): void;
+    /**
+     * Navigate to previous page
+     */
+    handlePreviousClick(): void;
+    /**
+     * Navigate to next page
+     */
+    handleNextClick(): void;
+    /**
+     * Update all required variables whenever the number of items displayed per page is changed.
+     * @param value New amount of items per page
+     */
+    handlePageSizeChange(value: number): void;
+    private updateTotalPages;
+    private updateStartItem;
+    private updateEndItem;
+    /**
+     * Generate series of page numbers to display. The list always starts with page 1
+     * and ends with last page.
+     * Adds negative numbers for ellipsis.
+     */
+    private buildPageNumbers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaoPaginationComponent, "bao-pagination", never, { "totalItems": { "alias": "totalItems"; "required": false; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "itemLabel": { "alias": "itemLabel"; "required": false; }; "showItemsPerPageSelector": { "alias": "showItemsPerPageSelector"; "required": false; }; }, { "pageChanged": "pageChanged"; "itemsPerPageChanged": "itemsPerPageChanged"; }, never, never, false, never>;
+}
+
+declare class BaoPaginationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoPaginationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoPaginationModule, [typeof BaoPaginationComponent], [typeof i2.CommonModule, typeof BaoIconModule, typeof i4$1.FormsModule], [typeof BaoPaginationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoPaginationModule>;
+}
+
+declare class BaoModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BaoModule, never, [typeof BaoIconModule, typeof BaoButtonModule, typeof BaoAlertModule, typeof BaoCardModule, typeof BaoBreadcrumbModule, typeof BaoModalModule], [typeof BaoIconModule, typeof BaoButtonModule, typeof BaoAlertModule, typeof BaoBreadcrumbModule, typeof BaoCardModule, typeof BaoTagModule, typeof BaoHeaderInfoModule, typeof BaoListModule, typeof BaoCommonComponentsModule, typeof BaoCheckboxModule, typeof BaoRadioModule, typeof BaoSummaryModule, typeof BaoAvatarModule, typeof BaoTabsModule, typeof BaoModalModule, typeof BaoHyperlinkModule, typeof BaoDropdownMenuModule, typeof BaoFileModule, typeof BaoSnackBarModule, typeof BaoSystemHeaderModule, typeof BaoMessageBarModule, typeof BaoPaginationModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BaoModule>;
+}
+
+declare function baoFactory(): BaoSnackBarConfig<any>;
+/** Injection token that can be used to specify default snack bar. */
+declare const BAO_SNACK_BAR_DEFAULT_OPTIONS: InjectionToken<BaoSnackBarConfig<any>>;
+/**
+ * Service to dispatch Material Design snack bar messages.
+ */
+declare class BaoSnackBarService implements OnDestroy {
+    private _overlay;
+    private _live;
+    private _injector;
+    private _parentSnackBar;
+    private _defaultConfig;
+    /** The component that should be rendered as the snack bar's simple component. */
+    protected simpleSnackBarComponent: Type<ITextOnlySnackBar>;
+    /** The container component that attaches the provided template or component. */
+    protected snackBarContainerComponent: Type<IBaoSnackBarContainer>;
+    /**
+     * Reference to the current snack bar in the view *at this level* (in the Angular injector tree).
+     * If there is a parent snack-bar service, all operations should delegate to that parent
+     * via `_openedSnackBarRef`.
+     */
+    private _snackBarRefAtThisLevel;
+    constructor(_overlay: Overlay, _live: LiveAnnouncer, _injector: Injector, _parentSnackBar: BaoSnackBarService, _defaultConfig: BaoSnackBarConfig);
+    /** Reference to the currently opened snackbar at *any* level. */
+    get _openedSnackBarRef(): BaoSnackBarRef<any> | null;
+    set _openedSnackBarRef(value: BaoSnackBarRef<any> | null);
+    /**
+     * Creates and dispatches a snack bar with a custom component for the content, removing any
+     * currently opened snack bars.
+     *
+     * @param component Component to be instantiated.
+     * @param config Extra configuration for the snack bar.
+     */
+    openFromComponent<T>(component: ComponentType$1<T>, config?: BaoSnackBarConfig): BaoSnackBarRef<T>;
+    /**
+     * Creates and dispatches a snack bar with a custom template for the content, removing any
+     * currently opened snack bars.
+     *
+     * @param template Template to be instantiated.
+     * @param config Extra configuration for the snack bar.
+     */
+    openFromTemplate(template: TemplateRef<any>, config?: BaoSnackBarConfig): BaoSnackBarRef<EmbeddedViewRef<any>>;
+    /**
+     * Opens a snackbar with a message and an optional action.
+     * @param message The message to show in the snackbar.
+     * @param toastType The type of of toast to display the snackbar.
+     * @param actionLabelOrIcon The label or icon for the snackbar action.
+     * @param showClose If true, the snackbar will require user interaction to close.
+     * @param config Additional configuration options for the snackbar.
+     */
+    open(config: BaoSnackBarConfig): BaoSnackBarRef<ITextOnlySnackBar>;
+    /**
+     * Dismisses the currently-visible snack bar.
+     */
+    dismiss(): void;
+    ngOnDestroy(): void;
+    /**
+     * Attaches the snack bar container component to the overlay.
+     */
+    private attachSnackBarContainer;
+    /**
+     * Places a new component or a template as the content of the snack bar container.
+     */
+    private attach;
+    /** Animates the old snack bar out and the new one in. */
+    private animateSnackBar;
+    /**
+     * Creates a new overlay and places it in the correct location.
+     * @param config The user-specified snack bar config.
+     */
+    private createOverlay;
+    /**
+     * Creates an injector to be used inside of a snack bar component.
+     * @param config Config that was used to create the snack bar.
+     * @param snackBarRef Reference to the snack bar.
+     */
+    private createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaoSnackBarService, [null, null, null, { optional: true; skipSelf: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaoSnackBarService>;
+}
+
+export { BAO_FILE_INTL_PROVIDER, BAO_FILE_INTL_PROVIDER_FACTORY, BAO_MODAL_DATA, BAO_RADIO_GROUP, BAO_SNACK_BAR_DATA, BAO_SNACK_BAR_DEFAULT_OPTIONS, BaoAlertActions, BaoAlertComponent, BaoAlertContent, BaoAlertLink, BaoAlertModule, BaoAlertTitle, BaoAvatarComponent, BaoAvatarContent, BaoAvatarModule, BaoBackNavigationComponent, BaoBackNavigationInsert, BaoBadgeComponent, BaoBadgeModule, BaoBreadcrumbComponent, BaoBreadcrumbModule, BaoButtonComponent, BaoButtonModule, BaoCardComponent, BaoCardContent, BaoCardHeader, BaoCardModule, BaoCardTextInterface, BaoCardTitle, BaoCheckBoxDescription, BaoCheckboxComponent, BaoCheckboxGroupComponent, BaoCheckboxModule, BaoCommonComponentsModule, BaoDropdownMenuComponent, BaoDropdownMenuDivider, BaoDropdownMenuItem, BaoDropdownMenuItemDescription, BaoDropdownMenuItemLabel, BaoDropdownMenuModule, BaoDropdownMenuSection, BaoDropdownMenuService, BaoDropdownMenuTrigger, BaoErrorTextComponent, BaoFileDropDirective, BaoFileDropzoneIntructions, BaoFileInputComponent, BaoFileIntl, BaoFileIntlEnglish, BaoFileModule, BaoFilePreviewComponent, BaoGuidingTextComponent, BaoHeaderInfoComponent, BaoHeaderInfoContent, BaoHeaderInfoModule, BaoHeaderInfoSubtitle, BaoHeaderInfoSurtitle, BaoHeaderInfoTitle, BaoHeaderInfoTitleGroupComponent, BaoHyperlinkComponent, BaoHyperlinkModule, BaoIconComponent, BaoIconModule, BaoLabelTextComponent, BaoList, BaoListItem, BaoListItemDescription, BaoListItemTitle, BaoListModule, BaoListSummary, BaoListSummaryItem, BaoMessageBarComponent, BaoMessageBarContent, BaoMessageBarModule, BaoModal, BaoModalBase, BaoModalClose, BaoModalContainer, BaoModalInitialConfig, BaoModalModule, BaoModalRef, BaoModalState, BaoModule, BaoNavList, BaoPaginationComponent, BaoPaginationModule, BaoRadioButtonComponent, BaoRadioButtonGroupComponent, BaoRadioDescription, BaoRadioModule, BaoSimpleSnackBarComponent, BaoSnackBarConfig, BaoSnackBarContainerComponent, BaoSnackBarModule, BaoSnackBarRef, BaoSnackBarService, BaoSummaryComponent, BaoSummaryDescription, BaoSummaryModule, BaoSystemHeaderComponent, BaoSystemHeaderModule, BaoTabHeader, BaoTabPanel, BaoTablistComponent, BaoTabsContainer, BaoTabsModule, BaoTagComponent, BaoTagModule, BaoTitleTextComponent, EDisplayMode, FILTER_MODAL_WIDTH, _BaoModalContainerBase, _closeModalVia, baoFactory, eCheckboxAriaState, eModalDesktopWidthSize, eModalMobileWidthSize, eModalVariant, throwBaoModalContentAlreadyAttachedError };
+export type { AutoFocusTarget, BaoModalConfig, BaoSnackBarHorizontalPosition, BaoSnackBarToastType, BaoSnackBarVerticalPosition, IBaoSnackBarContainer, IBaoSnackBarDismiss, ITextOnlySnackBar, ModalPosition, ModalRole };