import * as i0 from '@angular/core';
import { AfterContentInit, ElementRef, EventEmitter, InjectionToken, OnInit, OnDestroy, TemplateRef, QueryList, Renderer2, NgZone, ViewContainerRef, ComponentFactoryResolver, PipeTransform, OnChanges, ModuleWithProviders, AfterViewInit, ChangeDetectorRef, SimpleChanges, AfterViewChecked, Injector, ComponentRef, DoCheck, ApplicationRef, RendererFactory2, Type } from '@angular/core';
import { AnimationEvent, AnimationTriggerMetadata } from '@angular/animations';
import * as i2 from '@angular/common';
import * as rxjs from 'rxjs';
import { Observable, Subscription, Subject, Subscriber, BehaviorSubject } from 'rxjs';
import * as i12 from '@angular/cdk/a11y';
import { ConfigurableFocusTrapFactory, ConfigurableFocusTrap } from '@angular/cdk/a11y';
import * as i11 from '@angular/cdk/overlay';
import { OverlayRef, Overlay, ComponentType as ComponentType$1, ScrollStrategy, CdkScrollable } from '@angular/cdk/overlay';
import * as i13 from '@angular/cdk/bidi';
import { Directionality } from '@angular/cdk/bidi';
import { HttpClient } from '@angular/common/http';
import * as i3 from '@angular/router';
import { Params, ActivatedRoute, Router, UrlSerializer } from '@angular/router';
import * as i4 from '@angular/forms';
import { ControlValueAccessor, NgControl, NgForm, FormGroupDirective, Validator, AbstractControl, ValidationErrors, FormGroup, FormControl } from '@angular/forms';
import * as i7 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i19 from '@angular/cdk/portal';
import { ComponentType, Portal, CdkPortalOutletAttachedRef } from '@angular/cdk/portal';
import * as i1 from '@angular/cdk/platform';
import { Platform } from '@angular/cdk/platform';
import * as i5 from '@angular/cdk/observers';
import * as i6 from '@angular/cdk/scrolling';
import { CdkScrollable as CdkScrollable$1 } from '@angular/cdk/scrolling';
import * as i6$1 from '@angular/cdk/table';
import { CdkColumnDef, CdkTable, CdkHeaderCellDef, CdkCellDef, CdkFooterCellDef, CdkHeaderCell, CdkCell, CdkFooterCell, CdkHeaderRowDef, CdkRowDef, CdkFooterRowDef, CdkHeaderRow, CdkRow, CdkFooterRow, DataSource } from '@angular/cdk/table';

/** Parent component that can have a `<hc-accordion-toolbar>` and content that is collapsable */
declare class AccordionComponent implements AfterContentInit {
    elementRef: ElementRef;
    private _animationDisabled;
    private _currentlyAnimating;
    private _hideToolbar;
    private _toolbarTrigger;
    private _triggerAlign;
    private __isOpen;
    private _disabled;
    constructor(elementRef: ElementRef);
    /** Side the accordion trigger is attached to: `left` or `right` */
    get triggerAlign(): string;
    set triggerAlign(alignType: string);
    /** Whether the entire width of the accordion bar is clickable, or only the down arrow button; default = true */
    get toolbarTrigger(): boolean;
    set toolbarTrigger(doTrigger: boolean);
    /** Hide toolbar. */
    get hideToolbar(): boolean;
    set hideToolbar(hide: boolean);
    /** Whether the accordion is opened. */
    get open(): boolean;
    set open(opened: boolean);
    /** Whether the accordion button is disabled. */
    get disabled(): boolean;
    set disabled(isDisabled: boolean);
    /** Allows for two-way binding of the `open` property */
    openChange: EventEmitter<boolean>;
    /** Event emitted when accordion is opened. */
    opened: EventEmitter<any>;
    /** Event emitted when accordion has started to open. */
    openStart: EventEmitter<any>;
    /** Event emitted when accordion is closed. */
    closed: EventEmitter<any>;
    /** Event emitted when accordion has started to close. */
    closeStart: EventEmitter<any>;
    _hostClass: boolean;
    get _alignment(): string;
    get _pointer(): string;
    get _hideButton(): string;
    get _openState(): 'void' | 'open-instant' | 'open';
    _animationStart(event: AnimationEvent): void;
    _animationEnd(event: AnimationEvent): void;
    get _isOpened(): boolean;
    get _isOpening(): boolean;
    get _isClosed(): boolean;
    get _isClosing(): boolean;
    ngAfterContentInit(): void;
    _triggerClick(event: Event, toolbarClick: boolean): void;
    /** Opens accordion. */
    toggleOpen(): void;
    /** Closes accordion. */
    toggleClose(): void;
    /** Toggle this accordion. */
    toggle(isOpen?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "hc-accordion", ["hcAccordion"], { "triggerAlign": { "alias": "triggerAlign"; "required": false; }; "toolbarTrigger": { "alias": "toolbarTrigger"; "required": false; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; }; "open": { "alias": "open"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "openChange": "openChange"; "opened": "opened"; "openStart": "openStart"; "closed": "closed"; "closeStart": "closeStart"; }, never, ["hc-accordion-toolbar", "*"], false, never>;
}

/** Container for content that is to be shown in-line with the accordion trigger  */
declare class AccordionToolbarComponent {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionToolbarComponent, "hc-accordion-toolbar", never, {}, {}, never, ["*"], false, never>;
}

declare class AccordionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AccordionModule, [typeof AccordionComponent, typeof AccordionToolbarComponent], [typeof i2.CommonModule], [typeof AccordionComponent, typeof AccordionToolbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AccordionModule>;
}

interface IDiscoveryApplication {
    /** Usually the name of the application */
    ServiceName: string;
    /** A formatted version of the name of the application */
    FriendlyName: string;
    /** A short description of the application */
    Description: string;
    /** Optional build number for the application */
    BuildNumber: string | null;
    /** Version number of the application */
    Version: number;
    /** The unique id for this application in the Discovery Service */
    DiscoveryServiceId: number | null;
    /** The url to link to for the application */
    ServiceUrl: string;
    /** The last successful ping of the application */
    Heartbeat?: Date;
    /** Whether the app should be displayed in the app switcher */
    IsHidden?: boolean;
    /** The type of element, usually `application` */
    DiscoveryType: string;
    /** The base64 encoded png or svg of the application icon */
    Icon: string;
}
interface IDiscoveryRequest {
    value: IDiscoveryApplication[];
}
interface IAppSwitcherService {
    /** Optional URL for a separate page the app switcher can link to with a complete list of all available applications */
    allApplicationsUri: string;
    getApplications(): Observable<IDiscoveryRequest>;
}
declare const APP_SWITCHER_SERVICE: InjectionToken<IAppSwitcherService>;
interface IAppSwitcherConfig {
    discoveryServiceUri: string;
}
declare const APP_SWITCHER_CONFIG: InjectionToken<IAppSwitcherConfig>;

declare class WorkTrackerService {
    start(task: () => Promise<unknown>): Observable<boolean>;
    startObservable(task: () => Subscription): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkTrackerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WorkTrackerService>;
}

/**
 * `hc-app-switcher` is typically included in a popover to display links to available apps from the Discovery Service
 */
declare class AppSwitcherComponent implements OnInit, OnDestroy {
    _appSwitcherService: IAppSwitcherService;
    private workTracker;
    _hostClass: boolean;
    /** The array of applications pulled from the Discovery Service */
    applications: IDiscoveryApplication[];
    /** Whether the app switcher is currently loading data from the Discovery Service */
    loading: Observable<boolean>;
    /** Whether the load from the Discovery Service was successful */
    loadFailed: boolean;
    private _iconHeight;
    private _serviceName;
    private _version;
    private ngUnsubscribe;
    /** Sets the height of the app thumbnail icons, width is auto (defaults to 60px) */
    get iconHeight(): number;
    set iconHeight(heightVal: number);
    /** Used to disable switching for your own app. `serviceVersion` must also be set. */
    get serviceName(): string;
    set serviceName(serviceNameVal: string);
    /** Used to disable switching for your own app. `serviceName` must also be set. */
    get serviceVersion(): string | number;
    set serviceVersion(serviceVersionVal: string | number);
    /** Event emitted when a user clicks an app in the app switcher */
    appClick: EventEmitter<IDiscoveryApplication>;
    constructor(_appSwitcherService: IAppSwitcherService, workTracker: WorkTrackerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /** Manually loads all applications from the configured Discovery Service */
    loadApplications(): void;
    private loadApplicationFromDiscoveryService;
    private handleError;
    _linkIfNotMe(app: IDiscoveryApplication): string | null;
    _appIsMe(app: IDiscoveryApplication): boolean;
    _appClick(app: IDiscoveryApplication): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppSwitcherComponent, "hc-app-switcher", never, { "iconHeight": { "alias": "iconHeight"; "required": false; }; "serviceName": { "alias": "serviceName"; "required": false; }; "serviceVersion": { "alias": "serviceVersion"; "required": false; }; }, { "appClick": "appClick"; }, never, never, false, never>;
}

/**
 * `hc-app-switcher-links` is used to link to an app switcher page from the navbar mobile menu
 */
declare class AppSwitcherLinksComponent {
    _appSwitcherService: IAppSwitcherService;
    constructor(_appSwitcherService: IAppSwitcherService);
    static ɵfac: i0.ɵɵFactoryDeclaration<AppSwitcherLinksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppSwitcherLinksComponent, "hc-app-switcher-links", never, {}, {}, never, never, false, never>;
}

/** Enumerated actions for a popover to perform. */
declare enum NotificationAction {
    /** Popover should open. */
    OPEN = 0,
    /** Popover should close. */
    CLOSE = 1,
    /** Popover should toggle open or closed. */
    TOGGLE = 2,
    /** Popover has new target positions. */
    REPOSITION = 3,
    /** Popover needs new configuration. */
    UPDATE_CONFIG = 4,
    /** Popover should realign itself to the anchor.  */
    REALIGN = 5
}
/** Event object for dispatching to anchoring service. */
declare class PopoverNotification {
    /** Action to perform. */
    action: NotificationAction;
    /** Optional payload. */
    value?: any | undefined;
    constructor(
    /** Action to perform. */
    action: NotificationAction, 
    /** Optional payload. */
    value?: any | undefined);
}
declare class PopoverNotificationService {
    private store;
    /** Dispatch a notification to all subscribers. */
    dispatch(notification: PopoverNotification): void;
    /** Stream of notification events. */
    events(): Observable<PopoverNotification>;
    /** Complete event stream. */
    dispose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverNotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverNotificationService>;
}

type HcPopoverScrollStrategy = 'noop' | 'block' | 'reposition' | 'close';
type HcPopoverTrigger = 'click' | 'mousedown' | 'rightclick' | 'hover' | 'none';
type HcPopoverHorizontalAlign = 'before' | 'start' | 'center' | 'end' | 'after' | 'mouse';
type HcPopoverVerticalAlign = 'above' | 'start' | 'center' | 'end' | 'below' | 'mouse';
interface HcPopoverOpenOptions {
    /**
     * Whether the popover should return focus to the previously focused element after
     * closing. Defaults to true.
     */
    restoreFocus?: boolean;
    /** Whether the first focusable element should be focused on open. Defaults to true. */
    autoFocus?: boolean;
    /** The horizontal position for a fixed position popover. Defaults to 0 if `y` is set. */
    x?: number;
    /** The vertical position for a fixed position popover. Defaults to 0 if `x` is set. */
    y?: number;
}

/** Use `hcMenuItem` for a selectable item in an hcMenu. */
declare class MenuItemDirective {
    ref: ElementRef;
    _hostClass: boolean;
    _itemEnter: EventEmitter<void>;
    focus(): void;
    blur(): void;
    constructor(ref: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemDirective, "[hcMenuItem], [hcButtonItem]", never, {}, { "_itemEnter": "_itemEnter"; }, never, never, false, never>;
}

declare class HcPopComponent implements OnInit, OnDestroy {
    _elementRef: ElementRef;
    private _focusTrapFactory;
    private _document;
    /** Whether or not to disable default popover container styles. *Defaults to `false`.* */
    disableStyle: boolean;
    /** Whether or not to show a connection arrow when possible. *Defaults to `true`.* */
    showArrow: boolean;
    /** Alignment of the popover on the horizontal axis. Can be `before`, `start`, `center`, `end`, `after`, or `mouse`.
     * *Defaults to `center`.* */
    get horizontalAlign(): HcPopoverHorizontalAlign;
    set horizontalAlign(val: HcPopoverHorizontalAlign);
    private _horizontalAlign;
    /** Alignment of the popover on the x axis. Alias for `horizontalAlign`. *Defaults to `"center"`.* */
    get xAlign(): HcPopoverHorizontalAlign;
    set xAlign(val: HcPopoverHorizontalAlign);
    /** Alignment of the popover on the vertical axis. Can be `above`, `start`, `center`, `end`, `below`, or `mouse`.
     * *Defaults to `"below"`.* */
    get verticalAlign(): HcPopoverVerticalAlign;
    set verticalAlign(val: HcPopoverVerticalAlign);
    private _verticalAlign;
    /** Alignment of the popover on the y axis. Alias for `verticalAlign`. *Defaults to `"below"`.* */
    get yAlign(): HcPopoverVerticalAlign;
    set yAlign(val: HcPopoverVerticalAlign);
    /** Whether the popover always opens with the specified alignment. *Defaults to `false`.* */
    get forceAlignment(): boolean;
    set forceAlignment(val: boolean);
    private _forceAlignment;
    /**
     * Whether the popover's alignment is locked after opening. This prevents the popover
     * from changing its alignement when scrolling or changing the size of the viewport.
     * *Defaults to `false`.*
     */
    get lockAlignment(): boolean;
    set lockAlignment(val: boolean);
    private _lockAlignment;
    /** Constrains the content of a container to a standard css string value; *Defaults to `none`.* */
    get maxWidth(): string;
    set maxWidth(val: string);
    private _maxWidth;
    /** Whether the first focusable element should be focused on open. *Defaults to `false`.* */
    get autoFocus(): boolean;
    set autoFocus(val: boolean);
    private _autoFocus;
    _autoFocusOverride: boolean;
    /** Whether the popover should return focus to the previously focused element after closing. *Defaults to `true`.* */
    get restoreFocus(): boolean;
    set restoreFocus(val: boolean);
    private _restoreFocus;
    _restoreFocusOverride: boolean;
    /** How the popover should handle scrolling. *Defaults to `"reposition"`.* */
    get scrollStrategy(): HcPopoverScrollStrategy;
    set scrollStrategy(val: HcPopoverScrollStrategy);
    private _scrollStrategy;
    /** Whether the popover should have a backdrop (includes closing on click). *Defaults to `true`.* */
    get hasBackdrop(): boolean;
    set hasBackdrop(val: boolean);
    private _hasBackdrop;
    /** Whether the popover should close when the user clicks the backdrop or presses ESC. *Defaults to `true`.* */
    get interactiveClose(): boolean;
    set interactiveClose(val: boolean);
    private _interactiveClose;
    /** Custom transition to use while opening. *Defaults to `'200ms cubic-bezier(0.25, 0.8, 0.25, 1)'`.* */
    get openTransition(): string;
    set openTransition(val: string);
    private _openTransition;
    /** Custom transition to use while closing. *Defaults to `'200ms cubic-bezier(0.25, 0.8, 0.25, 1)'`.* */
    get closeTransition(): string;
    set closeTransition(val: string);
    private _closeTransition;
    /** A link to an associated parent menu that will be closed when this menu closes. */
    get parent(): HcPopComponent | null;
    set parent(val: HcPopComponent | null);
    private _parentMenu;
    /** Should the popover animate? *Defaults to `true`.* */
    shouldAnimate: boolean;
    /** Optional backdrop class. *Defaults to `''`.* */
    backdropClass: string;
    /** Set to true if clicking anywhere inside the popover should close it. *Defaults to `false`.* */
    autoCloseOnContentClick: boolean;
    /** Emits when the popover is opened. If `context` was set on the anchor, it will be emitted with this event. */
    opened: EventEmitter<any>;
    /** Emits when the popover is closed. */
    closed: EventEmitter<any>;
    /** Emits when the popover has finished opening. */
    afterOpen: EventEmitter<void>;
    /** Emits when the popover has finished closing. */
    afterClose: EventEmitter<void>;
    /** Emits when the backdrop is clicked. */
    backdropClicked: EventEmitter<void>;
    /** Emits when a keydown event is targeted to this popover's overlay. */
    overlayKeydown: EventEmitter<KeyboardEvent>;
    /** Reference to template so it can be placed within a portal. */
    _templateRef: TemplateRef<any>;
    /** Stores the click coordinates for mouse-based positioning */
    _offsetPos: number[];
    /** Stores a reference to the associated overlay */
    _componentOverlay: OverlayRef;
    /** Classes to be added to the popover for setting the correct transform origin. */
    _classList: any;
    _yAlignClass: string;
    _xAlignClass: string;
    /** Whether the popover is presently open. */
    _open: boolean;
    /** Instance of notification service. Will be undefined until attached to an anchor. */
    _notifications: PopoverNotificationService;
    /** Reference to the element to build a focus trap around. */
    private _focusTrapElement;
    /** Reference to the element that was focused before opening. */
    private _previouslyFocusedElement;
    /** Reference to a focus trap around the popover. */
    private _focusTrap;
    /** If this menu has children, keep track of whether any of them are open */
    _subMenuOpen: boolean;
    /** Reference to subscription of parent popover close events */
    private _parentClose;
    /** Block this popover from closing its parent on close */
    _parentCloseBlock: boolean;
    /** Reference to hcMenuItems (if the popover contains them) */
    _menuItems: QueryList<MenuItemDirective>;
    constructor(_elementRef: ElementRef, _focusTrapFactory: ConfigurableFocusTrapFactory, _document: any);
    ngOnInit(): void;
    ngOnDestroy(): void;
    _popContainerClicked(): void;
    /** Open this popover. */
    open(options?: HcPopoverOpenOptions): void;
    /** Close this popover and its parent (if linked). */
    close(value?: unknown): void;
    /** Toggle this popover open or closed. */
    toggle(): void;
    /** Realign the popover to the anchor. */
    realign(): void;
    /** Gets whether the popover is presently open. */
    isOpen(): boolean;
    /** Gets an animation config with customized (or default) transition values. */
    _getAnimation(): {
        value: any;
        params: any;
    };
    /** Callback for when the popover is finished animating in or out. */
    _onAnimationDone(event: AnimationEvent): void;
    /** Apply alignment classes based on alignment inputs. */
    _setAlignmentClasses(horizAlign?: HcPopoverHorizontalAlign, vertAlign?: HcPopoverVerticalAlign): void;
    _setAlignmentClassesForAnimation(horizAlign?: HcPopoverHorizontalAlign, vertAlign?: HcPopoverVerticalAlign): void;
    _setAlignmentClassesForArrow(xAlign?: HcPopoverHorizontalAlign, yAlign?: HcPopoverVerticalAlign): void;
    /** Set the focus of an hcMenu based on a keyboard arrow press */
    _keyFocus(downPress: boolean): void;
    /** Restore focus to the element focused before the popover opened. Also destroy trap. */
    _restoreFocusAndDestroyTrap(): void;
    /** Save a reference to the element focused before the popover was opened. */
    _savePreviouslyFocusedElement(): void;
    /** Move the focus inside the focus trap and remember where to return later. */
    private _trapFocus;
    /** Dispatch a notification to the notification service, if possible. */
    private _dispatchConfigNotification;
    /** Dispatch a notification to the notification service and throw if unable to. */
    private _dispatchActionNotification;
    /** Throws an error if the alignment is not a valid horizontalAlign. */
    private _validateHorizontalAlign;
    /** Throws an error if the alignment is not a valid verticalAlign. */
    private _validateVerticalAlign;
    /** Throws an error if the scroll strategy is not a valid strategy. */
    private _validateScrollStrategy;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcPopComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcPopComponent, "hc-pop", never, { "disableStyle": { "alias": "disableStyle"; "required": false; }; "showArrow": { "alias": "showArrow"; "required": false; }; "horizontalAlign": { "alias": "horizontalAlign"; "required": false; }; "xAlign": { "alias": "xAlign"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; "yAlign": { "alias": "yAlign"; "required": false; }; "forceAlignment": { "alias": "forceAlignment"; "required": false; }; "lockAlignment": { "alias": "lockAlignment"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "interactiveClose": { "alias": "interactiveClose"; "required": false; }; "openTransition": { "alias": "openTransition"; "required": false; }; "closeTransition": { "alias": "closeTransition"; "required": false; }; "parent": { "alias": "parent"; "required": false; }; "shouldAnimate": { "alias": "shouldAnimate"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; "autoCloseOnContentClick": { "alias": "autoCloseOnContentClick"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; "afterOpen": "afterOpen"; "afterClose": "afterClose"; "backdropClicked": "backdropClicked"; "overlayKeydown": "overlayKeydown"; }, ["_menuItems"], ["*"], false, never>;
}

/** Displays additional information on hover above the element after a specified delay */
declare class HcTooltipComponent extends HcPopComponent {
    /** The content to be display in the tooltip */
    tooltipContent: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcTooltipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcTooltipComponent, "hc-tooltip", never, { "tooltipContent": { "alias": "tooltipContent"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HcPopoverAnchoringService implements OnDestroy {
    private _overlay;
    private _renderer;
    private _ngZone;
    private _dir;
    /** Emits when the popover is opened. */
    popoverOpened: Subject<void>;
    /** Emits when the popover is closed. */
    popoverClosed: Subject<void>;
    /** Reference to the overlay containing the popover component. */
    _overlayRef: OverlayRef | null;
    /** Reference to the target popover. */
    private _popover;
    /** Stores the context assigned to the popover */
    _context: any;
    /** Reference to the view container for the popover template. */
    private _viewContainerRef;
    /** Reference to the anchor */
    private _anchor;
    /** Reference to a template portal where the overlay will be attached. */
    private _portal;
    /** Communications channel with the popover. */
    private _notifications;
    /** Single subscription to notifications service events. */
    private _notificationsSubscription;
    /** Single subscription to position changes. */
    private _positionChangeSubscription;
    /** Whether the popover is presently open. */
    private _popoverOpen;
    /** Emits when the service is destroyed. */
    private _onDestroy;
    /** Stores the fixed position coordinates */
    _fixedPos: number[];
    /** Function to remove a right-click event listener if added */
    private _unlistener;
    constructor(_overlay: Overlay, _renderer: Renderer2, _ngZone: NgZone, _dir: Directionality);
    ngOnDestroy(): void;
    /** Anchor a popover instance to a view and connection element. */
    anchor(popover: HcPopComponent, viewContainerRef: ViewContainerRef, anchor: HcPopoverAnchorDirective): void;
    /** Gets whether the popover is presently open. */
    isPopoverOpen(): boolean;
    /** Toggles the popover between the open and closed states. */
    togglePopover(): void;
    /** Opens the popover. */
    openPopover(options?: HcPopoverOpenOptions): void;
    /** Closes the popover. */
    closePopover(value?: unknown, neighborSubMenusAreOpen?: boolean): void;
    /** Realign the popover to the anchor. */
    realignPopoverToAnchor(): void;
    /** Get a reference to the anchor element. */
    getAnchorElement(): ElementRef;
    /** Apply behavior properties on the popover based on the open options. */
    private _applyOpenOptions;
    /** Create an overlay to be attached to the portal. */
    private _createOverlay;
    /** Removes the popover from the DOM. Does NOT update open state. */
    private _destroyPopover;
    /**
     * Destroys the popover immediately if it is closed, or waits until it
     * has been closed to destroy it.
     */
    private _destroyPopoverOnceClosed;
    /**
     * Call appropriate anchor method when an event is dispatched through
     * the notification service.
     */
    private _subscribeToNotifications;
    /** Close popover when backdrop is clicked. */
    private _subscribeToBackdrop;
    /** Close popover when escape keydown event occurs. */
    private _subscribeToEscape;
    /** Set state back to closed when detached. */
    private _subscribeToDetachments;
    /** Save the opened state of the popover and emit. */
    private _saveOpenedState;
    /** Save the closed state of the popover and emit. */
    private _saveClosedState;
    /** Gets the text direction of the containing app. */
    private _getDirection;
    /** Create and return a config for creating the overlay. */
    private _getOverlayConfig;
    /**
     * Listen to changes in the position of the overlay and set the correct alignment classes,
     * ensuring that the animation origin is correct, even with a fallback position.
     */
    private _subscribeToPositionChanges;
    /** Map a scroll strategy string type to an instance of a scroll strategy. */
    private _getScrollStrategyInstance;
    /** Create and return a position strategy based on config provided to the component instance. */
    private _getPositionStrategy;
    /** Create and return a position strategy for a fixed position popover. */
    private _getFixedPositionStrategy;
    /** Get fallback positions based around target alignments. */
    private _getFallbacks;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcPopoverAnchoringService, [null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HcPopoverAnchoringService>;
}

interface HcPopKeyboardNotifier {
    isOpen: boolean;
    nativeElement: HTMLElement;
    hasSubmenu: () => boolean;
    onKeyDown: (event: KeyboardEvent) => void;
}
declare class HcPopoverAccessibilityService implements OnDestroy {
    private notifiers;
    constructor();
    ngOnDestroy(): void;
    registerNotifier(notifier: HcPopKeyboardNotifier): void;
    private handleKeydown;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcPopoverAccessibilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HcPopoverAccessibilityService>;
}

declare class HcPopoverAnchorDirective implements OnInit, AfterContentInit, OnDestroy {
    _elementRef: ElementRef;
    private _viewContainerRef;
    _anchoring: HcPopoverAnchoringService;
    private _accessibility;
    private _componentFactoryResolver;
    /** Reference to the popover instance. */
    get attachedPopover(): HcPopComponent;
    set attachedPopover(value: HcPopComponent);
    private _attachedPopover;
    /** A string of text to display as a tooltip above an element */
    get tooltipText(): string;
    set tooltipText(value: string);
    private _tooltipText;
    /** Trigger event to toggle the popover. *Defaults to `"click"`.*
     * Accepts `click`, `mousedown`, `hover`, `rightclick`, or `none`.
     * Note: if "hover" is selected, the backdrop for the popover will be disabled. */
    get trigger(): HcPopoverTrigger;
    set trigger(val: HcPopoverTrigger);
    private _trigger;
    /** Number that can be passed into the popover to change hover delay. Also used for tooltip.
     * Delay is measured in milliseconds.
     */
    get popoverDelay(): number;
    set popoverDelay(val: number);
    private _popoverDelay;
    /** Timer that delays togglePopover on hover. */
    private hoverInterval;
    /** Constrains the content of a popover to a standard css string value; *Defaults to `none`.* */
    get maxWidth(): string;
    set maxWidth(val: string);
    private _maxWidth;
    /** Whether the popover should return focus to the previously focused element after closing.* */
    get restoreFocus(): boolean;
    set restoreFocus(val: boolean);
    /** Object or value that can be passed into the popover to customize its content */
    get context(): unknown;
    set context(val: unknown);
    /** Alignment of the popover on the horizontal axis. Can be `before`, `start`, `center`, `end`, `after`, or `mouse`.
     * *Defaults to `center`.* */
    get horizontalAlign(): HcPopoverHorizontalAlign;
    set horizontalAlign(val: HcPopoverHorizontalAlign);
    /** Alignment of the popover on the vertical axis. Can be `above`, `start`, `center`, `end`, `below`, or `mouse`.
     * *Defaults to `"below"`.* */
    get verticalAlign(): HcPopoverVerticalAlign;
    set verticalAlign(val: HcPopoverVerticalAlign);
    _hasSubmenu: boolean;
    /** Emits when the popover is opened. */
    popoverOpened: EventEmitter<void>;
    /** Emits when the popover is closed. */
    popoverClosed: EventEmitter<unknown>;
    /** Instance of notification service. Will be undefined until attached to a popover. */
    _notifications: PopoverNotificationService;
    /** Emits when the directive is destroyed. */
    private _onDestroy;
    constructor(_elementRef: ElementRef, _viewContainerRef: ViewContainerRef, _anchoring: HcPopoverAnchoringService, _accessibility: HcPopoverAccessibilityService, _componentFactoryResolver: ComponentFactoryResolver);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    _showOrHideOnClick(event: MouseEvent): void;
    /** So popover anchors can be accessible via keyboard. */
    _showOrHideOnEnter(event: KeyboardEvent): void;
    _showOrHideOnMouseOver($event: MouseEvent): void;
    _showOrHideRightClick($event: MouseEvent): boolean;
    _showOnHover($event: MouseEvent): void;
    _hideOnLeave(): void;
    /** Handle keyboard navigation of a hcMenu using the arrow or tab keys */
    _keyEvent(event: KeyboardEvent): void;
    /** Gets whether the popover is presently open. */
    isPopoverOpen(): boolean;
    /** Toggles the popover between the open and closed states. */
    togglePopover(): void;
    /** Opens the popover. */
    openPopover(options?: HcPopoverOpenOptions): void;
    /** Closes the popover. */
    closePopover(value?: unknown, neighborSubMenusAreOpen?: boolean): void;
    /** Realign the popover to the anchor. */
    realignPopover(): void;
    /** Get a reference to the anchor element. */
    getElement(): ElementRef;
    /** Throws an error if the popover instance is not provided. */
    private _validateAttachedPopover;
    /** Throws an error if the trigger is not a valid HcPopoverTrigger. */
    private _validateTrigger;
    /** Dispatch a notification to the notification service, if possible. */
    private _dispatchConfigNotification;
    private _setupKeyboardEvents;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcPopoverAnchorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcPopoverAnchorDirective, "[hcPop],[hcTooltip]", ["hcPopAnchor"], { "attachedPopover": { "alias": "hcPop"; "required": false; }; "tooltipText": { "alias": "hcTooltip"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "popoverDelay": { "alias": "popoverDelay"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; }; "context": { "alias": "context"; "required": false; }; "horizontalAlign": { "alias": "horizontalAlign"; "required": false; }; "verticalAlign": { "alias": "verticalAlign"; "required": false; }; }, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never, never, false, never>;
}

/** The `hcMenu` directive provides a standard way of displaying a series of selectable elements in a popover. */
declare class MenuDirective implements AfterContentInit, OnDestroy {
    _hostClass: boolean;
    _subMenus: QueryList<HcPopoverAnchorDirective>;
    _menuItems: QueryList<MenuItemDirective>;
    private unsubscribe$;
    ngAfterContentInit(): void;
    /** Rechecks the content for instances of `HcPopComponent` and inits them as submenus */
    updateSubMenus(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuDirective, "[hcMenu]", never, {}, {}, ["_subMenus", "_menuItems"], never, false, never>;
}

/** Use `hcMenuIcon` to prefix an icon to the beginning of a button inside of a menu. */
declare class MenuIconDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuIconDirective, "[hcMenuIcon]", never, {}, {}, never, never, false, never>;
}

/** Use `hcMenuText` for main button text inside of a menu. */
declare class MenuTextDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTextDirective, "[hcMenuText]", never, {}, {}, never, never, false, never>;
}

/** Use `hcMenuSubText` for right-aligned subtext of a button inside of a menu. Often used for keyboard shortcuts. */
declare class MenuSubTextDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuSubTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuSubTextDirective, "[hcMenuSubText]", never, {}, {}, never, never, false, never>;
}

/** Use `hcDivider` for a horizontal divider in a menu. */
declare class DividerDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DividerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DividerDirective, "[hcDivider]", never, {}, {}, never, never, false, never>;
}

declare class PopModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PopModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PopModule, [typeof HcPopComponent, typeof HcTooltipComponent, typeof HcPopoverAnchorDirective, typeof MenuDirective, typeof MenuItemDirective, typeof MenuIconDirective, typeof MenuTextDirective, typeof MenuSubTextDirective, typeof DividerDirective], [typeof i2.CommonModule, typeof i11.OverlayModule, typeof i12.A11yModule, typeof i13.BidiModule], [typeof HcPopComponent, typeof HcTooltipComponent, typeof HcPopoverAnchorDirective, typeof i13.BidiModule, typeof MenuDirective, typeof MenuItemDirective, typeof MenuIconDirective, typeof MenuTextDirective, typeof MenuSubTextDirective, typeof DividerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PopModule>;
}

type EllipsisMode = 'characters' | 'words';
declare class EllipsisPipe implements PipeTransform {
    static readonly ELLIPSIS = "\u2026";
    transform(value: string, length: number, mode?: EllipsisMode): string;
    private firstNWords;
    private firstNCharacters;
    static ɵfac: i0.ɵɵFactoryDeclaration<EllipsisPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EllipsisPipe, "ellipsis", false>;
}

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

declare class NullOrEmptyStringPipe implements PipeTransform {
    transform(value: unknown, altText: string): string | unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<NullOrEmptyStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NullOrEmptyStringPipe, "ifNullOrEmpty", false>;
}

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

declare class FileSizePipe implements PipeTransform {
    private units;
    transform(bytes: number, precision?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", false>;
}

declare class FileSizePipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FileSizePipeModule, [typeof FileSizePipe], [typeof i2.CommonModule], [typeof FileSizePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FileSizePipeModule>;
}

/** Creates an abbreviated number for display. 1,234,234 => 1.23M */
declare class NumberAbbreviatorPipe implements PipeTransform {
    static powers: {
        key: string;
        value: number;
    }[];
    /**
     * @param value the value to be abbreviated
     * @param decimalPoints how many decimal points to round to
     * @param threshold represents the number at which we should start abbreviating;
     * if the threshold is 1 million, we'll leave number less than 1 million as is (aside from adding commas or decimal points)
     */
    transform(value: number, decimalPoints?: number, threshold?: number): string;
    private roundValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberAbbreviatorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NumberAbbreviatorPipe, "abbreviateNumber", false>;
}

declare class NumberAbbreviatorPipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberAbbreviatorPipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NumberAbbreviatorPipeModule, [typeof NumberAbbreviatorPipe], [typeof i2.CommonModule], [typeof NumberAbbreviatorPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NumberAbbreviatorPipeModule>;
}

declare class HighlightPipe implements PipeTransform {
    transform(text: string, search?: string, preserveHTML?: boolean): string;
    searchChildren(parent: ChildNode, regex: RegExp): void;
    escapeTags(input: string): string;
    reverseEscapeTags(input: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightPipe, "highlight", false>;
}

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

declare class PipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, never, [typeof EllipsisPipeModule, typeof NullOrEmptyStringPipeModule, typeof FileSizePipeModule, typeof NumberAbbreviatorPipeModule, typeof HighlightPipeModule], [typeof EllipsisPipeModule, typeof NullOrEmptyStringPipeModule, typeof FileSizePipeModule, typeof NumberAbbreviatorPipeModule, typeof HighlightPipeModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
}

/** Object used to pass values that will be used in an IconComponent */
interface HcIcon {
    /** Font set icon is a part of */
    fontSet: string;
    /** Name of icon within a font set */
    fontIcon: string;
    /** Optional height in pixels of the icon; defaults to 37 */
    fontSize?: number;
}
/** Makes using a font icon easier. */
declare class IconComponent implements OnChanges {
    private elementRef;
    private _fontIcon;
    private _fontSet;
    private _previousFontIcon;
    private _previousFontSet;
    _hostClass: boolean;
    /** Name of icon within a font set. */
    get fontIcon(): string;
    set fontIcon(icon: string);
    /** Font set icon is a part of. */
    get fontSet(): string;
    set fontSet(fontSet: string);
    constructor(elementRef: ElementRef, ariaHidden: string);
    ngOnChanges(): void;
    private _updateFontIcon;
    private _cleanupFontValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, [null, { attribute: "aria-hidden"; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "hc-icon", never, { "fontIcon": { "alias": "fontIcon"; "required": false; }; "fontSet": { "alias": "fontSet"; "required": false; }; }, {}, never, ["*"], false, never>;
}

/** `hcIconSm` - small size of hc-icon (14px) */
declare class HcIconSmallDirective {
    _hostHcIconSmallClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcIconSmallDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcIconSmallDirective, "[hcIconSm]", never, {}, {}, never, never, false, never>;
}

/** `hcIconMd` - medium size of hc-icon (20px) - default size */
declare class HcIconMediumDirective {
    _hostHcIconMediumClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcIconMediumDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcIconMediumDirective, "[hcIconMd]", never, {}, {}, never, never, false, never>;
}

/** `hcIconLg` - large size of hc-icon (36px) */
declare class HcIconLargeDirective {
    _hostHcIconLargeClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcIconLargeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcIconLargeDirective, "[hcIconLg]", never, {}, {}, never, never, false, never>;
}

declare class IconModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IconModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IconModule, [typeof IconComponent, typeof HcIconSmallDirective, typeof HcIconMediumDirective, typeof HcIconLargeDirective], never, [typeof IconComponent, typeof HcIconSmallDirective, typeof HcIconMediumDirective, typeof HcIconLargeDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IconModule>;
}

declare class ProgressSpinnerComponent {
    private _color;
    /** Color of the spinner: `blue`, `green`, `purple`, `orange`, `red`, `gray`, `white` */
    get color(): string;
    set color(colorVal: string);
    /** If true, the spinner will center itself inside its container. */
    isCentered: boolean;
    /** If true, include background "channel" circle. */
    hasChannel: boolean;
    /** If true, switches to determinate mode. Must pass in progress (0-100%), instead of having the loader spin freely. */
    isDeterminate: boolean;
    /** (0-100%) Only used if "isDeterminate" is set to true. */
    set progress(progress: number);
    get progress(): number;
    /** Set the diameter of the circle, in pixels. Minimum is 20, maximum is 250. */
    set diameter(diameter: number);
    get diameter(): number;
    _rightCircleTransform: string;
    _leftCircleTransform: string;
    _rightCircleTransition: string;
    _leftCircleTransition: string;
    private _progress;
    private _diameter;
    private _minDiameter;
    private _maxDiameter;
    private setProgress;
    private setProgressTransition;
    /**
     * Using a somewhat complicated set of transforms to achive the animation.
     * For 0% to 50% the right circle element rotates from -135deg to 45deg
     * For 51% to 100% the left circle element rotates from 135deg to 315deg
     */
    private setProgressTransform;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressSpinnerComponent, "hc-progress-spinner", never, { "color": { "alias": "color"; "required": false; }; "isCentered": { "alias": "isCentered"; "required": false; }; "hasChannel": { "alias": "hasChannel"; "required": false; }; "isDeterminate": { "alias": "isDeterminate"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; }, {}, never, never, false, never>;
}

type ProgressDotsColor = 'light' | 'dark';
declare class ProgressDotsComponent {
    private _color;
    /** Use `light` on darker backgrounds and `dark` for lighter backgrounds. */
    get color(): ProgressDotsColor;
    set color(colorVal: ProgressDotsColor);
    /** If true, the loader will center itself within its container. */
    isCentered: boolean;
    /** If true, you'll get a teeny tiny little loader. */
    isMini: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressDotsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressDotsComponent, "hc-progress-dots", never, { "color": { "alias": "color"; "required": false; }; "isCentered": { "alias": "isCentered"; "required": false; }; "isMini": { "alias": "isMini"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ProgressBarComponent {
    private _color;
    /** Color of the bar: `blue`, `green`, `purple`, `orange`, `red`, `gray`, `white` */
    get color(): string;
    set color(colorVal: string);
    /** If true, switches to determinate mode. Must pass in progress (0-100%), instead of having the loader spin freely. */
    isDeterminate: boolean;
    /** If true, displays the current percentage of the progress bar and expands the height to accomidate. Only used if "isDeterminate" is set to true.*/
    showValue: boolean;
    /** Optional text string to be displayed beneath the progress bar */
    label: string;
    /** (0-100%) Only used if "isDeterminate" is set to true. */
    set progress(progress: number);
    get progress(): number;
    private _progress;
    private setProgress;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "hc-progress-bar", never, { "color": { "alias": "color"; "required": false; }; "isDeterminate": { "alias": "isDeterminate"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "label": { "alias": "label"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ProgressIndicatorsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressIndicatorsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ProgressIndicatorsModule, [typeof ProgressSpinnerComponent, typeof ProgressDotsComponent, typeof ProgressBarComponent], [typeof i2.CommonModule], [typeof ProgressSpinnerComponent, typeof ProgressDotsComponent, typeof ProgressBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ProgressIndicatorsModule>;
}

declare class AppSwitcherModule {
    static forRoot(config: IAppSwitcherConfig): ModuleWithProviders<AppSwitcherModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppSwitcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AppSwitcherModule, [typeof AppSwitcherComponent, typeof AppSwitcherLinksComponent], [typeof i2.CommonModule, typeof PopModule, typeof PipesModule, typeof IconModule, typeof ProgressIndicatorsModule], [typeof AppSwitcherComponent, typeof AppSwitcherLinksComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AppSwitcherModule>;
}

/**
 * An app switcher service designed to work with the Health Catalyst DOS platform's DiscoveryService
 */
declare class AppSwitcherService implements IAppSwitcherService {
    private http;
    private config;
    /** Optional URL for a separate page the app switcher can link to with a complete list of all available applications */
    readonly allApplicationsUri: string;
    private readonly discoveryServiceUri;
    constructor(http: HttpClient, config: IAppSwitcherConfig);
    getApplications(): Observable<IDiscoveryRequest>;
    private normalizeUri;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppSwitcherService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppSwitcherService>;
}

type BannerType = 'success' | 'info' | 'warning' | 'alert';
/** Notification banners are used for general information about the state of the application or upcoming events. For instant
 * feedback responding to user actions, use a toaster message.*/
declare class HcBannerComponent {
    private _type;
    private _clickDismiss;
    /** If the banner can be dismissed, emits when the banner is clicked to close */
    bannerClose: EventEmitter<MouseEvent>;
    /** Style of the notification banner; Defaults to info.
     * Options are: `success`, `info`, `warning`, `alert`*/
    get type(): BannerType;
    set type(typeVal: BannerType);
    /** When set to true, a close icon is added to the right side and `bannerClose`
     * emits on a click. Defaults to false.*/
    get clickDismiss(): boolean;
    set clickDismiss(dismissVal: boolean);
    _bannerClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcBannerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcBannerComponent, "hc-banner", never, { "type": { "alias": "type"; "required": false; }; "clickDismiss": { "alias": "clickDismiss"; "required": false; }; }, { "bannerClose": "bannerClose"; }, never, ["*"], false, never>;
}

/** Including `hcBannerStamp` wraps the enclosed text in a stamp to provide greater emphasis */
declare class BannerStampDirective {
    get _hostClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BannerStampDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BannerStampDirective, "[hcBannerStamp]", never, {}, {}, never, never, false, never>;
}

declare class BannerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BannerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BannerModule, [typeof HcBannerComponent, typeof BannerStampDirective], [typeof i2.CommonModule], [typeof HcBannerComponent, typeof BannerStampDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BannerModule>;
}

/**
 * IBreadcrumb interface is used to store all required data for each breadcrumb element
 * @docs-private
 */
interface IBreadcrumb {
    label: string;
    params?: Params;
    url: string;
}
type QueryParamsHandling = 'merge' | 'preserve' | '';
/** A navigational aid that allows users to keep track of their location within the current application  */
declare class BreadcrumbsComponent implements OnInit, OnDestroy {
    private activatedRoute;
    private router;
    _breadcrumbs: IBreadcrumb[];
    _routerSubscription: Subscription;
    _backURL: string;
    _backShow: string;
    _locationLabel: string;
    _queryParamsHandling: QueryParamsHandling;
    /** Sets the handling of the query parameters for the breadcrumb. Choose from: `'preserve' | 'merge' | '' (default)` */
    get queryParamsHandling(): QueryParamsHandling;
    set queryParamsHandling(queryParamsHandling: QueryParamsHandling);
    constructor(activatedRoute: ActivatedRoute, router: Router);
    ngOnInit(): void;
    private setBreadcrumbs;
    private getBreadcrumbs;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbsComponent, "hc-breadcrumbs", never, { "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; }; }, {}, never, never, false, never>;
}

declare class BreadcrumbsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbsModule, [typeof BreadcrumbsComponent], [typeof i2.CommonModule, typeof i3.RouterModule, typeof IconModule], [typeof BreadcrumbsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BreadcrumbsModule>;
}

/** Cashmere styled button */
declare class ButtonComponent {
    elementRef: ElementRef;
    private renderer;
    private _disabled;
    private _style;
    private _size;
    /** Sets style of button. Choose from: `'primary' | 'primary-alt' | 'destructive' |
     * 'neutral' | 'secondary' | 'minimal' | link' | 'link-inline'`. If needed, colors from
     * the primary, secondary, or neutral palette may be used as well (e.g. 'pink', 'red-orange', etc) */
    get buttonStyle(): string;
    set buttonStyle(btnStyle: string);
    /** Sets size of button. Choose from: `'sm' | 'md' | 'lg' |`. *Defaults to `md`.* */
    get size(): string;
    set size(size: string);
    /** Whether the control is disabled. */
    get disabled(): boolean;
    set disabled(isDisabled: boolean);
    get _disabledAttr(): string | null;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    /** Used to give focus to the button */
    focus(): void;
    private setHostClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "button[hc-button], button[hc-icon-button]", never, { "buttonStyle": { "alias": "buttonStyle"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class AnchorComponent extends ButtonComponent {
    get _hostAriaDisabled(): string;
    get _hostTabIndex(): number;
    get _handleClickEvents(): string;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AnchorComponent, "a[hc-button]", never, {}, {}, never, ["*"], false, never>;
}

/** SplitButton click event */
declare class SplitButtonClickEvent {
    source: SplitButtonComponent;
    constructor(source: SplitButtonComponent);
}
/** Split button provides a primary action button along with a secondary menu of actions */
declare class SplitButtonComponent {
    private elementRef;
    private _tabIndex;
    private _disabled;
    private _style;
    private _size;
    _splitBtnToggle: ButtonComponent;
    _splitMenu: HcPopComponent;
    _menuItems: QueryList<MenuItemDirective>;
    /** Primary button's click event */
    click: EventEmitter<SplitButtonClickEvent>;
    /** Additional information shown as tooltip */
    title: string;
    /** Positioning for the menu. Possible values: 'start', 'end', 'center' */
    menuPosition: string;
    /** True if clicking anywhere in the menu should automatically close it. */
    autoCloseMenuOnClick: boolean;
    /** Type of button. Possible values: 'submit', 'reset', 'button' */
    type: string;
    /** Used as a reference in JavaScript, or to reference form data after a form is submitted */
    name: string;
    /** Value of primary button when submitted within a form */
    value: string;
    /** Button tabindex */
    get tabIndex(): number;
    set tabIndex(value: number);
    /** Sets style of button. Choose from: `'primary' | 'primary-alt' | 'destructive' |
     * 'neutral' | 'secondary' | 'minimal'`. If needed, colors from
     * the primary or secondary palette may be used as well (e.g. 'pink', 'red-orange', etc) */
    get buttonStyle(): string;
    set buttonStyle(btnStyle: string);
    /** Sets size of button. Choose from: `'sm' | 'md' | 'lg'` */
    get size(): string;
    set size(size: string);
    /** Whether the control is disabled. */
    get disabled(): boolean;
    set disabled(isDisabled: boolean);
    get _hostClass(): boolean;
    constructor(elementRef: ElementRef);
    _stopClick($event: MouseEvent): void;
    /** Used to give focus to the button */
    focus(): void;
    _mainBtnClick(event: MouseEvent): void;
    /** Manually close the menu */
    closeMenu(): void;
    /** Manually open the menu */
    openMenu(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SplitButtonComponent, "hc-split-button", never, { "title": { "alias": "title"; "required": false; }; "menuPosition": { "alias": "menuPosition"; "required": false; }; "autoCloseMenuOnClick": { "alias": "autoCloseMenuOnClick"; "required": false; }; "type": { "alias": "type"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "buttonStyle": { "alias": "buttonStyle"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "click": "click"; }, ["_menuItems"], ["*", "[hcButtonItem], [hcMenuItem]"], false, never>;
}

declare class ButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, [typeof AnchorComponent, typeof ButtonComponent, typeof SplitButtonComponent], [typeof i2.CommonModule, typeof PopModule], [typeof AnchorComponent, typeof ButtonComponent, typeof SplitButtonComponent, typeof PopModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
}

/** Button Toggle components are the individually selectable buttons used within the Button Toggle Group component. */
declare class ButtonToggleComponent {
    _disabled: boolean;
    _parentDisabled: boolean;
    _selected: boolean;
    _hostClass: string;
    /** Event emitted when this specific toggle is changed. */
    _toggleClick: EventEmitter<ButtonToggleComponent>;
    /** The value assigned to this particular toggle. Used by the group to get/set the value of the selected item(s). */
    value: string;
    /** Whether the toggle is currently selected. Updates the value of the group when set. *Defaults to `false`.* */
    get selected(): boolean;
    set selected(isSelected: boolean);
    /** Whether the individual toggle is disabled */
    get disabled(): boolean;
    set disabled(isDisabled: boolean);
    _onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonToggleComponent, "hc-button-toggle", never, { "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "_toggleClick": "_toggleClick"; }, never, ["*"], false, never>;
}

declare class ButtonToggleChangeEvent {
    source: ButtonToggleComponent | null;
    buttonToggles: ButtonToggleComponent[] | null;
    selectedValues: string[] | null;
    /**
     * @param source the button toggle that fired the event
     * @param buttonToggles the collection of button toggles in the group
     * @param selectedValues the values of all 'selected' button toggles
     */
    constructor(source: ButtonToggleComponent | null, buttonToggles: ButtonToggleComponent[] | null, selectedValues: string[] | null);
}

/** Wrapper component that textual form controls extend to work with hc-form-field */
declare abstract class HcFormControlComponent {
    /** Whether the control should be displaying an associated error */
    _errorState: boolean;
    /** An error message to be shown in the UI when there is an error state present */
    _errorMessage: string;
    /** An object that represents the Angular validation errors that are present on the form */
    _errors: {
        [key: string]: unknown;
    };
    /** Whether the control is disabled */
    _isDisabled: boolean;
    /** ID identifier of the the control */
    _componentId: string;
    /** Whether the control is required */
    _isRequired: boolean;
    /** Whether the control should apply tight styling */
    _tight: boolean;
}

/** `hc-button-toggle-group` components are on/off toggles with the appearance of an `hc-button`.
 * These toggle groups may be configured to behave as single-select (like radio buttons), or multi-select (like checkboxes). */
declare class ButtonToggleGroupComponent extends HcFormControlComponent implements AfterContentInit, OnDestroy, ControlValueAccessor {
    private _disabled;
    private _style;
    private _size;
    private _valueRequired;
    private _multiple;
    private unsubscribe$;
    private _value;
    _hostClass: boolean;
    _buttons: QueryList<ButtonToggleComponent>;
    /** Event fired whenever a change is made to any button toggle in the group. */
    selectionChangedEvent: EventEmitter<ButtonToggleChangeEvent>;
    /** Sets style of toggle. Choose from: `'primary' | 'primary-alt' | 'destructive' | 'neutral' | 'secondary'`.
    * If needed, colors from the primary or secondary palette may be used as well (e.g. 'pink', 'red-orange', etc).
    * *Defaults to `secondary`.* */
    get buttonStyle(): string;
    set buttonStyle(val: string);
    get value(): unknown;
    set value(newValue: unknown);
    /** Sets size of toggle. Choose from: `'sm' | 'md' | 'lg' |`. *Defaults to `md`.* */
    get size(): string;
    set size(size: string);
    /** Whether multiple button toggles can be selected. *Defaults to `false`.* */
    get multiple(): boolean;
    set multiple(val: boolean);
    /** Whether at least one button must remain selected. */
    get valueRequired(): boolean;
    set valueRequired(required: boolean);
    /** Whether the entire toggle group is disabled. */
    get disabled(): boolean;
    set disabled(isDisabled: boolean);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    writeValue(value: unknown): void;
    onChange: (value: unknown) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    setDisabledState(state: boolean): void;
    _touch(): void;
    _updateButtonStyle(): void;
    _updateButtonStateFromModel(): void;
    _updateValueOnClick(targetButton: ButtonToggleComponent): void;
    /** The component allows you to set [selected] on individual buttons, so we need to honor that in the model. */
    private _setInitalModelAsNeeded;
    private _emitEventForInitiallySelected;
    private _connectToButtonChildren;
    private _subscribeToButtonClick;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonToggleGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonToggleGroupComponent, "hc-button-toggle-group", never, { "buttonStyle": { "alias": "buttonStyle"; "required": false; }; "value": { "alias": "value"; "required": false; }; "size": { "alias": "size"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "valueRequired": { "alias": "valueRequired"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectionChangedEvent": "selectionChangedEvent"; }, ["_buttons"], ["*"], false, never>;
}

declare class ButtonToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonToggleModule, [typeof ButtonToggleComponent, typeof ButtonToggleGroupComponent], [typeof i2.CommonModule, typeof i4.FormsModule], [typeof ButtonToggleComponent, typeof ButtonToggleGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonToggleModule>;
}

declare class CheckboxChangeEvent {
    source: CheckboxComponent;
    checked: boolean;
    constructor(source: CheckboxComponent, checked: boolean);
}
declare class CheckboxGroup extends HcFormControlComponent {
    /** A list of all the checkboxes included in the group */
    private _checkboxes;
    private _checkboxesArray;
    _groupState: boolean;
    _parentLabel: string;
    _disableParent: boolean;
    _isIndeterminate: boolean;
    /** gets all children and subscribes to their events */
    get checkboxes(): QueryList<CheckboxComponent>;
    set checkboxes(value: QueryList<CheckboxComponent>);
    /** Input to disable the Parent button *Defaults to `false`.* */
    get disableParent(): boolean;
    set disableParent(disableParent: boolean);
    /** Input to change the label for the parent checkbox *Defaults to 'Parent Checkbox'* */
    get parentLabel(): string;
    set parentLabel(parentLabel: string);
    /** Function to handle the indeterminate checkbox */
    updateParentState(): void;
    /** Function to return all checkboxes*/
    getSelected(): CheckboxComponent[];
    /** Function that handles the parent checkbox functionality */
    toggleCheckAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxGroup, "hc-checkbox-group", ["hcCheckboxGroup"], { "disableParent": { "alias": "disableParent"; "required": false; }; "parentLabel": { "alias": "parentLabel"; "required": false; }; }, {}, ["checkboxes"], ["*"], false, never>;
}
declare class CheckboxComponent extends HcFormControlComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
    private _renderer;
    _ngControl: NgControl;
    private _changeRef;
    private _uniqueId;
    private _form;
    private _checked;
    private _tabIndex;
    private _parent;
    private readonly checkboxGroup;
    private _unsubscribe;
    _componentId: string;
    /** Value attribute of the native checkbox */
    value: string;
    /** Whether the checkbox is indeterminate. It can represent a checkbox with three states. */
    indeterminate: boolean;
    /** If true, the checkbox is for display purposes (not user interaction). As such its checked/unchecked state
     * can only be controlled programatically. Useful for embedding in an ng-select typeahead */
    isStub: boolean;
    /** Unique id for the checkbox element. If none is supplied, one will be auto-generated. */
    get id(): string;
    set id(idVal: string);
    /** If true, condense the default margin and reduce the font size. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    /** Sets the position of the checkbox relative to its associated label. *Defaults to `center`.*  */
    align: 'center' | 'top' | 'bottom';
    /** Sets unique name used in a form */
    name: string | null;
    /** Event emitted whenever the state changes */
    change: EventEmitter<CheckboxChangeEvent>;
    _checkboxInput: ElementRef;
    get _getHostId(): string;
    get _getCheckboxCheckedClass(): boolean;
    get _getCheckboxDisabledClass(): boolean;
    get _getCheckboxIndeterminateClass(): boolean;
    /** Whether the checkbox is required. */
    get required(): boolean;
    set required(requiredVal: boolean);
    /** Whether the checkbox is disabled. */
    get disabled(): boolean;
    set disabled(disabledVal: boolean);
    /** Whether the checkbox is checked. */
    get checked(): boolean;
    set checked(checked: boolean);
    /** Whether the checkbox is a parent. */
    get parent(): boolean;
    set parent(parent: boolean);
    /** TabIndex attribute of native checkbox */
    get tabIndex(): number;
    set tabIndex(value: number);
    get _inputId(): string;
    ngAfterViewInit(): void;
    constructor(tabindex: string, _renderer: Renderer2, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, checkboxGroup: CheckboxGroup, _ngControl: NgControl, _changeRef: ChangeDetectorRef);
    writeValue(value: unknown): void;
    onChange: (value: unknown) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    setDisabledState(disabledVal: boolean): void;
    /** Toggles the current checked state of the checkbox */
    toggle(): void;
    _clickEvent(event: Event): void;
    _stopChangeEvent(event: Event): void;
    private _emitChangeEvent;
    _onBlur(): void;
    private _updateErrorState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, [{ attribute: "tabindex"; }, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "hc-checkbox", ["hcCheckbox"], { "value": { "alias": "value"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "isStub": { "alias": "isStub"; "required": false; }; "id": { "alias": "id"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "align": { "alias": "align"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "parent": { "alias": "parent"; "required": false; }; }, { "change": "change"; }, never, ["*"], false, never>;
}

/** @docs-private */
declare class HcCheckboxRequiredValidatorDirective implements Validator {
    private _required;
    private _onChange?;
    validate(control: AbstractControl): ValidationErrors | null;
    get required(): boolean | string;
    set required(value: boolean | string);
    registerOnValidatorChange(fn: () => void): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcCheckboxRequiredValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcCheckboxRequiredValidatorDirective, "hc-checkbox[required][formControlName],hc-checkbox[required][formControl],hc-checkbox[required][ngModel]", never, { "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CheckboxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckboxModule, [typeof CheckboxComponent, typeof HcCheckboxRequiredValidatorDirective, typeof CheckboxGroup], [typeof i2.CommonModule, typeof i4.FormsModule], [typeof CheckboxComponent, typeof HcCheckboxRequiredValidatorDirective, typeof CheckboxGroup]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CheckboxModule>;
}

/** Chips represent complex entities in small blocks, such as filters, contacts, or system information */
declare class ChipComponent {
    private _hasCloseButton;
    private _color;
    _tight: boolean;
    /** Emitted when the 'X' close button is clicked. `(click)` may be used for clicks on the entire chip */
    closeClick: EventEmitter<MouseEvent>;
    /** Sets chip color to one of: `neutral`, `yellow`, `green`, `red`, or `blue` (default=`neutral`) */
    get color(): string;
    set color(colorType: string);
    /** If true, displays an X button on the right side of the chip which emits a `closeClick` event */
    get hasCloseButton(): boolean;
    set hasCloseButton(hasButton: boolean);
    /** If true, removes the margins & padding from the chip; defaults to `false` */
    get tight(): boolean;
    set tight(val: boolean);
    /** Allows you to customize the width of a chip (ie. `100%`, `250px`); defaults to `auto` */
    width: string;
    /** Called on a click of the X close button */
    _closeClick(e: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipComponent, "hc-chip", never, { "color": { "alias": "color"; "required": false; }; "hasCloseButton": { "alias": "hasCloseButton"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "closeClick": "closeClick"; }, never, ["*"], false, never>;
}

/** Supporting component to help with grouping chips into collections */
declare class ChipRowComponent {
    private _wrap;
    /** If false, constrain the container to one line with overflow ellipses (default=true) */
    get wrap(): boolean;
    set wrap(doWrap: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipRowComponent, "hc-chip-row", never, { "wrap": { "alias": "wrap"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class ChipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ChipModule, [typeof ChipComponent, typeof ChipRowComponent], [typeof i2.CommonModule], [typeof ChipComponent, typeof ChipRowComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ChipModule>;
}

/** The interface for caching a sortable/hidable column in local storage */
interface HcCachedColumn {
    key: string;
    isHidden: boolean;
}
/**
 * Interface to configure a column that hideable/sortable in the column menu.
 */
interface HcDynamicColumn {
    /** property name from data element */
    name: string;
    /** ui-ready label for this data element */
    title?: string;
    /** true if this property can be hidden/shown */
    isHidable?: boolean;
    /** true if this property should be shown default. only applicable if the column is hidable. */
    isShownByDefault?: boolean;
    /** description for this property */
    description?: string;
}

/** Component for toggling and reordering columns within a data grid */
declare class ColumnMenuComponent implements OnInit {
    /** Reference to the popover menu. */
    menu: HcPopComponent;
    /** Every time column settings are changed, emits an array of displayed columns in their proper order. */
    displayedColumnChange: EventEmitter<string[]>;
    /** Fires when button to open menu is clicked. */
    onMenuIconClick: EventEmitter<void>;
    /** Key used when caching the column order and display settings in local storage. If not provided, these settings will not be cached. */
    cacheKey: string;
    /** Keys for columns that cannot be moved or hidden and sit at the start of the row. */
    set staticPrefixCols(prefixCols: string[]);
    get staticPrefixCols(): string[];
    private _staticPrefixCols;
    /** Keys for columns that cannot be moved or hidden and sit at the end of the row. */
    set staticSuffixCols(suffixCols: string[]);
    get staticSuffixCols(): string[];
    private _staticSuffixCols;
    /** Collection of columns that can be hidden and/or reordered. */
    set dynamicCols(cols: Array<HcDynamicColumn>);
    get dynamicCols(): Array<HcDynamicColumn>;
    private _dynamicCols;
    /** An array of the currently displayed column keys sorted in their proper order. */
    get displayedColumns(): string[];
    _displayedColumns: string[];
    /** Collection of the sortable/hidable column forms. */
    get colSelectionForm(): FormGroup;
    _colSelectionForm: FormGroup<{}>;
    ngOnInit(): void;
    /** Returns true if every hideable column is currently hidden. */
    get allHidden(): boolean;
    /** Show all columns */
    selectAll(): void;
    /** Hide all columns */
    clearAll(): void;
    /** Open the column menu */
    open(): void;
    /** Close the column menu */
    close(): void;
    _onColChange(): void;
    _generateColumnSelectionForms(cols: Array<HcDynamicColumn>): void;
    _interpretOptionalBoolean(val?: boolean): boolean;
    _refreshCols(): string[];
    _getDisplayedColumns(): string[];
    /**
     * Handle rearanging of columns via drag and drop
     * @param event contains data from the drag and drop event
     * @param isInDataGrid if true, we need to take in account the fact that some columns may currently be hidden
     */
    columnDropped(event: CdkDragDrop<any>, isInDataGrid?: boolean): void;
    /**
     * Save ordered list of columns with their display status to local storage
     */
    saveCachedPreferences(): void;
    /**
     * Load user preferences for columns order and display status
     */
    _getCachedPreferences(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnMenuComponent, "hc-column-menu", never, { "cacheKey": { "alias": "cacheKey"; "required": false; }; "staticPrefixCols": { "alias": "staticPrefixCols"; "required": false; }; "staticSuffixCols": { "alias": "staticSuffixCols"; "required": false; }; "dynamicCols": { "alias": "dynamicCols"; "required": false; }; }, { "displayedColumnChange": "displayedColumnChange"; "onMenuIconClick": "onMenuIconClick"; }, never, never, false, never>;
}

declare class ColumnMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ColumnMenuModule, [typeof ColumnMenuComponent], [typeof i2.CommonModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof ButtonModule, typeof CheckboxModule, typeof PopModule, typeof i7.DragDropModule, typeof IconModule], [typeof ColumnMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ColumnMenuModule>;
}

/** Datepicker data that requires internationalization. */
declare class HcDatepickerIntl {
    /**
     * Stream that emits whenever the labels here are changed. Use this to notify
     * components if the labels have changed after initialization.
     */
    readonly changes: Subject<void>;
    /** A label for the calendar popup (used by screen readers). */
    calendarLabel: string;
    /** A label for the button used to open the calendar popup (used by screen readers). */
    openCalendarLabel: string;
    /** A label for the current month button (used by screen readers). */
    currentMonthLabel: string;
    /** A label for the previous month button (used by screen readers). */
    prevMonthLabel: string;
    /** A label for the next month button (used by screen readers). */
    nextMonthLabel: string;
    /** A label for the previous year button (used by screen readers). */
    prevYearLabel: string;
    /** A label for the next year button (used by screen readers). */
    nextYearLabel: string;
    /** A label for the previous multi-year button (used by screen readers). */
    prevMultiYearLabel: string;
    /** A label for the next multi-year button (used by screen readers). */
    nextMultiYearLabel: string;
    /** A label for the 'switch to month view' button (used by screen readers). */
    switchToMonthViewLabel: string;
    /** A label for the 'switch to year view' button (used by screen readers). */
    switchToMultiYearViewLabel: string;
    /** A label for the 'jump to the current date' button (used by screen readers). */
    switchToTodayLabel: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcDatepickerIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HcDatepickerIntl>;
}

/**
 * @license
 * Copyright Health Catalyst All Rights Reserved.
 *
 * Use of this source code is governed by an Apache-2.0 license that can be
 * found in the LICENSE file at https://raw.githubusercontent.com/HealthCatalyst/Fabric.Cashmere/dev/LICENSE
 */

type D = Date;
type HcDateFormats = {
    parse: {
        dateInput: any;
    };
    display: {
        dateInput: any;
        timeInput: any;
        dateTimeInput: any;
        monthYearLabel: any;
        dateA11yLabel: any;
        monthYearA11yLabel: any;
    };
};
declare const HC_DATE_FORMATS: InjectionToken<HcDateFormats>;

/**
 * @license
 * Copyright Health Catalyst All Rights Reserved.
 *
 * Use of this source code is governed by an Apache-2.0 license that can be
 * found in the LICENSE file at https://raw.githubusercontent.com/HealthCatalyst/Fabric.Cashmere/dev/LICENSE
 */

/** InjectionToken for datepicker that can be used to override default locale code. */
declare const HC_DATE_LOCALE: InjectionToken<string>;
/** @docs-private */
declare function HC_DATE_LOCALE_FACTORY(): string;
/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */
declare abstract class DateAdapter<D> {
    /** The locale to use for all dates. */
    protected locale: any;
    /** A stream that emits when the locale changes. */
    get localeChanges(): Observable<void>;
    protected _localeChanges: Subject<void>;
    /**
     * Gets the year component of the given date.
     * @param date The date to extract the year from.
     * @returns The year component.
     */
    abstract getYear(date: D): number;
    /**
     * Gets the month component of the given date.
     * @param date The date to extract the month from.
     * @returns The month component (0-indexed, 0 = January).
     */
    abstract getMonth(date: D): number;
    /**
     * Gets the date of the month component of the given date.
     * @param date The date to extract the date of the month from.
     * @returns The month component (1-indexed, 1 = first of month).
     */
    abstract getDate(date: D): number;
    abstract getHours(date: D): number;
    abstract getMinutes(date: D): number;
    /**
     * Gets the day of the week component of the given date.
     * @param date The date to extract the day of the week from.
     * @returns The month component (0-indexed, 0 = Sunday).
     */
    abstract getDayOfWeek(date: D): number;
    /**
     * Gets a list of names for the months.
     * @param style The naming style (e.g. long = 'January', short = 'Jan', narrow = 'J').
     * @returns An ordered list of all month names, starting with January.
     */
    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    /**
     * Gets a list of names for the dates of the month.
     * @returns An ordered list of all date of the month names, starting with '1'.
     */
    abstract getDateNames(): string[];
    /**
     * Gets a list of names for the days of the week.
     * @param style The naming style (e.g. long = 'Sunday', short = 'Sun', narrow = 'S').
     * @returns An ordered list of all weekday names, starting with Sunday.
     */
    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    /**
     * Gets the name for the year of the given date.
     * @param date The date to get the year name for.
     * @returns The name of the given year (e.g. '2017').
     */
    abstract getYearName(date: D): string;
    /**
     * Gets the first day of the week.
     * @returns The first day of the week (0-indexed, 0 = Sunday).
     */
    abstract getFirstDayOfWeek(): number;
    /**
     * Gets the number of days in the month of the given date.
     * @param date The date whose month should be checked.
     * @returns The number of days in the month of the given date.
     */
    abstract getNumDaysInMonth(date: D): number;
    /**
     * Clones the given date.
     * @param date The date to clone
     * @returns A new date equal to the given date.
     */
    abstract clone(date: D): D;
    /**
     * Creates a date with the given year, month, and date. Does not allow over/under-flow of the
     * month and date.
     * @param year The full year of the date. (e.g. 89 means the year 89, not the year 1989).
     * @param month The month of the date (0-indexed, 0 = January). Must be an integer 0 - 11.
     * @param date The date of month of the date. Must be an integer 1 - length of the given month.
     * @returns The new date, or null if invalid.
     */
    abstract createDate(year: number, month: number, date: number): D;
    /**
     * Gets today's date.
     * @returns Today's date.
     */
    abstract today(): D;
    /**
     * Parses a date from a user-provided value.
     * @param value The value to parse.
     * @param parseFormat The expected format of the value being parsed
     *     (type is implementation-dependent).
     * @returns The parsed date.
     */
    abstract parse(value: any, parseFormat: any): D | null;
    /**
     * Formats a date as a string according to the given format.
     * @param date The value to format.
     * @param displayFormat The format to use to display the date as a string.
     * @returns The formatted date string.
     */
    abstract format(date: D, displayFormat: any): string;
    /**
     * Adds the given number of years to the date. Years are counted as if flipping 12 pages on the
     * calendar for each year and then finding the closest date in the new month. For example when
     * adding 1 year to Feb 29, 2016, the resulting date will be Feb 28, 2017.
     * @param date The date to add years to.
     * @param years The number of years to add (may be negative).
     * @returns A new date equal to the given one with the specified number of years added.
     */
    abstract addCalendarYears(date: D, years: number): D;
    /**
     * Adds the given number of months to the date. Months are counted as if flipping a page on the
     * calendar for each month and then finding the closest date in the new month. For example when
     * adding 1 month to Jan 31, 2017, the resulting date will be Feb 28, 2017.
     * @param date The date to add months to.
     * @param months The number of months to add (may be negative).
     * @returns A new date equal to the given one with the specified number of months added.
     */
    abstract addCalendarMonths(date: D, months: number): D;
    /**
     * Adds the given number of days to the date. Days are counted as if moving one cell on the
     * calendar for each day.
     * @param date The date to add days to.
     * @param days The number of days to add (may be negative).
     * @returns A new date equal to the given one with the specified number of days added.
     */
    abstract addCalendarDays(date: D, days: number): D;
    /**
     * Gets the RFC 3339 compatible string (https://tools.ietf.org/html/rfc3339) for the given date.
     * This method is used to generate date strings that are compatible with native HTML attributes
     * such as the `min` or `max` attribute of an `<input>`.
     * @param date The date to get the ISO date string for.
     * @returns The ISO date string date string.
     */
    abstract toIso8601(date: D): string;
    /**
     * Checks whether the given object is considered a date instance by this DateAdapter.
     * @param obj The object to check
     * @returns Whether the object is a date instance.
     */
    abstract isDateInstance(obj: any): boolean;
    /**
     * Checks whether the given date is valid.
     * @param date The date to check.
     * @returns Whether the date is valid.
     */
    abstract isValid(date: D): boolean;
    /**
     * Gets date instance that is not valid.
     * @returns An invalid date.
     */
    abstract invalid(): D;
    /**
     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
     * string). The default implementation does not allow any deserialization, it simply checks that
     * the given value is already a valid date object or null. The `<sat-datepicker>` will call this
     * method on all of it's `@Input()` properties that accept dates. It is therefore possible to
     * support passing values from your backend directly to these properties by overriding this method
     * to also deserialize the format used by your backend.
     * @param value The value to be deserialized into a date object.
     * @returns The deserialized date object, either a valid date, null if the value can be
     *     deserialized into a null date (e.g. the empty string), or an invalid date.
     */
    deserialize(value: any): D | null;
    /**
     * Sets the locale used for all dates.
     * @param locale The new locale.
     */
    setLocale(locale: any): void;
    /**
     * Compares two dates.
     * @param first The first date to compare.
     * @param second The second date to compare.
     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
     *     a number greater than 0 if the first date is later.
     */
    compareDate(first: D, second: D): number;
    /**
     * Checks if two dates are equal.
     * @param first The first date to check.
     * @param second The second date to check.
     * @returns Whether the two dates are equal.
     *     Null dates are considered equal to other null dates.
     */
    sameDate(first: D | null, second: D | null): boolean;
    /**
     * Clamp the given date between min and max dates.
     * @param date The date to clamp.
     * @param min The minimum value to allow. If null or omitted no min is enforced.
     * @param max The maximum value to allow. If null or omitted no max is enforced.
     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
     *     otherwise `date`.
     */
    clampDate(date: D, min?: D | null, max?: D | null): D;
}

/**
 * Extra CSS classes that can be associated with a calendar cell.
 */
type HcCalendarCellCssClasses = string | string[] | Set<string> | {
    [key: string]: unknown;
};
/**
 * An internal class that represents the data corresponding to a single calendar cell.
 * @docs-private
 */
declare class HcCalendarCell {
    value: number;
    displayValue: string;
    ariaLabel: string;
    enabled: boolean;
    cssClasses?: HcCalendarCellCssClasses | undefined;
    constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean, cssClasses?: HcCalendarCellCssClasses | undefined);
}
/**
 * An internal component used to display calendar data in a table.
 * @docs-private
 */
declare class CalendarBodyComponent implements OnChanges {
    private _elementRef;
    private _ngZone;
    _hostClass: boolean;
    _role: string;
    _aria: boolean;
    /** The label for the table. (e.g. "Jan 2017"). */
    label: string;
    /** The cells to display in the table. */
    rows: HcCalendarCell[][];
    /** The value in the table that corresponds to today. */
    todayValue: number;
    /** The value in the table that is currently selected. */
    selectedValue: number;
    /** The minimum number of free cells needed to fit the label in the first row. */
    labelMinRequiredCells: number;
    /** The number of columns in the table. */
    numCols: number;
    /** The cell number of the active cell in the table. */
    activeCell: number;
    /**
     * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be
     * maintained even as the table resizes.
     */
    cellAspectRatio: number;
    /** Emits when a new value is selected. */
    readonly selectedValueChange: EventEmitter<number>;
    /** The number of blank cells to put at the beginning for the first row. */
    _firstRowOffset: number;
    /** Padding for the individual date cells. */
    _cellPadding: string;
    /** Width of an individual cell. */
    _cellWidth: string;
    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone);
    _cellClicked(cell: HcCalendarCell): void;
    ngOnChanges(changes: SimpleChanges): void;
    _isActiveCell(rowIndex: number, colIndex: number): boolean;
    /** Focuses the active cell after the microtask queue is empty. */
    _focusActiveCell(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarBodyComponent, "[hc-calendar-body]", ["hcCalendarBody"], { "label": { "alias": "label"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "todayValue": { "alias": "todayValue"; "required": false; }; "selectedValue": { "alias": "selectedValue"; "required": false; }; "labelMinRequiredCells": { "alias": "labelMinRequiredCells"; "required": false; }; "numCols": { "alias": "numCols"; "required": false; }; "activeCell": { "alias": "activeCell"; "required": false; }; "cellAspectRatio": { "alias": "cellAspectRatio"; "required": false; }; }, { "selectedValueChange": "selectedValueChange"; }, never, never, false, never>;
}

declare class MultiYearViewComponent implements AfterContentInit {
    private _changeDetectorRef;
    _dateAdapter: DateAdapter<D>;
    private _dir?;
    /** The date to display in this multi-year view (everything other than the year is ignored). */
    get activeDate(): D;
    set activeDate(value: D);
    private _activeDate;
    /** The currently selected date. */
    get selected(): D | null;
    set selected(value: D | null);
    private _selected;
    /** The minimum selectable date. */
    get minDate(): D | null;
    set minDate(value: D | null);
    private _minDate;
    /** The maximum selectable date. */
    get maxDate(): D | null;
    set maxDate(value: D | null);
    private _maxDate;
    /** A function used to filter which dates are selectable. */
    dateFilter: (date: D) => boolean;
    /** Emits when a new year is selected. */
    readonly selectedChange: EventEmitter<D>;
    /** Emits the selected year. This doesn't imply a change on the selected date */
    readonly yearSelected: EventEmitter<D>;
    /** Emits when any date is activated. */
    readonly activeDateChange: EventEmitter<D>;
    /** The body of calendar table */
    _hcCalendarBody: CalendarBodyComponent;
    /** Grid of calendar cells representing the currently displayed years. */
    _years: HcCalendarCell[][];
    /** The year that today falls on. */
    _todayYear: number;
    /** The year of the selected date. Null if the selected date is null. */
    _selectedYear: number | null;
    constructor(_changeDetectorRef: ChangeDetectorRef, _dateAdapter: DateAdapter<D>, _dir?: Directionality | undefined);
    ngAfterContentInit(): void;
    /** Initializes this multi-year view. */
    _init(): void;
    /** Handles when a new year is selected. */
    _yearSelected(year: number): void;
    /** Handles keydown events on the calendar body when calendar is in multi-year view. */
    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
    _getActiveCell(): number;
    /** Focuses the active cell after the microtask queue is empty. */
    _focusActiveCell(): void;
    /** Creates an hcCalendarCell for the given year. */
    private _createCellForYear;
    /** Whether the given year is enabled. */
    private _shouldEnableYear;
    /**
     * @param obj The object to check.
     * @returns The given object if it is both a date instance and valid, otherwise null.
     */
    private _getValidDateOrNull;
    /** Determines whether the user has the RTL layout direction. */
    private _isRtl;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiYearViewComponent, [null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiYearViewComponent, "hc-multi-year-view", ["hcMultiYearView"], { "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; }, { "selectedChange": "selectedChange"; "yearSelected": "yearSelected"; "activeDateChange": "activeDateChange"; }, never, never, false, never>;
}

/**
 * An internal component used to display a single month in the datepicker.
 * @docs-private
 */
declare class MonthViewComponent implements AfterContentInit {
    private _changeDetectorRef;
    private _dateFormats;
    _dateAdapter: DateAdapter<D>;
    private _dir?;
    /**
     * The date to display in this month view (everything other than the month and year is ignored).
     */
    get activeDate(): D;
    set activeDate(value: D);
    private _activeDate;
    /** The currently selected date. */
    get selected(): D | null;
    set selected(value: D | null);
    private _selected;
    /** The minimum selectable date. */
    get minDate(): D | null;
    set minDate(value: D | null);
    private _minDate;
    /** The maximum selectable date. */
    get maxDate(): D | null;
    set maxDate(value: D | null);
    private _maxDate;
    /** Function used to filter which dates are selectable. */
    dateFilter: (date: D) => boolean;
    /** Function that can be used to add custom CSS classes to dates. */
    dateClass: (date: D) => HcCalendarCellCssClasses;
    /** Emits when a new date is selected. */
    readonly selectedChange: EventEmitter<D | null>;
    /** Emits when any date is selected. */
    readonly _userSelection: EventEmitter<void>;
    /** Emits when any date is activated. */
    readonly activeDateChange: EventEmitter<D>;
    /** The body of calendar table */
    _hcCalendarBody: CalendarBodyComponent;
    /** The label for this month (e.g. "January 2017"). */
    _monthLabel: string;
    /** Grid of calendar cells representing the dates of the month. */
    _weeks: HcCalendarCell[][];
    /** The number of blank cells in the first row before the 1st of the month. */
    _firstWeekOffset: number;
    /**
     * The date of the month that the currently selected Date falls on.
     * Null if the currently selected Date is in another month.
     */
    _selectedDate: number | null;
    /** The date of the month that today falls on. Null if today is in another month. */
    _todayDate: number | null;
    /** The names of the weekdays. */
    _weekdays: {
        long: string;
        narrow: string;
    }[];
    constructor(_changeDetectorRef: ChangeDetectorRef, _dateFormats: HcDateFormats, _dateAdapter: DateAdapter<D>, _dir?: Directionality | undefined);
    ngAfterContentInit(): void;
    /** Handles when a new date is selected. */
    _dateSelected(date: number): void;
    /** Handles keydown events on the calendar body when calendar is in month view. */
    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
    /** Initializes this month view. */
    _init(): void;
    /** Focuses the active cell after the microtask queue is empty. */
    _focusActiveCell(): void;
    /** Creates hcCalendarCells for the dates in this month. */
    private _createWeekCells;
    /** Date filter for the month */
    private _shouldEnableDate;
    /**
     * Gets the date in this month that the given Date falls on.
     * Returns null if the given Date is in another month.
     */
    private _getDateInCurrentMonth;
    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */
    private _hasSameMonthAndYear;
    /**
     * @param obj The object to check.
     * @returns The given object if it is both a date instance and valid, otherwise null.
     */
    private _getValidDateOrNull;
    /** Determines whether the user has the RTL layout direction. */
    private _isRtl;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonthViewComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MonthViewComponent, "hc-month-view", ["hcMonthView"], { "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "dateClass": { "alias": "dateClass"; "required": false; }; }, { "selectedChange": "selectedChange"; "_userSelection": "_userSelection"; "activeDateChange": "activeDateChange"; }, never, never, false, never>;
}

/**
 * An internal component used to display a single year in the datepicker.
 * @docs-private
 */
declare class YearViewComponent implements AfterContentInit {
    private _changeDetectorRef;
    private _dateFormats;
    _dateAdapter: DateAdapter<D>;
    private _dir?;
    /** The date to display in this year view (everything other than the year is ignored). */
    get activeDate(): D;
    set activeDate(value: D);
    private _activeDate;
    /** The currently selected date. */
    get selected(): D | null;
    set selected(value: D | null);
    private _selected;
    /** The minimum selectable date. */
    get minDate(): D | null;
    set minDate(value: D | null);
    private _minDate;
    /** The maximum selectable date. */
    get maxDate(): D | null;
    set maxDate(value: D | null);
    private _maxDate;
    /** A function used to filter which dates are selectable. */
    dateFilter: (date: D) => boolean;
    /** Emits when a new month is selected. */
    readonly selectedChange: EventEmitter<D>;
    /** Emits the selected month. This doesn't imply a change on the selected date */
    readonly monthSelected: EventEmitter<D>;
    /** Emits when any date is activated. */
    readonly activeDateChange: EventEmitter<D>;
    /** The body of calendar table */
    _hcCalendarBody: CalendarBodyComponent;
    /** Grid of calendar cells representing the months of the year. */
    _months: HcCalendarCell[][];
    /** The label for this year (e.g. "2017"). */
    _yearLabel: string;
    /** The month in this year that today falls on. Null if today is in a different year. */
    _todayMonth: number | null;
    /**
     * The month in this year that the selected Date falls on.
     * Null if the selected Date is in a different year.
     */
    _selectedMonth: number | null;
    constructor(_changeDetectorRef: ChangeDetectorRef, _dateFormats: HcDateFormats, _dateAdapter: DateAdapter<D>, _dir?: Directionality | undefined);
    ngAfterContentInit(): void;
    /** Handles when a new month is selected. */
    _monthSelected(month: number): void;
    /** Handles keydown events on the calendar body when calendar is in year view. */
    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
    /** Initializes this year view. */
    _init(): void;
    /** Focuses the active cell after the microtask queue is empty. */
    _focusActiveCell(): void;
    /**
     * Gets the month in this year that the given Date falls on.
     * Returns null if the given Date is in another year.
     */
    private _getMonthInCurrentYear;
    /** Creates an hcCalendarCell for the given month. */
    private _createCellForMonth;
    /** Whether the given month is enabled. */
    private _shouldEnableMonth;
    /**
     * Tests whether the combination month/year is after this.maxDate, considering
     * just the month and year of this.maxDate
     */
    private _isYearAndMonthAfterMaxDate;
    /**
     * Tests whether the combination month/year is before this.minDate, considering
     * just the month and year of this.minDate
     */
    private _isYearAndMonthBeforeMinDate;
    /**
     * @param obj The object to check.
     * @returns The given object if it is both a date instance and valid, otherwise null.
     */
    private _getValidDateOrNull;
    /** Determines whether the user has the RTL layout direction. */
    private _isRtl;
    static ɵfac: i0.ɵɵFactoryDeclaration<YearViewComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<YearViewComponent, "hc-year-view", ["hcYearView"], { "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; }, { "selectedChange": "selectedChange"; "monthSelected": "monthSelected"; "activeDateChange": "activeDateChange"; }, never, never, false, never>;
}

/**
 * Possible views for the calendar.
 * @docs-private
 */
type CalendarViewComponent = 'month' | 'year' | 'multi-year';
/** Default header for hcCalendar */
declare class CalendarHeaderComponent {
    private _intl;
    calendar: CalendarComponent;
    private _dateAdapter;
    private _dateFormats;
    constructor(_intl: HcDatepickerIntl, calendar: CalendarComponent, _dateAdapter: DateAdapter<D>, _dateFormats: HcDateFormats, changeDetectorRef: ChangeDetectorRef);
    /** The label for the currently visible month */
    get monthButtonText(): string;
    /** The label for the current calendar view. */
    get periodButtonText(): string;
    get periodButtonLabel(): string;
    /** The label for the jump to today button */
    get _todayButtonLabel(): string;
    /** The label for the currently displayed month */
    get monthButtonLabel(): string;
    /** The label for the the previous button. */
    get prevButtonLabel(): string;
    /** The label for the the next button. */
    get nextButtonLabel(): string;
    /** Handles user clicks on the period label. */
    currentPeriodClicked(): void;
    /** Handles user clicks on the previous button. */
    previousClicked(): void;
    /** Handles user clicks on the next button. */
    nextClicked(): void;
    /** Handles clicks on the jump to today button */
    _todayClicked(): void;
    /** Whether the previous period button is enabled. */
    previousEnabled(): boolean;
    /** Whether the next period button is enabled. */
    nextEnabled(): boolean;
    _todayEnabled(): boolean;
    /** Whether the two dates represent the same view in the current view mode (month or year). */
    private _isSameView;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarHeaderComponent, [null, null, { optional: true; }, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarHeaderComponent, "hc-calendar-header", ["hcCalendarHeader"], {}, {}, never, ["*"], false, never>;
}
/**
 * A calendar that is used as part of the datepicker.
 * @docs-private
 */
declare class CalendarComponent implements AfterContentInit, AfterViewChecked, OnDestroy, OnChanges {
    private _intl;
    private _dateAdapter;
    private _dateFormats;
    private _changeDetectorRef;
    _hostClass: boolean;
    /** An input indicating the type of the header component, if set. */
    headerComponent: ComponentType<unknown>;
    /** A portal containing the header component type for this calendar. */
    _calendarHeaderPortal: Portal<unknown>;
    /** Stores the current am/pm value */
    _period: FormControl;
    private _intlChanges;
    /**
     * Used for scheduling that focus should be moved to the active cell on the next tick.
     * We need to schedule it, rather than do it immediately, because we have to wait
     * for Angular to re-evaluate the view children.
     */
    private _moveFocusOnNextTick;
    /** A date representing the period (month or year) to start the calendar in. */
    get startAt(): D | null;
    set startAt(value: D | null);
    private _startAt;
    /** Whether the calendar should be started in month or year view. */
    startView: CalendarViewComponent;
    /** Whether the calendar should show calendar, time-picker, or both */
    mode: 'date' | 'time' | 'date-time';
    /** Whether the time picker should display a 12-hour or 24-clock. Accepts 12 or 24. Defaults to 12. */
    get hourCycle(): string | number;
    set hourCycle(value: string | number);
    _hourCycle: number;
    /** The currently selected date. */
    get selected(): D | null;
    set selected(value: D | null);
    private _selected;
    /** The minimum selectable date. */
    get minDate(): D | null;
    set minDate(value: D | null);
    private _minDate;
    /** The maximum selectable date. */
    get maxDate(): D | null;
    set maxDate(value: D | null);
    private _maxDate;
    /** Function used to filter which dates are selectable. */
    dateFilter: (date: D) => boolean;
    /** Function that can be used to add custom CSS classes to dates. */
    dateClass: (date: D) => HcCalendarCellCssClasses;
    /** Emits when the currently selected date changes. */
    readonly selectedChange: EventEmitter<D>;
    /**
     * Emits the year chosen in multiyear view.
     * This doesn't imply a change on the selected date.
     */
    readonly yearSelected: EventEmitter<D>;
    /**
     * Emits the month chosen in year view.
     * This doesn't imply a change on the selected date.
     */
    readonly monthSelected: EventEmitter<D>;
    /** Emits when any date is selected; boolean indicates if Today button was clicked */
    readonly _userSelection: EventEmitter<boolean>;
    /** Reference to the current month view component. */
    monthView: MonthViewComponent;
    /** Reference to the current year view component. */
    yearView: YearViewComponent;
    /** Reference to the current multi-year view component. */
    multiYearView: MultiYearViewComponent;
    /**
     * The current active date. This determines which time period is shown and which date is
     * highlighted when using keyboard navigation.
     */
    get activeDate(): D;
    set activeDate(value: D);
    private _clampedActiveDate;
    /** Whether the calendar is in month view. */
    get currentView(): CalendarViewComponent;
    set currentView(value: CalendarViewComponent);
    private _currentView;
    /**
     * Emits whenever there is a state change that the header may need to respond to.
     */
    stateChanges: Subject<void>;
    /** A string containing the value of minutes for the current date */
    get minutes(): string | null;
    set minutes(value: string | null);
    /** A string containing the hour for the current date */
    get hours(): string | null;
    set hours(value: string | null);
    _periodChange(): void;
    constructor(_intl: HcDatepickerIntl, _dateAdapter: DateAdapter<D>, _dateFormats: HcDateFormats, _changeDetectorRef: ChangeDetectorRef);
    ngAfterContentInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    focusActiveCell(): void;
    /** Updates today's date after an update of the active date */
    updateTodaysDate(): void;
    /** Handles date selection in the month view. */
    _dateSelected(date: D): void;
    /** Handles year selection in the multiyear view. */
    _yearSelectedInMultiYearView(normalizedYear: D): void;
    /** Handles month selection in the year view. */
    _monthSelectedInYearView(normalizedMonth: D): void;
    _userSelected(): void;
    /** Handles year/month selection in the multi-year/year views. */
    _goToDateInView(date: D, view: 'month' | 'year' | 'multi-year'): void;
    /**
     * @param obj The object to check.
     * @returns The given object if it is both a date instance and valid, otherwise null.
     */
    private _getValidDateOrNull;
    /** Returns the component instance that corresponds to the current calendar view. */
    private _getCurrentViewComponent;
    _hoursUp(): void;
    _hoursDown(): void;
    _changeMeridiem(curHour: number, hourChange: number): void;
    _minutesUp(): void;
    _minutesDown(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarComponent, [null, { optional: true; }, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarComponent, "hc-calendar", ["hcCalendar"], { "headerComponent": { "alias": "headerComponent"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "hourCycle": { "alias": "hourCycle"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "dateClass": { "alias": "dateClass"; "required": false; }; }, { "selectedChange": "selectedChange"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; "_userSelection": "_userSelection"; }, never, never, false, never>;
}

/** Single error to be shown under HcFormFieldComponent */
declare class HcErrorComponent {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcErrorComponent, "hc-error", never, {}, {}, never, ["*"], false, never>;
}

/** Position an element at the front of HcFormFieldComponent */
declare class HcPrefixDirective {
    _hostHcPrefixClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcPrefixDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcPrefixDirective, "[hcPrefix]", never, {}, {}, never, never, false, never>;
}

/** Position an element at the end of HcFormFieldComponent */
declare class HcSuffixDirective {
    _hostHcSuffixClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcSuffixDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcSuffixDirective, "[hcSuffix]", never, {}, {}, never, never, false, never>;
}

/** Label for HcFormFieldComponent */
declare class HcLabelComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcLabelComponent, "hc-label", never, {}, {}, never, ["*"], false, never>;
}

/** Directive that allows a native input to work inside a HcFormFieldComponent */
declare class InputDirective extends HcFormControlComponent implements AfterViewInit, OnDestroy {
    private _elementRef;
    _ngControl: NgControl;
    private _changeRef;
    private _focused;
    private _mobile;
    private _validationType;
    private _uniqueInputId;
    private _form;
    private _unsubscribe;
    _componentId: string;
    /** Input type of the element. */
    get type(): string;
    set type(type: string);
    private _type;
    /** Element id. */
    get id(): string;
    set id(idVal: string);
    /** Sets input element as readonly. */
    get readonly(): boolean;
    set readonly(isReadOnly: boolean);
    private _readonly;
    /** Disables the input element. */
    get disabled(): boolean;
    set disabled(disabledInput: boolean);
    /** Sets required attribute. */
    get required(): boolean;
    set required(requiredInput: boolean);
    /** Fires when the input either gets focus or loses focus. */
    focusChanged: EventEmitter<boolean>;
    /** Fires on either a `change` or `input` event type from the input. */
    inputEvent: EventEmitter<Event>;
    _hostHcInputClass: boolean;
    get _hostId(): string;
    get _hostReadOnly(): boolean;
    get _hostDisabled(): boolean;
    get _hostRequired(): boolean;
    _onBlur(): void;
    _onFocus(): void;
    /** Sets value of the input element */
    get value(): string;
    set value(value: string);
    _inputEvent(event: Event): void;
    _changeEvent(event: Event): void;
    /** Determines when validation checks run. Choose from: `'onBlur' | 'onChange' |`. *Defaults to `onBlur`.* */
    get validationType(): string;
    set validationType(type: string);
    /** Sets whether the input should be sized for small screens (if true, overrides the `tight` param on FormField) */
    get mobile(): boolean;
    set mobile(value: boolean);
    /** Output for two-way binding on the `mobile` param. Emits when the property is updated */
    mobileChange: EventEmitter<boolean>;
    ngAfterViewInit(): void;
    constructor(_elementRef: ElementRef, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _ngControl: NgControl, _changeRef: ChangeDetectorRef);
    /** Sets the focus on the input element */
    focus(): void;
    private _changeFocus;
    private _isTextArea;
    private _updateErrorState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective, [null, { optional: true; }, { optional: true; }, { optional: true; self: true; }, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective, "[hcInput]", never, { "type": { "alias": "type"; "required": false; }; "id": { "alias": "id"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; "validationType": { "alias": "validationType"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; }, { "focusChanged": "focusChanged"; "inputEvent": "inputEvent"; "mobileChange": "mobileChange"; }, never, never, false, never>;
}

/** Container for form fields that applies Cashmere styling and behavior */
declare class HcFormFieldComponent implements AfterContentInit, OnDestroy {
    private _elementRef;
    private _inline;
    private _tight;
    private unsubscribe$;
    _control: HcFormControlComponent;
    _controls: QueryList<HcFormControlComponent>;
    _errorChildren: QueryList<HcErrorComponent>;
    _prefixChildren: QueryList<HcPrefixDirective>;
    _suffixChildren: QueryList<HcSuffixDirective>;
    _inputChildren: QueryList<InputDirective>;
    _labelChildren: QueryList<HcLabelComponent>;
    _classHcFormFieldClass: boolean;
    get _disabledClass(): boolean;
    /** Read-only boolean value of whether the form field has an associated label element */
    get hasLabel(): boolean;
    /** Read-only boolean value of whether the form field has an input element */
    get hasInput(): boolean;
    _hasFocusedInput: boolean;
    /** Whether the form elements should be stacked (default), or inline */
    get inline(): boolean;
    set inline(isInline: boolean);
    /** If true, condense the default padding on all included elements and reduce the font size. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    _mobileInput: boolean;
    constructor(_elementRef: ElementRef<HTMLInputElement>);
    ngAfterContentInit(): void;
    iconClicked(): void;
    ngOnDestroy(): void;
    _updateTightControls(): void;
    getConnectedOverlayOrigin(): ElementRef;
    _shouldShowErrorMessages(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcFormFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcFormFieldComponent, "hc-form-field", never, { "inline": { "alias": "inline"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; }, {}, ["_control", "_controls", "_errorChildren", "_prefixChildren", "_suffixChildren", "_inputChildren", "_labelChildren"], ["hc-label", "hc-label-ext", "[hcPrefix]", "[hcInput]", "[hcSuffix]", "*", "hc-error"], false, never>;
}

/** @docs-private */
declare const HC_DATEPICKER_VALUE_ACCESSOR: {
    provide: i0.InjectionToken<readonly ControlValueAccessor[]>;
    useExisting: i0.Type<any>;
    multi: boolean;
};
/** @docs-private */
declare const HC_DATEPICKER_VALIDATORS: {
    provide: i0.InjectionToken<readonly (Function | Validator)[]>;
    useExisting: i0.Type<any>;
    multi: boolean;
};
/**
 * An event used for datepicker input and change events. We don't always have access to a native
 * input or change event because the event may have been triggered by the user clicking on the
 * calendar popup. For consistency, we always use hcDatepickerInputEvent instead.
 */
declare class HcDatepickerInputEvent {
    /** Reference to the datepicker input component that emitted the event. */
    target: DatepickerInputDirective;
    /** Reference to the native input element associated with the datepicker input. */
    targetElement: HTMLElement;
    /** The new value for the target datepicker input. */
    value: D | null;
    constructor(
    /** Reference to the datepicker input component that emitted the event. */
    target: DatepickerInputDirective, 
    /** Reference to the native input element associated with the datepicker input. */
    targetElement: HTMLElement);
}
declare class DatepickerInputDirective implements ControlValueAccessor, OnDestroy, Validator {
    private _elementRef;
    _dateAdapter: DateAdapter<D>;
    private _dateFormats;
    private _formField;
    /** The datepicker that this input is associated with. */
    set hcDatepicker(value: DatepickerComponent);
    _datepicker: DatepickerComponent;
    /** Function that can be used to filter out dates within the datepicker. */
    set hcDatepickerFilter(value: (date: D | null) => boolean);
    _dateFilter: (date: D | null) => boolean;
    /** The value of the input. */
    get value(): D | null;
    set value(value: D | null);
    private _value;
    /** The minimum valid date. */
    get min(): D | null;
    set min(value: D | null);
    private _min;
    /** The maximum valid date. */
    get max(): D | null;
    set max(value: D | null);
    private _max;
    /** Whether the datepicker-input is disabled. */
    get disabled(): boolean;
    set disabled(value: boolean);
    private _disabled;
    /** Emits when a `change` event is fired on this `<input>`. */
    readonly dateChange: EventEmitter<HcDatepickerInputEvent>;
    /** Emits when an `input` event is fired on this `<input>`. */
    readonly dateInput: EventEmitter<HcDatepickerInputEvent>;
    /** Stores the mode & hourCycle for the inputs of the date range (which don't have a DatePickerComponent) */
    _mode: string;
    _hourCycle: number;
    /** When true, this allows the date picker to validate with a blank value OR a valid date value. Defaults to false. */
    get allowsBlankValues(): boolean;
    set allowsBlankValues(value: boolean);
    private _allowsBlankValues;
    /** Emits when the value changes (either due to user input or programmatic change). */
    _valueChange: EventEmitter<Date | null>;
    /** Emits when the disabled state has changed */
    _disabledChange: EventEmitter<boolean>;
    _onTouched: () => void;
    private _cvaOnChange;
    private _validatorOnChange;
    private _datepickerSubscription;
    private _localeSubscription;
    private _timeDate;
    /** The form control validator for whether the input parses. */
    private _parseValidator;
    /** The form control validator for the min date. */
    private _minValidator;
    /** The form control validator for the max date. */
    private _maxValidator;
    /** The form control validator for the date filter. */
    private _filterValidator;
    /** The combined form control validator for this input. */
    private _validator;
    /** Whether the last value set on the input was valid. */
    private _lastValueValid;
    constructor(_elementRef: ElementRef<HTMLInputElement>, _dateAdapter: DateAdapter<D>, _dateFormats: HcDateFormats, _formField: HcFormFieldComponent);
    ngOnDestroy(): void;
    /** @docs-private */
    registerOnValidatorChange(fn: () => void): void;
    /** @docs-private */
    validate(c: AbstractControl): ValidationErrors | null;
    /**
     * Gets the element that the datepicker popup should be connected to.
     * @return The element to connect the popup to.
     */
    getConnectedOverlayOrigin(): ElementRef;
    /** Sets the focus on the input element */
    focus(): void;
    writeValue(value: D): void;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    setDate(selected: D): void;
    _onKeydown(event: KeyboardEvent): void;
    _onInput(value: string): void;
    _onChange(): void;
    /** Handles blur events on the input. */
    _onBlur(): void;
    /** Formats a value and sets it on the input element. */
    private _formatValue;
    /**
     * @param obj The object to check.
     * @returns The given object if it is both a date instance and valid, otherwise null.
     */
    private _getValidDateOrNull;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerInputDirective, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DatepickerInputDirective, "input[hcDatepicker]", never, { "hcDatepicker": { "alias": "hcDatepicker"; "required": false; }; "hcDatepickerFilter": { "alias": "hcDatepickerFilter"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "_mode": { "alias": "_mode"; "required": false; }; "_hourCycle": { "alias": "_hourCycle"; "required": false; }; "allowsBlankValues": { "alias": "allowsBlankValues"; "required": false; }; }, { "dateChange": "dateChange"; "dateInput": "dateInput"; }, never, never, false, never>;
}

/** Injection token that determines the scroll handling while the calendar is open. */
declare const HC_DATEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
/** @docs-private */
declare function HC_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
/** @docs-private */
declare const HC_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
    provide: InjectionToken<() => ScrollStrategy>;
    deps: (typeof Overlay)[];
    useFactory: typeof HC_DATEPICKER_SCROLL_STRATEGY_FACTORY;
};
/** @docs-private */
declare class HcDatepickerContentBase {
    _elementRef: ElementRef;
    constructor(_elementRef: ElementRef);
}
/** Component responsible for managing the datepicker popup */
declare class DatepickerComponent implements OnDestroy {
    private _overlay;
    private _ngZone;
    private _viewContainerRef;
    private _dateAdapter;
    private _dir;
    private _document;
    private _scrollStrategy;
    /**
     * Whether the datepicker can be set to a blank value (by deleting its contents). Defaults to `false`.
     */
    get allowsBlankValues(): boolean;
    set allowsBlankValues(val: boolean);
    /**
     * Whether the datepicker includes the calendar, time selector, or both. Defaults to `date`.
     */
    get mode(): 'date' | 'time' | 'date-time';
    set mode(value: 'date' | 'time' | 'date-time');
    private _mode;
    /**
     * Whether the time picker uses a 12 or 24 hour clock. Defaults to 12.
     */
    get hourCycle(): string | number;
    set hourCycle(value: string | number);
    private _hourCycle;
    /** An input indicating the type of the custom header component for the calendar, if set. */
    calendarHeaderComponent: ComponentType$1<unknown>;
    /** The date to open the calendar to initially. */
    get startAt(): D | null;
    set startAt(value: D | null);
    private _startAt;
    /** The view that the calendar should start in. */
    startView: 'month' | 'year' | 'multi-year';
    /** Whether the datepicker pop-up should be disabled. */
    get disabled(): boolean;
    set disabled(value: boolean);
    private _disabled;
    /**
     * Emits selected year in multiyear view.
     * This doesn't imply a change on the selected date.
     */
    readonly yearSelected: EventEmitter<D>;
    /**
     * Emits selected month in year view.
     * This doesn't imply a change on the selected date.
     */
    readonly monthSelected: EventEmitter<D>;
    /** Classes to be passed to the date picker panel. Supports the same syntax as `ngClass`. */
    panelClass: string | string[];
    /** Function that can be used to add custom CSS classes to dates. */
    dateClass: (date: D) => HcCalendarCellCssClasses;
    /** Emits when the datepicker has been opened. */
    openedStream: EventEmitter<void>;
    /** Emits when the datepicker has been closed. */
    closedStream: EventEmitter<void>;
    /** Whether the calendar is open. */
    get opened(): boolean;
    set opened(value: boolean);
    private _opened;
    /** The id for the datepicker calendar. */
    id: string;
    /** The currently selected date. */
    get _selected(): D | null;
    set _selected(value: D | null);
    private _validSelected;
    /** The minimum selectable date. */
    get _minDate(): D | null;
    /** The maximum selectable date. */
    get _maxDate(): D | null;
    get _dateFilter(): (date: D | null) => boolean;
    /** A reference to the overlay when the calendar is opened as a popup. */
    _popupRef: OverlayRef | null;
    /** A portal containing the calendar for this datepicker. */
    private _calendarPortal;
    /** Reference to the component instantiated in popup mode. */
    private _popupComponentRef;
    /** The element that was focused before the datepicker was opened. */
    private _focusedElementBeforeOpen;
    /** Subscription to value changes in the associated input element. */
    private _inputSubscription;
    /** The input element this datepicker is associated with. */
    _datepickerInput: DatepickerInputDirective;
    /** Emits when the datepicker is disabled. */
    readonly _disabledChange: Subject<boolean>;
    /** Emits new selected date when selected date changes. */
    readonly _selectedChanged: Subject<Date>;
    constructor(_overlay: Overlay, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, scrollStrategy: any, _dateAdapter: DateAdapter<D>, _dir: Directionality, _document: any);
    ngOnDestroy(): void;
    /** Selects the given date */
    select(date: D): void;
    /** Emits the selected year in multiyear view */
    _selectYear(normalizedYear: D): void;
    /** Emits selected month in year view */
    _selectMonth(normalizedMonth: D): void;
    /**
     * Register an input with this datepicker.
     * @param input The datepicker input to register with this datepicker.
     */
    _registerInput(input: DatepickerInputDirective): void;
    /** Open the calendar. */
    open(): void;
    /** Close the calendar. */
    close(): void;
    /** Open the calendar as a popup. */
    private _openAsPopup;
    /** Create the popup. */
    private _createPopup;
    /** Create the popup PositionStrategy. */
    private _createPopupPositionStrategy;
    /**
     * @param obj The object to check.
     * @returns The given object if it is both a date instance and valid, otherwise null.
     */
    private _getValidDateOrNull;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerComponent, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerComponent, "hc-datepicker", ["hcDatepicker"], { "allowsBlankValues": { "alias": "allows-blank-values"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "hourCycle": { "alias": "hourCycle"; "required": false; }; "calendarHeaderComponent": { "alias": "calendarHeaderComponent"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "dateClass": { "alias": "dateClass"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; }, { "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; "openedStream": "opened"; "closedStream": "closed"; }, never, never, false, never>;
}

/**
 * Component used as the content for the datepicker popup. We use this instead of using
 * hcCalendar directly as the content so we can control the initial focus. This also gives us a
 * place to put additional features of the popup that are not part of the calendar itself in the
 * future. (e.g. confirmation buttons).
 * @docs-private
 */
declare class DatepickerContentComponent implements AfterViewInit {
    /** Reference to the internal calendar component. */
    _calendar: CalendarComponent;
    /** Reference to the datepicker that created the overlay. */
    datepicker: DatepickerComponent;
    /** Whether the datepicker is above or below the input. */
    _isAbove: boolean;
    ngAfterViewInit(): void;
    /** Close the datepicker automatically on selection only if in date mode */
    autoClose(todayClicked: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerContentComponent, "hc-datepicker-content", ["hcDatepickerContent"], {}, {}, never, never, false, never>;
}

/** Can be used to override the icon of a `hcDatepickerToggle`. */
declare class DatepickerToggleIconDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerToggleIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DatepickerToggleIconDirective, "[hcDatepickerToggleIcon]", never, {}, {}, never, never, false, never>;
}
declare class DatepickerToggleComponent implements AfterContentInit, OnChanges, OnDestroy {
    _intl: HcDatepickerIntl;
    private _changeDetectorRef;
    private _stateChanges;
    /** Datepicker instance that the button will toggle. */
    datepicker: DatepickerComponent;
    /** Tabindex for the toggle. */
    tabIndex: number | null;
    /** Whether the toggle button is disabled. */
    get disabled(): boolean;
    set disabled(value: boolean);
    private _disabled;
    /** Custom icon set by the consumer. */
    _customIcon: DatepickerToggleIconDirective;
    /** Underlying button element. */
    _button: ButtonComponent;
    constructor(_intl: HcDatepickerIntl, _changeDetectorRef: ChangeDetectorRef, defaultTabIndex: string);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    ngAfterContentInit(): void;
    _open(event: Event): void;
    private _watchStateChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerToggleComponent, [null, null, { attribute: "tabindex"; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerToggleComponent, "hc-datepicker-toggle", ["hcDatepickerToggle"], { "datepicker": { "alias": "for"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["_customIcon"], ["[hcDatepickerToggleIcon]"], false, never>;
}

declare class NativeDateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NativeDateModule, never, [typeof i1.PlatformModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NativeDateModule>;
}
declare class HcNativeDateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcNativeDateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HcNativeDateModule, never, [typeof NativeDateModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HcNativeDateModule>;
}

/**
 * @license
 * Copyright Health Catalyst All Rights Reserved.
 *
 * Use of this source code is governed by an Apache-2.0 license that can be
 * found in the LICENSE file at https://raw.githubusercontent.com/HealthCatalyst/Fabric.Cashmere/dev/LICENSE
 */

/** Adapts the native JS Date for use with cdk-based components that work with dates. */
declare class NativeDateAdapter extends DateAdapter<Date> {
    /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */
    private readonly _clampDate;
    /**
     * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.
     * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off
     * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`
     * will produce `'8/13/1800'`.
     *
     * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now
     * getting the string representation of a Date object from it's utc representation. We're keeping
     * it here for sometime, just for precaution, in case we decide to revert some of these changes
     * though.
     */
    useUtcForDisplay: boolean;
    constructor(hcDateLocale: string, platform: Platform);
    getYear(date: Date): number;
    getMonth(date: Date): number;
    getDate(date: Date): number;
    getHours(date: Date): number;
    getMinutes(date: Date): number;
    getDayOfWeek(date: Date): number;
    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    getDateNames(): string[];
    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    getYearName(date: Date): string;
    getFirstDayOfWeek(): number;
    getNumDaysInMonth(date: Date): number;
    clone(date: Date): Date;
    createDate(year: number, month: number, date: number): Date;
    today(): Date;
    parse(value: unknown): Date | null;
    format(date: Date, displayFormat: Record<string, unknown>): string;
    addCalendarYears(date: Date, years: number): Date;
    addCalendarMonths(date: Date, months: number): Date;
    addCalendarDays(date: Date, days: number): Date;
    toIso8601(date: Date): string;
    /**
     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
     * invalid date for all other values.
     */
    deserialize(value: unknown): Date | null;
    isDateInstance(obj: unknown): boolean;
    isValid(date: Date): boolean;
    invalid(): Date;
    /** Creates a date but allows the month and date to overflow. */
    private _createDateWithOverflow;
    /**
     * Pads a number to make it two digits.
     * @param n The number to pad.
     * @returns The padded number.
     */
    private _2digit;
    /**
     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
     * other browsers do not. We remove them to make output consistent and because they interfere with
     * date parsing.
     * @param str The string to strip direction characters from.
     * @returns The stripped string.
     */
    private _stripDirectionalityCharacters;
    /**
     * When converting Date object to string, javascript built-in functions may return wrong
     * results because it applies its internal DST rules. The DST rules around the world change
     * very frequently, and the current valid rule is not always valid in previous years though.
     * We work around this problem building a new Date object which has its internal UTC
     * representation with the local date and time.
     * @param dtf Intl.DateTimeFormat object, containg the desired string format. It must have
     *    timeZone set to 'utc' to work fine.
     * @param date Date from which we want to get the string representation according to dtf
     * @returns A Date object with its UTC representation based on the passed in date info
     */
    private _format;
    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDateAdapter, [{ optional: true; }, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NativeDateAdapter>;
}

/**
 * @license
 * Copyright Health Catalyst All Rights Reserved.
 *
 * Use of this source code is governed by an Apache-2.0 license that can be
 * found in the LICENSE file at https://raw.githubusercontent.com/HealthCatalyst/Fabric.Cashmere/dev/LICENSE
 */

declare const HC_NATIVE_DATE_FORMATS: HcDateFormats;

/**
 * @license
 * Copyright Health Catalyst All Rights Reserved.
 *
 * Use of this source code is governed by an Apache-2.0 license that can be
 * found in the LICENSE file at https://raw.githubusercontent.com/HealthCatalyst/Fabric.Cashmere/dev/LICENSE
 */

/**
 * Animations used by the Material datepicker.
 * @docs-private
 */
declare const HcDatepickerAnimations: {
    readonly transformPanel: AnimationTriggerMetadata;
    readonly fadeInCalendar: AnimationTriggerMetadata;
};

declare class ClearInputComponent {
    /** A reference to the HTML input element */
    inputEl: HTMLInputElement;
    clearClicked: EventEmitter<void>;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClearInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ClearInputComponent, "hc-clear-input-btn", never, { "inputEl": { "alias": "inputEl"; "required": false; }; }, { "clearClicked": "clearClicked"; }, never, never, false, never>;
}

/** Container for additional label content for HcFormFieldComponent */
declare class HcLabelExtensionComponent {
    _hostHcLabelClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcLabelExtensionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcLabelExtensionComponent, "hc-label-ext", never, {}, {}, never, ["*"], false, never>;
}

/** `hcForm` directive that allows settings to be applied to all included HcFormFields */
declare class HcFormDirective implements AfterContentInit, OnDestroy {
    private _tight;
    private unsubscribe$;
    _formFields: QueryList<HcFormFieldComponent>;
    /** Set the tight parameter on all enclosed HcFormFields. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    _updateTightFields(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcFormDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcFormDirective, "[hcForm]", never, { "tight": { "alias": "tight"; "required": false; }; }, {}, ["_formFields"], never, false, never>;
}

declare class FormFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormFieldModule, [typeof HcFormFieldComponent, typeof HcErrorComponent, typeof HcPrefixDirective, typeof HcSuffixDirective, typeof HcLabelComponent, typeof HcLabelExtensionComponent, typeof HcFormDirective], [typeof i2.CommonModule], [typeof HcFormFieldComponent, typeof HcErrorComponent, typeof HcPrefixDirective, typeof HcSuffixDirective, typeof HcLabelComponent, typeof HcLabelExtensionComponent, typeof HcFormDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormFieldModule>;
}

declare class InputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InputModule, [typeof InputDirective, typeof ClearInputComponent], [typeof i2.CommonModule, typeof FormFieldModule], [typeof InputDirective, typeof ClearInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InputModule>;
}

declare class SelectService {
    _optionMap: Map<string, any>;
    _optionIdCounter: number;
    _registerOption(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectService>;
}

declare class SelectChangeEvent {
    source: SelectComponent;
    value: any;
    constructor(source: SelectComponent, value: any);
}
/** Select one of many options from a dropdown */
declare class SelectComponent extends HcFormControlComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
    private _renderer;
    private selectService;
    _ngControl: NgControl;
    private _changeRef;
    private _uniqueInputId;
    private _form;
    private _unsubscribe;
    private _value;
    private _placeholderValue;
    get _optionMap(): Map<string, any>;
    _componentId: string;
    _nativeSelect: ElementRef;
    _nativePlaceholder: ElementRef;
    /** Optional string of text to appear before selection is made */
    placeholder: string;
    /** Optional value for when the placeholder should appear -
     * defaults to the empty string, but could be set to `null` or `undefined` */
    get placeholderValue(): any;
    set placeholderValue(val: any);
    /** Enables or disables the component */
    get disabled(): boolean;
    set disabled(disabledVal: boolean);
    /** Sets whether this is a required form element */
    get required(): boolean;
    set required(requiredVal: boolean);
    /** Element id. */
    get id(): string;
    set id(idVal: string);
    /** Get or set the value of the select component */
    get value(): any;
    set value(val: any);
    /** If true, condense the default margin and reduce the font size. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    readonly focus: EventEmitter<void>;
    readonly blur: EventEmitter<void>;
    /** Event emitted whenever the state changes */
    change: EventEmitter<SelectChangeEvent>;
    _hostClass: boolean;
    get _disabledClass(): boolean;
    /** A function to compare the option values with the selected values. The first argument is a value from an option.
     * The second is a value from the selection(model). A boolean should be returned. */
    set compareWith(fn: (o1: any, o2: any) => boolean);
    private _compareWith;
    constructor(_renderer: Renderer2, selectService: SelectService, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _ngControl: NgControl, _changeRef: ChangeDetectorRef);
    ngAfterViewInit(): void;
    _onBlur(): void;
    onChange: (value: unknown) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    writeValue(value: any): void;
    _applyValueToNativeControl(): void;
    _applyPlaceholderValueToNativeControl(): void;
    _change(event: Event, value: any): void;
    _getOptionId(value: any): string | null;
    _getOptionValue(valueString: string): any;
    _extractId(valueString: string): string;
    _onContentUpdated(): void;
    private _updateErrorState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, [null, null, { optional: true; }, { optional: true; }, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "hc-select", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderValue": { "alias": "placeholderValue"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, { "focus": "focus"; "blur": "blur"; "change": "change"; }, never, ["*"], false, never>;
}

/** Utility directive to hold objects used in ngValue */
declare class HcOptionDirective implements OnDestroy {
    private _element;
    private _renderer;
    private _selectService;
    /** id of the option element, use in identifying stringifyied values */
    _id: string;
    constructor(_element: ElementRef, _renderer: Renderer2, _selectService: SelectService);
    /** Tracks the value bound to the option element. Unlike the value binding, ngValue supports binding to objects. */
    set ngValue(value: unknown);
    /** Tracks simple string values bound to the option element. For objects, use the `ngValue` input binding. */
    set value(value: string);
    _setElementValue(value: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcOptionDirective, [null, null, { optional: true; host: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcOptionDirective, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectModule, [typeof SelectComponent, typeof HcOptionDirective], [typeof i2.CommonModule, typeof i4.FormsModule, typeof i5.ObserversModule], [typeof SelectComponent, typeof HcOptionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SelectModule>;
}

declare class DatepickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DatepickerModule, [typeof CalendarComponent, typeof CalendarBodyComponent, typeof DatepickerComponent, typeof DatepickerContentComponent, typeof DatepickerInputDirective, typeof DatepickerToggleComponent, typeof DatepickerToggleIconDirective, typeof MonthViewComponent, typeof YearViewComponent, typeof MultiYearViewComponent, typeof CalendarHeaderComponent], [typeof i2.CommonModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof ButtonModule, typeof IconModule, typeof InputModule, typeof FormFieldModule, typeof SelectModule, typeof i11.OverlayModule, typeof i12.A11yModule, typeof i19.PortalModule], [typeof CalendarComponent, typeof CalendarBodyComponent, typeof DatepickerComponent, typeof DatepickerContentComponent, typeof DatepickerInputDirective, typeof DatepickerToggleComponent, typeof DatepickerToggleIconDirective, typeof MonthViewComponent, typeof YearViewComponent, typeof MultiYearViewComponent, typeof CalendarHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DatepickerModule>;
}

declare class CalendarOverlayService implements OnDestroy {
    private overlay;
    private injector;
    private hostElemRef;
    readonly _dismissed: EventEmitter<boolean>;
    private unsubscribe$;
    constructor(overlay: Overlay, injector: Injector);
    open(hostElemRef: ElementRef, center?: boolean): OverlayRef;
    private _createOverlay;
    private _getOverlayConfig;
    private _createInjector;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarOverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarOverlayService>;
}

interface PresetItem {
    /** Friendly description */
    presetLabel: string;
    /** Date range */
    range: DateRange;
}
interface DateRange {
    /** Beginning Date */
    fromDate?: Date;
    /** Ending Date */
    toDate?: Date;
}
interface DateRangeOptions {
    /** set of predefined dates user can select */
    presets?: Array<PresetItem>;
    /** Display format of date. See https://angular.io/api/common/DatePipe#pre-defined-format-options */
    format?: string;
    /** Whether the date range pickers include the calendar, time selector, or both. Defaults to `date`. */
    mode?: 'date' | 'time' | 'date-time';
    /** If the time picker should use the 12 or 24 hour clock. Defaults to 12 */
    hourCycle?: number;
    /** Exclude weekends in date picker selection */
    excludeWeekends?: boolean;
    /** Locale settings of dates */
    locale?: string;
    /** Beginning date maximum allowed value */
    fromMinMax?: DateRange;
    /** Ending date maximum allowed value */
    toMinMax?: DateRange;
    /** Text label of apply button. Default 'Apply' */
    applyLabel?: string;
    /** Text label of cancel button Default 'Cancel' */
    cancelLabel?: string;
    /** Text label above start date. Default 'Start date' */
    startDatePrefix?: string;
    /** Text label above end date. Default 'End date' */
    endDatePrefix?: string;
    /** Text label of invalid date. Default 'Please enter valid date' */
    invalidDateLabel?: string;
    /** Centers the DateRange component to the screen instead of the target. Default 'false' */
    center?: boolean;
    /** Disabling this allows an open-ended date range from the distant past to 'endDate'. Default 'true' */
    startDateIsRequired?: boolean;
    /** Disabling this allows an open-ended date range from 'endDate' to the distant future. Default 'true' */
    endDateIsRequired?: boolean;
}

declare class ConfigStoreService {
    private defaultOptions;
    private dateRangeOptionsSubject;
    dateRangeOptions$: Observable<DateRangeOptions>;
    private rangeUpdateSubject;
    rangeUpdate$: Observable<DateRange>;
    private presetUpdateSubject;
    presetUpdate$: Observable<number | DateRange>;
    weekendFilter: (d: D) => boolean;
    private readonly emptyWeekendFilter;
    private readonly excludeWeekendFilter;
    constructor();
    updateDateRangeOptions(options: DateRangeOptions): void;
    updateRange(dateRange: DateRange): void;
    updatePreset(value: number | DateRange): void;
    currentSelection(): DateRange;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigStoreService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigStoreService>;
}

/** Trigger the date range selector using the `hcDateRange` directive on a button or other clickable element  */
declare class DateRangeDirective implements OnDestroy, OnChanges, ControlValueAccessor {
    private _elementRef;
    private calendarOverlayService;
    _configStoreService: ConfigStoreService;
    /** Emits when date range is been changed. */
    readonly selectedDateRangeChanged: EventEmitter<DateRange>;
    /** Sets the selected date range. Accepts either a `DateRange` or a numerical index for preset. */
    selectedDate: number | DateRange;
    /** Emits either a numerical index for the selected preset, or a `DateRange` if the selected value is not a preset */
    readonly selectedPresetChanged: EventEmitter<number | DateRange>;
    /** Emits after the popover is closed; returns `null` on cancel or dismiss and a `DateRange` on apply */
    readonly closed: EventEmitter<null | DateRange>;
    /** Configuration to setup behavior of component. */
    options: DateRangeOptions;
    /** If disabled, clicks to the element will not trigger the date range popover. */
    disabled: boolean;
    private _touched;
    private _overlayRef;
    private unsubscribe$;
    constructor(_elementRef: ElementRef<HTMLInputElement>, calendarOverlayService: CalendarOverlayService, _configStoreService: ConfigStoreService);
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: number | DateRange): void;
    _updateSelected(selectedDate: number | DateRange): void;
    _onClick(): void;
    onChange: (value: number | DateRange) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    setDisabledState(disabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DateRangeDirective, "[hcDateRange]", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectedDateRangeChanged": "selectedDateRangeChanged"; "selectedPresetChanged": "selectedPresetChanged"; "closed": "closed"; }, never, never, false, never>;
}

/** Component combining a calendar and input as a representation of a date  */
declare class CalendarWrapperComponent implements OnChanges {
    configStore: ConfigStoreService;
    private ref;
    _hostClass: boolean;
    hcCalendar: CalendarComponent;
    datePickerInput: DatepickerInputDirective;
    /** Emits when selected date has changed. */
    readonly selectedDateChange: EventEmitter<D>;
    /** Current selected date. */
    selectedDate: D | undefined;
    dateFormat: string;
    /** Whether the pickers include the calendar, time selector, or both. Defaults to `date`. */
    mode: 'date' | 'time' | 'date-time';
    /** Whether the time picker should use a 12 or 24 hour clock. Defaults to 12. */
    hourCycle: number;
    /** Whether the field is required to contain a value. Defaults to `true`. */
    required: boolean;
    /** Prefix label on top of component. */
    prefixLabel: string;
    /** Flag to filter out weekends. */
    excludeWeekends: boolean;
    /** The minimum selectable date. */
    minDate: D | undefined;
    /** The maximum selectable date. */
    maxDate: D | undefined;
    /** Message displayed when a date is invalid. */
    invalidDateLabel: string;
    weekendFilter: () => boolean;
    constructor(configStore: ConfigStoreService, ref: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    _onCalendarChange(date: D): void;
    _onInputChange(event: HcDatepickerInputEvent): void;
    /** Focus inner input */
    focusInput(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarWrapperComponent, "hc-calendar-wrapper", never, { "selectedDate": { "alias": "selectedDate"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "hourCycle": { "alias": "hourCycle"; "required": false; }; "required": { "alias": "required"; "required": false; }; "prefixLabel": { "alias": "prefixLabel"; "required": false; }; "excludeWeekends": { "alias": "excludeWeekends"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "invalidDateLabel": { "alias": "invalidDateLabel"; "required": false; }; }, { "selectedDateChange": "selectedDateChange"; }, never, never, false, never>;
}

declare class PickerOverlayComponent implements OnInit, AfterViewInit {
    configStoreService: ConfigStoreService;
    private overlayRef;
    private cd;
    options$: Observable<DateRangeOptions>;
    set _fromDate(fd: D | undefined);
    get _fromDate(): D | undefined;
    set _toDate(td: D | undefined);
    get _toDate(): D | undefined;
    set _selectedPreset(s: number | null);
    get _selectedPreset(): number | null;
    set _rangeIsInvalid(isInvalid: boolean);
    get _rangeIsInvalid(): boolean;
    get _invalidRangeErrorMessage(): string | null;
    _presetValues: PresetItem[] | undefined;
    _skipRangeCheck: boolean;
    __fromDate: D | undefined;
    __toDate: D | undefined;
    __selectedPreset: number | null;
    __rangeIsInvalid: boolean;
    __invalidRangeErrorMessage: string | null;
    _fromDateIsRequired?: boolean;
    _toDateIsRequired?: boolean;
    __startDatePrefix: string | undefined;
    __endDatePrefix: string | undefined;
    readonly _dismissed: EventEmitter<boolean>;
    calendarWrappers: QueryList<CalendarWrapperComponent>;
    constructor(configStoreService: ConfigStoreService, overlayRef: OverlayRef, cd: ChangeDetectorRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    _updateFromDate(date?: D): void;
    _updateToDate(date?: D): void;
    _updateRangeByPreset(index: number): void;
    _isRangePreset(): void;
    _applyNewDates(): void;
    _validateRange(): void;
    _discardNewDates(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickerOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PickerOverlayComponent, "hc-date-range-picker-overlay", never, {}, {}, never, never, false, never>;
}

/** Groups single radio buttons together into a set for which only one can be selected */
declare class RadioGroupDirective extends HcFormControlComponent implements ControlValueAccessor, AfterContentInit, OnDestroy {
    private _cdRef;
    _ngControl: NgControl;
    _verticalClass: boolean;
    _horizontalClass: boolean;
    /** Event emitted when the value of a radio button changes inside the group. */
    change: EventEmitter<RadioButtonChangeEvent>;
    /** A list of all the radio buttons included in the group */
    radios: QueryList<RadioButtonComponent>;
    private _value;
    private _uniqueName;
    private _name;
    private _inline;
    private _align;
    private _initialized;
    private _selected;
    private _form;
    private _unsubscribe;
    _componentId: string;
    /** Name of radio group. Auto-generated name will be used if no name is set */
    get name(): string;
    set name(value: string);
    /** Unique id for the radio group. If none is supplied, defaults to name. */
    get id(): string;
    set id(idVal: string);
    /** Value of radio buttons */
    get value(): any;
    set value(newValue: any);
    /** Boolean value that enables/disables the radio group */
    get disabled(): boolean;
    set disabled(value: boolean);
    /** Boolean value of whether the radio group is required on a form */
    get required(): boolean;
    set required(value: boolean);
    /** Gets and sets the currently selected value of the radio button group */
    get selected(): RadioButtonComponent | null;
    set selected(button: RadioButtonComponent | null);
    /** Sets the layout orientation of the radio button group; defaults to false */
    get inline(): boolean;
    set inline(value: boolean);
    /** If true, condense the default margin and reduce the font size on all contained radios. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    /** Sets the position all radios in the group relative to their associated label. *Defaults to `center`.*  */
    get align(): 'center' | 'top' | 'bottom';
    set align(value: 'center' | 'top' | 'bottom');
    constructor(_cdRef: ChangeDetectorRef, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _ngControl: NgControl);
    ngAfterContentInit(): void;
    writeValue(value: any): void;
    onChange: (value: unknown) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    setDisabledState(disabledVal: boolean): void;
    _touch(): void;
    _emitChangeEvent(): void;
    private _markRadiosForCheck;
    private _updateSelectedRadio;
    private _checkSelectedRadio;
    private _updateRadioButtonNames;
    private _updateErrorState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupDirective, [null, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioGroupDirective, "hc-radio-group", ["hcRadioGroup"], { "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, { "change": "change"; }, ["radios"], never, false, never>;
}
/** Event type that is emitted when a radio button or radio button group changes */
declare class RadioButtonChangeEvent {
    source: RadioButtonComponent | null;
    value: any;
    /**
     * @param source the radio button that fired the event
     * @param value the value of that radio button
     */
    constructor(source: RadioButtonComponent | null, value: any);
}
/** Radio buttons allow the user to choose only one of a predefined set of mutually exclusive options. */
declare class RadioButtonComponent implements OnInit, AfterContentInit, OnDestroy {
    private cdRef;
    _elementRef: ElementRef;
    private _uniqueId;
    /** Element id for the radio button. Auto-generated id will be used if none is set */
    id: string;
    /** Name of radio button */
    name: string;
    /** Event emitted when the value of the radio button changes */
    change: EventEmitter<RadioButtonChangeEvent>;
    private _checked;
    private _value;
    private _required;
    private _disabled;
    private _tight;
    private _align;
    private readonly radioGroup;
    private unsubscribe$;
    _inputChild: InputDirective;
    /** Value of radio buttons */
    get value(): any;
    set value(value: any);
    get _getHostId(): string;
    /** Boolean value of whether the radio button is required */
    get required(): boolean;
    set required(required: boolean);
    /** Boolean value that enables/disables the radio button */
    get disabled(): boolean;
    set disabled(isDisabled: boolean);
    /** Boolean that returns whether the radio button is selected */
    get checked(): boolean;
    set checked(value: boolean);
    get _inlineGroup(): boolean;
    /** If true, condense the default margin, reduce the font size, and decrease the circle size.
     * Inherits value from parent radio group if part of one. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    /** Sets the position of the radio button relative to its associated label (if not already set in the group). *Defaults to `center`.*  */
    get align(): 'center' | 'top' | 'bottom';
    set align(value: 'center' | 'top' | 'bottom');
    get _overlayClass(): string;
    get _inputId(): string;
    constructor(radioGroup: RadioGroupDirective, cdRef: ChangeDetectorRef, _elementRef: ElementRef);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    _onInputClick(event: Event): void;
    _onInputChange(event?: Event): void;
    private _emitChangeEvent;
    _markForCheck(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, [{ optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "hc-radio-button", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "align": { "alias": "align"; "required": false; }; }, { "change": "change"; }, ["_inputChild"], ["*"], false, never>;
}

declare class RadioButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioButtonModule, [typeof RadioButtonComponent, typeof RadioGroupDirective], [typeof i2.CommonModule], [typeof RadioButtonComponent, typeof RadioGroupDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<RadioButtonModule>;
}

declare class DateRangeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DateRangeModule, [typeof DateRangeDirective, typeof CalendarWrapperComponent, typeof PickerOverlayComponent], [typeof i2.CommonModule, typeof ChipModule, typeof FormFieldModule, typeof DatepickerModule, typeof HcNativeDateModule, typeof InputModule, typeof ButtonModule, typeof RadioButtonModule, typeof i11.OverlayModule, typeof i4.FormsModule], [typeof DateRangeDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DateRangeModule>;
}

/** Result of opening or closing the drawer */
declare class DrawerPromiseResult {
    type: 'open' | 'close';
    constructor(type: 'open' | 'close');
}
/** Drawer that can be opened or closed on the drawer container */
declare class Drawer implements AfterContentInit {
    protected elementRef: ElementRef;
    private _mode;
    private _align;
    _animated: boolean;
    /** Defaults to false. Set to true to disable the closure of drawer by pressing the escape key. */
    ignoreEscapeKey: boolean;
    /** Mode of the drawer: `over`, `push` or `side` */
    get mode(): string;
    set mode(modeType: string);
    /** Side the drawer is attached to: `left` or `right` */
    get align(): string;
    set align(alignType: string);
    /** Event emitted when drawer has started to open */
    get openStart(): Observable<void>;
    /** Event emitted when drawer has started to close */
    get closeStart(): Observable<void>;
    openedChange: EventEmitter<boolean>;
    /** Tabindex of the element */
    tabindex: number;
    _drawerClass: boolean;
    readonly _animationStarted: EventEmitter<AnimationEvent>;
    private _animationDisabled;
    private _drawerOpened;
    private _animationPromise;
    private _resolveAnimationPromise;
    /** Whether the drawer is opened. */
    get opened(): boolean;
    set opened(opened: boolean);
    get _width(): number;
    get _isOpened(): boolean;
    get _isOpening(): boolean;
    get _isClosed(): boolean;
    get _isClosing(): boolean;
    get _isRight(): boolean;
    get _openState(): 'void' | 'open-instant' | 'close-instant' | 'open-left' | 'open-right';
    _onAnimationStart(event: AnimationEvent): void;
    _onAnimationEnd(): void;
    _onKeyDown(event: KeyboardEvent): void;
    constructor(elementRef: ElementRef);
    ngAfterContentInit(): void;
    /** Toggles the drawer open */
    toggleOpen(): Promise<DrawerPromiseResult>;
    /** Toggles the drawer closed */
    toggleClose(): Promise<DrawerPromiseResult>;
    /** Toggles the drawer */
    toggle(isOpen?: boolean): Promise<DrawerPromiseResult>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Drawer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Drawer, "hc-drawer", never, { "ignoreEscapeKey": { "alias": "ignoreEscapeKey"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "align": { "alias": "align"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; }, { "openStart": "openStart"; "closeStart": "closeStart"; "openedChange": "openedChange"; }, never, ["*"], false, never>;
}

declare class BackdropComponent {
    _ignoreEscapeKey: boolean;
    onClose: EventEmitter<void>;
    _hostClass: boolean;
    zIndex: number;
    _fadeInOut(): string | unknown;
    _onClick(): void;
    _escapeKey(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BackdropComponent, "hc-backdrop", never, { "_ignoreEscapeKey": { "alias": "_ignoreEscapeKey"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
}

declare class BackdropHostDirective implements OnDestroy {
    viewContainerRef: ViewContainerRef;
    private _ignoreEscapeKey;
    private _currentBackdrop;
    get ignoreEscapeKey(): boolean;
    set ignoreEscapeKey(ignoreEscapeKey: boolean);
    onClose: EventEmitter<void>;
    private _destroyed;
    constructor(viewContainerRef: ViewContainerRef);
    showBackdrop(): ComponentRef<BackdropComponent>;
    hideBackdrop(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropHostDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BackdropHostDirective, "[backdropHost]", never, { "ignoreEscapeKey": { "alias": "ignoreEscapeKey"; "required": false; }; }, { "onClose": "onClose"; }, never, never, false, never>;
}

/** Parent component that houses one or two `<hc-drawer>` that applies content styling */
declare class DrawerContainer implements AfterContentInit, DoCheck, OnDestroy {
    private _elementRef;
    private _renderer;
    private _ngZone;
    private _changeDetector;
    _drawers: QueryList<Drawer>;
    _backdropHost: BackdropHostDirective;
    private _leftDrawer;
    private _rightDrawer;
    private _animated;
    private _useBackdrop;
    _contentMargins: {
        left: number;
        right: number;
    };
    private readonly _doCheckSubject;
    private readonly _destroyed;
    _hostClass: boolean;
    /** Defaults to true. Whether the content and drawers slide or snap open and closed. */
    get animated(): boolean;
    set animated(val: boolean);
    /** Whether to use a backdrop, which closes the drawer when clicked */
    get useBackdrop(): boolean;
    set useBackdrop(useBackdrop: boolean);
    constructor(_elementRef: ElementRef, _renderer: Renderer2, _ngZone: NgZone, _changeDetector: ChangeDetectorRef);
    ngDoCheck(): void;
    ngAfterContentInit(): void;
    private _isDrawerOpen;
    /** Open all drawers */
    open(): Promise<DrawerPromiseResult[]>;
    /** Close all drawers */
    close(): Promise<DrawerPromiseResult[]>;
    private _calculateContentMargins;
    _validateDrawers(): void;
    private _setContainerClass;
    _showBackdrop(drawer: Drawer): void;
    _hideBackdrop(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerContainer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerContainer, "hc-drawer-container", never, { "animated": { "alias": "animated"; "required": false; }; "useBackdrop": { "alias": "useBackdrop"; "required": false; }; }, {}, ["_drawers"], ["hc-drawer,hc-menu-drawer", "*"], false, never>;
}

declare class DrawerToolbar {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerToolbar, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DrawerToolbar, "[hcDrawerToolbar]", never, {}, {}, never, never, false, never>;
}

/** Menu drawer that provides default themes */
declare class MenuDrawer extends Drawer implements AfterContentInit {
    private renderer;
    private _previousTheme;
    toolbar: DrawerToolbar;
    /** Sets menu style of the drawer. Choose from: `'dark-theme'` */
    get menuTheme(): string;
    set menuTheme(menuStyle: string);
    private _menuTheme;
    _hostClass: boolean;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    ngAfterContentInit(): void;
    private _themeClass;
    private _setThemeClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDrawer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuDrawer, "hc-menu-drawer", never, { "menuTheme": { "alias": "menuTheme"; "required": false; }; }, {}, ["toolbar"], ["[hcDrawerToolbar]", "hc-drawer-item"], false, never>;
}

declare class DrawerItem {
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerItem, "hc-drawer-item", never, {}, {}, never, ["*"], false, never>;
}

declare class BackdropModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BackdropModule, [typeof BackdropComponent, typeof BackdropHostDirective], [typeof i2.CommonModule], [typeof BackdropComponent, typeof BackdropHostDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BackdropModule>;
}

declare class DrawerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DrawerModule, [typeof Drawer, typeof DrawerContainer, typeof MenuDrawer, typeof DrawerItem, typeof DrawerToolbar], [typeof i2.CommonModule, typeof BackdropModule], [typeof Drawer, typeof DrawerContainer, typeof MenuDrawer, typeof DrawerItem, typeof DrawerToolbar]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DrawerModule>;
}

/** Interface for making/receiving assignments */
interface DragDropAssignment {
    /** The target awaiting an option assignment. */
    target: any;
    /** The assigned option. */
    assignment: any | null;
    /** When `true` prevents modification. Use this if you have an assignment you want to lock. */
    locked?: boolean;
}
/** A control for making assignments with drag-drop functionality */
declare class DragListComponent implements OnChanges {
    /** Current assignments, refer to the `DragDropAssignment` interface. Pass in your targets and their current assignments with this. */
    assignments: DragDropAssignment[];
    /** The `id` or "key" property of your targets (`options` are assigned to `targets`). Defaults to `id`. */
    targetIdField: string;
    /** The display name property of your targets. Defaults to `name`. */
    targetDisplayNameField: string;
    /** The tooltip or title property of your targets. Defaults to `title`. */
    targetHoverTextField: string;
    /** The available options to assign to your targets. */
    options: any[];
    /** The `id` or "key" property of your options (`options` are assigned to `targets`). Defaults to `id`. */
    optionIdField: string;
    /** The display name property of your options. Defaults to `name`. */
    optionDisplayNameField: string;
    /** The tooltip or title property of your options. Defaults to `title`. */
    optionHoverTextField: string;
    /** The placeholder text for unassigned targets. Empty by default. */
    targetPlaceholder: string;
    /** The target area label. Defaults to "Targets". */
    targetHelperText: string;
    /** The tooltip text for the target area label, if defined an info icon will be displayed to the right. Empty by default. */
    targetTooltip: string;
    /** The help text for unassigned options. Defaults to "Drag values to desired location in the left pane". */
    optionsHelperText: string;
    /** The help text for locked options. Defaults to "This assignment is locked and cannot be changed.". */
    optionLockedText: string;
    /** When set to `true`, all targets must have an assignment before the `submissionAllowed` property will return `true`. Defaults to `false`. */
    requireAllAssignments: boolean;
    _modifiedAssignments: DragDropAssignment[];
    _targetsById: {
        [id: string]: any;
    };
    _optionsById: {
        [id: string]: any;
    };
    _optionIsAssigned: {
        [id: string]: boolean;
    };
    _tooltipsByOptionId: {
        [id: string]: string;
    };
    get _unassignedOptions(): any;
    /** Returns `true` is selections are valid. */
    get submissionAllowed(): boolean;
    /** Returns assignments. */
    get selections(): DragDropAssignment[];
    private _dragData;
    ngOnChanges(changes: SimpleChanges): void;
    private _indexBy;
    private _indexByExt;
    private _setOptionIsAssigned;
    _makeAssignment(ev: any): void;
    _returnToOptionsList(ev: any): void;
    _unassign(assignment: DragDropAssignment): void;
    _findNearestWithClass(e: HTMLElement | null, className: string): HTMLElement | null;
    _dragover(ev: any): void;
    _dragstart(ev: any): void;
    _dragenter(ev: any): void;
    _dragleave(ev: any): void;
    /** Marks control as pristine. Typically called after saving modifications. */
    setPristine(): void;
    /** Resets assigments to original values. */
    resetChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DragListComponent, "hc-drag-list", never, { "assignments": { "alias": "assignments"; "required": false; }; "targetIdField": { "alias": "targetIdField"; "required": false; }; "targetDisplayNameField": { "alias": "targetDisplayNameField"; "required": false; }; "targetHoverTextField": { "alias": "targetHoverTextField"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionIdField": { "alias": "optionIdField"; "required": false; }; "optionDisplayNameField": { "alias": "optionDisplayNameField"; "required": false; }; "optionHoverTextField": { "alias": "optionHoverTextField"; "required": false; }; "targetPlaceholder": { "alias": "targetPlaceholder"; "required": false; }; "targetHelperText": { "alias": "targetHelperText"; "required": false; }; "targetTooltip": { "alias": "targetTooltip"; "required": false; }; "optionsHelperText": { "alias": "optionsHelperText"; "required": false; }; "optionLockedText": { "alias": "optionLockedText"; "required": false; }; "requireAllAssignments": { "alias": "requireAllAssignments"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DragListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DragListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DragListModule, [typeof DragListComponent], [typeof i2.CommonModule, typeof IconModule, typeof PopModule], [typeof DragListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DragListModule>;
}

interface IMetadataEnvironment {
    /** A unique identifier for the environment. */
    id: number;
    /** An identifier representing a given tenant. (For example, a particular client.) */
    tenantCode: string;
    /** The full name of environment. */
    name: string;
    /** An abbreviated environment name. Used in environment badge ui element. */
    shortName: string;
    /** Describes the environment. */
    description: string;
    /** Hex code for the color associated with an environment. Used in the environment badge ui element.
     * Color options include: `"#ffffff", "#7acb91", "#00acac", "#00a859", "#e7c447", "#ebba82", "#f89012", "#f13c45", "#eea2C0", "#a94c9d", "#3194fe", "#ace5ff"`.
     * If no color (or an invalid color) is provided, will default to white (#ffffff).*/
    color: string;
}
/** Extended version of metadata environment model ready for display in the environment switcher UI */
interface IMetadataEnvironmentVM extends IMetadataEnvironment {
    badgeColorClass: string;
}

declare class EnvSwitcherComponent implements OnDestroy, ControlValueAccessor {
    _hostClass: boolean;
    /** The currently active metadata environments.
     * NgModel/FormValue is bound to just the environment IDs, but you can access this property for an array with the entire environment model. */
    get selectedEnvironments(): IMetadataEnvironment[];
    /** When disabled, the environment switcher cannot be opened. *Defaults to false.* */
    get disabled(): boolean;
    private _disabled;
    /** The ids of the selected metadata environments */
    _activeEnvIds: number[];
    /** In multiselect mode, track the ids of selected environments in this 'staging' model (and then actually apply them when the user is done) */
    _stagedActiveEnvIds: number[];
    /** Text to show in the badge shown in the navbar. */
    _badgeText: string;
    /** Tooltip shown when a user hover over the badge in the navbar. */
    _badgeTooltip: string;
    /** Color of the badge in the navbar. */
    _badgeColor: string;
    /** collection of allowed colors mapped to their matching css classes */
    private readonly _colorClassesMap;
    private _onChange;
    private _destroy$;
    /** Reference to the popover containing the environment selection menu. */
    pop: HcPopComponent;
    /** Set to true while waiting for environments to load from MDS. *Defaults to false.* */
    loading: boolean;
    /** Set to true if unable to load environments from MDS. A "Failed to load" message will be shown in the switcher. *Defaults to false.* */
    failedToLoad: boolean;
    /** Header to display above the expanded list of environments. *Defaults to 'Environments'.* */
    listHeader: string;
    /** If true, will allow multiple environments to be selected at once. *Defaults to false.* */
    get canSelectMultiple(): boolean;
    set canSelectMultiple(canSelectMultiple: boolean);
    private _canSelectMultiple;
    /** If true, will show an icon that allows user to click to open an environment in a new tab.
     * When clicking this icon, a `(openInNewTab)` event will be fired that the consuming app will
     * need to listen for and respond to. *Defaults to false.*
     */
    get canOpenInNewTab(): boolean;
    set canOpenInNewTab(canOpenInNewTab: boolean);
    private _canOpenInNewTab;
    /** The metadata environments to show in the switcher. */
    set environmentOptions(envs: IMetadataEnvironment[]);
    get environmentOptions(): IMetadataEnvironment[];
    _environmentOptionVMs: IMetadataEnvironmentVM[];
    /** Event that fires when model is updated. Outputs an array of the currently selected environments.
     * Consuming app will need to set appropriate environment headers refresh elements on page as needed. */
    updateEnvironments: EventEmitter<IMetadataEnvironment[]>;
    /** Event that fires when the "open in new tab" action is triggered. Outputs the selected environment.
     * Consuming app will need implement functionality to actually open a new tab with the given environment active. */
    openInNewTab: EventEmitter<IMetadataEnvironment>;
    /** Event that fires when users click a link to reload environments. This link is shown if `failedToLoad` is set to true. */
    reloadEnvironments: EventEmitter<void>;
    writeValue(selectedEnvs: number[]): void;
    registerOnChange(fn: () => null): void;
    registerOnTouched(): void;
    setDisabledState(state: boolean): void;
    ngOnDestroy(): void;
    /** Manually open the app switcher menu. */
    openMenu(): void;
    /** Manually close the app switcher menu. */
    closeMenu(): void;
    /** Convenience method for setting the current active environment(s) by their Ids. Invalid environment Ids will not be selected. */
    setActiveEnvironments(envs: number[]): void;
    _isEnvSelected(envId: number): boolean;
    _onBadgeClick(): void;
    _envClicked(env: IMetadataEnvironmentVM): void;
    /** Used when `canSelectMultiple` is true. applies the state of the 'staging' model (`_stagedSelectedEnvs`) and closes the menu. */
    _applyEnvs(): void;
    /** Used when `canSelectMultiple` is true. toggles the environment as needed in the 'staging' model (`_stagedSelectedEnvs`). */
    private _envClickedForMulti;
    /** Used when `canSelectMultiple` is false. selects an environment and closes the menu */
    private _envClickedForSingle;
    private _onEnvironmentsChanged;
    /** Update the text displayed on the environment switcher badge in the navbar */
    private _updateBadgeText;
    /** Returns a list of the active environments */
    private _buildActiveEnvList;
    /** Set the appropriate color for environment switcher badge displayed in the navbar */
    private _updateBadgeColor;
    /** Translate an environment's color code into an appropriate css class */
    private _getBadgeColorClass;
    /** Prepares given environment models into view models read for display in the UI. */
    private _convertEnvsToVMs;
    _generateShortName(name: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EnvSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EnvSwitcherComponent, "hc-env-switcher", never, { "loading": { "alias": "loading"; "required": false; }; "failedToLoad": { "alias": "failedToLoad"; "required": false; }; "listHeader": { "alias": "listHeader"; "required": false; }; "canSelectMultiple": { "alias": "canSelectMultiple"; "required": false; }; "canOpenInNewTab": { "alias": "canOpenInNewTab"; "required": false; }; "environmentOptions": { "alias": "environmentOptions"; "required": false; }; }, { "updateEnvironments": "updateEnvironments"; "openInNewTab": "openInNewTab"; "reloadEnvironments": "reloadEnvironments"; }, never, never, false, never>;
}

declare class EnvSwitcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EnvSwitcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EnvSwitcherModule, [typeof EnvSwitcherComponent], [typeof i2.CommonModule, typeof PopModule, typeof PipesModule, typeof IconModule, typeof ProgressIndicatorsModule, typeof CheckboxModule, typeof ButtonModule], [typeof EnvSwitcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EnvSwitcherModule>;
}

/** Standard front-end for uploading files from the users local environment */
declare class FileUploaderComponent extends HcFormControlComponent implements AfterViewInit, OnDestroy {
    _ngControl: NgControl;
    private _changeRef;
    _dropZone: ElementRef<HTMLElement>;
    _fileInputElement: ElementRef;
    private _form;
    private _unsubscribe;
    private _uniqueId;
    _fileIcon: string;
    _fileTypes: string;
    _fileNames: string[];
    _multiple: boolean;
    _disabled: boolean;
    _isRequired: boolean;
    _fileList: FileList;
    _subtext: string;
    _baseClass: boolean;
    /** Fires a `FileList` when files have been selected by the uploader */
    filesAdded: EventEmitter<FileList>;
    /** Unique id for the file uploader element. If none is supplied, one will be auto-generated. */
    get id(): string;
    set id(idVal: string);
    /** File types that the uploader will accept (eg. "image/png, image/jpeg"). Defaults to "*". */
    get fileTypes(): string;
    set fileTypes(value: string);
    /** Allow for multiple files to be selected. Defaults to false. */
    get multiple(): boolean;
    set multiple(value: boolean | string);
    /** Apply tight styling that condenses the controller to one line. Defaults to false. */
    get tight(): boolean;
    set tight(value: boolean | string);
    /** Whether the uploader is disabled. */
    get disabled(): boolean;
    set disabled(val: boolean | string);
    /** Sets whether this is a required form element */
    get required(): boolean;
    set required(requiredVal: boolean | string);
    /** Displays an optional string of text below the browse button - typically used for instructions or info about file constraints */
    get subtext(): string;
    set subtext(val: string);
    ngAfterViewInit(): void;
    constructor(_parentForm: NgForm, _parentFormGroup: FormGroupDirective, _ngControl: NgControl, _changeRef: ChangeDetectorRef);
    writeValue(value: FileList): void;
    onChange: (value: FileList) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: FileList) => void): void;
    registerOnTouched(fn: () => FileList): void;
    setDisabledState(disabledVal: boolean): void;
    private _updateErrorState;
    /** Triggers the system file selection dialog to open */
    browseFiles(): void;
    /** Clears any selected files and returns to the initial state */
    reset(): void;
    _fileSelected(): void;
    _onFileDrop(event: DragEvent): void;
    _determineFileIcon(): void;
    _allowDrop(event: Event): void;
    _highlight(): void;
    _unhighlight(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploaderComponent, [{ optional: true; }, { optional: true; }, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploaderComponent, "hc-file-uploader", never, { "id": { "alias": "id"; "required": false; }; "fileTypes": { "alias": "fileTypes"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "subtext": { "alias": "subtext"; "required": false; }; }, { "filesAdded": "filesAdded"; }, never, never, false, never>;
}

declare class FileUploaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploaderModule, [typeof FileUploaderComponent], [typeof i2.CommonModule, typeof FormFieldModule, typeof InputModule, typeof ButtonModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule], [typeof FileUploaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploaderModule>;
}

/**
 * This service provides the logic to fill up a container
 * with components contained inside Measurable Components.
 */
declare class MeasurableService {
    /**
     * Fills a container with as many components as will fit. See usage for more details.
     *
     * @param components The array of components to try and fill the container.
     * @param availableSize The available width or height in the container to fill with the given components.
     * @param moreSize The width or height of a more control.
     * @param direction Which way to fill the container, either horizontally or vertically.
     * @param showFunc Additional actions to take on a component that is shown. *Defaults to a function that does nothing.*
     * @param hideFunc Additional actions to take on a component that is hidden. *Defaults to a function that does nothing.*
     * @returns A set containing all of the keys of components that were hidden.
     */
    fillContainer(components: MeasurableComponent[], availableSize: number, moreSize: number, direction?: 'horizontal' | 'vertical', showFunc?: (component: MeasurableComponent) => void, hideFunc?: (component: MeasurableComponent) => void): Set<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MeasurableService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MeasurableService>;
}

/**
 * Helper component for creating a container which automatically
 * overflows components into a more menu.
 */
declare class MeasurableComponent {
    private ref;
    private _width;
    private _height;
    _isShown: boolean;
    _itemKey: string | null;
    _targetItem: ElementRef;
    /**
     * The unique key of the item displayed inside this measurable component.
     */
    get itemKey(): string;
    set itemKey(itemKeyVal: string);
    /**
     * Calculates and returns the measured width of this container.
     * The width is cached for future calls to this property.
     */
    get width(): number;
    /**
     * Calculates and returns the measured height of this container.
     * The height is cached for future calls to this property.
     */
    get height(): number;
    constructor(ref: ChangeDetectorRef);
    /**
     * Shows the contents of this container, forcing a change detection
     * cycle to run.
     */
    show(): void;
    /**
     * Hides the contents of this container, forcing a change detection
     * cycle to run.
     */
    hide(): void;
    reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MeasurableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MeasurableComponent, "hc-measurable", never, { "itemKey": { "alias": "itemKey"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class MeasurableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MeasurableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MeasurableModule, [typeof MeasurableComponent], [typeof i2.CommonModule], [typeof MeasurableComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MeasurableModule>;
}

/**
 * Represents an instance to be displayed on the Instance Switcher.
 */
interface IInstance {
    /** The unique key corresponding to this instance. */
    instanceKey: string;
    /** The text that should be displayed on the instance switcher for this instance. */
    displayText: string;
    /** Text displayed for a tooltip on the instance tab */
    tooltipText?: string;
}
/**
 * Configuration for what text to show on tooltips attached
 * to various controls in the Instance Switcher.
 */
interface IInstanceSwitcherTooltipText {
    /** The tooltip text for the add button. */
    addText?: string;
    /** The tooltip text for the close button. */
    closeText?: string;
}

type InstanceSwitcherTooltipConfig = IInstanceSwitcherTooltipText & {
    addTrigger: string;
    closeTrigger: string;
};
/**
 * `hc-instance-switcher` is used to manage multiple instances of the same page.
 */
declare class InstanceSwitcherComponent implements OnDestroy, AfterViewInit {
    private _measurableService;
    private _ref;
    _instances: IInstance[];
    _moreInstances: IInstance[];
    _selectedKey: string | null;
    _editKey: string | null;
    _previouslySelected: string[];
    _closable: boolean;
    _isOpen: boolean;
    _openState: 'void' | 'open';
    _tooltipText: InstanceSwitcherTooltipConfig;
    _renameInstanceControl: FormControl<string | null>;
    _renameInstanceSize$: rxjs.Observable<number>;
    private _unsubscribe$;
    private _animationFrameCount;
    private _blurActive;
    _instanceContextKey: string | null;
    _instanceContextValue: string | null;
    private _baseSize;
    _collapse: boolean;
    _moreList: Array<IInstance>;
    /**
     * The instances to display on the Instance Switcher. *Required.*
     */
    get instances(): IInstance[];
    set instances(instancesVal: IInstance[]);
    /**
     * Controls whether or not to display the close button
     * on the Instance Switcher. *Defaults to true.*
     */
    get closable(): boolean;
    set closable(closableVal: boolean);
    /**
     * Controls whether or not the instance chips are
     * editable. *Defaults to true.*
     */
    editable: boolean;
    /**
     * Sets the Instance Switcher to either open or closed. *Defaults to true. Required if `closable` is also true.*
     */
    get isOpen(): boolean;
    set isOpen(isOpenVal: boolean);
    /**
     * Sets which instance is selected.
     */
    get selectedKey(): string | null;
    set selectedKey(selectedKeyVal: string | null);
    /**
     * Configures the tooltip text that shows up on the various
     * controls.
     */
    get tooltipText(): IInstanceSwitcherTooltipText;
    set tooltipText(toolTipVal: IInstanceSwitcherTooltipText);
    get _moreOpenState(): 'open' | 'closed';
    /** Configure the max width for the instance names. Default to fit content or `none`; use maxWidth to constrain and truncate the content to a fixed width (e.g. `150px`)*/
    chipMaxWidth: string;
    /**
     * Value emitted when an instance tab is clicked. The value
     * is the unique key assigned to the instance.
     */
    selected: EventEmitter<string | null>;
    /**
     * Empty event emitted when the add instance button is clicked.
     */
    added: EventEmitter<never>;
    edited: EventEmitter<IInstance>;
    /**
     * Value emitted when the close button is clicked on an
     * instance tab. The value is the unique key assigned to the
     * instance.
     */
    removed: EventEmitter<string>;
    /**
     * Empty event emitted when the close button is clicked on the
     * instance switcher.
     */
    closed: EventEmitter<never>;
    _instanceChips: QueryList<MeasurableComponent>;
    _instancesMore: HcPopoverAnchorDirective;
    _instancesTooltips: QueryList<HcPopoverAnchorDirective>;
    _instancesContainer: ElementRef;
    _instanceEditInput: ElementRef;
    _instancePopovers: QueryList<HcPopoverAnchorDirective>;
    /**
     * Recalculates which instances should be shown, and which
     * ones should be moved to the more menu.
     */
    refreshInstances(): void;
    constructor(_measurableService: MeasurableService, _ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    _updateContainerSize(): void;
    /**
     * Checks the container size a few times to see if the instances can be refreshed for the first
     * time. For more information about this approach, see the Usage tab on the website.
     */
    private checkContainerSize;
    ngOnDestroy(): void;
    _isSelected(key: string, isMore: boolean, index: number): boolean;
    _contextTrigger(): string;
    _isEditable(key: string): boolean;
    _inputWidth(charCount: number): number;
    _closeClick(): void;
    _instanceClick(key: string): void;
    _instanceContextOpened(key: string, value: string): void;
    _instanceEdit(key: string | null, value: string | null, clickEvent?: MouseEvent): void;
    _cancelEdit(): void;
    _instanceBlur(key: string): void;
    _instanceClose(key: string, event?: MouseEvent): void;
    _instanceAdd(): void;
    _calculateAvailableSize(): number;
    _instanceTrackBy(index: number, instance: IInstance): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<InstanceSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InstanceSwitcherComponent, "hc-instance-switcher", never, { "instances": { "alias": "instances"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "selectedKey": { "alias": "selectedKey"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "chipMaxWidth": { "alias": "chipMaxWidth"; "required": false; }; }, { "selected": "selected"; "added": "added"; "edited": "edited"; "removed": "removed"; "closed": "closed"; }, never, never, false, never>;
}

declare class InstanceSwitcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InstanceSwitcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InstanceSwitcherModule, [typeof InstanceSwitcherComponent], [typeof i2.CommonModule, typeof ChipModule, typeof ButtonModule, typeof IconModule, typeof MeasurableModule, typeof InputModule, typeof i4.ReactiveFormsModule], [typeof InstanceSwitcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InstanceSwitcherModule>;
}

/** Parent component that can house multiple `<hc-list-item>` and applies Cashmere list styling */
declare class ListComponent {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "hc-list", never, {}, {}, never, ["*"], false, never>;
}

/**
 * Represents a row within a `<hc-list>`. Multiple `[hcListLine]` can be used
 * per `<hc-list-item>`. You can also prefix a `[hcListAvatar]` or `[hcListIcon]`
 * to the beginning of the `<hc-list-item>`.
 */
declare class ListItemComponent {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListItemComponent, "hc-list-item", never, {}, {}, never, ["[hcListAvatar], [hcListIcon]", "[hcListLine]", "*"], false, never>;
}

/** Prepends an avatar styled element to the beginning of a `<hc-list-item>`. */
declare class ListAvatarDirective {
    get _hostClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListAvatarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListAvatarDirective, "[hcListAvatar]", never, {}, {}, never, never, false, never>;
}

/** Prefixes an icon to the beginning of a `<hc-list-item>`. */
declare class ListIconDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListIconDirective, "[hcListIcon]", never, {}, {}, never, never, false, never>;
}

/** Represents a line within a `hc-list-item` row. Multiple can be used within `hc-list-item`. */
declare class ListLineDirective {
    _hostClass: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListLineDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListLineDirective, "[hcListLine]", never, {}, {}, never, never, false, never>;
}

declare class ListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ListModule, [typeof ListComponent, typeof ListItemComponent, typeof ListAvatarDirective, typeof ListIconDirective, typeof ListLineDirective], [typeof i2.CommonModule], [typeof ListComponent, typeof ListItemComponent, typeof ListAvatarDirective, typeof ListIconDirective, typeof ListLineDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ListModule>;
}

declare class ActiveModal<T = any, U = any> {
    /** Data that was passed in through ModalOptions */
    data?: T;
    /** Closes the modal with an optional result.
     * Use this close method when opening a modal using a component. When doing so,
     * ActiveModal must be injected in order to get access to the close method.
     * To dismiss a modal that was created from a TemplateRef, use the dismiss method
     * on HcModal */
    close(_result?: U): void;
    /** Dismisses the modal with no result.
     * Use this dismiss method when opening a modal using a component. When doing so,
     * ActiveModal must be injected in order to get access to the dismiss method.
     * To dismiss a modal that was created from a TemplateRef, use the dismiss method
     * on HcModal */
    dismiss(): void;
}

declare class ModalBodyComponent {
    elementRef: ElementRef;
    _modalBodyClass: boolean;
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalBodyComponent, "hc-modal-body", never, {}, {}, never, ["*"], false, never>;
}

declare class ModalFooterComponent {
    _modalFooterClass: boolean;
    /** Removes all padding and displays the footer as a 15px high cap to the bottom of the modal.
     * Useful when you anticipate scrollable modal content to account for the rounded edges of the modal container.
     */
    minimal: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalFooterComponent, "hc-modal-footer", never, { "minimal": { "alias": "minimal"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class ModalHeaderComponent {
    _modalHeaderClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderComponent, "hc-modal-header", never, {}, {}, never, ["*"], false, never>;
}

declare class ModalComponent implements AfterContentInit {
    _modalWrapperClass: boolean;
    _modalMinHeight: string;
    /** Checks for header/footer/body */
    _modalHeader: ModalHeaderComponent;
    _modalBody: ModalBodyComponent;
    _modalFooter: ModalFooterComponent;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "hc-modal", never, {}, {}, ["_modalHeader", "_modalBody", "_modalFooter"], ["*"], false, never>;
}

declare class ModalOverlayComponent {
    private activeModal;
    _ignoreEscapeKey: boolean;
    _hostClass: boolean;
    constructor(activeModal: ActiveModal);
    _fadeInOut(): string | unknown;
    _escapeKey(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalOverlayComponent, "hc-modal-overlay", never, { "_ignoreEscapeKey": { "alias": "_ignoreEscapeKey"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ModalWindowComponent {
    private activeModal;
    private el;
    private _document;
    private _focusTrapFactory;
    _ignoreOverlayClick: boolean;
    _isDraggable: boolean;
    _isResizable: boolean;
    _size: string;
    _tight: boolean;
    _closeIcon: boolean;
    _disableFullScreen: boolean;
    _restoreFocus: boolean;
    _autoFocus: boolean;
    _previouslyFocusedElement: HTMLElement | null;
    _focusTrap: ConfigurableFocusTrap | undefined;
    _hostClass: boolean;
    constructor(activeModal: ActiveModal, el: ElementRef, _document: any, _focusTrapFactory: ConfigurableFocusTrapFactory);
    /** Reference to the element to build a focus trap around. */
    private _focusTrapElement;
    /** Reference to the close button. */
    private _closeBtn;
    _fadeInOut(): unknown;
    _overlayClick(event: unknown): void;
    _eventPath(evt: any): typeof globalThis[];
    /** Save a reference to the element focused before the modal was opened. */
    _savePreviouslyFocusedElement(): void;
    /** Move the focus inside the focus trap and remember where to return later. */
    _trapFocus(): void;
    _avoidInitialFocusOnCloseButton(): void;
    /** Dismiss the modal from a click on the close icon */
    _dismiss(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalWindowComponent, [null, null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModalWindowComponent, "hc-modal-window", never, {}, {}, never, ["*"], false, never>;
}

type ModalSize = 'auto' | 'sm' | 'md' | 'lg' | 'xl';
interface ModalOptions {
    /** Optional size of the modal window. Defaults to auto sizing based on content.
     * Options are: `auto`, `sm`, `md`, `lg`, and `xl`.*/
    size?: ModalSize;
    /** Defaults to false. Set to true to reduce padding of modal sections and title font size. */
    tight?: boolean;
    /** Optional. Specify data that will be available on the active modal context. */
    data?: unknown;
    /** Optional. Specify a different HTML element to append the modal overlay and modal window.
     * If not specified the modal elements will be added to the body. */
    container?: HTMLElement;
    /** Defaults to false. Set to true to disable the closure of a modal by clicking on the overlay. */
    ignoreOverlayClick?: boolean;
    /** Defaults to false. Set to true to disable the closure of a modal by pressing the escape key. */
    ignoreEscapeKey?: boolean;
    /** Defaults to false. When set to true, a drag handle is added to the top-right corner which can be used to reposition the modal. */
    isDraggable?: boolean;
    /** Defaults to false. When set to true, a resize handle is added to the bottom-right corner which can be used to adjust the dimensions
     * of the modal. Browser support - https://caniuse.com/mdn-css_selectors_-webkit-resizer */
    isResizable?: boolean;
    /** Defaults to false. When set to true, the modal will no longer display in full-screen for mobile devices. */
    disableFullScreen?: boolean;
    /** Whether the modal should return focus to the previously focused element after closing. *Defaults to `true`.* */
    restoreFocus?: boolean;
    /** Whether the first focusable element should be focused on open. *Defaults to `false`.* */
    autoFocus?: boolean;
    /** Adds a close icon to the right side of the header that dismisses the modal *Defaults to `false`.* */
    closeIcon?: boolean;
}

/** Used with ModalService's `alert()`, `confirm()`, and `confirmDestructive()` functions, which generate a
 * quick alert or confirmation modal. */
declare class SimpleModalOptions {
    /** Message to show in the body of the modal. */
    message?: string;
    /** Message to show in the body of the modal that includes HTML markup.
     * **WARNING:** You are responsible to sanitize any unsafe user input. */
    messageHTML?: string;
    /** Text to show in the header of the modal. */
    headerText?: string;
    /** Main icon to show. Appears to the left of the header text, or in the body of the modal if there is no header.*/
    icon?: string;
    /** Text to show for the modal's cancel button. Leave empty for no cancel button */
    cancelButtonText?: string;
    /** Text to show for the modal's confirm button. */
    confirmButtonText?: string;
    /** Icon to show in the button. */
    confirmButtonIcon?: string;
    /** True if the modal's button should be colored to designate a destructive action. *Defaults to false.* */
    confirmButtonIsDestructive?: boolean | undefined;
    /** Sets style of confirmation button. Overrides confirmButtonIsDestructive.
     * Choose from: `'primary' | 'primary-alt' | 'destructive' |
     * 'neutral' | 'secondary' | 'minimal' | link' | 'link-inline'`. If needed, colors from
     * the primary or secondary palette may be used as well (e.g. 'pink', 'red-orange', etc) */
    confirmButtonStyle?: string;
    /** Sets style of cancel button. Choose from: `'primary' | 'primary-alt' | 'destructive' |
     * 'neutral' | 'secondary' | 'minimal' | link' | 'link-inline'`. If needed, colors from
     * the primary or secondary palette may be used as well (e.g. 'pink', 'red-orange', etc) */
    cancelButtonStyle?: boolean | undefined;
    /** Text for an optional informational tooltip that will be in the footer. */
    footerTooltipText?: string;
    /** If true, will preserve white-space in the message of the modal */
    preserveMessageWhitespace?: boolean | undefined;
}

declare class SimpleModalComponent implements OnInit {
    private activeModal;
    options: SimpleModalOptions;
    constructor(activeModal: ActiveModal);
    ngOnInit(): void;
    cancel(): void;
    confirm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleModalComponent, "hc-simple-modal", never, {}, {}, never, never, false, never>;
}

declare class ModalModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ModalModule, [typeof ModalOverlayComponent, typeof ModalWindowComponent, typeof ModalHeaderComponent, typeof ModalBodyComponent, typeof ModalFooterComponent, typeof ModalComponent, typeof SimpleModalComponent], [typeof i2.CommonModule, typeof i7.DragDropModule, typeof ButtonModule], [typeof ModalHeaderComponent, typeof ModalBodyComponent, typeof ModalFooterComponent, typeof ModalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ModalModule>;
}

declare class HcModal<T> {
    /** Allows direct access to the component used to create the modal. Null when TemplateRef is used */
    componentRef: ComponentRef<T> | null;
    /** Allows direct access to overlay component which holds the component/template */
    overlay: ComponentRef<ModalOverlayComponent> | null;
    /** Allows direct access to window component which holds the component/template */
    window: ComponentRef<ModalWindowComponent> | null;
    /** Subscribe to result in order to get access to modal result values passed in ActiveModal.close() */
    get result(): Observable<unknown>;
    private _result;
    _removeOpenClass: (() => void) | null;
    _modalClose: EventEmitter<any>;
    /** Data that was passed in through ModalOptions */
    data?: unknown;
    /** Closes the modal with a result.
     * Use this close method when opening a modal using a TemplateRef.
     * To close a modal that was created from a Component, inject ActiveModal and use the close method
     * on ActiveModal */
    close(result?: unknown): void;
    /** Dismisses the modal with no result.
     * Use this dismiss method when opening a modal using a TemplateRef.
     * To dismiss a modal that was created from a Component, inject ActiveModal and use the dismiss method
     * on ActiveModal */
    dismiss(): void;
    private removeModalElements;
}

type ModalContentType = Type<unknown> | TemplateRef<unknown>;
declare class ModalService {
    private _componentFactory;
    private _injector;
    private _applicationRef;
    /** Defaults to false. Restricts multiple modals from being opened on top of each other
     * (an error will be thrown if attempted). It's generally considered bad practice to open multiple
     * models at once, so only change this with good reason.
     */
    allowMultiple: boolean;
    private _zIndexBase;
    private _zIndexCounter;
    private _renderer;
    private _modalsOpen;
    constructor(_componentFactory: ComponentFactoryResolver, _injector: Injector, _applicationRef: ApplicationRef, _rendererFactory: RendererFactory2);
    /** Opens a new modal either from a Component or a TemplateRef with the options specified in ModalOptions
     * In order to use a component, it must be specified in your module's EntryComponents.
     */
    open<T>(modalContent: ModalContentType, modalOptions?: ModalOptions): HcModal<T>;
    /**
     * Opens a confirmation modal pre-populated with default options for a destructive action.
     * @param contentOptions Options to configure the content of the confirmation modal
     * @param modalOptions Options to configure the modal window itself
     * @returns True if the user confirmed the action, false if they cancelled
     */
    confirmDestructive(contentOptions: SimpleModalOptions, modalOptions?: ModalOptions): Observable<boolean>;
    /**
     * Opens a simple confirmation modal with a confirm and cancel button.
     * @param contentOptions Options to configure the content of the confirmation modal
     * @param modalOptions Options to configure the modal window itself
     * @returns True if the user confirmed the action, false if they cancelled
     */
    confirm(contentOptions: SimpleModalOptions, modalOptions?: ModalOptions): Observable<boolean>;
    /**
     * Opens a simple alert modal
     * @param contentOptions Options to configure the content of the confirmation modal
     * @param modalOptions Options to configure the modal window itself
     * @returns True when the user confirms
     */
    alert(contentOptions: SimpleModalOptions, modalOptions?: ModalOptions): Observable<boolean>;
    /** Convenience function for opening a simple alert or confirmation modal w/ minimal boilerplate */
    _openSimpleModal(contentOptions: SimpleModalOptions, modalOptions?: ModalOptions): Observable<boolean>;
    /** Restore focus to the element focused before the popover opened. Also destroy trap. */
    _restoreFocusAndDestroyTrap(modalWindow: ModalWindowComponent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}

/** Cashmere wrapper for the ng-select component */
declare class MultiselectComponent extends HcFormControlComponent {
    private _uniqueInputId;
    _componentId: string;
    _hostClass: boolean;
    /** Element id */
    get id(): string;
    set id(idVal: string);
    /** Whether the slider is valid; triggers error messages in `hc-form-field` */
    get valid(): boolean;
    set valid(val: boolean | string);
    /** Sets whether this is a required form element */
    get required(): boolean;
    set required(requiredVal: boolean | string);
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectComponent, "hc-multiselect", never, { "id": { "alias": "id"; "required": false; }; "valid": { "alias": "valid"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class MultiselectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiselectModule, [typeof MultiselectComponent], [typeof i2.CommonModule], [typeof MultiselectComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MultiselectModule>;
}

declare class MoreItem {
    name: string;
    uri: string;
    dropdown?: unknown;
}

/** Primary navigation links */
declare class NavbarLinkComponent {
    private el;
    private ref;
    _active: boolean | null;
    /** Forces active state. Overrides router state when set; to remove the override set to null. *Default is `null`.* */
    get active(): boolean | null;
    set active(value: boolean | null);
    /** RouterLink uri. See https://angular.io/api/router/RouterLink */
    uri: string;
    /** The text to display. This can also optionally be the contents within the element */
    linkText: string;
    /** Sets the RouterLinkActive options to match the url exactly to set active state. *Default is false.*
     * See https://angular.io/api/router/RouterLinkActive#description
     */
    exact: boolean;
    _hidden: boolean;
    constructor(el: ElementRef, ref: ChangeDetectorRef);
    /** Disable visibility of component from view */
    hide(): void;
    /** Enable visibility of component from view */
    show(): void;
    _getWidth(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarLinkComponent, "hc-navbar-link", never, { "active": { "alias": "active"; "required": false; }; "uri": { "alias": "uri"; "required": false; }; "linkText": { "alias": "linkText"; "required": false; }; "exact": { "alias": "exact"; "required": false; }; }, {}, never, ["*"], false, never>;
}

/** Navigation dropdown for small screen sizes */
declare class NavbarMobileMenuComponent {
    _openState: string;
    /** Slide the mobile menu down from under the navbar */
    show(): void;
    /** Slide the mobile menu back up under the navbar */
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarMobileMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarMobileMenuComponent, "hc-navbar-mobile-menu", never, {}, {}, never, ["*"], false, never>;
}

/** A dropdown menu in a `hc-navbar` */
declare class NavbarDropdownComponent extends NavbarLinkComponent implements AfterViewInit {
    _menuPop: HcPopComponent;
    /** Reference to hcMenuItems (if the content contains them) */
    _menuItems: QueryList<MenuItemDirective>;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarDropdownComponent, "hc-navbar-dropdown", never, {}, {}, ["_menuItems"], ["*"], false, never>;
}

/** The navbar is a wrapper that positions branding, navigation, and other elements in a concise header. */
declare class NavbarComponent implements AfterViewInit, OnDestroy {
    private ref;
    /** Display name of current user */
    user: string;
    /** Url to application logo image file */
    appIcon: string;
    /** Either url to brand icon image file or HcIcon object for a font glyph */
    brandIcon: string | HcIcon;
    /** Router link triggered when home icon is clicked */
    homeUri: unknown[] | string;
    /** Fixes the position of navbar to the top of the page. *Default is false.* */
    fixedTop: boolean;
    _mobileMenu: QueryList<NavbarMobileMenuComponent>;
    _navLinks: QueryList<NavbarLinkComponent | NavbarDropdownComponent>;
    _navbarContent: ElementRef;
    _navContent: ElementRef;
    _navbarMore: HcPopoverAnchorDirective;
    _morePop: HcPopComponent;
    private unsubscribe$;
    private _menuOpen;
    private _linkWidths;
    private _linksTotalWidth;
    _collapse: boolean;
    _moreList: Array<MoreItem>;
    /** Runs the initial calculation of navlink widths after the page has fully rendered */
    _setupNavLinks(): void;
    /** Subscribes to the changes to the set of links to refresh the More menu widths */
    ngAfterViewInit(): void;
    /** Forces a recalculation of the navbar links to determine how many should be rolling into a More menu.
     * Call this if you've updated the contents of any navbar links. */
    refreshNavLinks(): void;
    constructor(ref: ChangeDetectorRef);
    private _collectNavLinkWidths;
    ngOnDestroy(): void;
    _toggleMobileMenu(): void;
    _menuClick(event: Event): void;
    get _mobileMenuIcon(): string;
    _moreClick(): void;
    _brandIconType(): string;
    _brandIconSet(): string;
    _brandIconGlyph(): string;
    _brandIconSize(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarComponent, "hc-navbar", never, { "user": { "alias": "user"; "required": false; }; "appIcon": { "alias": "appIcon"; "required": false; }; "brandIcon": { "alias": "brandIcon"; "required": false; }; "homeUri": { "alias": "homeUri"; "required": false; }; "fixedTop": { "alias": "fixedTop"; "required": false; }; }, {}, ["_mobileMenu", "_navLinks"], ["hc-navbar-link, hc-navbar-dropdown", "*", "hc-navbar-cobrand", "hc-navbar-mobile-menu"], false, never>;
}

/** Element to add a co-branding image to the right of the navbar */
declare class NavbarCobrandComponent {
    _color: 'light' | 'dark';
    _imgHeight: string;
    _imgWidth: string;
    _hostClass: string;
    /** Defines the path for the co-branding image.
     * The image should be in landscape (horizontal) format; it will automatically be scaled to fit the navbar. */
    src: string;
    /** Sets the background for co-branding; use `light` for images that require a white background. Defaults to `light` */
    get color(): 'light' | 'dark';
    set color(val: 'light' | 'dark');
    /** Validate that the image will not be wider than 200px when scaled to 37px height; if not, scale the width rather than the height */
    _checkRatio(evt: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarCobrandComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarCobrandComponent, "hc-navbar-cobrand", never, { "src": { "alias": "src"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NavbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NavbarModule, [typeof NavbarComponent, typeof NavbarDropdownComponent, typeof NavbarLinkComponent, typeof NavbarMobileMenuComponent, typeof NavbarCobrandComponent], [typeof i2.CommonModule, typeof i3.RouterModule, typeof IconModule, typeof PopModule], [typeof NavbarComponent, typeof NavbarDropdownComponent, typeof NavbarLinkComponent, typeof NavbarMobileMenuComponent, typeof NavbarCobrandComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NavbarModule>;
}

/** Abstract class for common initialization functionality */
declare abstract class Initializable {
    /** Whether this directive has been marked as initialized. */
    _isInitialized: boolean;
    /**
     * List of subscribers that subscribed before the directive was initialized. Should be notified
     * during _markInitialized. Set to null after pending subscribers are notified, and should
     * not expect to be populated after.
     */
    _pendingSubscribers: Subscriber<never>[] | null;
    /**
     * Observable stream that emits when the directive initializes. If already initialized, the
     * subscriber is stored to be notified once _markInitialized is called.
     * @docs-private
     */
    initialized: Observable<never>;
    /**
     * Marks the state as initialized and notifies pending subscribers. Should be called at the end
     * of ngOnInit.
     * @docs-private
     */
    _markInitialized(): void;
    /** Emits and completes the subscriber stream (should only emit once). */
    _notifySubscriber(subscriber: Subscriber<never>): void;
}

/**
 * Change event object that is emitted when the user selects a
 * different page size or navigates to another page.
 */
declare class PageEvent {
    /** The current page index */
    pageNumber: number;
    /** Index of the page that was selected previously */
    previousPageNumber?: number;
    /** The current page size */
    pageSize: number;
    /** The current total number of items being paged */
    length: number;
}

/**
 * Base Pagination class for shared functionality
 * */
declare class BasePaginationComponent extends Initializable implements OnInit {
    static _DEFAULT_PAGE_SIZE: number;
    private _inputCheckTimeoutSet;
    /**
     * The total number of items to be paged through
     */
    get length(): number;
    set length(value: number);
    private _length;
    private _prevPageNumber?;
    private _pageNumber;
    /** The currently displayed page. *Defaults to 1.* */
    get pageNumber(): number;
    set pageNumber(value: number);
    /** Number of items to display on a page. *Defaults to 20.* */
    get pageSize(): number;
    set pageSize(value: number);
    private _prevPageSize?;
    private _pageSize;
    /** Event emitted when the paginator changes the page size or page index. */
    readonly page: EventEmitter<PageEvent>;
    /** Emits the new page number when the page number changes. */
    readonly pageNumberChange: EventEmitter<number>;
    /** Emits the new page size when the page size changes. */
    readonly pageSizeChange: EventEmitter<number>;
    ngOnInit(): void;
    private ensureInputCheckTimeoutSet;
    private shouldEmitPageNumberChangeEvent;
    private shouldEmitPageSizeChangeEvent;
    /**
     * The computed total number of pages
     */
    get totalPages(): number;
    get _isFirstPage(): boolean;
    get _isLastPage(): boolean;
    /**
     * Changes the page size so that the first item displayed on the page will still be
     * displayed using the new page size.
     *
     * For example, if the page size is 10 and on the second page (items indexed 11-20) then
     * switching so that the page size is 5 will set the third page as the current page so
     * that the 11th item will still be displayed.
     */
    _changePageSize(pageSize: number): void;
    _pageSizeUpdated(): void;
    private _sanitizePageNumber;
    private _emitPageEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<BasePaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BasePaginationComponent, "ng-component", never, { "length": { "alias": "length"; "required": false; }; "pageNumber": { "alias": "pageNumber"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "page": "page"; "pageNumberChange": "pageNumberChange"; "pageSizeChange": "pageSizeChange"; }, never, never, false, never>;
}

/** The pagination control enables the user to navigate across paged content.
 * Although commonly used with tables and data grids, this control may be used any place where paged data is used.
 * */
declare class PaginationComponent extends BasePaginationComponent implements OnInit {
    /** The set of provided page size options to display to the user. *Defaults to [10, 20, 50].* */
    get pageSizeOptions(): number[];
    set pageSizeOptions(value: number[]);
    private _pageSizeOptions;
    isFocused: boolean;
    _pageSizeControl: FormControl<number>;
    /** Displayed set of page size options. Will be sorted and include current page size. */
    _displayedPageSizeOptions: number[];
    /** Sets the controller to a specific width type - `lg`, `md`, or `sm`. Typically adjusted in a window
     * resize listener for responsive layouts. *Defaults to lg.* */
    displayWidth: 'lg' | 'md' | 'sm';
    /** Whether to hide the page size selection UI from the user. *Defaults to false.* */
    get hidePageSize(): boolean;
    set hidePageSize(value: boolean);
    private _hidePageSize;
    /** If true, remove all default padding and margin. *Defaults to `false`.*  */
    tight: boolean;
    ngOnInit(): void;
    get _visiblePages(): Array<number | null>;
    get _collapsedVisiblePages(): Array<number | null>;
    _pageSizeUpdated(): void;
    _previousPage(): void;
    _goToPage(pageNum: number): number;
    _nextPage(): void;
    /**
     * Changes the page size so that the first item displayed on the page will still be
     * displayed using the new page size.
     *
     * For example, if the page size is 10 and on the second page (items indexed 11-20) then
     * switching so that the page size is 5 will set the third page as the current page so
     * that the 11th item will still be displayed.
     */
    _changePageSize(pageSize: number): void;
    /**
     * Updates the list of page size options to display to the user. Includes making sure that
     * the page size is an option and that the list is sorted.
     */
    private _updateDisplayedPageSizeOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "hc-pagination", never, { "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "displayWidth": { "alias": "displayWidth"; "required": false; }; "hidePageSize": { "alias": "hidePageSize"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; }, {}, never, never, false, never>;
}

/** A simple "load more" pagination button. */
declare class LoadMorePaginationComponent extends BasePaginationComponent implements OnInit {
    /**
     * Text to show on the button. *Defaults to 'Load more'.*
     */
    buttonText: string;
    /** Sets style of button. Choose from: `'primary' | 'primary-alt' | 'destructive' | 'neutral' | 'secondary' | 'link' | 'link-inline'`.
     * *Defaults to `'secondary'`.*
     */
    get buttonStyle(): string;
    set buttonStyle(btnStyle: string);
    private _style;
    _loadNextPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadMorePaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadMorePaginationComponent, "hc-load-more-pagination", never, { "buttonText": { "alias": "buttonText"; "required": false; }; "buttonStyle": { "alias": "buttonStyle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PaginationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginationModule, [typeof PaginationComponent, typeof LoadMorePaginationComponent, typeof BasePaginationComponent], [typeof i2.CommonModule, typeof ButtonModule, typeof IconModule, typeof SelectModule, typeof i4.ReactiveFormsModule], [typeof PaginationComponent, typeof LoadMorePaginationComponent, typeof BasePaginationComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PaginationModule>;
}

/**
 * @type
 * @docs-private
 */
type PicklistValueType = 'values' | 'valuesets' | 'both';
/** Represents a simple picklist option. */
interface IValueOption {
    /** Any unique string identifier. */
    code: string;
    /** The name of the option that will be displayed in the UI. */
    title: string;
}
/** Represents a collection or bundle of picklist options. */
interface IValueSetOption extends IValueOption {
    /** Number of subvalues. Required because of the fact that `subValues` isn't always preloaded. */
    subValueCount: number;
    /** Collection of values in this value set. The code and title of each subvalue should match what
     * is used by the value when used outside of a valueset. Note: The `subValues` array can initially be
     * empty if the `getValuesForValueset` callback function is provided. */
    subValues: IValueOption[];
}
interface IPicklistOptions {
    /** A collection of values. */
    values: IValueOption[];
    /** A collection of value sets, which may or may not be pre-seeded with its subvalues. */
    valueSets: IValueSetOption[];
}
interface IPicklistSettings {
    /** True if code is considered important. If so, search and sorting will use the code. *Defaults to false.* */
    codeIsSignificant?: boolean;
    /** Set to true to use valuesets. *Defaults to false.* */
    useValuesets?: boolean;
    /** Set to true to show text in the header. *Defaults to true.* */
    showHeaderText?: boolean;
    /** Text for left header. *Defaults to "Available".* */
    leftHeaderText?: string;
    /** Text for right header. *Defaults to "Selected".* */
    rightHeaderText?: string;
    /** How to sort options in the pane. Options: `asc` | `desc` | `none`; *Defaults to `none`.* */
    sort?: string;
    /** Pre-seed the modal with selected options. */
    selected?: IPicklistOptions;
    /** Available options in the picklist. Set with local values or callbacks to retrieve remote values. */
    options?: IPicklistOptionsSource;
}
interface IPicklistOptionsSource {
    /** Collection of values to select from. */
    values?: IValueOption[];
    /** Collection of value sets to select from. */
    valueSets?: IValueSetOption[];
    /** Will the results from the server be paged? *Defaults to false.* Not used without `getOptions` callback. */
    isPaged?: boolean;
    /** What size results will be returned from the server? *Defaults to 100.* Not used without `getOptions` callback. */
    pageSize?: number;
    /** Callback function retrieve values. */
    getOptions?: (params: PicklistRemoteQueryOptions) => Observable<IPicklistRemoteQueryResponse>;
    /** Callback function to retrieve values for a value set. */
    getValuesForValueset?: (code: string) => Observable<IValueOption[]>;
}
/**
 * @docs-private
 */
declare class PicklistOptionsSource implements IPicklistOptionsSource {
    values: IValueOption[];
    valueSets: IValueSetOption[];
    isPaged: boolean;
    pageSize: number;
    getOptions?: (params: PicklistRemoteQueryOptions) => Observable<IPicklistRemoteQueryResponse>;
    getValuesForValueset?: (code: string) => Observable<IValueOption[]>;
    optionsAreLocal(): boolean;
}
/**
 * @docs-private
 */
declare class PicklistSettings implements IPicklistSettings {
    codeIsSignificant: boolean;
    useValuesets: boolean;
    showHeaderText: boolean;
    leftHeaderText: string;
    rightHeaderText: string;
    sort: string;
    selected: {
        values: IValueOption[];
        valueSets: IValueSetOption[];
    };
    options: PicklistOptionsSource;
}
/** Interface to be used as part of the response when loading values over HTTP. */
interface IPagedCollection<IT> {
    /** Page being returned in the response, and the number of items per page. */
    pagerSettings: IPageSettings;
    /** Total number of items, including those already on the client or included in this response. */
    totalItems: number;
    /** Total number of pages. */
    totalPages: number;
    /** An array of `IValueOption` or `IValuesetOption`. */
    values: IT[];
}
interface IPageSettings {
    /** Current page of the request or response. */
    currentPage: number;
    /** Total number of items on a page */
    itemsPerPage: number;
}
/** Interface to be used for the response when loading values over HTTP. This the type your `getOptions()` callback should return. */
interface IPicklistRemoteQueryResponse {
    /** Paged collection of `IValueOptions`. Only used if this picklist has `optionSource.isPaged` set to true. */
    pagedValues?: IPagedCollection<IValueOption>;
    /** Paged collection of `IValueSetOptions`. Only used if this picklist has `optionSource.isPaged` set to true. */
    pagedValueSets?: IPagedCollection<IValueSetOption>;
    /** An array of `{ code: string, title: string}`. Only used if this picklist has `optionSource.isPaged` set to false. */
    values?: Array<IValueOption>;
    /** An array of `{ code: string, title: string, subValueCount: number, subValues: IValueOption[]}`.
     * Only used if this picklist has `optionSource.isPaged` set to false. Note: The `subValues` array can
     * initially be empty if the `getValuesForValueset` callback function is provided. */
    valueSets?: Array<IValueSetOption>;
}
/** An instance of this class will be sent to the `getOptions()` callback if loading values over HTTP. */
declare class PicklistRemoteQueryOptions {
    /** The settings for this picklist. Particularly, `codeIsSignificant`, `useValuesets`,
     * and selected values will be useful in obtaining the needed values & value sets. */
    picklist: IPicklistSettings;
    /** Search term entered by the user that triggered the request. */
    searchTerm: string;
    /** Which types of values should we be getting? */
    valueTypeToQuery: PicklistValueType;
    /** Page and number of items per page requested for values. */
    valuePageSettings?: IPageSettings;
    /** Page and number of items per page requested for value sets. */
    valueSetPageSettings?: IPageSettings;
    constructor(
    /** The settings for this picklist. Particularly, `codeIsSignificant`, `useValuesets`,
     * and selected values will be useful in obtaining the needed values & value sets. */
    picklist: IPicklistSettings, 
    /** Search term entered by the user that triggered the request. */
    searchTerm: string, 
    /** Which types of values should we be getting? */
    valueTypeToQuery: PicklistValueType);
}

declare class FilterableSelectList<T extends SelectListOption> {
    options: Map<string, T>;
    selectedOptions: Map<string, T>;
    lastClickedOption: T | null;
    filteredOptions: T[];
    isActive: boolean;
    additionalRemoteOptions: number;
    loadingOptions: Observable<boolean>;
    appendingOptions: Observable<boolean>;
    codeIsSignificant: boolean;
    sort: string;
    constructor(options?: Map<string, T>);
}
declare class SubSelectList extends FilterableSelectList<ValueListOption> {
    parentValueSet: ValueSetListOption;
    options: Map<string, ValueListOption>;
    constructor(parentValueSet: ValueSetListOption, options?: Map<string, ValueListOption>);
}
declare class SelectListOption {
    option: any;
    code: string;
    selected: boolean;
    constructor(option: any, code: string);
}
declare class ValueListOption extends SelectListOption {
    constructor(option: IValueOption, code: string);
}
declare class ValueSetListOption extends SelectListOption {
    subValuesSelectList: SubSelectList;
    showValues: boolean;
    loadingValues: boolean;
    constructor(option: IValueSetOption, code: string);
}
declare class PicklistValueOptions {
    values: Map<string, ValueListOption>;
    valueSets: Map<string, ValueSetListOption>;
}

declare class PicklistFilterLocalService {
    filter<T extends SelectListOption>(list: FilterableSelectList<T>, searchTokens: string[]): void;
    itemHasSearchTokens<T extends SelectListOption>(list: FilterableSelectList<T>, item: T, searchTokens: string[]): boolean;
    private getSortFunc;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistFilterLocalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistFilterLocalService>;
}

declare class PicklistStateService {
    private localFilterService;
    pane: PicklistPaneComponent;
    picklist: PicklistSettings;
    optionsSource: PicklistOptionsSource;
    valueList: FilterableSelectList<ValueListOption>;
    valueSetList: FilterableSelectList<ValueSetListOption>;
    constructor(localFilterService: PicklistFilterLocalService);
    reset(settings: PicklistSettings, optionsSource: PicklistOptionsSource, pane: PicklistPaneComponent): void;
    updateValueList(options: IValueOption[], searchTokens?: string[]): void;
    updateValueSetList(options: IValueSetOption[], searchTokens?: string[]): void;
    clearList<T extends SelectListOption>(list: FilterableSelectList<T>): void;
    private updateList;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistStateService>;
}

declare class PicklistFilterRemoteService {
    private stateService;
    filterService?: PicklistFilterService;
    get valueList(): FilterableSelectList<ValueListOption>;
    get valueSetList(): FilterableSelectList<ValueSetListOption>;
    get searchTerm(): string;
    currentValuePage: number;
    currentValueSetPage: number;
    private cancelSearch;
    private get cancelSearch$();
    private options$;
    constructor(stateService: PicklistStateService);
    reset(filterService: PicklistFilterService): void;
    filter(type?: PicklistValueType, shouldAppend?: boolean, selectAllCount?: number | null): Subscription;
    private processIncomingRemoteOptions;
    private processPagedValues;
    private processPagedValueSets;
    private buildRemoteQueryParams;
    private buildPageSettings;
    private resetPagingForSelectAllIfNeeded;
    private clearLists;
    private clearFilteredOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistFilterRemoteService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistFilterRemoteService>;
}

declare class PicklistFilterService {
    private workTracker;
    private stateService;
    private remoteFilterService;
    private localFilterService;
    get valueList(): FilterableSelectList<ValueListOption>;
    get valueSetList(): FilterableSelectList<ValueSetListOption>;
    get searchTokens(): string[];
    searchTerm: string;
    constructor(workTracker: WorkTrackerService, stateService: PicklistStateService, remoteFilterService: PicklistFilterRemoteService, localFilterService: PicklistFilterLocalService);
    reset(): void;
    runFilter(searchTerm: string): void;
    filterOptionsRemote(type?: PicklistValueType, shouldAppend?: boolean, selectAllCount?: number | null): Subscription;
    loadMore(type?: PicklistValueType, autoLoadMore?: boolean): void;
    loadForSelectAll(numberToLoad: number): Observable<boolean>;
    reloadIfEmpty(): void;
    preFilterOptionsForRemoteMode(valuesMap: Map<string, SelectListOption>, list: FilterableSelectList<SelectListOption>): void;
    showListLoadingIndicators(workTracker: Observable<boolean>, type?: PicklistValueType, isAppending?: boolean): void;
    private showLoadingIndicatorForList;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistFilterService>;
}

declare class PicklistValuesetMovingService {
    private filterService;
    private stateService;
    get valueList(): FilterableSelectList<ValueListOption>;
    get valueSetList(): FilterableSelectList<ValueSetListOption>;
    constructor(filterService: PicklistFilterService, stateService: PicklistStateService);
    moveOutValuesets(optionsToMove: PicklistValueOptions, pane: PicklistPaneComponent, shouldBreakValuesets?: boolean): void;
    private breakValueset;
    private moveSubValues;
    /**
     * Handles complex logic for when one pane is paged, and we want to keep the "x of y" counts accurate without a round trip to the server
     */
    private removeValuesFromPane;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistValuesetMovingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistValuesetMovingService>;
}

/**
 * Handles loading + moving items to/from list
 */
declare class PicklistOldService {
    private workTracker;
    private filterService;
    private localFilterService;
    private valuesetMovingService;
    private stateService;
    get pane(): PicklistPaneComponent;
    get picklist(): PicklistSettings;
    get optionsSource(): PicklistOptionsSource;
    get valueList(): FilterableSelectList<ValueListOption>;
    get valueSetList(): FilterableSelectList<ValueSetListOption>;
    get totalValuesCount(): number;
    get totalValueSetsCount(): number;
    constructor(workTracker: WorkTrackerService, filterService: PicklistFilterService, localFilterService: PicklistFilterLocalService, valuesetMovingService: PicklistValuesetMovingService, stateService: PicklistStateService);
    reset(settings: PicklistSettings, optionsSource: PicklistOptionsSource, pane: PicklistPaneComponent): void;
    addOptions(listOptions: PicklistValueOptions): void;
    moveOutSelectedOptions(shouldBreakValuesets?: boolean): PicklistValueOptions;
    loadValuesForValueset(valueset: ValueSetListOption): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistOldService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistOldService>;
}

declare class PicklistActionService {
    private listService;
    get valueList(): FilterableSelectList<ValueListOption>;
    get valueSetList(): FilterableSelectList<ValueSetListOption>;
    constructor(listService: PicklistOldService);
    onItemClicked<T extends SelectListOption>(event: MouseEvent, index: number, list: FilterableSelectList<T>, item: T): void;
    onItemDoubleClicked<T extends SelectListOption>(event: MouseEvent, list: FilterableSelectList<T>, item: T): void;
    onValuesetCaretClicked(event: MouseEvent, valueset: ValueSetListOption): void;
    selectAll(): void;
    selectNone(): void;
    selectAllInList<T extends SelectListOption>(list: FilterableSelectList<T>): void;
    private clearListSelection;
    private shiftClick;
    private ctrlClick;
    private deselectItem;
    private selectItem;
    private toggleItemSelection;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistActionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistActionService>;
}

declare class PicklistPaneComponent {
    listService: PicklistOldService;
    actionService: PicklistActionService;
    filterService: PicklistFilterService;
    emptyMsg: string;
    moveSelectedItems: EventEmitter<PicklistPaneComponent>;
    listContainerEl: ElementRef | undefined;
    searchInputEl: ElementRef | undefined;
    companion: PicklistPaneComponent | null;
    shouldExcludeCompanion: boolean;
    codeIsSignificant: boolean;
    searchTerm: string;
    searchTermStream: Subject<string>;
    selectAllWasLastClicked: boolean;
    selectAllLimit: number;
    constructor(listService: PicklistOldService, actionService: PicklistActionService, filterService: PicklistFilterService);
    reset(source: PicklistOptionsSource, settings: PicklistSettings, companion: PicklistPaneComponent, excludeCompanion?: boolean): void;
    get valueList(): FilterableSelectList<ValueListOption>;
    get valueSetList(): FilterableSelectList<ValueSetListOption>;
    get isPaged(): boolean;
    get optionsAvailableCount(): number;
    get PicklistValueOptionsTotal(): number;
    get valueSetOptionsTotal(): number;
    get optionsShowingCount(): number;
    get showTooManyToSelectAllMsg(): boolean;
    shouldShowList<T extends SelectListOption>(list: FilterableSelectList<T>): boolean;
    listIsFilteredToEmpty<T extends SelectListOption>(list: FilterableSelectList<T>): boolean;
    isAnySelected(): boolean;
    focusSearch(): void;
    scrollToTop(): void;
    onSearchKeyup(): void;
    onItemClicked<T extends SelectListOption>(event: MouseEvent, index: number, list: FilterableSelectList<T>, item: T): void;
    preventIEHighlightBug(): void;
    onValuesetCaretClicked(event: MouseEvent, valueset: ValueSetListOption): void;
    triggerLoadMore(type: PicklistValueType): void;
    onItemDoubleClicked<T extends SelectListOption>(event: MouseEvent, list: FilterableSelectList<T>, item: T): void;
    selectAll(): void;
    selectNone(): void;
    private loadAndSelectAll;
    private pagingValueList;
    private wireUpSearch;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistPaneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PicklistPaneComponent, "hc-picklist-pane", never, { "emptyMsg": { "alias": "emptyMsg"; "required": false; }; }, { "moveSelectedItems": "moveSelectedItems"; }, never, never, false, never>;
}

declare class PicklistOldComponent implements ControlValueAccessor {
    /**
     * Settings for the picklist. Internally, this will trigger a call to `reset()`.
     */
    set settings(settings: PicklistSettings);
    get settings(): PicklistSettings;
    /**
     * An array of unique strings to be used as the picklist options.
     */
    set simpleOptions(options: Array<string> | null);
    get simpleOptions(): Array<string> | null;
    /**
     * Set to true to show text in the header. *Defaults to true.*
     */
    set showHeaderText(shouldShow: boolean);
    get showHeaderText(): boolean;
    /**
     * Text for left header. *Defaults to "Available".*
     */
    set leftHeaderText(text: string);
    get leftHeaderText(): string;
    /**
     * Text for right header. *Defaults to "Selected".*
     */
    set rightHeaderText(text: string);
    get rightHeaderText(): string;
    /**
     * How to sort options in the pane. Options: `asc` | `desc` | `none`; *Defaults to `none`.*
     */
    set sort(sort: string);
    get sort(): string;
    _available: PicklistPaneComponent | undefined;
    _confirmed: PicklistPaneComponent | undefined;
    /** Fired when a change is made to the picklist selection. */
    changed: EventEmitter<any>;
    private picklistSettings;
    get _leftToRightMoveBtnIsDisabled(): boolean;
    private stringOptions;
    /**
     * Current selected value of the picklist. Will be either `IPicklistOptions` or `string[]` depending on the type of options provided.
     */
    set value(model: IPicklistOptions | string[]);
    get value(): IPicklistOptions | string[];
    onChange: (value: unknown) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    writeValue(value: IPicklistOptions | string[]): void;
    /**
     * Will update the picklist with the given settings, maintaining any previous settings that have not been overridden.
     */
    update(settings: IPicklistSettings): void;
    /**
     * Will reset the picklist settings with the given settings. (Clears out any previous settings.)
     */
    reset(settings?: IPicklistSettings): void;
    /**
     * Will change the active tab. (Will do nothing if `settings.useValuesets` is false.)
     */
    setActiveValueType(type: 'values' | 'valueSets'): void;
    /**
     * Will move all selected items from the given pane into its companion pane. Used internally by the left and right arrow buttons.
     * @param pane the pane from which we are moving items out of
     */
    moveSelectedItems(pane: PicklistPaneComponent): void;
    private updateStateFromStringOptions;
    private resetPanes;
    private applyChangeToModel;
    private convertStringsToValueOptions;
    private picklistModelisArray;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistOldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PicklistOldComponent, "hc-picklist-old", never, { "settings": { "alias": "settings"; "required": false; }; "simpleOptions": { "alias": "simpleOptions"; "required": false; }; "showHeaderText": { "alias": "showHeaderText"; "required": false; }; "leftHeaderText": { "alias": "leftHeaderText"; "required": false; }; "rightHeaderText": { "alias": "rightHeaderText"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, { "changed": "changed"; }, never, never, false, never>;
}

declare class PicklistOldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistOldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PicklistOldModule, [typeof PicklistPaneComponent, typeof PicklistOldComponent], [typeof i2.CommonModule, typeof i4.FormsModule, typeof ButtonModule, typeof IconModule, typeof InputModule, typeof FormFieldModule, typeof ProgressIndicatorsModule], [typeof PicklistPaneComponent, typeof PicklistOldComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PicklistOldModule>;
}

type SelectionModelFactory = () => PickSelectionModel;
/** @docs-private */
interface PickSelectionModel {
    value: PickOption[];
    select(item: PickOption): any;
    unselect(item: PickOption): any;
    clear(keepDisabled: boolean): any;
    selectAll(items: Array<PickOption>, canSelectGroup: boolean): any;
}

/** @docs-private */
declare class PickOption {
    [name: string]: unknown;
    /** zero-based position in the list */
    index?: number;
    /** used as the id for the DOM element representing this option */
    htmlId?: string;
    /** true if the option is highlighted in its pane */
    selected?: boolean;
    /** true if the option should not be available for interaction */
    disabled?: boolean;
    /** true if the option currently has focus in the list */
    marked?: boolean;
    /** the display name for the option */
    label?: string;
    /** the option given to the form or NgModel for this option */
    value?: any;
    /** reference to this option's parent option */
    parent?: PickOption;
    /** identifier for the group. typically a string, but can be an HcOption if items provided to the
     * component were grouped before being passed in */
    groupKey?: string | PickOption;
    /** collection of nested HcOptions */
    children?: PickOption[];
    /** true if this group should be collapsed in the UI*/
    isClosed: boolean;
    get isChild(): boolean;
    get isParent(): boolean;
    constructor(config: IPickOption);
    toggleOpenState(event: MouseEvent): void;
}
type IPickOption = Partial<PickOption>;
type AddCustomItemFn = ((term: string) => any | Promise<any>);
type CompareWithFn = (a: any, b: any) => boolean;
type GroupValueFn = (key: string | Record<string, any>, children: any[]) => string | Record<string, any>;
type GroupByFn = (item: any) => any;
type SortFn = (a: PickOption, b: PickOption) => number;
type SearchFn = (term: string, item: any) => boolean;
type TrackByFn = <U>(index: number, item: U) => U;

/** Helps manage the state of the list */
declare class ItemsList {
    private _pickPane;
    private _selectionModel;
    constructor(_pickPane: PickPaneComponent, _selectionModel: PickSelectionModel);
    get itemsShownCountStr(): string;
    private _itemsShownCountStr;
    get itemsTotalCountStr(): string;
    private _itemsTotalCountStr;
    get itemsTotalCount(): number;
    private _itemsTotalCount;
    /** containts all items in the list, including parent items */
    get items(): Array<PickOption>;
    private _items;
    get filteredItems(): Array<PickOption>;
    private _filteredItems;
    private _optionGroups;
    private readonly DEFAULT_GROUP_KEY;
    private _markedIndex;
    /** Represents the "focused" item */
    get markedIndex(): number;
    /** Return true if some item in the list should have focus. -1 means nothing is focused. */
    get hasMarkedItem(): boolean;
    /** The highlighted options in this list */
    get selectedItems(): Array<PickOption>;
    /** The HcOption that currently has focus */
    get markedItem(): PickOption;
    /** The last option in the list to be highlighted */
    get lastSelectedItem(): PickOption | null;
    /** Remove all options from the list */
    clearList(): void;
    /** Converts an array of raw values into HcOptions and set them on the list */
    setItems(items: any[]): void;
    /** Reset the indexes on each HcOption */
    reIndex(): void;
    /** Highlight a given option in the list */
    select(item: PickOption): void;
    /** Remove highlight from a given option in the list */
    unselect(item: PickOption): void;
    /**
     * Find the option in this list for a given value
     */
    findOption(value: any): PickOption | undefined;
    /** Adds an existing HcOption to the list. */
    addOption(option: PickOption): void;
    /** Removes an existing HcOption from the list */
    removeOption(option: PickOption): void;
    /** Create a new HcOption and add it to the list from a given raw value. Also returns the newly created option */
    addNewOption(item: unknown): PickOption;
    /** Maps the given raw value into an HcOption. */
    _createHcOption(item: any, index?: number): PickOption;
    private _deleteItem;
    /** Create item groups. If we're not grouping, everything just gets placed in one default group. */
    private _groupItems;
    /** If a sort function was provided, sort at the child and group level*/
    private _sortOptions;
    /**
     * Removed highlight from all items in the list.
     * @param keepDisabled if true, don't deselect any options that are currently disabled
    */
    clearSelected(keepDisabled?: boolean): void;
    /** Highlight all the items in the list */
    selectAll(): void;
    /** Find an item in the list by its label */
    findByLabel(term: string): PickOption | undefined;
    /** Filter the options in the list with the given search term */
    filter(term: string): void;
    resetFilteredItemsForCustomOptionAdded(isRemoteFilter: boolean, searchTerm: string): void;
    /** Unfilter the list */
    resetFilteredItems(): void;
    /** Wipe out selection state and marked state, then mark the first selectable option */
    resetListSelectionState(): void;
    /** Remove focus from any of the options */
    unmark(): void;
    /** Move focus up or down in the list */
    markNextItem(stepIsDown: boolean): void;
    /** Focus the given item in the list */
    markItem(item: PickOption): void;
    /** Focus on the last selected item, or the first item in the list */
    markSelectedOrDefault(): void;
    /** Unmarks what ever is currently marked and then marks the first selectable item */
    markFirst(): void;
    /** Obtain a nested value from a given object. It could be a direct property, or a nested property */
    resolveNested(option: any, key: string): any;
    /** Update the 'Showing x of y' counts */
    updateCounts(): void;
    /** If picklist is not configured with a search function, use this one. */
    private _defaultSearchFn;
    /** Get index of an item a given number of steps above or below the current focus item */
    private _getNextItemIndex;
    /** Move focus a certain number of steps above or below the current focused item */
    private _stepToItem;
    /** Find the index of the item in the list was marked most recently */
    private _getLastMarkedIndex;
    /** Group the items in the list as configured */
    private _groupBy;
    /** Creates parent HcOption as needed */
    private _createParentHcOptions;
    private createOptionGroup;
    private getStringForKey;
    private sortAndIndex;
}

interface ItemsRangeResult {
    scrollHeight: number;
    topPadding: number;
    start: number;
    end: number;
}
interface PanelDimensions {
    itemHeight: number;
    panelHeight: number;
    itemsPerViewport: number;
}
declare class PickPaneListService {
    private _dimensions;
    get dimensions(): PanelDimensions;
    calculateItems(scrollPos: number, itemsLength: number, buffer: number): ItemsRangeResult;
    setDimensions(itemHeight: number, panelHeight: number): void;
    getScrollTo(itemTop: number, itemHeight: number, lastScroll: number): number | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneListService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PickPaneListService>;
}

declare class PickPaneListComponent implements OnInit, OnChanges, OnDestroy {
    private _zone;
    private _panelService;
    items: PickOption[];
    markedItem: PickOption;
    bufferAmount: number;
    virtualScroll: boolean;
    filterValue: string;
    update: EventEmitter<PickOption[]>;
    scroll: EventEmitter<{
        start: number;
        end: number;
    }>;
    scrollToEnd: EventEmitter<void>;
    contentElementRef: ElementRef;
    scrollElementRef: ElementRef;
    paddingElementRef: ElementRef;
    readonly _panel: HTMLElement;
    private readonly _destroy$;
    private _virtualPadding;
    private _scrollablePanel;
    private _contentPanel;
    private _scrollToEndFired;
    private _updateScrollHeight;
    private _lastScrollPosition;
    constructor(_zone: NgZone, _panelService: PickPaneListService, _elementRef: ElementRef);
    private _itemsLength;
    private get itemsLength();
    private set itemsLength(value);
    private get _startOffset();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    scrollTo(option: PickOption, startFromOption?: boolean): void;
    scrollToCustomOption(): void;
    refreshListLayout(isInitialList: boolean): void;
    private _handleScroll;
    private _onItemsChange;
    private _updateItems;
    private _updateItemsRange;
    private _onContentScrolled;
    private _updateVirtualHeight;
    private _setVirtualHeight;
    private _onItemsLengthChanged;
    private _renderItemsRange;
    private _measureDimensions;
    private _fireScrollToEnd;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PickPaneListComponent, "hc-pick-pane-list", never, { "items": { "alias": "items"; "required": false; }; "markedItem": { "alias": "markedItem"; "required": false; }; "bufferAmount": { "alias": "bufferAmount"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; }, { "update": "update"; "scroll": "scroll"; "scrollToEnd": "scrollToEnd"; }, never, ["*"], false, never>;
}

declare class PicklistService {
    availablePane: PickPaneComponent;
    selectedPane: PickPaneComponent;
    reset(availablePane: PickPaneComponent, selectedPane: PickPaneComponent): void;
    /** When the option/items are updated, update corresponding selected options in the selected pane.
     *  Make sure they aren't duplicated in the available pane */
    mapIncomingOptionsToSelected(bindValue?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PicklistService>;
}

declare class PickPaneDragService {
    private pane;
    reset(pane: PickPaneComponent): void;
    drag(event: DragEvent, list: ItemsList, item: PickOption): void;
    allowDrop(event: DragEvent): void;
    drop(event: DragEvent): void;
    dragEnd(): void;
    dragLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneDragService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PickPaneDragService>;
}

/** @docs-private */
declare class PickPaneComponent implements OnChanges {
    private picklistService;
    private _cd;
    dragService: PickPaneDragService;
    _isLeftPane: boolean;
    bindLabel: string;
    bindValue: string;
    addCustomItem: boolean | AddCustomItemFn | undefined;
    addCustomItemText: string;
    groupBy: string | GroupByFn | undefined;
    groupValue: GroupValueFn | undefined;
    canSelectGroup: boolean;
    canCloseGroup: boolean;
    closeGroupsByDefault: boolean;
    orphanItemsGroupName: string;
    virtualScroll: boolean;
    bufferAmount: number;
    trackByFn: TrackByFn;
    sortFn: SortFn | undefined;
    readonly: boolean;
    hasSearch: boolean;
    searchPlaceholder: string;
    searchFn: SearchFn | undefined;
    searchWhileComposing: boolean;
    externalSearchTermMinLength: number;
    externalSearchSubject: Subject<string>;
    externalTotalOptionCount: number;
    notFoundText: string;
    loading: boolean;
    hasToolbar: boolean;
    hasFooter: boolean;
    escapeHTML: boolean;
    get items(): unknown[];
    set items(value: unknown[]);
    get compareWith(): CompareWithFn;
    set compareWith(fn: CompareWithFn);
    optionTemplate: TemplateRef<unknown>;
    optgroupTemplate: TemplateRef<unknown>;
    toolbarTemplate: TemplateRef<unknown>;
    footerTemplate: TemplateRef<unknown>;
    customItemTemplate: TemplateRef<unknown>;
    /** Fires when option are being moved via an enter keypress. */
    triggerMove: EventEmitter<any>;
    /** Fires when search is triggered on the pane. */
    search: EventEmitter<{
        term: string;
        items: unknown[];
    }>;
    /** Fires when pane is scrolled. */
    scroll: EventEmitter<{
        start: number;
        end: number;
    }>;
    /** Fires when pane has been scrolled to the bottom. */
    scrollToEnd: EventEmitter<any>;
    dropdownPanel: PickPaneListComponent;
    searchInput: ElementRef<HTMLInputElement>;
    /** Object that manages the state of the list. */
    itemsList: ItemsList;
    /** items displayed in the viewport. important for virtual scrolling */
    viewPortItems: PickOption[];
    /** what this pane is being filtered by */
    searchTerm: string;
    /** unique identifier used as the HTML id on the list element */
    paneId: string;
    element: HTMLElement;
    /** true if an item is being dragged from this pane */
    _isDragging: boolean;
    /** true if the pane has an item being dragged over it from another pane */
    _willAcceptDrop: boolean;
    /** true if the item list has focus.
     * using this property and adding a css class works more smoothly than relying on :focus psuedo selector */
    _paneHasFocus: boolean;
    get disabled(): boolean;
    get externalOptionCountStr(): string | null;
    get _companionPane(): PickPaneComponent;
    useDefaultClass: boolean;
    private _items;
    private _disabled;
    private _defaultLabel;
    private _primitive;
    private _compareWith;
    private _isComposing;
    constructor(newSelectionModel: SelectionModelFactory, _elementRef: ElementRef<HTMLElement>, picklistService: PicklistService, _cd: ChangeDetectorRef, dragService: PickPaneDragService);
    get selectedItems(): PickOption[];
    get selectedValues(): unknown;
    get hasSelectedItems(): boolean;
    ngOnChanges(changes: SimpleChanges): void;
    /** Called when a key is pressed in the search input box */
    onSearchKeydown($event: KeyboardEvent): void;
    /** Called when a key is pressed while the list has focus */
    onPanelKeydown($event: KeyboardEvent): void;
    /** Place focus on the list pane */
    panelFocus(): void;
    /** Remove focus from the list pane */
    panelBlur(): void;
    /** Focus on the first item in the list, scrolling as needed */
    private _jumpFocusToFirstItem;
    /** Moves focus, or moves or expands the highlighted options in the list */
    private _handlePanelArrowKeyPress;
    /** Selects a given item, scrolling to keep it in the viewport as needed */
    private _selectAndScrollToItem;
    /** Remove highlight from all items in the list */
    deselectAll(): void;
    /** Highlight all items in the list */
    selectAll(): void;
    /**
     * Shift + click selects a range
     * Ctrl + click adds to current selection
     * Regular click clears current selection and selects anew
     */
    onItemClick($event: MouseEvent, item: PickOption): void;
    /** Selects items as needed, and moves options to the companion pane */
    onItemDoubledClicked($event: MouseEvent, item: PickOption): void;
    /** If not already selected, selects a given item if that option or the entire pane are not disabled */
    select(item: PickOption): void;
    /** If not already unselected, unselects a given item if that option or the entire pane are not disabled */
    unselect(item: PickOption): void;
    /** Place focus in the searchbar, or the list if searchbar is not available */
    focus(): void;
    /** Remove focus from searchbar and list */
    blur(): void;
    /** Create as custom item from a search term that didn't match available options from either pane */
    addAndSelectCustomOption(): void;
    /** Convert the given custom item into an HcOption, add it to the list, and then highlight it */
    _selectNewCustomOption(customItem: unknown): void;
    /** Used in the ngFor of the list to maximize DOM reusage */
    trackByOption: (_: number, item: PickOption) => PickOption;
    /** If true, the "add custom" option should be displayed */
    get showAddCustomOption(): boolean | AddCustomItemFn | undefined;
    /** If true, the "add custom" option currently has focus */
    get addCustomOptionIsMarked(): boolean | undefined;
    /** If true, the empty pane message should be displayed */
    get showNoItemsFound(): boolean | string;
    /** Called when user begins typing in the searchbox */
    _onCompositionStart(): void;
    /** Called when user finsihes typing in the searchbox */
    _onCompositionEnd(term: string): void;
    /** Search the items in the list */
    filter(term?: string): void;
    /** Force change detection to refresh the UI */
    detectChanges(): void;
    /** Refreshes the dimensions of the virtual scroll container and the items displayed within */
    refreshScrollArea(): void;
    /** Creates HcOptions according to the configured options, sets them on this list, and selects the first option. */
    _setItems(items: unknown[]): void;
    /** Clear out search term if any and refresh the list */
    clearSearch(): void;
    /** Update search term and notify external search as needed */
    private _changeSearch;
    /** Scroll the list to he currently "focused" item. */
    private _scrollToMarked;
    /** Scroll the list to the option a user can select to create a custom option */
    private _scrollToCustomItem;
    /** Returns true if the next item that would be highlighted is the "add custom" option */
    private _nextItemIsCustomItem;
    /** Returns true if external search is being used */
    private get _isUsingSearchSubject();
    /** Returns true if the search term is long enough to be considered valid */
    private get _validTerm();
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PickPaneComponent, "hc-pick-pane", never, { "_isLeftPane": { "alias": "_isLeftPane"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "addCustomItem": { "alias": "addCustomItem"; "required": false; }; "addCustomItemText": { "alias": "addCustomItemText"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "groupValue": { "alias": "groupValue"; "required": false; }; "canSelectGroup": { "alias": "canSelectGroup"; "required": false; }; "canCloseGroup": { "alias": "canCloseGroup"; "required": false; }; "closeGroupsByDefault": { "alias": "closeGroupsByDefault"; "required": false; }; "orphanItemsGroupName": { "alias": "orphanItemsGroupName"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "bufferAmount": { "alias": "bufferAmount"; "required": false; }; "trackByFn": { "alias": "trackByFn"; "required": false; }; "sortFn": { "alias": "sortFn"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hasSearch": { "alias": "hasSearch"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "searchFn": { "alias": "searchFn"; "required": false; }; "searchWhileComposing": { "alias": "searchWhileComposing"; "required": false; }; "externalSearchTermMinLength": { "alias": "externalSearchTermMinLength"; "required": false; }; "externalSearchSubject": { "alias": "externalSearchSubject"; "required": false; }; "externalTotalOptionCount": { "alias": "externalTotalOptionCount"; "required": false; }; "notFoundText": { "alias": "notFoundText"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "hasToolbar": { "alias": "hasToolbar"; "required": false; }; "hasFooter": { "alias": "hasFooter"; "required": false; }; "escapeHTML": { "alias": "escapeHTML"; "required": false; }; "items": { "alias": "items"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; "optgroupTemplate": { "alias": "optgroupTemplate"; "required": false; }; "toolbarTemplate": { "alias": "toolbarTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; "customItemTemplate": { "alias": "customItemTemplate"; "required": false; }; }, { "triggerMove": "triggerMove"; "search": "search"; "scroll": "scroll"; "scrollToEnd": "scrollToEnd"; }, never, never, false, never>;
}

interface PickOptionStateChange {
    value: boolean;
    disabled: boolean;
    label?: string;
}
/** Component used to add options to a picklist in declarative way. `<hc-pick-option>` */
declare class PickOptionComponent implements OnChanges, AfterViewChecked, OnDestroy {
    /** Reference to underlying HTML element. */
    elementRef: ElementRef<HTMLElement>;
    /** Value for this option. */
    value: boolean;
    /** If true, the option cannot be selected. */
    set disabled(value: boolean);
    get disabled(): boolean;
    readonly _stateChange$: Subject<PickOptionStateChange>;
    private _disabled;
    private _previousLabel;
    constructor(
    /** Reference to underlying HTML element. */
    elementRef: ElementRef<HTMLElement>);
    /** Getter. Returns the text used as the label for this option. */
    get label(): string;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    private _isDisabled;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickOptionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PickOptionComponent, "hc-pick-option", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
}

/** Control for selecting multiple items from a very large set of options. `<hc-picklist>` */
declare class PicklistComponent implements OnDestroy, AfterViewInit, ControlValueAccessor {
    private picklistService;
    private _cd;
    private autoFocus;
    /** If options are objects, this matches the object property to use for display in the list.
     * Can use nested properties. Example: `'property.nestedProperty'`. *Defaults to `'label'`.* */
    bindLabel: string;
    /** If options are objects, this matches the object property to use for the selected model.
     * Can use nested properties. Example: `'property.nestedProperty'`. *By default, binds to whole object.* */
    bindValue: string;
    /** When addCustomItem is true, this changes the default message for adding a new item. *Defaults to `"Add custom option."`* */
    addCustomItemText: string;
    /** True if user should be able to add custom items. The button to add an option will appear when a search term is not exactly
     * matched. Can optionally provide a function that will generate a value for the custom option based on the given search term.
     * *Defaults to false.* If a function is provided, must follow this signature: `((term: string) => any | Promise<any>)`. The
     * function is passed the search term string and returns a value that should match the type of options in the picklist. */
    addCustomItem: boolean | AddCustomItemFn;
    /** Group items by property or function expression. If a function is provided, must follow this signature: `((item: any) => any)`. The
     * function is passed an option and returns a value to represent the identifier for the group that option should belong to.
     * *Grouping is off by default.* */
    groupBy: string | GroupByFn;
    /** Function expression to provide group value: `(key: string | object, children: any[]) => string | object`. Same as
     * described in ng-select component. https://ng-select.github.io/ng-select#/grouping */
    groupValue: GroupValueFn;
    /** True if group should be clickable. Clicking the group will select all its children. *Defaults to false.* */
    canSelectGroup: boolean;
    /** True if group can be closed to hide its child options. *Defaults to false.* */
    canCloseGroup: boolean;
    /** True if groups should be closed to begin with. Must have `canCloseGroup` set to true to use. *Defaults to true.* */
    closeGroupsByDefault: boolean;
    /** Items that cannot be grouped are placed in an orphan group.
     * This property sets a name for that group. *Defaults to `"Other Items"`* */
    orphanItemsGroupName: string;
    /** True to enable virtual scroll for better performance when rendering a lot of data. *Defaults to false.* */
    virtualScroll: boolean;
    /** When using virtual scroll, determines how many extra items on top and bottom should be rendered outside the viewport.
     * *Defaults to 4.* */
    bufferAmount: number;
    /** Provide custom trackBy function for better DOM reusage by Angular's *ngFor in the items list. */
    trackByFn: null;
    /** Function used to sort the groups and items in the list: `(a: PickOption, b: PickOption) => number`. If the function
     * result is negative, a is sorted before b. If it's positive, b is sorted before a. If the result is 0, no changes are
     * done with the sort order of the two values. *By default, options are not sorted.* */
    sortFn: SortFn;
    /** If true, items can be viewed but not highlighted or moved from pane to pane. Same as adding `disabled` attribute.
     * *Defaults to false.* */
    readonly: boolean;
    /** True if search bar should be present. *Defaults to true.* */
    hasSearch: boolean;
    /** Placeholder for the search input. *Defaults to 'Search'.* */
    searchPlaceholder: string;
    /** A custom search function: `(term: string, item: any) => boolean`. *Default function does a simple scan for entire
     * given term within the options label.* */
    searchFn: SearchFn;
    /** True if items should be filtered while user is still typing. *Defaults to true.* */
    searchWhileComposing: boolean;
    /** Number of characters required for search to be fired. Only applies when using `externalSearchSubject`.
     * *Defaults to 0.* */
    externalSearchTermMinLength: number;
    /** A subject through which an updated search term will be sent. Use for advanced searching functionality,
     * like searching over http. */
    externalSearchSubject: Subject<string>;
    /** For the left pane, force the 'Showing x of y' message to be the given number. Useful when using external search
     * and you want to display the total number of items available on the server rather than just those currently
     * available in the component. */
    externalTotalOptionCount: number;
    /** Message shown in each pane when empty. *Defaults to 'No options to show.'* */
    notFoundText: string;
    /** Text for left pane header. Ignored if `hcPaneHeaderLeftTmp` is used. *Defaults to 'Available'.* */
    leftHeaderText: string;
    /** Text for right pane header. Ignored if `hcPaneHeaderRightTmp` is used. *Defaults to 'Selected'.* */
    rightHeaderText: string;
    /** True when left pane should show as loading. *Defaults to false.* */
    leftPaneLoading: boolean;
    /** True when right pane should show as loading. *Defaults to false.* */
    rightPaneLoading: boolean;
    /** True if each pane should have a header. *Defaults to true.* */
    hasHeader: boolean;
    /** True if each pane should have a toolbar section. *Defaults to true.* */
    hasToolbar: boolean;
    /** True if each pane should have a footer section. *Defaults to true.* */
    hasFooter: boolean;
    /** Set a limit to the number of selected items.
     * Note: This will not prevent more than limit from being added to the model outside the component.
     * *No limit by default.* */
    maxSelectedItems: number;
    /** Total height of the picklist control. Should be passed as a string, including the
     * unit (pixels, percentage, rem, etc). *Defaults to '400px'.* */
    height: string;
    /** An array of options for the picklist. Options can be of any type, and the array can be an observable stream.
     * Can alternatively use `<hc-pick-option>` components to pass in options. */
    get items(): unknown[];
    set items(value: unknown[]);
    /** A function to compare the option values with the selected values. `(a: any, b: any) => boolean;`
     * The first argument is a value from an option. The second is a value from the selection (model).
     * A boolean should be returned.
     * Same as used by https://angular.io/api/forms/SelectControlValueAccessor */
    get compareWith(): CompareWithFn;
    set compareWith(fn: CompareWithFn);
    /** Fires when model is updated. Sends an array of the currently selected values. */
    change: EventEmitter<(string | Record<string, unknown> | undefined)[]>;
    /** Fires when options are added. Sends an array of the values being added. */
    add: EventEmitter<(string | Record<string, unknown> | undefined)[]>;
    /** Fires when options are removed. Sends an array of the values being removed. */
    remove: EventEmitter<(string | Record<string, unknown> | undefined)[]>;
    _optionTemplate: TemplateRef<unknown>;
    _optgroupTemplate: TemplateRef<unknown>;
    _toolbarTemplate: TemplateRef<unknown>;
    _footerTemplate: TemplateRef<unknown>;
    _customItemTemplate: TemplateRef<unknown>;
    _paneHeaderRightTemplate: TemplateRef<unknown>;
    _paneHeaderLeftTemplate: TemplateRef<unknown>;
    /** A template-based/declarative way to pass options available in the picklist. */
    _ngOptions: QueryList<PickOptionComponent>;
    _availablePane: PickPaneComponent;
    _selectedPane: PickPaneComponent;
    /** Getter. Returns true if readonly property is true, or if disabled attribute is present on the control. */
    get disabled(): boolean;
    /** whether or not we should escape HTML in default option templates. will be set to false if
     * using <hc-pick-option> instead of passing in an items array */
    _escapeHTML: boolean;
    _el: HTMLElement;
    private _items;
    private _itemsAreUsed;
    private _defaultLabel;
    private _disabled;
    private readonly _destroy$;
    private _compareWith;
    private _onChange;
    private _onTouched;
    constructor(_elementRef: ElementRef<HTMLElement>, picklistService: PicklistService, _cd: ChangeDetectorRef, autoFocus: any);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    writeValue(value: unknown | unknown[]): void;
    registerOnChange(fn: () => null): void;
    registerOnTouched(fn: () => null): void;
    setDisabledState(state: boolean): void;
    /** Getter. Returns true if any items are selected. */
    get hasValue(): boolean;
    /** Getter. Returns true if the number of selected items matches or exceeds the maximum number. Useful if you'd like to show a custom
     * warning label.
     */
    get hasMaxItemsSelected(): boolean;
    /** Getter. Returns true if the number of selected items exceeds the maximum number. UI won't normally allow this, but the model can
     * be manipulated or set outside of the component to cause this. */
    get hasExceededMaxItemsSelected(): boolean;
    /** Getter. Returns true if the "Available" pane is empty. */
    get leftPaneIsEmpty(): boolean;
    /** Move highlighted items from the left pane over to the right pane. */
    moveLeftToRight(): void;
    /** Move highlighted items from the right pane over to the left pane. */
    moveRightToLeft(): void;
    /** Move selected (highlighted) options from one pane to the other */
    _move(source: PickPaneComponent, destination: PickPaneComponent, isAdding?: boolean): void;
    /** Refreshes the dimensions of the virtual scroll container and the items displayed within. Helpful when using virtual scrolling and
     * the window changes such that the picklist was resized.
     */
    refreshScrollArea(): void;
    /** Manually trigger change detection to update the UI. */
    _detectChanges(): void;
    /** Convert <hc-pick-option> components into HcOptions */
    private _setItemsFromHcPickOptions;
    /** Apply value passed in from ngModel as the current selection in the component */
    private _handleWriteValue;
    /** Rerun filters and grouping logic in each pane, than force UI refresh. */
    private refreshPanes;
    private _isValidWriteValue;
    private validateBinding;
    private _updateNgModel;
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistComponent, [null, null, null, { attribute: "autofocus"; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PicklistComponent, "hc-picklist", never, { "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "addCustomItemText": { "alias": "addCustomItemText"; "required": false; }; "addCustomItem": { "alias": "addCustomItem"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "groupValue": { "alias": "groupValue"; "required": false; }; "canSelectGroup": { "alias": "canSelectGroup"; "required": false; }; "canCloseGroup": { "alias": "canCloseGroup"; "required": false; }; "closeGroupsByDefault": { "alias": "closeGroupsByDefault"; "required": false; }; "orphanItemsGroupName": { "alias": "orphanItemsGroupName"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "bufferAmount": { "alias": "bufferAmount"; "required": false; }; "trackByFn": { "alias": "trackByFn"; "required": false; }; "sortFn": { "alias": "sortFn"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "hasSearch": { "alias": "hasSearch"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "searchFn": { "alias": "searchFn"; "required": false; }; "searchWhileComposing": { "alias": "searchWhileComposing"; "required": false; }; "externalSearchTermMinLength": { "alias": "externalSearchTermMinLength"; "required": false; }; "externalSearchSubject": { "alias": "externalSearchSubject"; "required": false; }; "externalTotalOptionCount": { "alias": "externalTotalOptionCount"; "required": false; }; "notFoundText": { "alias": "notFoundText"; "required": false; }; "leftHeaderText": { "alias": "leftHeaderText"; "required": false; }; "rightHeaderText": { "alias": "rightHeaderText"; "required": false; }; "leftPaneLoading": { "alias": "leftPaneLoading"; "required": false; }; "rightPaneLoading": { "alias": "rightPaneLoading"; "required": false; }; "hasHeader": { "alias": "hasHeader"; "required": false; }; "hasToolbar": { "alias": "hasToolbar"; "required": false; }; "hasFooter": { "alias": "hasFooter"; "required": false; }; "maxSelectedItems": { "alias": "maxSelectedItems"; "required": false; }; "height": { "alias": "height"; "required": false; }; "items": { "alias": "items"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, { "change": "change"; "add": "add"; "remove": "remove"; }, ["_optionTemplate", "_optgroupTemplate", "_toolbarTemplate", "_footerTemplate", "_customItemTemplate", "_paneHeaderRightTemplate", "_paneHeaderLeftTemplate", "_ngOptions"], never, false, never>;
}

/** @docs-private */
declare class PickItemLabelDirective implements OnChanges {
    private element;
    hcPickItemLabel: string;
    escape: boolean;
    constructor(element: ElementRef<HTMLElement>);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickItemLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickItemLabelDirective, "[hcPickItemLabel]", never, { "hcPickItemLabel": { "alias": "hcPickItemLabel"; "required": false; }; "escape": { "alias": "escape"; "required": false; }; }, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickPaneHeaderLeftTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneHeaderLeftTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickPaneHeaderLeftTemplateDirective, "[hcPaneHeaderLeftTmp]", never, {}, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickPaneHeaderRightTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneHeaderRightTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickPaneHeaderRightTemplateDirective, "[hcPaneHeaderRightTmp]", never, {}, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickOptionTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickOptionTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickOptionTemplateDirective, "[hcPickOptionTmp]", never, {}, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickOptgroupTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickOptgroupTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickOptgroupTemplateDirective, "[hcPickOptgroupTmp]", never, {}, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickPaneToolbarTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneToolbarTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickPaneToolbarTemplateDirective, "[hcPaneToolbarTmp]", never, {}, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickPaneFooterTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPaneFooterTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickPaneFooterTemplateDirective, "[hcPaneFooterTmp]", never, {}, {}, never, never, false, never>;
}
/** @docs-private */
declare class PickCustomItemTemplateDirective {
    template: TemplateRef<unknown>;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<PickCustomItemTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PickCustomItemTemplateDirective, "[hcPickCustomItemTmp]", never, {}, {}, never, never, false, never>;
}

declare class PicklistModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PicklistModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PicklistModule, [typeof PickPaneComponent, typeof PicklistComponent, typeof PickOptionComponent, typeof PickOptgroupTemplateDirective, typeof PickOptionTemplateDirective, typeof PickPaneHeaderLeftTemplateDirective, typeof PickPaneHeaderRightTemplateDirective, typeof PickPaneToolbarTemplateDirective, typeof PickPaneFooterTemplateDirective, typeof PickCustomItemTemplateDirective, typeof PickPaneListComponent, typeof PickItemLabelDirective], [typeof i2.CommonModule, typeof i4.FormsModule, typeof ButtonModule, typeof InputModule, typeof FormFieldModule, typeof ProgressIndicatorsModule], [typeof PickPaneComponent, typeof PicklistComponent, typeof PickOptionComponent, typeof PickOptgroupTemplateDirective, typeof PickOptionTemplateDirective, typeof PickPaneHeaderLeftTemplateDirective, typeof PickPaneHeaderRightTemplateDirective, typeof PickPaneToolbarTemplateDirective, typeof PickPaneFooterTemplateDirective, typeof PickCustomItemTemplateDirective, typeof PickPaneListComponent, typeof PickItemLabelDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PicklistModule>;
}

interface IReleaseNotesModalData {
    appName: string;
    headerLinkText?: string;
    headerLinkUrl?: string;
    releaseNotes: IReleaseNote[];
    showNotice?: boolean;
}
interface IReleaseNote {
    version: string;
    notesHTML: string;
    releaseMonth?: number;
    releaseYear?: number;
    releaseDay?: number;
}
/** Configuration data passed to the Release Notes modal */
declare class ReleaseNotesModalData implements IReleaseNotesModalData {
    /** Name of the application */
    appName: string;
    /** Text shown as a link in the header. Defaults to 'More on HC Community'. We recommend linking to the release notes page on Health Catalyst Community for your web app, but the link text and url can be configured however you would like. */
    headerLinkText?: string;
    /** URL for link in the header. We recommend linking to the release notes page on Health Catalyst Community for your web app, but the link text and url can be configured however you would like. */
    headerLinkUrl?: string;
    /** Collection of release notes by version. UI will be slightly simplified if only one version is given. */
    releaseNotes: ReleaseNote[];
    /** True to show notice about where to find this window again. Some apps like to open this window automatically the first time the app is loaded after a new release. In those cases, it's helpful to show a message in the footer explaining how to find this window again later. Default is to show those message. */
    showNotice?: boolean;
}
/** Notes for a single release */
declare class ReleaseNote implements IReleaseNote {
    /** Release version. Semantic versioning recommended. */
    version: string;
    /** Release notes for the given version.
    * **WARNING:** You are responsible to sanitize any unsafe user input. */
    notesHTML: string;
    /** Optional. What month is the release from? [1-12] */
    releaseMonth: number;
    /** Optional. What year is the release from? [YYYY] */
    releaseYear: number;
    /** Optional. What day is the release from? [1-31] */
    releaseDay: number;
    /** True if this release note accordion should be open */
    isOpen: boolean;
    /** Merges the release day, month and year into a string: "DD MMM YYYY" */
    get releaseDateStr(): string;
    private _releaseDateStr;
    constructor(
    /** Release version. Semantic versioning recommended. */
    version: string, 
    /** Release notes for the given version.
    * **WARNING:** You are responsible to sanitize any unsafe user input. */
    notesHTML: string, 
    /** Optional. What month is the release from? [1-12] */
    releaseMonth: number, 
    /** Optional. What year is the release from? [YYYY] */
    releaseYear: number, 
    /** Optional. What day is the release from? [1-31] */
    releaseDay?: number);
}

declare class ReleaseNotesModalComponent implements OnInit {
    private activeModal;
    _data: ReleaseNotesModalData;
    constructor(activeModal: ActiveModal);
    _onReleaseOpened(releaseIndex: number, modalBody: ElementRef, accordion: ElementRef): void;
    ngOnInit(): void;
    /** Close the modal */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReleaseNotesModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ReleaseNotesModalComponent, "hc-release-notes-modal", never, {}, {}, never, never, false, never>;
}

declare class ReleaseNotesModalModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ReleaseNotesModalModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ReleaseNotesModalModule, [typeof ReleaseNotesModalComponent], [typeof i2.CommonModule, typeof i7.DragDropModule, typeof ButtonModule, typeof ModalModule, typeof AccordionModule], [typeof ReleaseNotesModalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ReleaseNotesModalModule>;
}

/** Inject this service and call `open()` to get a Cashmere-standard modal for release notes. */
declare class ReleaseNotesService {
    private modalService;
    constructor(modalService: ModalService);
    /** Open the release notes modal
     * @param data Configuration data for the modal. See ReleaseNotesModalData class for details.
     * @param modalOptions Options for the modal. See ModalOptions class for details.
     * @returns A reference to the opened modal.
    */
    open(data: IReleaseNotesModalData, modalOptions?: ModalOptions): HcModal<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReleaseNotesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ReleaseNotesService>;
}

declare enum ResizablePositionOption {
    bottom = "bottom",
    left = "left",
    right = "right",
    top = "top"
}
type ResizablePosition = keyof typeof ResizablePositionOption;

/** A container that the user can resize the dimensions of */
declare class ResizableComponent implements OnChanges {
    _element: ElementRef<HTMLElement>;
    _className: string;
    _classNameSelector: string;
    private _mousePos;
    private _startSize;
    private _disabled;
    private _dragSubscription;
    _hostClass: boolean;
    /** Removes the resizable handle from the container when set to `true` */
    get disabled(): boolean;
    set disabled(value: boolean | string);
    /** Determines which corner of the container the drag handle will be available on.
     * Accepts `bottom`, `left`, `right`, or `top`.*/
    position: ResizablePosition;
    /** The maximum value (in pixels) that the container may expand to. There is no max by default.*/
    max: number;
    /** The minimum value (in pixels) that the container may contract to. There is no min by default.*/
    min: number;
    /** Emits a `DOMRect` after a drag event is complete */
    resized: EventEmitter<DOMRect>;
    constructor(_element: ElementRef<HTMLElement>);
    ngOnChanges(changes: SimpleChanges): void;
    _dragStarted(event: MouseEvent): void;
    _dragEnded(): void;
    _dragMoved(event: MouseEvent): void;
    /** Resets the resizeable container to its orginal default size */
    reset(): void;
    private _initClassName;
    private _isHorizontal;
    private _isVertical;
    private _setDefaultStyles;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResizableComponent, "[hcResizable]", never, { "disabled": { "alias": "disabled"; "required": false; }; "position": { "alias": "position"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; }, { "resized": "resized"; }, never, ["*"], false, never>;
}

/** Can be added to a sibling of a resizable element that does not need a resize handle */
declare class ResizableStaticDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableStaticDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableStaticDirective, "[hcResizableStatic]", never, {}, {}, never, never, false, never>;
}

/** Can be added to the parent element containing resizable and static elements */
declare class ResizableContainerDirective {
    _vertical: boolean;
    _horizontalClass: boolean;
    _verticalClass: boolean;
    /** Orients the container for horizontal or vertical resizing; defaults to `true` */
    get vertical(): boolean;
    set vertical(value: boolean | string);
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizableContainerDirective, "[hcResizableContainer]", never, { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ResizableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ResizableModule, [typeof ResizableComponent, typeof ResizableStaticDirective, typeof ResizableContainerDirective], [typeof i2.CommonModule], [typeof ResizableComponent, typeof ResizableStaticDirective, typeof ResizableContainerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ResizableModule>;
}

/** Marks the host element as a link within an `hc-scroll-nav`. */
declare class ScrollNavLinkDirective {
    private renderer;
    /** The `id` of the corresponding `hcScrollTarget` that you would like to link to. */
    hcScrollLink: string | null;
    /** Emits the associated content element when a nav link is clicked */
    navClick: EventEmitter<HTMLElement>;
    _hostClass: boolean;
    /** The `nativeElement` of the corresponding `hcScrollTarget` that you would like to link to. */
    nativeElement: HTMLElement;
    private readonly CLICKED_SUBSECTION_CLASS;
    private readonly SECTION_TAG_NAME;
    constructor(element: ElementRef, renderer: Renderer2);
    _setDirectiveToNode(node: Node): void;
    _onEnter(): void;
    _onClick(): void;
    private navigateToSection;
    private setSubsectionClass;
    private hasClickedSubsection;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollNavLinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollNavLinkDirective, "[hcScrollLink]", never, { "hcScrollLink": { "alias": "hcScrollLink"; "required": false; }; }, { "navClick": "navClick"; }, never, never, false, never>;
}

/** Container for scroll navigation links. */
declare class HcScrollNavComponent implements AfterViewInit, OnDestroy {
    _elementRef: ElementRef;
    private renderer;
    /** Set to true to enable scrolling the nav link pane as the content pane scrolls */
    scrollNavWithContent: boolean;
    /** Set to true to enable the component to change for dynamic content changes that might not be picked up by Angular */
    hasDynamicContent: boolean;
    _scrollEvent: EventEmitter<HTMLElement>;
    _cdkScrollableElement: CdkScrollable;
    private linkList;
    get _links(): Array<HTMLElement>;
    isScrolling: boolean;
    private unsubscribe$;
    private previousElementPosition;
    private previousList;
    private tryRefresh;
    private dynamicInterval;
    private readonly SCROLL_LINK_ATTRIBUTE;
    private readonly ACTIVE_CLASS;
    private readonly INACTIVE_CLASS;
    private readonly ACTIVE_PARENT_SECTION_CLASS;
    private readonly INACTIVE_PARENT_SECTION_CLASS;
    private readonly SUBSECTION_CLASS;
    private readonly PARENT_SECTION_CLASS;
    private readonly PARENT_SECTION_CONTENT_CLASS;
    private readonly LINKS_CONTAINER_CLASS;
    private readonly UNORDERED_LIST_TAG_NAME;
    private readonly LIST_TAG_NAME;
    constructor(_elementRef: ElementRef, renderer: Renderer2);
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    /** Refresh the scroll nav links when dynamic changes have been made. updateScrollLinkArray parameter is optional */
    refreshScrollNavLinks(updateScrollLinkArray?: ScrollNavLinkDirective[]): void;
    _setActiveSectionById(id: string): void;
    private initializeLinks;
    private setActiveSection;
    private scrollToElement;
    private handleActiveParentSections;
    private setActiveParentSection;
    private setClassesForSubsection;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcScrollNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcScrollNavComponent, "hc-scroll-nav", never, { "scrollNavWithContent": { "alias": "scrollNavWithContent"; "required": false; }; "hasDynamicContent": { "alias": "hasDynamicContent"; "required": false; }; }, { "_scrollEvent": "_scrollEvent"; }, ["linkList"], ["*"], false, never>;
}

/** Marks the host element as a linkable section within an `hc-scroll-nav-content`.
 * Must set the `id` and link to it via an `hcScrollLink`. */
declare class ScrollNavTargetDirective {
    _hostClass: boolean;
    /** The `nativeElement` of the corresponding `hcScrollTarget` that you would like to link to. */
    nativeElement: HTMLElement;
    constructor(element: ElementRef);
    _setDirectiveToNode(node: Node): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollNavTargetDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollNavTargetDirective, "[hcScrollTarget]", never, {}, {}, never, never, false, never>;
}

/** Contains scrollable content that is navigable via `hc-scroll-nav` links. */
declare class HcScrollNavContentComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private _elementRef;
    private renderer;
    private readonly DEFAULT_BUFFER;
    /** Reference to the scroll nav component. */
    nav: HcScrollNavComponent;
    /** If true, will force the height of the final scroll target area to be the height of the scrollable container.
     * This is helpful if you want the last target in the content area to be able to scroll to the top. You can alternatively
     * target the last item with css. *Defaults to true.* */
    makeLastTargetFullHeight: boolean;
    /** Adjust the min height of the last target */
    lastTargetMinHeightAdjustment: number;
    /** Number in pixels, used to give a little leeway in the shifting of the active nav when scrolling. *Defaults to 0.*
     * Example: If set to 40, if showing just the bottom 40 pixels of the section before, count the next section as active. */
    bufferSpace: number;
    /** If true, applies smooth scrolling via css. *Defaults to true.* */
    shouldAnimateScroll: boolean;
    /** Set to true to enable the component to change for dynamic content changes that might not be picked up by Angular */
    hasDynamicContent: boolean;
    /** Fires when a new section is scrolled into view. Broadcasts the id of that section. */
    newSectionInView: EventEmitter<string>;
    _cdkScrollableElement: CdkScrollable$1;
    private targets;
    /** Id of the current section scrolled into view. */
    sectionInView: string;
    get _scrollTargets(): Array<HTMLElement>;
    private unsubscribe$;
    private minHeightForLastTargetSet;
    private systemScrollToElementId;
    private lastElementScrolledTo;
    private systemScrollCount;
    private dynamicInterval;
    private readonly SCROLL_TARGET_ATTRIBUTE;
    constructor(_elementRef: ElementRef, renderer: Renderer2);
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    _onWindowResize(): void;
    /** Refresh the scroll nav targets when dynamic changes have been made. updateScrollTargetArray parameter is optional */
    refreshScrollNavTargets(updateScrollTargetArray?: ScrollNavTargetDirective[]): void;
    /** Scroll to top and reset the 'automatic full height for the last item' setting. */
    refresh(): void;
    /** Helper function to scroll to the top of the content area. */
    scrollToTop(): void;
    /** Will update the navigation state. */
    checkActiveSection(): void;
    /** Sets the active section to passed in scrollTarget */
    setActiveSection(scrollTarget: string): void;
    private initializeTargets;
    private getTargets;
    private insureMinHeightForLastTarget;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcScrollNavContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcScrollNavContentComponent, "hc-scroll-nav-content", never, { "nav": { "alias": "nav"; "required": false; }; "makeLastTargetFullHeight": { "alias": "makeLastTargetFullHeight"; "required": false; }; "lastTargetMinHeightAdjustment": { "alias": "lastTargetMinHeightAdjustment"; "required": false; }; "bufferSpace": { "alias": "bufferSpace"; "required": false; }; "shouldAnimateScroll": { "alias": "shouldAnimateScroll"; "required": false; }; "hasDynamicContent": { "alias": "hasDynamicContent"; "required": false; }; }, { "newSectionInView": "newSectionInView"; }, ["targets"], ["*"], false, never>;
}

declare class ScrollNavModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollNavModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ScrollNavModule, [typeof HcScrollNavContentComponent, typeof HcScrollNavComponent, typeof ScrollNavTargetDirective, typeof ScrollNavLinkDirective], [typeof i2.CommonModule, typeof i6.ScrollingModule], [typeof HcScrollNavContentComponent, typeof HcScrollNavComponent, typeof ScrollNavTargetDirective, typeof ScrollNavLinkDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ScrollNavModule>;
}

declare class SearchBarComponent implements OnInit, OnDestroy, OnChanges {
    /** Placeholder text for the search bar. *Defaults to `Search`.* */
    placeholder: string;
    /** If true, disables the search bar. *Defaults to `false`.* */
    disabled: boolean;
    /** Preseed the search bar with a particular text value. *Defaults to empty string.* */
    initialSearchTerm: string;
    /** If true, show the search icon in the right side of the search bar. *Defaults to `true`.* */
    showSearchIcon: boolean;
    /** If true, show a clickable clear icon in the right side of the search bar when there's a search term present. *Defaults to `true`.* */
    showClearIcon: boolean;
    /** If true, fire triggerSearch event on user keyup (with a built-in 100ms debounce). *Defaults to `true`.* */
    autoSearch: boolean;
    /** Sets whether the input should be sized for small screens (if true, overrides the `tight` param) *Defaults to `false`.* */
    mobile: boolean;
    /** If true, condense the default padding and reduce the font size. *Defaults to `false`.*  */
    tight: boolean;
    /** If true, trigger search when search icon is clicked. *Defaults to `true`.*  */
    triggerSearchOnSearchIcoClick: boolean;
    /** Sets the time in milliseconds to wait before triggering a search. *Defaults to `100`. */
    debounce: number;
    /** Fires when a search should be run. Outputs the search term. */
    triggerSearch: EventEmitter<string>;
    /** Fires when clear icon is clicked. */
    clearClicked: EventEmitter<void>;
    /** Fires when search icon is clicked. */
    searchIconClicked: EventEmitter<void>;
    private searchBar;
    /** Returns the current search term. */
    get value(): string;
    private searchStream;
    private destroy$;
    ngOnDestroy(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /** Places focus in the search bar. */
    focus(): void;
    /** Manually set the value of the search bar. */
    setValue(val: string): void;
    _onKeyUp(event: KeyboardEvent, term: string): void;
    /** Clear out search bar and trigger search. */
    clear(): void;
    /** Manually trigger search event. Optionally pass in a value to search for */
    search(term?: string): void;
    _onEnter(term: string): void;
    _onSearchIconClicked(): void;
    private setupSearchStream;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SearchBarComponent, "hc-search-bar", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "initialSearchTerm": { "alias": "initialSearchTerm"; "required": false; }; "showSearchIcon": { "alias": "showSearchIcon"; "required": false; }; "showClearIcon": { "alias": "showClearIcon"; "required": false; }; "autoSearch": { "alias": "autoSearch"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "triggerSearchOnSearchIcoClick": { "alias": "triggerSearchOnSearchIcoClick"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; }, { "triggerSearch": "triggerSearch"; "clearClicked": "clearClicked"; "searchIconClicked": "searchIconClicked"; }, never, never, false, never>;
}

declare class SearchBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SearchBarModule, [typeof SearchBarComponent], [typeof i2.CommonModule, typeof FormFieldModule, typeof InputModule], [typeof SearchBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SearchBarModule>;
}

declare enum buttonSize {
    small = "sm",
    medium = "md",
    large = "lg"
}
declare enum buttonStyle {
    blue = "blue",
    purple = "purple",
    green = "green",
    red = "red",
    orange = "orange",
    rubyred = "ruby-red",
    deepred = "deep-red",
    redorange = "red-orange",
    magenta = "magenta",
    azure = "azure",
    teal = "teal",
    darkgreen = "dark-green",
    yelloworange = "yellow-orange",
    darkblue = "dark-blue"
}
declare enum labelPosition {
    left = "left",
    right = "right"
}
/** A boolean control that can be toggled via clicking  */
declare class SlideToggleComponent extends HcFormControlComponent implements AfterViewInit, OnDestroy {
    _ngControl: NgControl;
    private _changeRef;
    private _uniqueId;
    private _form;
    private _unsubscribe;
    _buttonState: boolean;
    _disabled: boolean;
    _insideLabel: string;
    _insideLabelTypes: {
        none: string[];
        on: string[];
        true: string[];
        yes: string[];
    };
    /** Unique id for the slide toggle element. If none is supplied, one will be auto-generated. */
    get id(): string;
    set id(idVal: string);
    /** An optional label positioned outside of the slide toggle. Use `labelPosition` to set which side. */
    sideLabel: string;
    /** The text inside the toggle. Choose from: `none`, `on` (ON/OFF), `true` (TRUE/FALSE), `yes` (YES/NO). *Defaults to `on`**/
    get insideLabel(): string;
    set insideLabel(val: string);
    /** Whether the individual toggle is disabled. */
    get disabled(): boolean;
    set disabled(val: boolean | string);
    /** Sets whether this is a required form element */
    get required(): boolean;
    set required(requiredVal: boolean | string);
    /** Sets the size of slide toggle. Choose from: `'sm' | 'md' | 'lg' |`. *Defaults to `sm`.**/
    buttonSize: buttonSize;
    /** Sets the style of the slide toggle. Choose from: `'blue' | 'purple' | 'green' |` 'red' | 'orange' | 'ruby-red' | 'deep-red' | 'red-orange' | 'magenta' | 'azure' | 'teal' | 'dark-green' | 'yellow-orange' | 'dark-blue'. *Defaults to `blue`.**/
    buttonStyle: buttonStyle;
    /** Sets which side of slide toggle the outside label is positioned on. Choose from: `'left' | 'right' |`. *Defaults to `left`.**/
    labelPosition: labelPosition;
    /** Sets the on/off state of the toggle. Supports two-way binding. */
    get buttonState(): boolean;
    set buttonState(val: boolean | string);
    /** Event fired with boolean value when the toggle state is changed. */
    buttonStateChanged: EventEmitter<boolean>;
    ngAfterViewInit(): void;
    constructor(_parentForm: NgForm, _parentFormGroup: FormGroupDirective, _ngControl: NgControl, _changeRef: ChangeDetectorRef);
    writeValue(value: unknown): void;
    onChange: (value: unknown) => void;
    onTouch: () => unknown;
    registerOnChange(fn: (value: unknown) => void): void;
    registerOnTouched(fn: () => unknown): void;
    _onBlur(): void;
    setDisabledState(disabledVal: boolean): void;
    private _updateErrorState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlideToggleComponent, [{ optional: true; }, { optional: true; }, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SlideToggleComponent, "hc-slide-toggle", never, { "id": { "alias": "id"; "required": false; }; "sideLabel": { "alias": "sideLabel"; "required": false; }; "insideLabel": { "alias": "insideLabel"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "buttonSize": { "alias": "buttonSize"; "required": false; }; "buttonStyle": { "alias": "buttonStyle"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "buttonState": { "alias": "buttonState"; "required": false; }; }, { "buttonStateChanged": "buttonStateChanged"; }, never, never, false, never>;
}

declare class SlideToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SlideToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SlideToggleModule, [typeof SlideToggleComponent], [typeof i2.CommonModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule], [typeof SlideToggleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SlideToggleModule>;
}

/** Cashmere wrapper for the ngx-slider component  */
declare class SliderComponent extends HcFormControlComponent {
    private _uniqueInputId;
    _componentId: string;
    _hostClass: boolean;
    /** Element id */
    get id(): string;
    set id(idVal: string);
    /** Whether the slider is valid; triggers error messages in `hc-form-field` */
    get valid(): boolean;
    set valid(val: boolean | string);
    /** Sets whether this is a required form element */
    get required(): boolean;
    set required(requiredVal: boolean | string);
    static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "hc-slider", never, { "id": { "alias": "id"; "required": false; }; "valid": { "alias": "valid"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class SliderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SliderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SliderModule, [typeof SliderComponent], [typeof i2.CommonModule], [typeof SliderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SliderModule>;
}

/** @docs-private */
interface LinkParent {
    iconClass?: string;
    title: string;
    description: string;
    labelHTML: string;
    children: SidenavLink[];
    parent?: LinkParent;
    tabCSSClass?: string;
}
declare class SidenavLink implements LinkParent {
    /** Name of the link. Used as the primary label in the UI. */
    title: string;
    /** Serves as the primary label in the UI. Will override "title". **WARNING:** You are responsible to sanitize any unsafe user input. */
    labelHTML: string;
    /** Unique identifier for this link. If not provided at initialization, will be auto generated. */
    key: string;
    /** Extra detail for this link, preferably less than 10 characters. Shown as a sub label in the UI. */
    subText?: string;
    /** Icon associated with this link */
    iconClass?: string;
    /** Describes the link. Will be used for hover tooltips. */
    description: string;
    /** Passed to routerLink */
    routerLink?: string;
    /** Additional CSS class to apply */
    tabCSSClass?: string;
    /** Instead of a route, can provide a callback function.
     * Alternative is to listen to SideNav's tabClicked or favoriteClicked `@Output` events. */
    onClick?: (e: MouseEvent, link: SidenavLink) => void;
    /** If true, this link will not respond to clicks and will look disabled. *Defaults to `false`.* */
    disabled: boolean;
    /** If false, this link will not respond to clicks. Will not look disabled, but will just serve as a non-clickable label. *Defaults to `true`.**/
    clickable: boolean;
    /** Nested sub links. Will be displayed in a tree structure */
    children: SidenavLink[];
    /** True if this parent link is open and children links should be shown. */
    open: boolean;
    /** @docs-private */
    parent: LinkParent;
    /** @docs-private */
    get isLastLeafNode(): boolean;
    /** Text or markup to be inserted into a badge.
     * **WARNING:** You are responsible to sanitize any unsafe user input.
    */
    badgeHTML: string;
    /** Select a valid cashmere color for the badge background color (from the primary, secondary, or neutral palette. eg 'blue', 'slate-gray-300', or 'light-pink') */
    badgeColor: string;
    constructor(partial: Partial<SidenavLink>);
}
declare class SidenavTabGroup implements LinkParent {
    /** Icon associated with this link section */
    iconClass?: string;
    /** Name of the link section. Used as the primary label in the UI. */
    title: string;
    /** Alternate name of the link section to show when sidenav is collapsed. */
    collapsedTitle: string;
    /** Name of the link section. shown on hover */
    description: string;
    /** Serves as the primary label in the UI. Will override "title". **WARNING:** You are responsible to sanitize any unsafe user input. */
    labelHTML: string;
    /** Alternate markup to serve as the primary label in the UI when the sidenav is collapsed. Will override other title or label properties. **WARNING:** You are responsible to sanitize any unsafe user input. */
    collapsedLabelHTML: string;
    /** Nested links for this section*/
    children: SidenavLink[];
    /** If true, will put child links into popover menu when the sidenav is collapsed */
    hideChildrenOnCollapse: boolean;
    /** Additional CSS class to apply */
    tabCSSClass?: string;
    /** @docs-private */
    hasNestedLinks: boolean;
    constructor(partial: Partial<SidenavTabGroup>);
}
declare class SidenavLinkClickEvent {
    event: MouseEvent;
    link: SidenavLink;
}

/** Component for standard sidebar navigation */
declare class SidenavComponent {
    /** Add a custom css class to the sidebar container. */
    containerCssClass: string;
    /** Set width of the sidebar. Include unit. Can be pixels, rem, em, etc. Default is 260px */
    width: string;
    /** True for a darker sidebar navigation. *Defaults to `false`.* */
    darkMode: boolean;
    /** If true, collapse the sidebar to a minimal width. Defaults to false. */
    collapsed: boolean;
    /** Event triggered when the sidebar is expanded or collapsed. */
    collapsedChange: EventEmitter<boolean>;
    /** If true, sidebar can toggle between collapsed and expanded. Will have an expand/collapse button. Defaults to true. */
    canToggle: boolean;
    /** True if nested children should be shown by default. *Defaults to `false`.* */
    set openChildrenByDefault(openByDefault: boolean);
    get openChildrenByDefault(): boolean;
    private _openChildrenByDefault;
    /** True if nested children should be hideable. Overrides `openChildrenByDefault` and `openChildrenWhenActive`. *Defaults to `true`.* */
    set collapsibleChildren(collapsible: boolean);
    get collapsibleChildren(): boolean;
    private _collapsibleChildren;
    /** True if nested children should be shown if the link is active. Overrides `openChildrenByDefault`. *Defaults to `true`.* */
    openChildrenWhenActivated: boolean;
    /** True to show lines of tree structure. *Defaults to `true`.* */
    showTreeLines: boolean;
    /** Collection of objects representing the main links in the sidenav. */
    set tabs(tabs: SidenavLink[]);
    get tabs(): SidenavLink[];
    private _tabs;
    /** Collection of tabGroups. These are styled like the main tabs, but are grouped together under a separate header. */
    set tabGroups(tabGroups: SidenavTabGroup[]);
    get tabGroups(): SidenavTabGroup[];
    private _tabGroups;
    /** Event triggered when a tab group header is clicked. */
    tabGroupHeaderClicked: EventEmitter<SidenavLinkClickEvent>;
    /** @docs-private */
    hasNestedLinks: boolean;
    /** True to show loading indicator for tabs. Use while data is loading to show tabs */
    isLoadingTabs: boolean;
    /** Event triggered when a tab is clicked. */
    tabClicked: EventEmitter<SidenavLinkClickEvent>;
    /** Key of the tab that should be marked as active. */
    activeTabKey: string;
    /** If using routerLinks, routerLinkActiveClass can be used to set appropriate class for the active route.
     * If used, the `activeTabKey` property will be ignored.
     * If a class besides `active-tab` is used, you'll need to provide your own css. */
    routerLinkActiveClass: string;
    /** True to show scrollable favorites section. */
    showFavorites: boolean;
    /** Collection of objects representing user favorited items. */
    favorites: SidenavLink[];
    /** True to show loading indicator for favorites. */
    isLoadingFavorites: boolean;
    /** Event triggered when a favorite is clicked. */
    favoriteClicked: EventEmitter<SidenavLinkClickEvent>;
    /** Label for the favorites section. */
    favoritesTitleLabel: string;
    /** Description of the favorites section for display in the UI as a tooltip */
    favoritesDescription: string;
    /** An icon to show in the favorites header. */
    favoritesTitleIconClass: string;
    /** A clickable action icon to show next to each favorite list item. Default is a filled yellow star.*/
    favoritesItemActionIconClass: string;
    /** Tooltip for a favorite's action icon. */
    favoritesItemActionIconTooltip: string;
    /** Event triggered when the action icon for a favorite list item is clicked. Typically for "unfavoriting" an item. */
    favoriteItemIconClicked: EventEmitter<SidenavLinkClickEvent>;
    /** @docs-private */
    tabTooltipText: string;
    /** @docs-private */
    menuContext: {
        links?: SidenavLink[];
        title?: string;
        titleIco?: string;
        parent?: LinkParent;
        isFav: boolean;
    };
    /** Expand the sidebar to full width. */
    open(): void;
    /** Collapse the sidebar to a minimal width. */
    close(): void;
    /** Toggle the sidebar's expand/collapse state. */
    toggle(): void;
    _onRouterLinkActiveChange(isActive: boolean, tab: SidenavLink): void;
    /** @docs-private */
    onTabClick(event: MouseEvent, link: SidenavLink, isMenuHeader?: boolean, isFavorite?: boolean): void;
    /** @docs-private */
    onTabGroupHeaderClick(event: MouseEvent, link: SidenavLink): void;
    /** @docs-private */
    onFavoriteClicked(event: MouseEvent, link: SidenavLink): void;
    /** @docs-private */
    onFavoriteItemIconClicked(event: MouseEvent, link: SidenavLink): void;
    /** @docs-private */
    trackContentItem(index: number, item: SidenavLink): string | undefined;
    /** @docs-private */
    childrenChevClicked(tab: SidenavLink, event: MouseEvent): void;
    toggleAllNestedLinks(shouldOpen?: boolean): void;
    collapseAllNestedLinks(): void;
    openAllNestedLinks(): void;
    private toggleLinkAndChildren;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidenavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SidenavComponent, "hc-sidenav", never, { "containerCssClass": { "alias": "containerCssClass"; "required": false; }; "width": { "alias": "width"; "required": false; }; "darkMode": { "alias": "darkMode"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "canToggle": { "alias": "canToggle"; "required": false; }; "openChildrenByDefault": { "alias": "openChildrenByDefault"; "required": false; }; "collapsibleChildren": { "alias": "collapsibleChildren"; "required": false; }; "openChildrenWhenActivated": { "alias": "openChildrenWhenActivated"; "required": false; }; "showTreeLines": { "alias": "showTreeLines"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "tabGroups": { "alias": "tabGroups"; "required": false; }; "isLoadingTabs": { "alias": "isLoadingTabs"; "required": false; }; "activeTabKey": { "alias": "activeTabKey"; "required": false; }; "routerLinkActiveClass": { "alias": "routerLinkActiveClass"; "required": false; }; "showFavorites": { "alias": "showFavorites"; "required": false; }; "favorites": { "alias": "favorites"; "required": false; }; "isLoadingFavorites": { "alias": "isLoadingFavorites"; "required": false; }; "favoritesTitleLabel": { "alias": "favoritesTitleLabel"; "required": false; }; "favoritesDescription": { "alias": "favoritesDescription"; "required": false; }; "favoritesTitleIconClass": { "alias": "favoritesTitleIconClass"; "required": false; }; "favoritesItemActionIconClass": { "alias": "favoritesItemActionIconClass"; "required": false; }; "favoritesItemActionIconTooltip": { "alias": "favoritesItemActionIconTooltip"; "required": false; }; }, { "collapsedChange": "collapsedChange"; "tabGroupHeaderClicked": "tabGroupHeaderClicked"; "tabClicked": "tabClicked"; "favoriteClicked": "favoriteClicked"; "favoriteItemIconClicked": "favoriteItemIconClicked"; }, never, ["[hcSidenavHeader]", "[hcSidenavBody]", "*", "[hcSidenavFooter]"], false, never>;
}

/** Apply this attribute directive to any element to have it projected into `hc-sidenav` as a header. */
declare class SidenavHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<SidenavHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SidenavHeaderDirective, "[hcSidenavHeader]", never, {}, {}, never, never, false, never>;
}

/** Apply this attribute directive to any element to have it projected into `hc-sidenav` as the body. */
declare class SidenavBodyDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<SidenavBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SidenavBodyDirective, "[hcSidenavBody]", never, {}, {}, never, never, false, never>;
}

/** Apply this attribute directive to any element to have it projected into `hc-sidenav` as the body. */
declare class SidenavFooterDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<SidenavFooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SidenavFooterDirective, "[hcSidenavFooter]", never, {}, {}, never, never, false, never>;
}

declare class SidenavModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SidenavModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SidenavModule, [typeof SidenavComponent, typeof SidenavHeaderDirective, typeof SidenavBodyDirective, typeof SidenavFooterDirective], [typeof i2.CommonModule, typeof ProgressIndicatorsModule, typeof ButtonModule, typeof PopModule, typeof i3.RouterModule], [typeof SidenavComponent, typeof SidenavHeaderDirective, typeof SidenavBodyDirective, typeof SidenavFooterDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SidenavModule>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
type SortDirection = 'asc' | 'desc' | '';

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/** Interface for a directive that holds sorting state consumed by `HcSortHeaderComponent`. */
interface HcSortable {
    /** The id of the column being sorted. */
    id: string;
    /** Starting sort direction. */
    start: 'asc' | 'desc';
    /** Whether to disable clearing the sorting state. */
    disableClear: boolean;
}
/** The current sort state. */
interface Sort {
    /** The id of the column being sorted. */
    active: string;
    /** The sort direction. */
    direction: SortDirection;
}
/** Container for HcSortables to manage the sort state and provide default sort parameters. */
declare class HcSort extends Initializable implements OnChanges, OnDestroy, OnInit {
    /** Collection of all registered sortables that this directive manages. */
    sortables: Map<string, HcSortable>;
    /** Used to notify any child components listening to state changes. */
    readonly _stateChanges: Subject<never>;
    /** The id of the most recently sorted HcSortable. */
    active: string;
    /**
     * The direction to set when an HcSortable is initially sorted.
     * May be overriden by the HcSortable's sort start.
     */
    start: 'asc' | 'desc';
    /** The sort direction of the currently active HcSortable. */
    get direction(): SortDirection;
    set direction(direction: SortDirection);
    private _direction;
    /**
     * Whether to disable the user from clearing the sort by finishing the sort direction cycle.
     * May be overriden by the HcSortable's disable clear input.
     */
    get disableClear(): boolean;
    set disableClear(v: boolean);
    private _disableClear;
    get disabled(): boolean;
    set disabled(value: boolean);
    private _disabled;
    /** Event emitted when the user changes either the active sort or sort direction. */
    readonly sortChange: EventEmitter<Sort>;
    /**
     * Register function to be used by the contained HcSortables. Adds the HcSortable to the
     * collection of HcSortables.
     */
    register(sortable: HcSortable): void;
    /**
     * Unregister function to be used by the contained HcSortables. Removes the HcSortable from the
     * collection of contained HcSortables.
     */
    deregister(sortable: HcSortable): void;
    /** Sets the active sort id and determines the new sort direction. */
    sort(sortable: HcSortable): void;
    /** Returns the next sort direction of the active sortable, checking for potential overrides. */
    getNextSortDirection(sortable: HcSortable): SortDirection;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcSort, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcSort, "[hcSort]", ["hcSort"], { "active": { "alias": "hcSortActive"; "required": false; }; "start": { "alias": "hcSortStart"; "required": false; }; "direction": { "alias": "hcSortDirection"; "required": false; }; "disableClear": { "alias": "hcSortDisableClear"; "required": false; }; "disabled": { "alias": "hcSortDisabled"; "required": false; }; }, { "sortChange": "hcSortChange"; }, never, never, false, never>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * To modify the labels and text displayed, create a new instance of HcSortHeaderIntl and
 * include it in a custom provider.
 */
declare class HcSortHeaderIntl {
    /**
     * Stream that emits whenever the labels here are changed. Use this to notify
     * components if the labels have changed after initialization.
     */
    readonly changes: Subject<void>;
    /** ARIA label for the sorting button. */
    sortButtonLabel: (id: string) => string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcSortHeaderIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HcSortHeaderIntl>;
}

/**
 * Valid positions for the arrow to be in for its opacity and translation. If the state is a
 * sort direction, the position of the arrow will be above/below and opacity 0. If the state is
 * hint, the arrow will be in the center with a slight opacity. Active state means the arrow will
 * be fully opaque in the center.
 *
 * @docs-private
 */
type ArrowViewState = SortDirection | 'hint' | 'active';
/**
 * States describing the arrow's animated position (animating fromState to toState).
 * If the fromState is not defined, there will be no animated transition to the toState.
 * @docs-private
 */
interface ArrowViewStateTransition {
    fromState?: ArrowViewState;
    toState: ArrowViewState;
}
/**
 * Applies sorting behavior (click to change sort) and styles to an element, including an
 * arrow to display the current sort direction.
 *
 * Must be provided with an id and contained within a parent HcSort directive.
 *
 * If used on header cells in a CdkTable, it will automatically default its id from its containing
 * column definition.
 */
declare class HcSortHeader implements HcSortable, OnDestroy, OnInit {
    _intl: HcSortHeaderIntl;
    _sort: HcSort;
    _cdkColumnDef: CdkColumnDef;
    private _rerenderSubscription;
    /**
     * Flag set to true when the indicator should be displayed while the sort is not active. Used to
     * provide an affordance that the header is sortable by showing on focus and hover.
     */
    _showIndicatorHint: boolean;
    /**
     * The view transition state of the arrow (translation/ opacity) - indicates its `from` and `to`
     * position through the animation. If animations are currently disabled, the fromState is removed
     * so that there is no animation displayed.
     */
    _viewState: ArrowViewStateTransition;
    /** The direction the arrow should be facing according to the current state. */
    _arrowDirection: SortDirection;
    /**
     * Whether the view state animation should show the transition between the `from` and `to` states.
     */
    _disableViewStateAnimation: boolean;
    /**
     * ID of this sort header. If used within the context of a CdkColumnDef, this will default to
     * the column's name.
     */
    id: string;
    /** Sets the position of the arrow that displays when sorted. */
    arrowPosition: 'before' | 'after';
    /** Overrides the sort start value of the containing HcSort for this HcSortable. */
    start: 'asc' | 'desc';
    /** Overrides the disable clear value of the containing HcSort for this HcSortable. */
    get disableClear(): boolean;
    set disableClear(v: boolean);
    private _disableClear;
    get disabled(): boolean;
    set disabled(value: boolean);
    _hostClass: boolean;
    private _disabled;
    constructor(_intl: HcSortHeaderIntl, changeDetectorRef: ChangeDetectorRef, _sort: HcSort, _cdkColumnDef: CdkColumnDef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Sets the "hint" state such that the arrow will be semi-transparently displayed as a hint to the
     * user showing what the active sort will become. If set to false, the arrow will fade away.
     */
    _setIndicatorHintVisible(visible: boolean): void;
    /**
     * Sets the animation transition view state for the arrow's position and opacity. If the
     * `disableViewStateAnimation` flag is set to true, the `fromState` will be ignored so that
     * no animation appears.
     */
    _setAnimationTransitionState(viewState: ArrowViewStateTransition): void;
    /** Triggers the sort on this sort header and removes the indicator hint. */
    _handleClick(): void;
    /** Whether this HcSortHeader is currently sorted in either ascending or descending order. */
    _isSorted(): boolean;
    /** Returns the animation state for the arrow direction (indicator and pointers). */
    _getArrowDirectionState(): string;
    /** Returns the arrow position state (opacity, translation). */
    _getArrowViewState(): string;
    /**
     * Updates the direction the arrow should be pointing. If it is not sorted, the arrow should be
     * facing the start direction. Otherwise if it is sorted, the arrow should point in the currently
     * active sorted direction. The reason this is updated through a function is because the direction
     * should only be changed at specific times - when deactivated but the hint is displayed and when
     * the sort is active and the direction changes. Otherwise the arrow's direction should linger
     * in cases such as the sort becoming deactivated but we want to animate the arrow away while
     * preserving its direction, even though the next sort direction is actually different and should
     * only be changed once the arrow displays again (hint or activation).
     */
    _updateArrowDirection(): void;
    _isDisabled(): boolean;
    /**
     * Gets the aria-sort attribute that should be applied to this sort header. If this header
     * is not sorted, returns null so that the attribute is removed from the host element. Aria spec
     * says that the aria-sort property should only be present on one header at a time, so removing
     * ensures this is true.
     */
    _getAriaSortAttribute(): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcSortHeader, [null, null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcSortHeader, "[hc-sort-header]", ["hcSortHeader"], { "id": { "alias": "hc-sort-header"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "start": { "alias": "start"; "required": false; }; "disableClear": { "alias": "disableClear"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*", "hc-cell-resizer"], false, never>;
}

declare class SortModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SortModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SortModule, [typeof HcSort, typeof HcSortHeader], [typeof i2.CommonModule], [typeof HcSort, typeof HcSortHeader]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SortModule>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/** Animations used by HcSort. */
declare const hcSortAnimations: {
    readonly indicator: AnimationTriggerMetadata;
    readonly leftPointer: AnimationTriggerMetadata;
    readonly rightPointer: AnimationTriggerMetadata;
    readonly arrowOpacity: AnimationTriggerMetadata;
    readonly arrowPosition: AnimationTriggerMetadata;
    readonly allowChildren: AnimationTriggerMetadata;
};

interface StepInterface {
    /** The text to be displayed under the step indicator */
    label?: string;
    /** If using a router, the route this step should navigate to */
    routerLink?: string;
    /** The icon set the step's hc-icon should use. Must be set if using the icon parameter. */
    iconSet?: string;
    /** An glyph that should be displayed inside the step's circle.
     * If not set, the step number will display in the circle instead. */
    icon?: string;
    /** If true, the step will not be clickable */
    disabled?: boolean;
    /** Apply query params to the routerLink */
    queryParams?: Params;
}
type StepColor = 'green' | 'blue' | 'purple' | 'orange' | 'red' | 'none';
type StepType = 'arrow' | 'isolated';
/** Convey progress through numbered steps, providing a wizard-like workflow.  */
declare class StepperComponent implements AfterContentInit {
    private router;
    private urlSerializer;
    _routerEnabled: boolean;
    /** An array defining the steps in the stepper */
    steps: StepInterface[];
    /** Sets the layout of the progress stepper. *Defaults to `arrow`.*  */
    type: StepType;
    /** Sets the highlight color of the progress stepper. *Defaults to `green`.*  */
    get color(): StepColor;
    set color(value: StepColor);
    private _color;
    /** Determines whether numerals should be displayed on each step indicator for the isolated type.
     * *Defaults to `false`.*  */
    get showStepCount(): boolean;
    set showStepCount(value: boolean);
    private _showStepCount;
    /** If true, include a router outlet with the component. *Defaults to `true`.*  */
    get useRouterOutlet(): boolean;
    set useRouterOutlet(value: boolean);
    private _useRouterOutlet;
    /** Get or set the currently selected zero-based index of the stepper */
    get activeIndex(): number | undefined;
    set activeIndex(value: number | undefined);
    private _activeIndex;
    /** Emits the current zero-based index for the active step whenever it changes */
    activeIndexChange: EventEmitter<number>;
    _hostClass: string;
    constructor(router: Router, urlSerializer: UrlSerializer);
    ngAfterContentInit(): void;
    _stepClick(index: number | undefined): void;
    private _checkForRouterUse;
    /** Can be used to activate the current step following @Input() steps routerLink or queryParams updates  */
    findCurrentStep(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "hc-stepper", never, { "steps": { "alias": "steps"; "required": false; }; "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showStepCount": { "alias": "showStepCount"; "required": false; }; "useRouterOutlet": { "alias": "useRouterOutlet"; "required": false; }; "activeIndex": { "alias": "activeIndex"; "required": false; }; }, { "activeIndexChange": "activeIndexChange"; }, never, [".before-steps-content", ".after-steps-content"], false, never>;
}

declare class StepperModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StepperModule, [typeof StepperComponent], [typeof i2.CommonModule, typeof i3.RouterModule, typeof IconModule], [typeof StepperComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StepperModule>;
}

/** Secondary navigation bar appearing below the primary navbar  */
declare class SubnavComponent {
    _hostClass: boolean;
    /** **DEPRECATED** Not compatible with notification banners, so you should set
     * the fixed position of the subnav and other header content within your app instead */
    fixedTop: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubnavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubnavComponent, "hc-subnav", never, { "fixedTop": { "alias": "fixedTop"; "required": false; }; }, {}, never, ["*"], false, never>;
}

/** Can be added to a div or individual component to align it to the right side of the subnav  */
declare class SubnavRightDirective {
    _hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubnavRightDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SubnavRightDirective, "[hcSubnavRight]", never, {}, {}, never, never, false, never>;
}

declare class SubnavModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SubnavModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SubnavModule, [typeof SubnavComponent, typeof SubnavRightDirective], [typeof i2.CommonModule], [typeof SubnavComponent, typeof SubnavRightDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SubnavModule>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

declare class HcTable<T> extends CdkTable<T> {
    /** Overrides the sticky CSS class set by the `CdkTable`. */
    protected stickyCssClass: string;
    _hostHcTableClass: boolean;
    _hostHcBordersClass: boolean;
    _hostHcTableSmall: boolean;
    /** Sets whether the table should have a 2px border around each cell (defaults to true) */
    get borders(): boolean;
    set borders(hasBorders: boolean);
    /** If true, table has less padding and a smaller font size (defaults to false)  */
    get tight(): boolean;
    set tight(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<HcTable<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcTable<any>, "hc-table, table[hc-table]", ["matTable"], { "borders": { "alias": "borders"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; }, {}, never, ["caption", "colgroup, col"], false, never>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * Cell definition for the hc-table.
 * Captures the template of a column's data row cell as well as cell-specific properties.
 */
declare class HcCellDef extends CdkCellDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcCellDef, "[hcCellDef]", never, {}, {}, never, never, false, never>;
}
/**
 * Header cell definition for the hc-table.
 * Captures the template of a column's header cell and as well as cell-specific properties.
 */
declare class HcHeaderCellDef extends CdkHeaderCellDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcHeaderCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcHeaderCellDef, "[hcHeaderCellDef]", never, {}, {}, never, never, false, never>;
}
/**
 * Footer cell definition for the hc-table.
 * Captures the template of a column's footer cell and as well as cell-specific properties.
 */
declare class HcFooterCellDef extends CdkFooterCellDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcFooterCellDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcFooterCellDef, "[hcFooterCellDef]", never, {}, {}, never, never, false, never>;
}
/**
 * Column definition for the hc-table.
 * Defines a set of cells available for a table column.
 */
declare class HcColumnDef extends CdkColumnDef {
    private _justify;
    /** Unique name for this column. */
    get colName(): string;
    set colName(value: string);
    /** Sets the text alignment for this column: `left` (default), `center` or `right` */
    get justify(): string;
    set justify(justifyVal: string);
    /** Whether this column should be sticky positioned at the start of the row */
    get sticky(): boolean;
    set sticky(value: boolean);
    /** Whether this column should be sticky positioned on the end of the row */
    get stickyEnd(): boolean;
    set stickyEnd(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<HcColumnDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcColumnDef, "[hcColumnDef]", never, { "colName": { "alias": "hcColumnDef"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "sticky": { "alias": "sticky"; "required": false; }; "stickyEnd": { "alias": "stickyEnd"; "required": false; }; }, {}, never, never, false, never>;
}
/** Header cell template container that adds the right classes and role. */
declare class HcHeaderCell extends CdkHeaderCell {
    _hostClass: boolean;
    _role: string;
    constructor(columnDef: HcColumnDef, elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<HcHeaderCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcHeaderCell, "hc-header-cell, th[hc-header-cell]", never, {}, {}, never, never, false, never>;
}
/** Footer cell template container that adds the right classes and role. */
declare class HcFooterCell extends CdkFooterCell {
    _hostClass: boolean;
    _role: string;
    constructor(columnDef: HcColumnDef, elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<HcFooterCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcFooterCell, "hc-footer-cell, td[hc-footer-cell]", never, {}, {}, never, never, false, never>;
}
/** Cell template container that adds the right classes and role. */
declare class HcCell extends CdkCell {
    _hostClass: boolean;
    _role: string;
    constructor(columnDef: HcColumnDef, elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<HcCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcCell, "hc-cell, td[hc-cell]", never, {}, {}, never, never, false, never>;
}
/** Row index cell template container that adds the right classes and role. */
declare class HcIndexCell extends CdkCell {
    _hostClass: boolean;
    _role: string;
    constructor(columnDef: HcColumnDef, elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<HcIndexCell, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcIndexCell, "hc-index-cell, td[hc-index-cell], th[hc-index-cell]", never, {}, {}, never, never, false, never>;
}

/**
 * Header row definition for the hc-table.
 * Captures the header row's template and other header properties such as the columns to display.
 */
declare class HcHeaderRowDef extends CdkHeaderRowDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcHeaderRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcHeaderRowDef, "[hcHeaderRowDef]", never, { "columns": { "alias": "hcHeaderRowDef"; "required": false; }; "sticky": { "alias": "hcHeaderRowDefSticky"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * Footer row definition for the mat-table.
 * Captures the footer row's template and other footer properties such as the columns to display.
 */
declare class HcFooterRowDef extends CdkFooterRowDef {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcFooterRowDef, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcFooterRowDef, "[hcFooterRowDef]", never, { "columns": { "alias": "hcFooterRowDef"; "required": false; }; "sticky": { "alias": "hcFooterRowDefSticky"; "required": false; }; }, {}, never, never, false, never>;
}
/**
 * Data row definition for the mat-table.
 * Captures the footer row's template and other footer properties such as the columns to display and
 * a when predicate that describes when this row should be used.
 */
declare class HcRowDef<T> extends CdkRowDef<T> {
    static ɵfac: i0.ɵɵFactoryDeclaration<HcRowDef<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<HcRowDef<any>, "[hcRowDef]", never, { "columns": { "alias": "hcRowDefColumns"; "required": false; }; "when": { "alias": "hcRowDefWhen"; "required": false; }; }, {}, never, never, false, never>;
}
/** Footer template container that contains the cell outlet. Adds the right class and role. */
declare class HcHeaderRow extends CdkHeaderRow {
    _hostClass: boolean;
    _role: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcHeaderRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcHeaderRow, "hc-header-row, tr[hc-header-row]", ["hcHeaderRow"], {}, {}, never, never, false, never>;
}
/** Footer template container that contains the cell outlet. Adds the right class and role. */
declare class HcFooterRow extends CdkFooterRow {
    _hostClass: boolean;
    _role: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcFooterRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcFooterRow, "hc-footer-row, tr[hc-footer-row]", ["hcFooterRow"], {}, {}, never, never, false, never>;
}
/** Data row template container that contains the cell outlet. Adds the right class and role. */
declare class HcRow extends CdkRow {
    _hostClass: boolean;
    _role: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcRow, "hc-row, tr[hc-row]", ["hcRow"], {}, {}, never, never, false, never>;
}

/** Use `hcTableContainer` to wrap around tables that have sticky headers/columns or other advanced use cases. */
declare class TableContainerDirective {
    private elRef;
    private readonly onlyNumbersRegex;
    _hostClass: boolean;
    _hasGrayBg: boolean;
    set tableHeight(height: number | string);
    get tableHeight(): string | number;
    private _height;
    set hasGrayBg(hasGrayBg: boolean);
    get hasGrayBg(): boolean;
    constructor(elRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<TableContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableContainerDirective, "[hcTableContainer]", never, { "tableHeight": { "alias": "tableHeight"; "required": false; }; "hasGrayBg": { "alias": "hasGrayBg"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CellResizeEvent {
    width: number;
    directionLeft: boolean;
    constructor(width: number, directionLeft: boolean);
}
declare class HcCellResizer implements OnInit, OnDestroy {
    /**
     * Sets whether the resizer is active or not
     */
    disabled: boolean;
    /**
     * Stores the width value for this resizer;
     * typically used with two-way binding on the cell's style.width property
     */
    get width(): number;
    set width(value: number);
    private _width;
    private _directionModifier;
    private _mouseX;
    /**
     * Emits a `CellResizeEvent` when a cell has been resized
     */
    resized: EventEmitter<CellResizeEvent>;
    private isResizing;
    private isResizing$;
    /**
     * Emits a boolean value of true while a cell is being resized
     */
    resizing: EventEmitter<boolean>;
    private dragSubscription?;
    ngOnInit(): void;
    private _resizeColumn;
    private _stopResizing;
    _startResizing(event: MouseEvent): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcCellResizer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcCellResizer, "hc-cell-resizer", never, { "disabled": { "alias": "disabled"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "resized": "resized"; "resizing": "resizing"; }, never, never, false, never>;
}

declare class TableModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof HcTable, typeof HcHeaderCellDef, typeof HcHeaderRowDef, typeof HcColumnDef, typeof HcCellDef, typeof HcRowDef, typeof HcFooterCellDef, typeof HcFooterRowDef, typeof HcHeaderCell, typeof HcCell, typeof HcFooterCell, typeof HcIndexCell, typeof HcHeaderRow, typeof HcRow, typeof HcFooterRow, typeof TableContainerDirective, typeof HcCellResizer], [typeof i6$1.CdkTableModule, typeof i2.CommonModule], [typeof HcTable, typeof HcHeaderCellDef, typeof HcHeaderRowDef, typeof HcColumnDef, typeof HcCellDef, typeof HcRowDef, typeof HcFooterCellDef, typeof HcFooterRowDef, typeof HcHeaderCell, typeof HcCell, typeof HcFooterCell, typeof HcIndexCell, typeof HcHeaderRow, typeof HcRow, typeof HcFooterRow, typeof TableContainerDirective, typeof HcCellResizer]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
}

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

/**
 * Data source that accepts a client-side data array and includes native support of filtering,
 * sorting (using HcSort), and pagination (using BasePaginationComponent).
 *
 * Allows for sort customization by overriding sortingDataAccessor, which defines how data
 * properties are accessed. Also allows for filter customization by overriding filterTermAccessor,
 * which defines how row data is converted to a string for filter matching.
 */
declare class HcTableDataSource<T extends {}> extends DataSource<T> {
    /** Stream that emits when a new data array is set on the data source. */
    private readonly _data;
    /** Stream emitting render data to the table (depends on ordered data changes). */
    private readonly _renderData;
    /** Stream that emits when a new filter string is set on the data source. */
    private readonly _filter;
    /**
     * Subscription to the changes that should trigger an update to the table's rendered rows, such
     * as filtering, sorting, pagination, or base data changes.
     */
    _renderChangesSubscription: Subscription;
    /**
     * The filtered set of data that has been matched by the filter string, or all the data if there
     * is no filter. Useful for knowing the set of data the table represents.
     * For example, a 'selectAll()' function would likely want to select the set of filtered data
     * shown to the user rather than all the data.
     */
    filteredData: T[];
    /** Array of data that should be rendered by the table, where each object represents one row. */
    get data(): T[];
    set data(data: T[]);
    /**
     * Filter term that should be used to filter out objects from the data array. To override how
     * data objects match to this filter string, provide a custom function for filterPredicate.
     */
    get filter(): string;
    set filter(filter: string);
    /**
     * Instance of the HcSort directive used by the table to control its sorting. Sort changes
     * emitted by the HcSort will trigger an update to the table's rendered data.
     */
    get sort(): HcSort | null;
    set sort(sort: HcSort | null);
    private _sort;
    /**
     * Instance of the PaginationComponentused by the table to control what page of the data is
     * displayed. Page changes emitted by the hc-pagination will trigger an update to the
     * table's rendered data.
     *
     * Note that the data source uses the paginator's properties to calculate which page of data
     * should be displayed. If the paginator receives its properties as template inputs,
     * e.g. `[pageLength]=100` or `[pageIndex]=1`, then be sure that the paginator's view has been
     * initialized before assigning it to this data source.
     */
    get paginator(): BasePaginationComponent | null;
    set paginator(paginator: BasePaginationComponent | null);
    private _paginator;
    /**
     * Data accessor function that is used for accessing data properties for sorting through
     * the default sortData function.
     * This default function assumes that the sort header IDs (which defaults to the column name)
     * matches the data's properties (e.g. column Xyz represents data['Xyz']).
     * Converts strings to lowercase characters
     * May be set to a custom function for different behavior.
     * @param data Data object that is being accessed.
     * @param sortHeaderId The name of the column that represents the data.
     */
    sortingDataAccessor: (data: T, sortHeaderId: string) => string | number;
    /**
     * Gets a sorted copy of the data array based on the state of the HcSort. Called
     * after changes are made to the filtered data or when sort changes are emitted from HcSort.
     * By default, the function retrieves the active sort and its direction and compares data
     * by retrieving data using the sortingDataAccessor. May be overridden for a custom implementation
     * of data ordering.
     * @param data The array of data that should be sorted.
     * @param sort The connected HcSort that holds the current sort state.
     */
    sortData: (data: T[], sort: HcSort) => T[];
    /**
     * Checks if a data object matches the data source's filter string. By default, each data object
     * is converted to a string of its properties and returns true if the filter has
     * at least one occurrence in that string. By default, the filter string has its whitespace
     * trimmed and the match is case-insensitive. May be overridden for a custom implementation of
     * filter matching.
     * @param data Data object used to check against the filter.
     * @param filter Filter string that has been set on the data source.
     * @returns Whether the filter matches against the data
     */
    filterPredicate: (data: T, filter: string) => boolean;
    constructor(initialData?: T[]);
    /**
     * Subscribe to changes that should trigger an update to the table's rendered rows. When the
     * changes occur, process the current state of the filter, sort, and pagination along with
     * the provided base data and send it to the table for rendering.
     */
    _updateChangeSubscription(): void;
    /**
     * Returns a filtered data array where each filter object contains the filter string within
     * the result of the filterTermAccessor function. If no filter is set, returns the data array
     * as provided.
     */
    _filterData(data: T[]): T[];
    /**
     * Returns a sorted copy of the data if HcSort has a sort applied, otherwise just returns the
     * data array as provided. Uses the default data accessor for data lookup, unless a
     * sortDataAccessor function is defined.
     */
    _orderData(data: T[]): T[];
    /**
     * Returns a paged splice of the provided data array according to the provided BasePaginationComponent's page
     * index and length. If there is no paginator provided, returns the data array as provided.
     */
    _pageData(data: T[]): T[];
    /**
     * Updates the paginator to reflect the length of the filtered data, and makes sure that the page
     * index does not exceed the paginator's last page. Values are changed in a resolved promise to
     * guard against making property changes within a round of change detection.
     */
    _updatePaginator(filteredDataLength: number): void;
    /**
     * Used by the HcTable. Called when it connects to the data source.
     * @docs-private
     */
    connect(): BehaviorSubject<T[]>;
    /**
     * Used by the HcTable. Called when it is destroyed. No-op.
     * @docs-private
     */
    disconnect(): void;
}

/** Contains the HTML markup for tab titles */
declare class HcTabTitleComponent {
    tabTitle: TemplateRef<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcTabTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcTabTitleComponent, "hc-tab-title", never, {}, {}, never, ["*"], false, never>;
}

declare class TabComponent implements AfterContentInit {
    _el: ElementRef;
    _hostClass: boolean;
    _active: boolean;
    /** Plain text title of the tab; for HTML support include a `hc-tab-title` element */
    tabTitle: string;
    /** Router path that the tab routes to. If one tab uses the routerLink in a tab set, all must use the router link.
     * Can be specified as '/path/2' or ['path', '2']
     */
    routerLink: string[] | string;
    /** Add queryParams to the routerLink */
    queryParams: Params;
    /** Tab widths default to fit content; use maxWidth to constrain and truncate the content to a fixed width (e.g. `150px`)*/
    maxWidth: string;
    /** If set to true, [routerLinkActiveOptions]="{exact: true}" is added */
    exactRouteMatch: boolean;
    /** Overrides the default Angular hidden behavior to support overflow states; ngIf is also supported to hide tabs */
    get hidden(): boolean;
    set hidden(val: string | boolean);
    _hideOverride: boolean;
    _tabHideChange: EventEmitter<Event>;
    _routerActiveChange: EventEmitter<TabComponent>;
    /** Emits when this tab is selected; use instead of `(click)` for click binding    */
    tabClick: EventEmitter<Event>;
    _hostIndex: number;
    /** The template to be used when this tab is selected. Defaults to the content of this tab component.
     * Not used when the tab set uses routing. */
    tabContent: TemplateRef<unknown>;
    _direction: string;
    _tight: boolean;
    _hidden: boolean;
    _htmlTitle: HcTabTitleComponent;
    _tabTitle: QueryList<HcTabTitleComponent>;
    constructor(_el: ElementRef);
    ngAfterContentInit(): void;
    _onEnter($event: KeyboardEvent): void;
    _tabClickHandler(event: Event): void;
    _getWidth(): number;
    _isActiveChange(state: boolean): void;
    /** Used by the overflow functionality to hide the tab */
    _hide(): void;
    /** Used by the overflow functionality to show the tab */
    _show(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "hc-tab", never, { "tabTitle": { "alias": "tabTitle"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "exactRouteMatch": { "alias": "exactRouteMatch"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, { "_tabHideChange": "_tabHideChange"; "_routerActiveChange": "_routerActiveChange"; "tabClick": "tabClick"; }, ["_tabTitle"], ["*"], false, never>;
}

/** Object returned by a `selectedTabChange` event; a -1 index is returned if all tabs are deselected */
declare class TabChangeEvent {
    index: number;
    tab: TabComponent | null;
    constructor(index: number, tab: TabComponent | null);
}
declare class TabSetComponent implements AfterContentInit {
    private router;
    private route;
    private changeDetector;
    private el;
    _routerEnabled: boolean;
    _routerDeselected: boolean;
    _tabArrowsEnabled: boolean[];
    private _direction;
    private _defaultTab;
    private _stopTabSubscriptionSubject;
    private _stopTabArrowSubject;
    private _widthRecheckSub;
    private _tabWidths;
    private _tabsTotalWidth;
    _collapse: boolean;
    _moreList: Array<TabComponent>;
    private _selectedTabSubject;
    private unsubscribe;
    /** The content to be displayed for the currently selected tab.
     * This is read from the tab when it is selected.
     * Not used when this component uses routing.
     */
    tabContent: TemplateRef<unknown> | null;
    _tabs: QueryList<TabComponent>;
    _tabBar: ElementRef;
    _moreButton: HcPopoverAnchorDirective;
    _selectedTab: number | TabComponent;
    /** **Write-only**: specify which tab is currently selected. Does not fire a `selectedTabChange` emission. */
    set selectedTab(selected: number | TabComponent);
    /** Emits when the selected tab is changed. Use to keep track of the currently selected tab. */
    selectedTabChange: EventEmitter<TabChangeEvent>;
    /** Specify direction of tabs as either `horizontal` or `vertical`. Defaults to `vertical` */
    get direction(): string;
    set direction(directionType: string);
    /** Zero-based numerical value specifying which tab to select by default, setting to `none` means no tab
     * will be immediately selected. Defaults to 0 (the first tab).
     * For tabs using routing, the default tab will be set by the url and use this value as a fallback if no tab routerLinks match the url.
     * **NOTE** - if using the `selectedTab` param, it will override this value. */
    get defaultTab(): string | number;
    set defaultTab(tabValue: string | number);
    /** Determines whether the tab set will create a router-outlet or ng-container for the tab content.
     * If set to false, the app will need to add its own container.  Defaults to `true`. */
    get addContentContainer(): boolean;
    set addContentContainer(value: boolean);
    _addContentContainer: boolean;
    /** If true, condense the default padding on all included tabs. *Defaults to `false`.*  */
    get tight(): boolean;
    set tight(value: boolean);
    private _tight;
    /** When horzontal tabs overflow the container, specify either 'more', 'arrows', or 'none' for navigation control. Defaults to `more` */
    get overflowStyle(): string;
    set overflowStyle(overflowType: string);
    private _overflowStyle;
    constructor(router: Router, route: ActivatedRoute, changeDetector: ChangeDetectorRef, el: ElementRef);
    ngAfterContentInit(): void;
    /** Forces a recalculation of the tabs to determine how many should be rolling into a More menu.
     * By default the function will use cached values of the tab widths;
     * if you've changed the title of a tab, set `forceRecalculate` to true to update the cache */
    refreshTabWidths(forceRecalulate?: boolean): void;
    _moreClick(event: Event, tab: TabComponent): void;
    _tabArrowInterval: rxjs.Observable<number>;
    _handleTabsWheel(event: WheelEvent): void;
    _tabArrowClick(scrollRight: boolean): void;
    _tabArrowTouch(scrollRight: boolean): void;
    _tabArrowCheck(): void;
    private setUpTabs;
    private _forceRecollect;
    private _collectTabWidths;
    private setTabDirection;
    private subscribeToTabEvents;
    /** Sets the currently selected tab by either its numerical index or `TabComponent` object.
     * Passing a value of -1 or a hidden tab will deselect all tabs in the set. */
    selectTab(tab: number | TabComponent, shouldEmit?: boolean): void;
    _setActive(tab: TabComponent, shouldEmit?: boolean): void;
    private defaultToFirstTab;
    private checkForRouterUse;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabSetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabSetComponent, "hc-tab-set", never, { "selectedTab": { "alias": "selectedTab"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "defaultTab": { "alias": "defaultTab"; "required": false; }; "addContentContainer": { "alias": "addContentContainer"; "required": false; }; "tight": { "alias": "tight"; "required": false; }; "overflowStyle": { "alias": "overflowStyle"; "required": false; }; }, { "selectedTabChange": "selectedTabChange"; }, ["_tabs"], ["hc-tab", "*"], false, never>;
}

declare class TabsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, [typeof TabComponent, typeof HcTabTitleComponent, typeof TabSetComponent], [typeof i2.CommonModule, typeof i3.RouterModule, typeof IconModule, typeof PopModule], [typeof TabComponent, typeof HcTabTitleComponent, typeof TabSetComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
}

/** Container element to help segment content visually against a gray background.
 * The tile will expand to the height and width of the content it contains. */
declare class TileComponent {
    _hostClass: boolean;
    _tight: boolean;
    /** If true, compress the default padding in the tile. Defaults to false  */
    get tight(): boolean;
    set tight(value: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<TileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TileComponent, "hc-tile", never, { "tight": { "alias": "tight"; "required": false; }; }, {}, never, ["*"], false, never>;
}

type TileHeaderType = 'blue' | 'title' | 'center';
/** Applies one of the Cashmere standard tile header stylings to an element */
declare class TileHeaderDirective {
    private _type;
    _headerBlue: boolean;
    _headerTitle: boolean;
    _headerCenter: boolean;
    /** Sets the styling of the header, choices include `blue`, `center`, and `title`; defaults to `blue` */
    get type(): TileHeaderType;
    set type(typeStr: TileHeaderType);
    static ɵfac: i0.ɵɵFactoryDeclaration<TileHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TileHeaderDirective, "[hcTileHeader]", never, { "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TileModule, [typeof TileComponent, typeof TileHeaderDirective], [typeof i2.CommonModule], [typeof TileComponent, typeof TileHeaderDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TileModule>;
}

declare class HcToastComponent {
    _el: ElementRef;
    _viewContainerRef: ViewContainerRef;
    _changeRef: ChangeDetectorRef;
    _styleType: string;
    _toastIcon: string;
    _headerText: string;
    _bodyText: string;
    _animationState: 'void' | 'enter' | 'leave';
    _animationStateChanged: EventEmitter<AnimationEvent>;
    _closeClick: EventEmitter<MouseEvent>;
    _canDismiss: boolean;
    _canClick: boolean;
    _toastPortal: Portal<unknown>;
    _width: number;
    _hasProgressBar: boolean;
    _progressVal: number;
    _progressWidth: string;
    _customImage: string | HcIcon;
    readonly _componentInstance: BehaviorSubject<any>;
    get _widthStr(): string;
    _hostClass: boolean;
    constructor(_el: ElementRef, _viewContainerRef: ViewContainerRef, _changeRef: ChangeDetectorRef);
    _onAnimationStart(event: AnimationEvent): void;
    _onAnimationDone(event: AnimationEvent): void;
    _startExitAnimation(): void;
    _dismissClick(event: MouseEvent): void;
    _customComponentAttached(ref: CdkPortalOutletAttachedRef): void;
    _imgIsURL(val: string | HcIcon): boolean;
    _customFontSet(val: string | HcIcon): string;
    _customFontIcon(val: string | HcIcon): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HcToastComponent, "hc-toaster", never, {}, {}, never, never, false, never>;
}

interface HcToastOptions {
    /** A string of header text to be included in the toast message.*/
    header?: string;
    /** The body text to be displayed in the toast message.*/
    body?: string;
    /** Sets the background color of the toast. Defaults to success.
     * Options are: `success`, `info`, `warning`, `alert`, `custom`*/
    type?: string;
    /** Position and sizing of the toaster message. Defaults to bottom-right.
     * Options are: `top-right`, `top-center`, `top-left`, `top-full-width`,
     * `bottom-right`, `bottom-center`, `bottom-left`, `bottom-full-width`.*/
    position?: string;
    /** A custom image for the toast that overrides the default for the type.
     * Accepts either a URL for the image or a `HcIcon` object. */
    image?: string | HcIcon;
    /** Timeout value in milliseconds sets the amount of time the toast is displayed.
     *  Defaults to 5000. A value of 0 means the toast will not auto-dismiss.*/
    timeout?: number;
    /** When set to true, the user may click the Toast to dismiss it and a close icon is added
     * to the right side for standard types. Defaults to false.*/
    clickDismiss?: boolean;
    /** Function to be called when the toast is closed either via timeout or click*/
    toastClosed?: () => unknown;
    /** Function to be called when a click is detected anywhere in the body of the toast*/
    toastClicked?: () => unknown;
    /** Width of the toast in pixels. Minimum is 300px. Or, pass in 0 for an unconstrained width. Defaults to 300px.*/
    width?: number;
    /** When set to true, a progress bar is added to the bottom of the toast. The default is false.
     * There is a corresponding 0-100 `progress` value on the `hc-toast-ref` that may be set to make this a determinate progress bar.
     * If a `progress` value is not set, the progress bar will be indeterminate.*/
    hasProgressBar?: boolean;
}

declare class HcToastRef {
    _overlayRef: OverlayRef;
    private _beforeClose;
    private _afterClosed;
    _toastPosition: string;
    /** The HcToast component associated with the toast reference */
    componentInstance: HcToastComponent;
    /** If the `hasProgressBar` option is set to true in `hc-toast-options`, this 0-100 value can
     * be used to make it a determinate progress bar. If the progress bar is on but a value is not set,
     * the progress bar will be indeterminate.*/
    get progress(): number;
    set progress(progVal: number);
    constructor(_overlayRef: OverlayRef);
    /** Closes the associated toast message with this reference */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcToastRef, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HcToastRef>;
}

type ComponentSetup<T> = Partial<T> | ((instance: T) => void);
type ToastContentType<T> = Type<T> | TemplateRef<unknown>;
/** Toasts provide users with instant feedback on actions they've taken. For more general information,
 * use a `hc-banner`. */
declare class HcToasterService {
    private injector;
    private _overlay;
    _toasts: HcToastRef[];
    constructor(injector: Injector, _overlay: Overlay);
    /** Displays a new toaster message with the settings included in `toastOptions`. `toastContent` can be used to
     * create entirely custom toasts, but only if the type in toastOptions is set to `custom`. Be sure to set `border-radius: 5px`
     * in the style of your custom content template so it matches the toast container. If your custom toast is
     * using a component, the `componentSetup` parameter accepts an object or function to configure that component. */
    addToast<T>(toastOptions?: HcToastOptions, toastContent?: ToastContentType<T>, componentSetup?: ComponentSetup<T>): HcToastRef;
    /** Closes the most recent toast displayed */
    closeLastToast(): void;
    /** Closes currently visible toasts */
    closeAllToasts(): void;
    private _createOverlay;
    private _attachToastContainer;
    private _createInjector;
    private _getOverlayConfig;
    private _getPositionStrategy;
    private _removeToastPointer;
    private _getLastToast;
    private _updateToastPositions;
    static ɵfac: i0.ɵɵFactoryDeclaration<HcToasterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HcToasterService>;
}

declare class ToasterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToasterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ToasterModule, [typeof HcToastComponent], [typeof i2.CommonModule, typeof i19.PortalModule, typeof i11.OverlayModule, typeof IconModule], [typeof HcToastComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ToasterModule>;
}

declare class TypeformSurveyComponent {
    /**
     * TypeForm survey URI you want to use. Example: https://somecompany.typeform.com/to/surveyId?parameter=parametervalue
     */
    set surveyUri(uri: string);
    get surveyUri(): string;
    /**
     * App version which will be passed to the survey in a hidden field. Ensures you know what version the feedback is referencing.
     */
    set appVersion(version: string);
    get appVersion(): string;
    _fullUri: string;
    private _surveyUri;
    private _appVersion;
    private _id;
    /**
     * Opens the survey specified in the surveyUri
     */
    open(): void;
    private refreshFullUri;
    private getScripts;
    static ɵfac: i0.ɵɵFactoryDeclaration<TypeformSurveyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TypeformSurveyComponent, "hc-typeform-survey", never, { "surveyUri": { "alias": "surveyUri"; "required": false; }; "appVersion": { "alias": "appVersion"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TypeformSurveyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TypeformSurveyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TypeformSurveyModule, [typeof TypeformSurveyComponent], [typeof i2.CommonModule], [typeof TypeformSurveyComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TypeformSurveyModule>;
}

export { APP_SWITCHER_CONFIG, APP_SWITCHER_SERVICE, AccordionComponent, AccordionModule, AccordionToolbarComponent, ActiveModal, AnchorComponent, AppSwitcherComponent, AppSwitcherLinksComponent, AppSwitcherModule, AppSwitcherService, BannerModule, BannerStampDirective, BasePaginationComponent, BreadcrumbsComponent, BreadcrumbsModule, ButtonComponent, ButtonModule, ButtonToggleChangeEvent, ButtonToggleComponent, ButtonToggleGroupComponent, ButtonToggleModule, CalendarBodyComponent, CalendarComponent, CalendarHeaderComponent, CalendarOverlayService, CalendarWrapperComponent, CellResizeEvent, CheckboxChangeEvent, CheckboxComponent, CheckboxGroup, CheckboxModule, ChipComponent, ChipModule, ChipRowComponent, ClearInputComponent, ColumnMenuComponent, ColumnMenuModule, ConfigStoreService, DateAdapter, DateRangeDirective, DateRangeModule, DatepickerComponent, DatepickerContentComponent, DatepickerInputDirective, DatepickerModule, DatepickerToggleComponent, DatepickerToggleIconDirective, DividerDirective, DragListComponent, DragListModule, Drawer, DrawerContainer, DrawerItem, DrawerModule, DrawerPromiseResult, DrawerToolbar, EllipsisPipe, EllipsisPipeModule, EnvSwitcherComponent, EnvSwitcherModule, FileSizePipe, FileSizePipeModule, FileUploaderComponent, FileUploaderModule, FormFieldModule, HC_DATEPICKER_SCROLL_STRATEGY, HC_DATEPICKER_SCROLL_STRATEGY_FACTORY, HC_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, HC_DATEPICKER_VALIDATORS, HC_DATEPICKER_VALUE_ACCESSOR, HC_DATE_FORMATS, HC_DATE_LOCALE, HC_DATE_LOCALE_FACTORY, HC_NATIVE_DATE_FORMATS, HcBannerComponent, HcCalendarCell, HcCell, HcCellDef, HcCellResizer, HcCheckboxRequiredValidatorDirective, HcColumnDef, HcDatepickerAnimations, HcDatepickerContentBase, HcDatepickerInputEvent, HcDatepickerIntl, HcErrorComponent, HcFooterCell, HcFooterCellDef, HcFooterRow, HcFooterRowDef, HcFormControlComponent, HcFormDirective, HcFormFieldComponent, HcHeaderCell, HcHeaderCellDef, HcHeaderRow, HcHeaderRowDef, HcIconLargeDirective, HcIconMediumDirective, HcIconSmallDirective, HcIndexCell, HcLabelComponent, HcLabelExtensionComponent, HcModal, HcNativeDateModule, HcOptionDirective, HcPopComponent, HcPopoverAnchorDirective, HcPrefixDirective, HcRow, HcRowDef, HcScrollNavComponent, HcScrollNavContentComponent, HcSort, HcSortHeader, HcSortHeaderIntl, HcSuffixDirective, HcTabTitleComponent, HcTable, HcTableDataSource, HcToastComponent, HcToastRef, HcToasterService, HcTooltipComponent, HighlightPipe, HighlightPipeModule, IconComponent, IconModule, InputDirective, InputModule, InstanceSwitcherComponent, InstanceSwitcherModule, ListAvatarDirective, ListComponent, ListIconDirective, ListItemComponent, ListLineDirective, ListModule, LoadMorePaginationComponent, MeasurableComponent, MeasurableModule, MeasurableService, MenuDirective, MenuDrawer, MenuIconDirective, MenuItemDirective, MenuSubTextDirective, MenuTextDirective, ModalBodyComponent, ModalComponent, ModalFooterComponent, ModalHeaderComponent, ModalModule, ModalOverlayComponent, ModalService, ModalWindowComponent, MonthViewComponent, MultiYearViewComponent, MultiselectComponent, MultiselectModule, NativeDateAdapter, NativeDateModule, NavbarCobrandComponent, NavbarComponent, NavbarDropdownComponent, NavbarLinkComponent, NavbarMobileMenuComponent, NavbarModule, NullOrEmptyStringPipe, NullOrEmptyStringPipeModule, NumberAbbreviatorPipe, NumberAbbreviatorPipeModule, PageEvent, PaginationComponent, PaginationModule, PickCustomItemTemplateDirective, PickItemLabelDirective, PickOptgroupTemplateDirective, PickOption, PickOptionComponent, PickOptionTemplateDirective, PickPaneComponent, PickPaneFooterTemplateDirective, PickPaneHeaderLeftTemplateDirective, PickPaneHeaderRightTemplateDirective, PickPaneListComponent, PickPaneToolbarTemplateDirective, PickerOverlayComponent, PicklistComponent, PicklistModule, PicklistOldComponent, PicklistOldModule, PicklistPaneComponent, PicklistRemoteQueryOptions, PipesModule, PopModule, ProgressBarComponent, ProgressDotsComponent, ProgressIndicatorsModule, ProgressSpinnerComponent, RadioButtonChangeEvent, RadioButtonComponent, RadioButtonModule, RadioGroupDirective, ReleaseNote, ReleaseNotesModalComponent, ReleaseNotesModalData, ReleaseNotesModalModule, ReleaseNotesService, ResizableComponent, ResizableContainerDirective, ResizableModule, ResizableStaticDirective, ScrollNavLinkDirective, ScrollNavModule, ScrollNavTargetDirective, SearchBarComponent, SearchBarModule, SelectChangeEvent, SelectComponent, SelectModule, SidenavBodyDirective, SidenavComponent, SidenavFooterDirective, SidenavHeaderDirective, SidenavLink, SidenavLinkClickEvent, SidenavModule, SidenavTabGroup, SimpleModalOptions, SlideToggleComponent, SlideToggleModule, SliderComponent, SliderModule, SortModule, SplitButtonClickEvent, SplitButtonComponent, StepperComponent, StepperModule, SubnavComponent, SubnavModule, SubnavRightDirective, TabChangeEvent, TabComponent, TabSetComponent, TableContainerDirective, TableModule, TabsModule, TileComponent, TileHeaderDirective, TileModule, ToasterModule, TypeformSurveyComponent, TypeformSurveyModule, YearViewComponent, hcSortAnimations };
export type { ArrowViewState, ArrowViewStateTransition, CalendarViewComponent, D, DateRange, DateRangeOptions, DragDropAssignment, HcCachedColumn, HcCalendarCellCssClasses, HcDateFormats, HcDynamicColumn, HcIcon, HcPopoverOpenOptions, HcSortable, HcToastOptions, IAppSwitcherConfig, IAppSwitcherService, IBreadcrumb, IDiscoveryApplication, IDiscoveryRequest, IInstance, IInstanceSwitcherTooltipText, IMetadataEnvironment, IPageSettings, IPagedCollection, IPicklistOptions, IPicklistOptionsSource, IPicklistRemoteQueryResponse, IPicklistSettings, IValueOption, IValueSetOption, ModalContentType, ModalOptions, ModalSize, PickSelectionModel, PresetItem, Sort, SortDirection, StepColor, StepInterface, StepType };