@ifsworld/granite-components 16.1.2 → 17.0.0

package/index.d.ts

@@ -1,86 +1,1981 @@
-export * from './lib/arrange-grid/arrange-grid.module';
-export * from './lib/arrange-grid/arrange-grid.component';
-export * from './lib/arrange-grid/arrange-grid-item.component';
-export * from './lib/grid/grid.module';
-export * from './lib/grid/grid.component';
-export * from './lib/badge/badge.module';
-export * from './lib/badge/badge.component';
-export * from './lib/badge/testing/badge.harness';
-export * from './lib/menu/menu.module';
-export * from './lib/menu/menu.component';
-export * from './lib/menu/menu-desktop-animations';
-export * from './lib/menu/menu-touch-animations';
-export * from './lib/menu/menu-item.component';
-export * from './lib/menu/menu-trigger-for.directive';
-export * from './lib/menu/testing/menu.harness';
-export * from './lib/menu/divider.directive';
-export * from './lib/menu/title.directive';
-export * from './lib/menu/menu-touch-close.component';
-export * from './lib/menu/menu-touch-title.component';
-export * from './lib/menu/menu-custom-template.directive';
-export * from './lib/icon/icon.module';
-export * from './lib/icon/icon.component';
-export * from './lib/toggle-switch/toggle-switch.module';
-export * from './lib/toggle-switch/toggle-switch.component';
-export * from './lib/radio-button/radio-button.module';
-export * from './lib/radio-button/radio-button.component';
-export * from './lib/radio-button/radio-group.component';
-export * from './lib/checkbox/checkbox.module';
-export * from './lib/checkbox/checkbox.component';
-export * from './lib/checkbox/checkbox-group.component';
-export * from './lib/button/button.module';
-export * from './lib/button/button.component';
-export * from './lib/input-field/input-field.module';
-export * from './lib/input-field/input-field.component';
-export * from './lib/chips/chips.module';
-export * from './lib/chips/chip-list.component';
-export * from './lib/chips/chip.component';
-export * from './lib/chips/chip-input';
-export * from './lib/label/label.module';
-export * from './lib/label/label.component';
-export * from './lib/contacts/contacts.module';
-export * from './lib/contacts/contacts.component';
-export * from './lib/contacts/contacts-types/contacts.component.public-types';
-export * from './lib/contacts/contacts-profile/contacts-profile.component';
-export * from './lib/contacts/contact-item/contact-item.component';
-export * from './lib/contacts/contact-item-default-status/contact-item-default-status.component';
-export * from './lib/contacts/contact-item-title/contact-item-title.component';
-export * from './lib/contacts/contacts-trigger/contacts-trigger-for.directive';
-export * from './lib/contacts/custom-status.directive';
-export * from './lib/contacts/custom-profile.directive';
-export * from './lib/contacts/contacts-types/contacts.component.public-types';
-export * from './lib/avatar/avatar.module';
-export * from './lib/avatar/avatar.component';
-export * from './lib/avatar/avatar-default-status/avatar-default-status.component';
-export * from './lib/avatar/custom-avatar-status.directive';
-export * from './lib/avatar/empty-avatar/empty-avatar.component';
-export * from './lib/avatar/avatar.component.public-types';
-export * from './lib/progress-bar/progress-bar.module';
-export * from './lib/progress-bar/progress-bar.component';
-export * from './lib/progress-bar/progress-bar.model';
-export * from './lib/core/client-environment';
-export * from './lib/core/core.module';
-export * from './lib/core/devices/client-output-touch.directive';
-export * from './lib/core/devices/client-output-desktop.directive';
-export * from './lib/core/devices/client-input-touch.directive';
-export * from './lib/core/devices/client-input-desktop.directive';
-export * from './lib/core/common-behaviors/disabled';
-export * from './lib/core/hide-on-overflow.directive';
-export * from './lib/core/pipes/pure-pipes.module';
-export * from './lib/core/pipes/title.pipe';
-export * from './lib/core/types';
-export * from './lib/card-list/card-list.module';
-export * from './lib/card-list/card-list.component';
-export * from './lib/card-list/card/card.component';
-export * from './lib/card-list/card/card-content/card-content.component';
-export * from './lib/card-list/card/card-content/card-actions.component';
-export * from './lib/card-list/card/card-content/card-body.component';
-export * from './lib/card-list/card/card-content/card-header.component';
-export * from './lib/card-list/card/card-avatar.component';
-export * from './lib/card-list/card/card-content/card-header-title.component';
-export * from './lib/card-list/card/card-content/card-header-subtitle.component';
-export * from './lib/card-list/card/card-content/card-footer.component';
-export * from './lib/collapsible-group/collapsible-group.module';
-export * from './lib/collapsible-group/collapsible-group.component';
-export * from './lib/collapsible-group/collapsible-group-body.directive';
-export * from './lib/collapsible-group/collapsible-group-header.directive';
+import * as i0 from '@angular/core';
+import { OnChanges, AfterContentInit, OnDestroy, QueryList, SimpleChanges, InjectionToken, TemplateRef, EventEmitter, AfterContentChecked, ElementRef, OnInit, AfterViewInit, DoCheck, PipeTransform } from '@angular/core';
+import * as i2 from '@angular/common';
+import { ComponentHarness, BaseHarnessFilters, HarnessPredicate } from '@angular/cdk/testing';
+import { FocusOrigin, FocusableOption, FocusMonitor, FocusKeyManager } from '@angular/cdk/a11y';
+import { Direction } from '@angular/cdk/bidi';
+import { AnimationEvent, AnimationTriggerMetadata } from '@angular/animations';
+import { Subject, BehaviorSubject, Observable, Subscription } from 'rxjs';
+import * as i10 from '@angular/cdk/overlay';
+import { ConnectedPosition, PositionStrategy, RepositionScrollStrategy, BlockScrollStrategy, CloseScrollStrategy } from '@angular/cdk/overlay';
+import * as i11 from '@angular/cdk/portal';
+import { SelectionModel } from '@angular/cdk/collections';
+import * as i5 from '@angular/forms';
+import { NgForm, FormGroupDirective, NgControl, ControlValueAccessor } from '@angular/forms';
+import * as i6 from '@ifsworld/granite-components/tooltip';
+import * as i12 from '@angular/cdk/scrolling';
+
+declare class GraniteArrangeGridItemComponent {
+    /**
+     * Column span to render.
+     * For use in template only. Do not use outside of this component.
+     * @ignore
+     */
+    _columnSpan: number | null;
+    private element;
+    /**
+     * Number of cells the item would span. Used by arrange grid in column
+     * orientation to fill any unused space caused by wrapped items.
+     */
+    set columnSpan(value: number | null);
+    /**
+     * Update element styles
+     */
+    updateStyles(): void;
+    /**
+     * Set CSS variable value or remove it if a null value is given.
+     * Would of course rather have used property binding but that is not
+     * supported until (perhaps) Angular 9.
+     * See: https://github.com/angular/angular/issues/9343
+     */
+    protected setCssProperty(variable: string, value: string | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteArrangeGridItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteArrangeGridItemComponent, "granite-arrange-grid-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare enum GraniteArrangeGridOrientation {
+    columns = "columns",
+    rows = "rows"
+}
+declare class GraniteArrangeGridComponent implements OnChanges, AfterContentInit, OnDestroy {
+    orientation: GraniteArrangeGridOrientation;
+    /** Default number of columns to use in column orientation */
+    /** Exposes column orientation to template */
+    classColumnOrientation: boolean;
+    /** Exposes row orientation to template */
+    classRowOrientation: boolean;
+    arrangeGridItemComponents: QueryList<GraniteArrangeGridItemComponent>;
+    static readonly defaultCols: number;
+    /** How to present grid items; `columns` (default) or `rows` */
+    /**
+     * Number of grid columns to use when orientation is set to `column`. The
+     * default is two columns.
+     */
+    set cols(value: number);
+    get cols(): number;
+    /** Number of columns to render */
+    protected _cols: number;
+    /**
+     * Number of rows to render. Will be set internally taking column count,
+     * the number of items and any cell wrapping into consideration.
+     */
+    protected _rows: number;
+    set rows(value: number);
+    get rows(): number;
+    private element;
+    /** Nexted on component destruction to complete other observables. */
+    private destroy$;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Update grid row template style.
+     *
+     * Use content height of all but last row and let the last grow
+     * to take up any remaining space.
+     */
+    updateStyles(): void;
+    /**
+     * Set CSS variable value or remove it if a null value is given.
+     * Would of course rather have used property binding but that is not
+     * supported until (perhaps) Angular 9.
+     * See: https://github.com/angular/angular/issues/9343
+     *
+     * TODO: Replace with property binding with Angular 9 upgrade
+     */
+    protected setCssProperty(variable: string, value: string | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteArrangeGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteArrangeGridComponent, "granite-arrange-grid", never, { "orientation": { "alias": "orientation"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; }, {}, ["arrangeGridItemComponents"], ["granite-arrange-grid-item"], false, never>;
+}
+
+declare class GraniteArrangeGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteArrangeGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteArrangeGridModule, [typeof GraniteArrangeGridComponent, typeof GraniteArrangeGridItemComponent], [typeof i2.CommonModule], [typeof GraniteArrangeGridComponent, typeof GraniteArrangeGridItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteArrangeGridModule>;
+}
+
+/**
+ * Grid item component
+ *
+ * Merely a wrapper for CSS Grid items, accepting item style as input parameters.
+ */
+declare class GraniteGridItemComponent implements OnChanges {
+    columnStart: number;
+    columnEnd: number;
+    rowStart: number;
+    rowEnd: number;
+    private element;
+    private renderer;
+    ngOnChanges(): void;
+    /**
+     * Update element styles
+     */
+    updateStyles(): void;
+    /**
+     * Sets the element style. Needs to be set manually to avoid "Changed after
+     * checked" errors that would occur with HostBinding.
+     */
+    private setStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteGridItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteGridItemComponent, "granite-grid-item", never, { "columnStart": { "alias": "columnStart"; "required": false; }; "columnEnd": { "alias": "columnEnd"; "required": false; }; "rowStart": { "alias": "rowStart"; "required": false; }; "rowEnd": { "alias": "rowEnd"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+/**
+ * Grid
+ *
+ * A wrapper around a native CSS Grid. Anything can be used for grid items, but
+ * `GridItemComponent` is recommended for common cases.
+ */
+declare class GraniteGridComponent implements AfterContentInit, OnChanges {
+    /**
+     * Number of grid columns, unless set via styling (grid-template-columns)
+     *
+     * Setting this value will produce equally sized columns
+     */
+    set cols(value: number);
+    get cols(): number;
+    /** Number of columns to render */
+    protected _cols: number;
+    /**
+     * Number of grid rows, unless set via styling (grid-template-rows)
+     *
+     * Setting this value will produce equally sized rows
+     */
+    set rows(value: number);
+    get rows(): number;
+    /** Number of rows to render */
+    protected _rows: number;
+    private element;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Update element styles */
+    updateStyles(): void;
+    /**
+     * Set CSS variable value or remove it if a null value is given.
+     * Would of course rather have used property binding but that is not
+     * supported until (perhaps) Angular 9.
+     * See: https://github.com/angular/angular/issues/9343
+     *
+     * TODO: Replace with property binding with Angular 9 upgrade
+     */
+    protected setCssProperty(variable: string, value: string | null): void;
+    /** Update grid column template style  */
+    protected updateColumnStyles(): void;
+    /** Update grid row template style  */
+    protected updateRowStyles(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteGridComponent, "granite-grid", never, { "cols": { "alias": "cols"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteGridModule, [typeof GraniteGridComponent, typeof GraniteGridItemComponent], [typeof i2.CommonModule], [typeof GraniteGridComponent, typeof GraniteGridItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteGridModule>;
+}
+
+declare class GraniteBadgeComponent implements OnChanges {
+    /**
+     * Design token name to get the value for the Background color
+     */
+    backgroundColor: string;
+    /**
+     * Design token name to get the value for the Font color
+     */
+    color: string;
+    /** Pill style badge */
+    pill: boolean;
+    private elementRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteBadgeComponent, "granite-badge", ["graniteBadge"], { "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "color": { "alias": "color"; "required": false; }; "pill": { "alias": "pill"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteBadgeModule, [typeof GraniteBadgeComponent], [typeof i2.CommonModule], [typeof GraniteBadgeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteBadgeModule>;
+}
+
+declare class GraniteBadgeHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `GraniteBadgeHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which badge instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: GraniteBadgeHarnessFilters): HarnessPredicate<GraniteBadgeHarness>;
+    /** Gets the Badge text. */
+    getText(): Promise<string>;
+    /** Whether it's a Pill type badge. */
+    isPill(): Promise<boolean>;
+}
+/** A set of criteria that can be used to filter a list of `GraniteBadgeHarness` instances. */
+interface GraniteBadgeHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    pill?: boolean;
+}
+
+/**
+ * Injection token used to provide components knowledge of what device types
+ * are being used for input.
+ */
+declare const GRANITE_CLIENT_INPUT: InjectionToken<ClientInputInterface>;
+/**
+ * Injection token used to provide components knowledge of what device type
+ * is being used for output.
+ */
+declare const GRANITE_CLIENT_OUTPUT: InjectionToken<ClientOutputInterface>;
+type InputDeviceTypes = void | 'touch' | 'mouse' | 'keyboard' | 'onscreen-keyboard';
+type OutputDeviceTypes = void | 'touch' | 'desktop';
+interface ClientInputInterface {
+    devices: InputDeviceTypes[];
+}
+interface ClientOutputInterface {
+    device: OutputDeviceTypes;
+}
+interface DevicePrefabInterface {
+    input: ClientInputInterface;
+    output: ClientOutputInterface;
+}
+declare const deviceDesktop: DevicePrefabInterface;
+declare const deviceTouch: DevicePrefabInterface;
+
+/**
+ * @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 MenuPositionX = 'before' | 'after' | 'center';
+type MenuPositionY = 'above' | 'below' | 'center';
+
+type ClosedEventType = void | 'click' | 'keydown' | 'tab';
+type OpenedEventType = void | 'click' | 'keydown';
+interface GraniteMenuPanelInterface {
+    xPosition: MenuPositionX;
+    yPosition: MenuPositionY;
+    templateRef: TemplateRef<any>;
+    parentMenu?: GraniteMenuPanelInterface | undefined;
+    direction?: Direction;
+    focusFirstItem: (origin?: FocusOrigin) => void;
+    closed: EventEmitter<ClosedEventType>;
+    opened: EventEmitter<OpenedEventType>;
+    readonly panelId?: string;
+    showBackButton: boolean;
+}
+
+declare class GraniteMenuItemComponent implements OnDestroy, FocusableOption {
+    /** ARIA role for the menu item. */
+    role: 'menuitem' | 'menuitemradio' | 'menuitemcheckbox';
+    _parentMenu?: GraniteMenuPanelInterface;
+    /** Stream that emits when the menu item is hovered. */
+    readonly _hovered: Subject<this>;
+    /** Stream that emits when the menu item is focused. */
+    readonly _focused: Subject<this>;
+    /** Whether the menu item acts as a trigger for a sub-menu (used for styling) */
+    _triggersSubmenu: boolean;
+    /**
+     * Whether the menu item is highlighted, e.g. in the "breadcrumb" parent chain
+     * of sub menu trigger items
+     */
+    _highlighted: boolean;
+    /** Client input device information */
+    _clientInput: ClientInputInterface;
+    /** Client output device information */
+    _clientOutput: ClientOutputInterface;
+    private _elementRef;
+    private _focusMonitor;
+    constructor();
+    ngOnDestroy(): void;
+    /** Focuses the menu item. */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Returns the host DOM element. */
+    _getHostElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteMenuItemComponent, "[graniteMenuItem]", ["graniteMenuItem"], { "role": { "alias": "role"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+/**
+ * Directive to mark an element as a custom template area within a menu.
+ * This allows inserting custom content (dropdowns, inputs, etc.) anywhere
+ * within the menu, maintaining the natural DOM order.
+ */
+declare class GraniteMenuCustomTemplateDirective {
+    private _elementRef;
+    _handleEvent(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuCustomTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteMenuCustomTemplateDirective, "[graniteMenuCustomTemplate]", ["graniteMenuCustomTemplate"], {}, {}, never, never, false, never>;
+}
+
+/** Menu panel animation states */
+type TransformMenuStates = 'void' | 'enter' | 'enter-from-below' | 'below-with-delay' | 'below' | 'pan' | 'hide' | 'pan-hidden';
+/**
+ * Menu panel animation transform/state object. Has to be an object as we supply
+ * the `xOffset` parameter and not just the state name.
+ */
+type TransformMenu = {
+    /** Current animation state name */
+    value: TransformMenuStates;
+    params: {
+        /** How far the menu has been panned/swiped by the user */
+        xOffset: number;
+    };
+};
+/** Base class with all of the menu functionality. */
+declare class _MenuBaseComponent implements AfterContentInit, OnDestroy, AfterContentChecked, GraniteMenuPanelInterface {
+    /** Position of the menu in the X axis. */
+    get xPosition(): MenuPositionX;
+    set xPosition(value: MenuPositionX);
+    /** Position of the menu in the Y axis. */
+    get yPosition(): MenuPositionY;
+    set yPosition(value: MenuPositionY);
+    /**
+     * Custom position configuration for the overlay.
+     * When provided, this overrides the default positioning logic based on
+     * xPosition and yPosition. Uses Angular CDK ConnectedPosition format.
+     * If empty or not provided, falls back to default positioning behavior.
+     */
+    cdkConnectedOverlayPosition: ConnectedPosition[];
+    /** Optional touch menu panel title */
+    title: string;
+    /**
+     * Touch menu close button label. If not set, any label set by parent will
+     * be used.
+     */
+    closeLabel: string;
+    openOnHover: boolean;
+    scrollStrategy: 'reposition' | 'close';
+    /**
+     * Styles to be applied to the menu.
+     * Added as there is no way to apply styles to the menu from the outside.
+     */
+    styles: {
+        [key: string]: string;
+    };
+    touchStyles: {
+        [key: string]: string;
+    };
+    templateRef: TemplateRef<any>;
+    /** All items inside the menu. Includes items nested inside another menu. */
+    _allItems: QueryList<GraniteMenuItemComponent>;
+    /**
+     * Event emitted when the menu is closed
+     */
+    readonly closed: EventEmitter<ClosedEventType>;
+    /**
+     * Event emitted when the menu is opened
+     */
+    readonly opened: EventEmitter<OpenedEventType>;
+    /**
+     * Reference to the custom template directive if present
+     */
+    customTemplate: GraniteMenuCustomTemplateDirective;
+    preventParentClose: boolean;
+    /**
+     * Used for locating the panel in tests and setting the aria-control attribute
+     * for the menu trigger.
+     */
+    readonly panelId: string;
+    /** Parent menu of the current menu panel. */
+    parentMenu: GraniteMenuPanelInterface | undefined;
+    /** Layout direction of the menu. */
+    direction: Direction;
+    /** Whether to show back button in touch menu title bar */
+    showBackButton: boolean;
+    /** Whether to show touch menu title bar */
+    showTitle: boolean;
+    /** Whether to add a close button below the menu */
+    showCloseButton: boolean;
+    /** Observable current state of the panel animation. */
+    _transformMenu: BehaviorSubject<TransformMenu>;
+    /** Emits whenever an animation on the menu completes. */
+    _animationDone: Subject<AnimationEvent>;
+    /** Whether the menu is animating. */
+    _isAnimating: boolean;
+    /** Whether the menu is about to be destroyed. */
+    _isClosing: boolean;
+    /** Client input device information */
+    _clientInput: ClientInputInterface;
+    /** Client output device information */
+    _clientOutput: ClientOutputInterface;
+    private _changeDetectorRef;
+    private _menuEmpty$;
+    _isMenuEmpty$: Observable<boolean>;
+    /** Only the direct descendant menu items. */
+    private _directDescendantItems;
+    private _keyManager;
+    /** Subscription to tab events on the menu panel */
+    private _tabSubscription;
+    private _xPosition;
+    private _yPosition;
+    /** Current state of the panel animation. */
+    set _panelAnimationState(state: TransformMenuStates);
+    /**
+     * Current horizontal offset. Used with `pan` and `pan-hidden`
+     * animation states.
+     */
+    private xOffset;
+    ngAfterContentChecked(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Stream that combines the `_hovered` observables of all the menu's items
+     * into a single observable. Emits whenever the hovered menu item changes.
+     */
+    _hovered(): Observable<GraniteMenuItemComponent>;
+    /** Handle a keyboard event from the menu, delegating to the appropriate action. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Focus the first item in the menu.
+     * @param origin Action from which the focus originated. Used to set the correct styling.
+     */
+    focusFirstItem(origin?: FocusOrigin): void;
+    /** Updates the `showTitle` property for touch device UI */
+    _updateShowTitle(): void;
+    /** Starts the enter animation */
+    _startAnimation(): void;
+    /** Resets the panel animation to its initial state. */
+    _resetAnimation(): void;
+    /**
+     * Starts the 'below' animation, moving a menu down, out of view below the
+     * viewport. Used to close the whole menu, for example when clicking
+     * the backdrop.
+     */
+    _startTouchCloseDownAnimation(): void;
+    /**
+     * Starts the 'below-with-delay' animation, moving a menu down, out of view below the
+     * viewport. Used to close the whole menu as a response to the user tapping
+     * a menu item. There is a short delay before the animation starts, to that
+     * the user gets a visual feedback on what item was selected.
+     */
+    _startTouchCloseDownAnimationWithDelay(): void;
+    /**
+     * Starts the 'void' animation, moving a (sub) menu out of view to the side
+     * of the viewport. Used when going "back" from a sub menu.
+     */
+    _startTouchCloseSideAnimation(): void;
+    /**
+     * Starts the enter-from-below animation, moving a (root) menu into view,
+     * Animates upwards from a starting position below the viewport.
+     */
+    _startTouchRootEnterAnimation(): void;
+    /** Starts the enter animation, moving a (sub) menu into view. */
+    _startTouchSubmenuEnterAnimation(): void;
+    /**
+     * Starts the pan animation, to position a submenu in a response
+     * to user dragging sideways (panning).
+     */
+    _startTouchPanAnimation(xOffset: number): void;
+    /**
+     * Starts the pan-hidden animation, to position a parent menu next to an
+     * active submenu that the user is dragging sideways (panning).
+     */
+    _startTouchHidePanAnimation(xOffset: number): void;
+    /**
+     * Starts the hide animation, to make a parent menu slide out to leave
+     * space for a submenu.
+     */
+    _startTouchHideAnimation(): void;
+    /** Callback that is invoked when the panel animation completes. */
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
+    /**
+     * Handle click on the menu by emitting on the `closed` emitter
+     * with a `click` reason
+     */
+    _handleClick(event?: Event): void;
+    /**
+     * Handle click on the close button by emitting on the `closed` emitter
+     * without any particular reason
+     */
+    _handleCloseClick(): void;
+    /**
+     * Handle click on the back icon by emitting on the `clicked` emitter
+     */
+    _handleBackClick(e: MouseEvent): void;
+    /**
+     * Update client device information for the menu and its menu items.
+     */
+    _setDevice(clientInput: ClientInputInterface, clientOutput: ClientOutputInterface): void;
+    /**
+     * Resets the active item in the menu. This is used when the menu is opened, allowing
+     * the user to start from the first option when pressing the down arrow.
+     */
+    resetActiveItem(): void;
+    /**
+     * Sets up a stream that will keep track of any newly-added menu items and will update the list
+     * of direct descendants. We collect the descendants this way, because `_allItems` can include
+     * items that are part of child menus, and using a custom way of registering items is unreliable
+     * when it comes to maintaining the item order.
+     */
+    private _updateDirectDescendants;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_MenuBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_MenuBaseComponent, never, never, { "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "cdkConnectedOverlayPosition": { "alias": "cdkConnectedOverlayPosition"; "required": false; }; "title": { "alias": "title"; "required": false; }; "closeLabel": { "alias": "closeLabel"; "required": false; }; "openOnHover": { "alias": "openOnHover"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; "styles": { "alias": "styles"; "required": false; }; "touchStyles": { "alias": "touchStyles"; "required": false; }; "preventParentClose": { "alias": "preventParentClose"; "required": false; }; }, { "closed": "closed"; "opened": "opened"; }, ["customTemplate", "_allItems"], never, true, never>;
+}
+
+declare class GraniteMenuComponent extends _MenuBaseComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteMenuComponent, "granite-menu", ["graniteMenu"], {}, {}, never, ["*"], false, never>;
+}
+
+/**
+ * Directive used to turn a button element into a (popup) menu trigger
+ *
+ * Stripped-down version of Angular Material's menu trigger directive (.../menu/menu-trigger.ts)
+ */
+declare class GraniteMenuTriggerForDirective implements AfterContentInit, OnDestroy, OnChanges {
+    /** References the menu instance that the trigger is associated with. */
+    menu: _MenuBaseComponent;
+    openOnClick?: boolean;
+    /** Whether the associated menu is open */
+    isMenuOpened: boolean;
+    private openedBy;
+    private _hoverSubscription;
+    private _menuCloseSubscription;
+    private _closingActionsSubscription;
+    private _portal;
+    private _overlayRef;
+    private _document?;
+    private _overlay;
+    private _element;
+    private _viewContainerRef;
+    private _changeDetectionRef;
+    private _parentMenu;
+    private _clientInput;
+    private _clientOutput;
+    private _menuItemInstance;
+    private _dir;
+    private _focusMonitor;
+    private _touchStartTime;
+    private _touchTimeTaken;
+    private _touchStartX;
+    private _touchStartY;
+    private _touchCurrentX;
+    private _touchCurrentY;
+    private _touchTranslateX;
+    private _touchLockedX;
+    private _touchMaxX;
+    private _touchTouchingElement;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Handles change of associated menu */
+    _handleMenuChange(): void;
+    isOpen(): boolean;
+    /** Open the associated menu */
+    openMenu(): void;
+    /** Emits an eventtype when the menu is opened */
+    openedEvent(): void;
+    /** Whether the menu triggers a sub-menu or a top-level one. */
+    triggersSubmenu(): boolean;
+    /** Toggles the menu between the open and closed states. */
+    toggleMenu(): void;
+    /** Close the associated menu */
+    closeMenu(): void;
+    /**
+     * Focuses the menu trigger.
+     * @param origin Source of the menu trigger's focus.
+     */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Detach menu portal from overlay and update open state */
+    _destroyMenu(): void;
+    /** Handles mouse presses on the trigger. */
+    _handleMousedown(event: MouseEvent): void;
+    /** Handles key presses on the trigger. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Handles click events on the trigger. */
+    _handleClick(event: MouseEvent): void;
+    /**
+     * Handles touch start events on the trigger.
+     * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
+     */
+    private _handleTouchStart;
+    /** Handles the cases where the user hovers over the trigger. */
+    private _handleHover;
+    /**
+     * Restores focus to the element that was focused before the menu was open.
+     * Could be the root trigger button or a submenu trigger item
+     */
+    private _restoreFocus;
+    private _setIsMenuOpen;
+    /**
+     * This method checks that a valid instance of MenuComponent has been passed into
+     * graniteMenuTriggerFor. If not, an exception is thrown.
+     */
+    private _checkMenu;
+    /**
+     * Returns strategy for positioning the overlay for desktop devices:
+     * Place adjacent to the trigger button (preferably immediately below)
+     * in order to show as much of the menu as possible.
+     */
+    private _desktopPositionStrategy;
+    /**
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param positionStrategy Strategy whose position to update.
+     */
+    private _setPosition;
+    /** Returns a stream that emits whenever an action that should close the menu occurs. */
+    private _menuClosingActions;
+    /**
+     * Whether to automatically open submenus on hover. This is true when showing
+     * desktop menus and having mouse support.
+     */
+    private _openOnHover;
+    /**
+     * Whether to toggle submenus on click. This is true when showing desktop menus
+     * without mouse support. Which, by the way, is not a great idea to begin with.
+     */
+    private _toggleOnSubmenuClick;
+    /** Set animation state to bring a newly opened menu into view */
+    private animateOpenMenu;
+    private animateTouchOpenMenu;
+    /** Set animation state to close the active menu */
+    private animateCloseMenu;
+    private _animateTouchCloseMenu;
+    /**
+     * Set animation state to place the menu and any parent at the given
+     * horizontal position, i.e. following touch pan movement.
+     *
+     * @param xOffset Horizontal offset
+     */
+    private animateSetMenuPosition;
+    /**
+     * Returns strategy for positioning the overlay depending on what type of
+     * device the menu is being shown on
+     */
+    private _positionStrategy;
+    /**
+     * Returns strategy for positioning the overlay for touch devices:
+     * Place centered at the bottom of the screen.
+     */
+    private _touchPositionStrategy;
+    /**
+     * Handles touch start events on the overlay host element (wrapper).
+     * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
+     */
+    private _handleOverlayTouchStart;
+    private _handleOverlayTouchMove;
+    private _handleOverlayTouchEnd;
+    /**
+     * Remove touch device pan/swipe listeners from overlay host element
+     */
+    private addOverlayListeners;
+    /**
+     * Remove touch device pan/swipe listeners from overlay host element
+     */
+    private removeOverlayListeners;
+    /**
+     * Standard exponential ease out function
+     *
+     * @param current Current value
+     * @param offset Offset value, to which calculated value will be added
+     * @param target The target value
+     * @param end Value to which current value is compared
+     */
+    private easeOutExpo;
+    /**
+     * Sets the scroll strategy for the overlay based on the client output device and menu scroll strategy input.
+     *
+     * @param {OutputDeviceTypes} clientOutputDevice - The type of client output device (e.g., 'touch').
+     * @param {'reposition' | 'close'} menuScrollStrategyInput - The scroll strategy input for the menu.
+     * @returns {ScrollStrategy} The appropriate scroll strategy for the overlay.
+     */
+    private setScrollStrategyToOverylay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuTriggerForDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteMenuTriggerForDirective, "[graniteMenuTriggerFor]", ["graniteMenuTriggerFor"], { "menu": { "alias": "graniteMenuTriggerFor"; "required": false; }; "openOnClick": { "alias": "openOnClick"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteMenuTouchCloseComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuTouchCloseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteMenuTouchCloseComponent, "[graniteMenuTouchCloseItem]", ["graniteMenuTouchCloseItem"], {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteMenuTouchTitleItemComponent {
+    /**
+     * Whether the menu item acts as a trigger to return to a parent menu
+     * (used for styling)
+     */
+    _triggersBack: boolean;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuTouchTitleItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteMenuTouchTitleItemComponent, "[graniteMenuTouchTitleItem]", ["graniteMenuTouchTitleItem"], {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteDividerDirective {
+    dividerDirection: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteDividerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteDividerDirective, "[graniteDivider]", ["graniteDivider"], { "dividerDirection": { "alias": "dividerDirection"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteTitleDirective, "[graniteTitle]", ["graniteTitle"], {}, {}, never, never, false, never>;
+}
+
+declare class GraniteIconComponent implements OnChanges {
+    fontIcon: string;
+    _elementRef: ElementRef<any>;
+    private renderer;
+    private _previousFontIconClass;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    private _updateFontIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteIconComponent, "granite-icon", never, { "fontIcon": { "alias": "fontIcon"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteIconModule, [typeof GraniteIconComponent], never, [typeof GraniteIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteIconModule>;
+}
+
+declare class GraniteMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteMenuModule, [typeof GraniteMenuComponent, typeof GraniteMenuItemComponent, typeof GraniteMenuTriggerForDirective, typeof GraniteMenuTouchCloseComponent, typeof GraniteMenuTouchTitleItemComponent, typeof GraniteDividerDirective, typeof GraniteTitleDirective, typeof GraniteMenuCustomTemplateDirective], [typeof i2.CommonModule, typeof i10.OverlayModule, typeof i11.PortalModule, typeof GraniteIconModule], [typeof GraniteMenuComponent, typeof GraniteMenuItemComponent, typeof GraniteMenuTriggerForDirective, typeof GraniteMenuTouchCloseComponent, typeof GraniteMenuTouchTitleItemComponent, typeof GraniteDividerDirective, typeof GraniteTitleDirective, typeof GraniteMenuCustomTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteMenuModule>;
+}
+
+/**
+ * Animations used by the `granite-menu` component, showing the desktop interface.
+ * @docs-private
+ */
+declare const graniteMenuDesktopAnimations: {
+    /**
+     * This animation trigger controls the menu panel's entry and exit from the
+     * stage on desktop output devices.
+     */
+    readonly transformMenuDesktop: AnimationTriggerMetadata;
+};
+
+/**
+ * Animations used by the `granite-menu` component, showing the touch interface.
+ * @docs-private
+ */
+declare const graniteMenuTouchAnimations: {
+    /**
+     * This animation trigger controls the menu panel's entry and exit from the
+     * stage on touch output devices.
+     */
+    readonly transformMenuTouch: AnimationTriggerMetadata;
+    /**
+     * This animation trigger controls the close button's entry and exit from the
+     * stage on touch output devices, using the same states as the menu panel.
+     */
+    readonly transformCloseButton: AnimationTriggerMetadata;
+};
+
+/**
+ * Test harness for menu component
+ *
+ * Stripped-down version of the Angular Material menu test harness (.../menu/menu-harness.ts)
+ * just to get things going.
+ */
+declare class GraniteMenuHarness extends ComponentHarness {
+    /**
+     * The selector for the host element of a `MenuComponent` instance,
+     * i.e. the button element used to open the menu.
+     */
+    static hostSelector: string;
+    private _documentRootLocator;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MenuHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which menu item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: GraniteMenuHarnessFilters): HarnessPredicate<GraniteMenuHarness>;
+    /** Gets the text of the menu trigger */
+    getText(): Promise<string>;
+    /** Opens the menu, unless already open */
+    open(): Promise<void>;
+    /** Closes the menu, unless already closed */
+    close(): Promise<void>;
+    /** Whether the menu is open */
+    isOpen(): Promise<boolean>;
+    /**
+     * Gets a list of `GraniteMenuItemHarness` representing the items in the menu.
+     * @param filters Optionally filters which menu items are included.
+     */
+    getItems(filters?: Omit<GraniteMenuItemHarnessFilters, 'ancestor'>): Promise<GraniteMenuItemHarness[]>;
+    /** Gets the menu panel (popup) associated with the menu */
+    private _getMenuPanel;
+    /** Gets the id of the menu panel (popup) associated with this menu */
+    private _getPanelId;
+}
+declare class GraniteMenuItemHarness extends ComponentHarness {
+    /** The selector for the host element of a `MenuItemComponent` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `GraniteMenuItemHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which menu item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: GraniteMenuItemHarnessFilters): HarnessPredicate<GraniteMenuItemHarness>;
+    /** Gets the text of the menu item. */
+    getText(): Promise<string>;
+    /** Whether this item has a submenu. */
+    hasSubmenu(): Promise<boolean>;
+    /** Gets the submenu associated with this menu item, or null if none. */
+    getSubmenu(): Promise<GraniteMenuHarness | null>;
+    /** Clicks the menu item. */
+    click(): Promise<void>;
+}
+/** A set of criteria that can be used to filter a list of `MenuHarness` instances. */
+interface GraniteMenuHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+}
+/** A set of criteria that can be used to filter a list of `GraniteMenuItemHarness` instances. */
+interface GraniteMenuItemHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+}
+
+type Position = 'before' | 'after';
+type Layout = 'horizontal' | 'vertical';
+
+declare class GraniteToggleSwitchComponent implements OnChanges {
+    id: string | null;
+    checked: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    labelPosition: Position;
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    readonly valueChange: EventEmitter<boolean>;
+    readonly toggleChange: EventEmitter<void>;
+    readonly toggleBlur: EventEmitter<void>;
+    private _inputElement;
+    _positionBefore: boolean;
+    _toggleSwitchDisabled: boolean;
+    private _focusMonitor;
+    ngOnChanges(changes: SimpleChanges): void;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    _onBlur(): void;
+    _toggleSwitchChange(): void;
+    _toggleSwitchClick(): void;
+    private _getInputElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteToggleSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteToggleSwitchComponent, "granite-toggle-switch", ["graniteToggleSwitch"], { "id": { "alias": "id"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, { "valueChange": "valueChange"; "toggleChange": "toggleChange"; "toggleBlur": "toggleBlur"; }, never, ["*"], false, never>;
+}
+
+declare class GraniteToggleSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteToggleSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteToggleSwitchModule, [typeof GraniteToggleSwitchComponent], never, [typeof GraniteToggleSwitchComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteToggleSwitchModule>;
+}
+
+declare class GraniteRadioButtonComponent implements OnChanges, OnDestroy {
+    value: any;
+    id: string | null;
+    name: string;
+    checked: boolean;
+    required: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    labelPosition: Position;
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    readonly radioChange: EventEmitter<any>;
+    readonly radioBlur: EventEmitter<void>;
+    private _inputElement;
+    _positionBefore: boolean;
+    _radioDisabled: boolean;
+    private _removeUniqueSelectionListenerFn;
+    private _focusMonitor;
+    private _radioDispatcher;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    _radioChange(element: Partial<HTMLInputElement>): void;
+    _onBlur(): void;
+    private _getInputElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteRadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteRadioButtonComponent, "granite-radio-button", ["graniteRadioButton"], { "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, { "radioChange": "radioChange"; "radioBlur": "radioBlur"; }, never, ["*"], false, never>;
+}
+
+declare abstract class GraniteRadioCheckboxBase {
+    layout: Layout;
+    ariaLabelledby: string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteRadioCheckboxBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteRadioCheckboxBase, never, never, { "layout": { "alias": "layout"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class GraniteRadioGroupComponent extends GraniteRadioCheckboxBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteRadioGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteRadioGroupComponent, "granite-radio-group", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteRadioButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteRadioButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteRadioButtonModule, [typeof GraniteRadioButtonComponent, typeof GraniteRadioGroupComponent], never, [typeof GraniteRadioButtonComponent, typeof GraniteRadioGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteRadioButtonModule>;
+}
+
+declare class GraniteCheckboxComponent implements OnChanges {
+    id: string | null;
+    checked: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    labelPosition: Position;
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    readonly valueChange: EventEmitter<boolean>;
+    readonly checkboxChange: EventEmitter<void>;
+    readonly checkboxBlur: EventEmitter<void>;
+    private _inputElement;
+    _positionBefore: boolean;
+    _checkboxDisabled: boolean;
+    private _focusMonitor;
+    ngOnChanges(changes: SimpleChanges): void;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    _onBlur(): void;
+    _checkboxChange(): void;
+    _checkboxClick(): void;
+    private _getInputElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCheckboxComponent, "granite-checkbox", ["graniteCheckbox"], { "id": { "alias": "id"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, { "valueChange": "valueChange"; "checkboxChange": "checkboxChange"; "checkboxBlur": "checkboxBlur"; }, never, ["*"], false, never>;
+}
+
+declare class GraniteCheckboxGroupComponent extends GraniteRadioCheckboxBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCheckboxGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCheckboxGroupComponent, "granite-checkbox-group", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteCheckboxModule, [typeof GraniteCheckboxComponent, typeof GraniteCheckboxGroupComponent], never, [typeof GraniteCheckboxComponent, typeof GraniteCheckboxGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteCheckboxModule>;
+}
+
+declare enum ButtonSelectors {
+    graniteButton = "granite-button",
+    granitePrimaryButton = "granite-primary-button",
+    graniteFlatButton = "granite-flat-button",
+    graniteToolbarButton = "granite-toolbar-button"
+}
+declare const ButtonComponentMixin: {
+    new (...args: any[]): {
+        [x: string]: unknown;
+        disabled: boolean;
+        ngOnChanges(changes: SimpleChanges): void;
+    };
+} & (new (...args: any[]) => Record<string, unknown>);
+declare class GraniteButtonComponent extends ButtonComponentMixin implements OnChanges {
+    toggled: boolean;
+    _buttonToggled: boolean;
+    protected _focusMonitor: FocusMonitor;
+    protected _elementRef: ElementRef<any>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    private _getHostElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteButtonComponent, "button[graniteButton],    button[granitePrimaryButton],    button[graniteFlatButton],    button[graniteToolbarButton]  ", ["graniteButton"], { "disabled": { "alias": "disabled"; "required": false; }; "toggled": { "alias": "toggled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+declare class GraniteAnchorComponent extends GraniteButtonComponent implements OnChanges {
+    _anchorClick(event: Event): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteAnchorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteAnchorComponent, "a[graniteButton],  a[graniteFlatButton]", ["graniteAnchor"], { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteButtonModule, [typeof GraniteButtonComponent, typeof GraniteAnchorComponent], never, [typeof GraniteButtonComponent, typeof GraniteAnchorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteButtonModule>;
+}
+
+declare class GraniteInputFieldComponent implements OnInit, OnChanges, AfterViewInit {
+    id: string | null;
+    name: string | null;
+    type: string;
+    value: string | number;
+    required: boolean;
+    readonly: boolean;
+    invalid: boolean;
+    disabled: boolean;
+    placeholder: string;
+    prefixicon: string;
+    maxlength: number;
+    countcharacters: boolean;
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    readonly valueChange: EventEmitter<string>;
+    private _inputElement;
+    private _textareaElement;
+    _supported: boolean;
+    _empty: boolean;
+    _passwordFieldIcon: string;
+    _passwordField: boolean;
+    _hasSuffixButton: boolean;
+    _currentCharCount: number;
+    private _passwordToggled;
+    private _lastEmittedValue;
+    private _focusMonitor;
+    private _cdr;
+    private _elementRef;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    _togglePassword(): void;
+    _onInput(event: Event): void;
+    protected _validateType(): void;
+    private _checkForSuffixButton;
+    private _applyCharacterCount;
+    private _getInputElement;
+    private _getTextareaElement;
+    private _emitValueIfChanged;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteInputFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteInputFieldComponent, "granite-input-field", ["graniteInputField"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "prefixicon": { "alias": "prefixicon"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "countcharacters": { "alias": "countcharacters"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["[graniteInputSuffixButton]"], false, never>;
+}
+
+declare class GraniteInputFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteInputFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteInputFieldModule, [typeof GraniteInputFieldComponent], [typeof i2.CommonModule, typeof GraniteIconModule, typeof GraniteButtonModule], [typeof GraniteInputFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteInputFieldModule>;
+}
+
+/** Event fired on an individual `granite-chip` element. */
+interface GraniteChipEvent {
+    /** The chip the event was fired on. */
+    chip: GraniteChipComponent;
+}
+/** Event object emitted by GraniteChip when selected or deselected. */
+declare class GraniteChipSelectionChangeEvent {
+    /** Reference to the chip that emitted the event. */
+    source: GraniteChipComponent;
+    /** Whether the chip that emitted the event is selected. */
+    selected: boolean;
+    /** Whether the selection change was a result of a user interaction. */
+    isUserInput: boolean;
+}
+declare class GraniteChipComponent implements FocusableOption, OnDestroy {
+    /** ARIA role that should be applied to the chip. */
+    role: string;
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    /** Emitted when the chip is selected or deselected. */
+    readonly selectionChange: EventEmitter<GraniteChipSelectionChangeEvent>;
+    /** Emitted when a chip is to be removed. */
+    readonly removed: EventEmitter<GraniteChipEvent>;
+    /** Emitted when the chip is destroyed. */
+    readonly destroyed: EventEmitter<GraniteChipEvent>;
+    /** Emits when the chip is focused. */
+    readonly chipFocus: EventEmitter<GraniteChipEvent>;
+    /** Emits when the chip is blurred. */
+    readonly chipBlur: EventEmitter<GraniteChipEvent>;
+    /** Whether the chip is selected. */
+    get selected(): boolean;
+    set selected(value: boolean);
+    /** The value of the chip. Defaults to the text content inside `<granite-chip>` tags. */
+    get value(): any;
+    set value(val: any);
+    /**
+     * Whether or not the chip is selectable. When a chip is not selectable,
+     * changes to its selected state are always ignored. By default a chip is
+     * selectable, and it becomes non-selectable if its parent chip list is
+     * not selectable.
+     */
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    /** Whether the chip is disabled. Also the individual chips are disabled when chip list is disabled */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Whether the chip can be removed from the list
+     */
+    get removable(): boolean;
+    set removable(value: boolean);
+    /** Whether the chip is in an invalid state. */
+    get invalid(): boolean;
+    set invalid(value: boolean);
+    _elementRef: ElementRef<any>;
+    /** Whether the chip has focus. */
+    _hasFocus: boolean;
+    /** Whether the chip list is selectable */
+    _chipListSelectable: boolean;
+    /** Whether the chip list is in multi-selection mode. */
+    _chipListMultiple: boolean;
+    /** Whether the chip list as a whole is disabled. */
+    _chipListDisabled: boolean;
+    tabIndex: number;
+    inputChip: boolean;
+    protected _selected: boolean;
+    protected _selectable: boolean;
+    protected _disabled: boolean;
+    protected _removable: boolean;
+    protected _invalid: boolean;
+    private _ngZone;
+    private _changeDetectorRef;
+    private _value;
+    constructor();
+    ngOnDestroy(): void;
+    /** Selects the chip. */
+    select(isUserInput?: boolean): void;
+    /** Deselects the chip. */
+    deselect(): void;
+    /** Toggles the current selected state of this chip. */
+    toggleSelected(isUserInput?: boolean): boolean;
+    /** Allows for programmatic focusing of the chip unless it's disabled. */
+    focus(): void;
+    /**
+     * Allows for programmatic removal of the chip.
+     * Called by the GraniteChipList when the DELETE or BACKSPACE keys are pressed.
+     * Informs any listeners of the removal request. Does not remove the chip from the DOM.
+     */
+    remove(): void;
+    /** Handles click events on the chip. */
+    _handleClick(event: Event): void;
+    /** Handle custom key presses. */
+    _handleKeydown(event: KeyboardEvent): void;
+    _handleRemoveClick(event: Event): void;
+    _blur(): void;
+    private _dispatchSelectionChange;
+    /** The ARIA selected applied to the chip. */
+    get ariaSelected(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteChipComponent, "granite-chip, granite-input-chip", ["graniteChip"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; "role": { "alias": "role"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; }, { "selectionChange": "selectionChange"; "removed": "removed"; "destroyed": "destroyed"; "chipFocus": "chipFocus"; "chipBlur": "chipBlur"; }, never, ["*"], false, never>;
+}
+
+interface GraniteChipTextControl {
+    /** Unique identifier for the text control. */
+    id: string;
+    /** The text control's placeholder text. */
+    placeholder: string;
+    /** Whether the text control has browser focus. */
+    focused: boolean;
+    /** Whether the text control is empty. */
+    empty: boolean;
+    /** Focuses the text control. */
+    setFocus(options?: FocusOptions): void;
+}
+/** Represents an input event on a `graniteChipInput`. */
+interface GraniteChipInputEvent {
+    /** The native `<input>` element that the event is being fired for. */
+    input: HTMLInputElement;
+    /** The value of the input. */
+    value: string;
+    /** Reference to the chip input that emitted the event. */
+    chipInput: GraniteChipInputDirective;
+}
+declare class GraniteChipInputDirective implements GraniteChipTextControl, OnChanges, OnDestroy, AfterContentInit {
+    /** Unique id for the input. */
+    id: string;
+    /** The input's placeholder text. */
+    placeholder: string;
+    /** Emitted when a chip is to be added. */
+    readonly graniteChipInputTokenEnd: EventEmitter<GraniteChipInputEvent>;
+    /** Register input for chip list */
+    set graniteChipInputFor(value: GraniteChipListComponent);
+    /**
+     * The list of key codes that will trigger a chipEnd event.
+     *
+     * Defaults to `[ENTER]`.
+     */
+    graniteChipInputSeparatorKeyCodes: readonly number[] | ReadonlySet<number>;
+    /**
+     * Whether or not the chipEnd event will be emitted when the input is blurred.
+     */
+    get graniteChipInputAddOnBlur(): boolean;
+    set graniteChipInputAddOnBlur(value: boolean);
+    _addOnBlur: boolean;
+    /**
+     * Whether this is a required field, currently we use it only for setting aria-required.
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    /** Whether the input is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** The native input element to which this directive is attached. */
+    readonly inputElement: HTMLInputElement;
+    _chipList: GraniteChipListComponent;
+    focused: boolean;
+    protected _elementRef: ElementRef<HTMLInputElement>;
+    protected _required: boolean | undefined;
+    /** Whether the input is empty. */
+    get empty(): boolean;
+    private _disabled;
+    /** Used to prevent focus moving to chips while user is holding backspace */
+    private _focusLastChipOnBackspace;
+    constructor();
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    /** Utility method to make host definition/tests more clear. */
+    _keydown(event?: KeyboardEvent): void;
+    /**
+     * Pass events to the keyboard manager. Available here for tests.
+     */
+    _keyup(event: KeyboardEvent): void;
+    /** Checks to see if the blur should emit the (chipEnd) event. */
+    _blur(): void;
+    _focus(): void;
+    /** Checks to see if the (chipEnd) event needs to be emitted. */
+    _emitChipEnd(event?: KeyboardEvent): void;
+    _onInput(): void;
+    /** Focuses the input (called from parent level). */
+    setFocus(options?: FocusOptions): void;
+    /** Clears the input */
+    clear(): void;
+    /** Checks whether a keycode is one of the configured separators. */
+    private _isSeparatorKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteChipInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteChipInputDirective, "input[graniteChipInputFor]", ["graniteChipInput", "graniteChipInputFor"], { "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "graniteChipInputFor": { "alias": "graniteChipInputFor"; "required": false; }; "graniteChipInputSeparatorKeyCodes": { "alias": "graniteChipInputSeparatorKeyCodes"; "required": false; }; "graniteChipInputAddOnBlur": { "alias": "graniteChipInputAddOnBlur"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "graniteChipInputTokenEnd": "graniteChipInputTokenEnd"; }, never, never, false, never>;
+}
+
+declare abstract class GraniteChipListBase {
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    readonly stateChanges: EventEmitter<void>;
+    constructor(_parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+}
+declare class GraniteChipListComponent extends GraniteChipListBase implements ControlValueAccessor, AfterContentInit, DoCheck, OnInit, OnDestroy {
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    ariaOrientation: 'horizontal' | 'vertical';
+    /** The chips contained within this chip list. */
+    chips: QueryList<GraniteChipComponent>;
+    /** The ARIA role applied to the chip list. */
+    get role(): string | null;
+    set role(role: string | null);
+    /** Whether the user should be allowed to select multiselect chips. */
+    get multiselect(): boolean;
+    set multiselect(value: boolean);
+    /**
+     * Whether the chip list is disabled.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Whether or not this chip list is selectable. When a chip list is not selectable,
+     * the selected states for all the chips inside the chip list are always ignored.
+     */
+    get selectable(): boolean;
+    set selectable(value: boolean);
+    set tabindex(value: number);
+    readonly controlType: string;
+    /** Uid of the chip list */
+    _uid: string;
+    /** Tab index for the chip list. */
+    _tabIndex: number;
+    /**
+     * User defined tab index.
+     * When it is not null, use user defined tab index. Otherwise use _tabIndex
+     */
+    _userTabIndex: number | null;
+    /** The FocusKeyManager which handles focus. */
+    _keyManager: FocusKeyManager<GraniteChipComponent>;
+    _selectionModel: SelectionModel<GraniteChipComponent>;
+    protected _elementRef: ElementRef<HTMLElement>;
+    /** The chip input to add more chips */
+    protected _chipInput: GraniteChipTextControl;
+    protected _disabled: boolean;
+    protected _selectable: boolean;
+    get focused(): boolean;
+    get empty(): boolean;
+    get chipSelectionChanges(): Observable<GraniteChipSelectionChangeEvent>;
+    get chipFocusChanges(): Observable<GraniteChipEvent>;
+    get chipBlurChanges(): Observable<GraniteChipEvent>;
+    get chipRemoveChanges(): Observable<GraniteChipEvent>;
+    private _changeDetectorRef;
+    private _dir;
+    /**
+     * When a chip is destroyed, we store the index of the destroyed chip until the chips
+     * query list notifies about the update. This is necessary because we cannot determine an
+     * appropriate chip that should receive focus until the array of chips updated completely.
+     */
+    private _lastDestroyedChipIndex;
+    /** Subject that emits when the component has been destroyed. */
+    private readonly _destroyed;
+    /** Subscription to focus changes in the chips. */
+    private _chipFocusSubscription;
+    /** Subscription to blur changes in the chips. */
+    private _chipBlurSubscription;
+    /** Subscription to selection changes in chips. */
+    private _chipSelectionSubscription;
+    /** Subscription to remove changes in chips. */
+    private _chipRemoveSubscription;
+    private _explicitRole?;
+    private _multiple;
+    constructor();
+    /** Function when changed */
+    _onChange: (value: any) => void;
+    /** Function when changed */
+    _onTouched: () => void;
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    /** Associates an HTML input element with this chip list. */
+    registerInput(inputElement: GraniteChipTextControl): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Focus chip list when click on the container.
+     */
+    onContainerClick(event: MouseEvent): void;
+    /**
+     * Focuses the first non-disabled chip in this chip list, or the associated input when there
+     * are no eligible chips.
+     */
+    focus(options?: FocusOptions): void;
+    /** Attempt to focus an input if we have one. */
+    _focusInput(options?: FocusOptions): void;
+    /**
+     * Pass events to the keyboard manager. Available here for tests.
+     */
+    _keydown(event: KeyboardEvent): void;
+    /** When blurred, mark the field as touched when focus moved outside the chip list. */
+    _blur(): void;
+    /** Mark the field as touched */
+    _markAsTouched(): void;
+    /**
+     * Removes the `tabindex` from the chip list and resets it back afterwards, allowing the
+     * user to tab out of it. This prevents the list from capturing focus and redirecting
+     * it back to the first chip, creating a focus trap, if it user tries to tab away.
+     */
+    _allowFocusEscape(): void;
+    /**
+     * Check the tab index as you should not be allowed to focus an empty list.
+     */
+    protected _updateTabIndex(): void;
+    /**
+     * If the amount of chips changed, we need to update the
+     * key manager state and focus the next closest chip.
+     */
+    protected _updateFocusForDestroyedChips(): void;
+    /**
+     * Utility to ensure all indexes are valid.
+     *
+     * @param index The index to be checked.
+     * @returns True if the index is valid for our list of chips.
+     */
+    private _isValidIndex;
+    private _setSelectionByValue;
+    /**
+     * Finds and selects the chip based on its value.
+     * @returns Chip that has the corresponding value.
+     */
+    private _selectValue;
+    private _initializeSelection;
+    /**
+     * Deselects every chip in the list.
+     * @param skip Chip that should not be deselected.
+     */
+    private _clearSelection;
+    /**
+     * Sorts the model values, ensuring that they keep the same
+     * order that they have in the panel.
+     */
+    private _sortValues;
+    private _compareWith;
+    private _resetChips;
+    private _dropSubscriptions;
+    /** Listens to user-generated selection events on each chip. */
+    private _listenToChipsSelection;
+    /** Listens to user-generated selection events on each chip. */
+    private _listenToChipsFocus;
+    private _listenToChipsRemoved;
+    /** Checks whether an event comes from inside a chip element. */
+    private _originatesFromChip;
+    /** Checks whether any of the chips is focused. */
+    private _hasFocusedChip;
+    /** Syncs the list's state with the individual chips. */
+    private _syncChipsState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteChipListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteChipListComponent, "granite-chip-list", ["graniteChipList"], { "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "ariaOrientation": { "alias": "aria-orientation"; "required": false; }; "role": { "alias": "role"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; }, {}, ["chips"], ["*"], false, never>;
+}
+
+declare class GraniteChipsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteChipsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteChipsModule, [typeof GraniteChipListComponent, typeof GraniteChipComponent, typeof GraniteChipInputDirective], [typeof i2.CommonModule, typeof i5.FormsModule, typeof i5.ReactiveFormsModule, typeof GraniteIconModule], [typeof GraniteChipListComponent, typeof GraniteChipComponent, typeof GraniteChipInputDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteChipsModule>;
+}
+
+declare class GraniteLabelComponent implements OnChanges {
+    for: string | null;
+    form: string | null;
+    required: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteLabelComponent, "granite-label", ["graniteLabel"], { "for": { "alias": "for"; "required": false; }; "form": { "alias": "form"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteLabelModule, [typeof GraniteLabelComponent], [typeof i2.CommonModule], [typeof GraniteLabelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteLabelModule>;
+}
+
+type ContactDefaultStatuses = (typeof CONTACT_DEFAULT_STATUS)[keyof typeof CONTACT_DEFAULT_STATUS];
+declare const CONTACT_DEFAULT_STATUS: {
+    readonly AVAILABLE: "Available";
+    readonly AWAY: "Away";
+    readonly BE_RIGHT_BACK: "BeRightBack";
+    readonly BUSY: "Busy";
+    readonly DO_NOT_DISTURB: "DoNotDisturb";
+    readonly OFFLINE: "Offline";
+};
+interface Contact<T = unknown> {
+    name: string;
+    label: string;
+    iconName?: string;
+    status?: ContactDefaultStatuses | string;
+    options?: ContactOption<T>[];
+    disabled?: boolean;
+    data?: T;
+}
+interface SelectedContact<T = unknown> {
+    contact: ContactOption<T>;
+    parent?: Contact<T>;
+}
+type ContactOption<T = unknown> = Omit<Contact<T>, 'options'>;
+interface Profile {
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    jobTitle?: string;
+    avatar?: string;
+}
+
+type PositionX$1 = 'before' | 'after';
+type PositionY$1 = 'above' | 'below';
+declare class ContactsTriggerDataComponent {
+    templateRef: TemplateRef<unknown>;
+    xPosition: PositionX$1;
+    yPosition: PositionY$1;
+    direction: Direction;
+    /**
+     * Used for locating the panel in tests and setting the aria-control attribute
+     * for the contacts trigger.
+     */
+    readonly panelId: string;
+    /** Client input device information */
+    clientInput: ClientInputInterface;
+    /** Client output device information */
+    clientOutput: ClientOutputInterface;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactsTriggerDataComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContactsTriggerDataComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class GraniteCustomStatusDirective {
+    graniteCustomStatus: string;
+    templateRef: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCustomStatusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteCustomStatusDirective, "[graniteCustomStatus]", never, { "graniteCustomStatus": { "alias": "graniteCustomStatus"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface ContactExtended extends Contact {
+    statusTemplate?: TemplateRef<unknown>;
+}
+type ProfileData = Omit<Profile, 'name'> & {
+    initials: string;
+};
+
+declare class GraniteCustomProfileDirective {
+    templateRef: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCustomProfileDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteCustomProfileDirective, "[graniteCustomProfile]", never, {}, {}, never, never, false, never>;
+}
+
+declare class GraniteContactsComponent extends ContactsTriggerDataComponent implements OnChanges, AfterContentChecked {
+    contacts: Contact[];
+    contactsClass: string;
+    profile: Profile | unknown;
+    profileClass: string;
+    defaultShow: boolean;
+    readonly selectedContact: EventEmitter<SelectedContact<unknown>>;
+    _customStatuses: QueryList<GraniteCustomStatusDirective>;
+    customProfileDirective: GraniteCustomProfileDirective;
+    _contactsExtended: ContactExtended[];
+    _profile: ProfileData;
+    private cd;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentChecked(): void;
+    onSelectedContact(contact: SelectedContact): void;
+    private setProperCustomStatusTemplates;
+    private applyTemplates;
+    private createProfileData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteContactsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteContactsComponent, "granite-contacts", ["graniteContacts"], { "contacts": { "alias": "contacts"; "required": false; }; "contactsClass": { "alias": "contactsClass"; "required": false; }; "profile": { "alias": "profile"; "required": false; }; "profileClass": { "alias": "profileClass"; "required": false; }; "defaultShow": { "alias": "defaultShow"; "required": false; }; }, { "selectedContact": "selectedContact"; }, ["customProfileDirective", "_customStatuses"], never, false, never>;
+}
+
+declare class GraniteContactsProfileComponent {
+    profile: ProfileData;
+    profileClass: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteContactsProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteContactsProfileComponent, "granite-contacts-profile", never, { "profile": { "alias": "profile"; "required": false; }; "profileClass": { "alias": "profileClass"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteContactItemComponent {
+    contact: ContactExtended;
+    readonly selectedContact: EventEmitter<SelectedContact<unknown>>;
+    emitSelectedContact(selectedContact: SelectedContact): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteContactItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteContactItemComponent, "granite-contact-item", never, { "contact": { "alias": "contact"; "required": false; }; }, { "selectedContact": "selectedContact"; }, never, never, false, never>;
+}
+
+declare class ContactItemDefaultStatusComponent {
+    status: ContactDefaultStatuses;
+    CONTACT_STATUS: {
+        readonly AVAILABLE: "Available";
+        readonly AWAY: "Away";
+        readonly BE_RIGHT_BACK: "BeRightBack";
+        readonly BUSY: "Busy";
+        readonly DO_NOT_DISTURB: "DoNotDisturb";
+        readonly OFFLINE: "Offline";
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContactItemDefaultStatusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContactItemDefaultStatusComponent, "granite-contact-item-default-status", never, { "status": { "alias": "status"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteContactItemTitleComponent {
+    contact: ContactExtended;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteContactItemTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteContactItemTitleComponent, "granite-contact-item-title", never, { "contact": { "alias": "contact"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteContactsTriggerForDirective implements AfterContentInit, OnDestroy {
+    /** References the contacts instance that the trigger is associated with. */
+    contacts: GraniteContactsComponent;
+    _clientInput: ClientInputInterface;
+    _clientOutput: ClientOutputInterface;
+    /** Whether the associated contacts is open */
+    _isContactsOpen: boolean;
+    private _overlay;
+    private _element;
+    private _viewContainerRef;
+    private _outsideClickDispatcher;
+    private _dir;
+    private _focusMonitor;
+    private _contactsCloseSubscription;
+    private _portal;
+    private _overlayRef;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    isOpen(): boolean;
+    openContacts(): void;
+    /** Toggles the contacts between the open and closed states. */
+    toggleContacts(): void;
+    /** Close the associated contacts */
+    closeContacts(): void;
+    /** Handles key presses on the trigger. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Handles click events on the trigger. */
+    _handleClick(): void;
+    /**
+     * Restores focus to the element that was focused before the contacts was open.
+     */
+    _restoreFocus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /**
+     * Returns strategy for positioning the overlay for desktop devices:
+     */
+    private _desktopPositionStrategy;
+    /**
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param positionStrategy Strategy whose position to update.
+     */
+    private _setPosition;
+    /**
+     * Returns strategy for positioning the overlay depending on what type of
+     * device the contacts is being shown on
+     */
+    private _positionStrategy;
+    /**
+     * Returns strategy for positioning the overlay for touch devices:
+     * Place centered in the screen.
+     */
+    private _touchPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteContactsTriggerForDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteContactsTriggerForDirective, "[graniteContactsTriggerFor]", never, { "contacts": { "alias": "graniteContactsTriggerFor"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteCustomAvatarStatusDirective {
+    graniteCustomAvatarStatus: string;
+    templateRef: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCustomAvatarStatusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteCustomAvatarStatusDirective, "[graniteCustomAvatarStatus]", never, { "graniteCustomAvatarStatus": { "alias": "graniteCustomAvatarStatus"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+type AvatarDefaultStatuses = (typeof AVATAR_DEFAULT_STATUS)[keyof typeof AVATAR_DEFAULT_STATUS];
+declare const AVATAR_DEFAULT_STATUS: {
+    readonly AVAILABLE: "Available";
+    readonly DO_NOT_DISTURB: "DoNotDisturb";
+    readonly DISABLED: "Disabled";
+    readonly AWAY: "Away";
+};
+
+declare class GraniteAvatarComponent extends ContactsTriggerDataComponent implements AfterContentChecked, OnChanges {
+    name: string;
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    status: AvatarDefaultStatuses;
+    ariaLabel: string | null;
+    _customStatusesQueryList: QueryList<GraniteCustomAvatarStatusDirective>;
+    _customStatusDirectives: Record<string, TemplateRef<unknown>>;
+    _nameInitials: string;
+    avatarAriaLabel: string;
+    private cd;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteAvatarComponent, "granite-avatar", ["graniteAvatar"], { "name": { "alias": "name"; "required": false; }; "firstName": { "alias": "firstName"; "required": false; }; "lastName": { "alias": "lastName"; "required": false; }; "avatar": { "alias": "avatar"; "required": false; }; "status": { "alias": "status"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; }, {}, ["_customStatusesQueryList"], never, false, never>;
+}
+
+type StatusClasses = 'available' | 'do-not-disturb' | 'disabled' | 'away';
+declare class GraniteAvatarDefaultStatusComponent {
+    status: AvatarDefaultStatuses;
+    AVATAR_STATUS: {
+        readonly AVAILABLE: "Available";
+        readonly DO_NOT_DISTURB: "DoNotDisturb";
+        readonly DISABLED: "Disabled";
+        readonly AWAY: "Away";
+    };
+    get statusClass(): StatusClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteAvatarDefaultStatusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteAvatarDefaultStatusComponent, "granite-avatar-default-status", never, { "status": { "alias": "status"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteEmptyAvatarComponent {
+    initials: string;
+    ariaLabel: string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteEmptyAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteEmptyAvatarComponent, "granite-empty-avatar", never, { "initials": { "alias": "initials"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class GraniteAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteAvatarModule, [typeof GraniteAvatarComponent, typeof GraniteAvatarDefaultStatusComponent, typeof GraniteCustomAvatarStatusDirective, typeof GraniteEmptyAvatarComponent], [typeof i2.CommonModule], [typeof GraniteAvatarComponent, typeof GraniteAvatarDefaultStatusComponent, typeof GraniteCustomAvatarStatusDirective, typeof GraniteEmptyAvatarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteAvatarModule>;
+}
+
+declare class GraniteContactsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteContactsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteContactsModule, [typeof GraniteContactsComponent, typeof GraniteContactsProfileComponent, typeof GraniteContactItemComponent, typeof ContactItemDefaultStatusComponent, typeof GraniteContactItemTitleComponent, typeof GraniteContactsTriggerForDirective, typeof GraniteCustomStatusDirective, typeof GraniteCustomProfileDirective], [typeof GraniteIconModule, typeof GraniteAvatarModule, typeof i2.CommonModule], [typeof GraniteContactsComponent, typeof GraniteContactsTriggerForDirective, typeof GraniteContactItemComponent, typeof GraniteCustomStatusDirective, typeof GraniteCustomProfileDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteContactsModule>;
+}
+
+interface GraniteProgressInterface {
+    value: number;
+    label?: string;
+    valueLabel?: string;
+    backgroundColor?: string;
+    foregroundColor?: string;
+}
+interface GraniteProgressLegendInterface {
+    label: string;
+    backgroundColor: string;
+}
+
+declare class GraniteProgressBarComponent implements OnChanges {
+    progressBarData: GraniteProgressInterface[];
+    legendData: GraniteProgressLegendInterface[];
+    showLabel: boolean;
+    showLegend: boolean;
+    DEFAULT_TOTAL: number;
+    DEFAULT_BACKGROUND: string;
+    DEFAULT_STACK_COLOR: string;
+    DEFAULT_COLOR: string;
+    total: number;
+    legendItems: GraniteProgressLegendInterface[];
+    getBackgroundColor(): string;
+    getFontColor(color: string): string;
+    getStackColor(color: string): string;
+    getColorVar(color: string): string;
+    getWidth(value: number): number;
+    getStringOfWidth(width: number): string;
+    checkStackTotal(): void;
+    getStackTotal(): number;
+    setLegendItems(): void;
+    getLegendItems(data: GraniteProgressInterface[] | GraniteProgressLegendInterface[]): GraniteProgressLegendInterface[];
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteProgressBarComponent, "granite-progress-bar", ["graniteProgressBar"], { "progressBarData": { "alias": "progressBarData"; "required": false; }; "legendData": { "alias": "legendData"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+type PositionX = 'before' | 'after';
+type PositionY = 'above' | 'below';
+declare class OverlayBaseComponent {
+    templateRef: TemplateRef<any>;
+    xPosition: PositionX;
+    yPosition: PositionY;
+    direction: Direction;
+    clientInput: ClientInputInterface;
+    clientOutput: ClientOutputInterface;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlayBaseComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class LegendBaseComponent extends OverlayBaseComponent {
+    readonly panelId: string;
+    xPosition: PositionX;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LegendBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LegendBaseComponent, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class GraniteProgressBarLegendComponent extends LegendBaseComponent {
+    legendItems: GraniteProgressLegendInterface[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteProgressBarLegendComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteProgressBarLegendComponent, "granite-progress-bar-legend", never, { "legendItems": { "alias": "legendItems"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface OverlayPositionConfig {
+    originX?: 'start' | 'center' | 'end';
+    originFallbackX?: 'start' | 'center' | 'end';
+    originY?: 'top' | 'center' | 'bottom';
+    originFallbackY?: 'top' | 'center' | 'bottom';
+    overlayX?: 'start' | 'center' | 'end';
+    overlayFallbackX?: 'start' | 'center' | 'end';
+    overlayY?: 'top' | 'center' | 'bottom';
+    overlayFallbackY?: 'top' | 'center' | 'bottom';
+    offsetX?: number;
+    offsetY?: number;
+}
+
+declare class GraniteOverlayTriggerForBaseDirective implements OnDestroy {
+    /** Client output device information */
+    private _clientOutput;
+    /** Client input device information */
+    private _clientInput;
+    private _dir;
+    protected componentRef: OverlayBaseComponent;
+    protected selector: string;
+    protected offsetX: number;
+    protected offsetY: number;
+    private _overlayRef;
+    private _overlay;
+    private _element;
+    private _viewContainerRef;
+    private _overlayService;
+    ngOnDestroy(): void;
+    protected getPositionConfig(): OverlayPositionConfig;
+    protected getPositionStrategy(): PositionStrategy;
+    protected getScrollStrategy(): RepositionScrollStrategy | BlockScrollStrategy | CloseScrollStrategy;
+    protected setScrollStrategy(scrollStrategy: 'reposition' | 'block' | 'close'): RepositionScrollStrategy | BlockScrollStrategy | CloseScrollStrategy;
+    protected toggleOverlay(isOpen: boolean): boolean;
+    protected onOutsideClick(): void;
+    private _openOverlay;
+    private _closeOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteOverlayTriggerForBaseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteOverlayTriggerForBaseDirective, "[graniteOverlayTriggerForBase]", never, {}, {}, never, never, false, never>;
+}
+
+declare class GraniteProgressBarLegendTriggerForDirective extends GraniteOverlayTriggerForBaseDirective {
+    get legend(): OverlayBaseComponent;
+    set legend(value: GraniteProgressBarLegendComponent);
+    isLegendOpen: boolean;
+    protected selector: string;
+    protected offsetY: number;
+    handleKeydown(event: KeyboardEvent): void;
+    handleClick(): void;
+    onOutsideClick(): void;
+    getScrollStrategy(): RepositionScrollStrategy | BlockScrollStrategy | CloseScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteProgressBarLegendTriggerForDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteProgressBarLegendTriggerForDirective, "[graniteProgressBarLegendTriggerFor]", never, { "legend": { "alias": "graniteProgressBarLegendTriggerFor"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Directive used to tell components and their sub components that client output
+ * should be adapted for desktop devices like personal computers.
+ */
+declare class ClientOutputDesktopDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientOutputDesktopDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClientOutputDesktopDirective, "[graniteClientOutputDesktop]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Directive used to tell components and their sub components that client output
+ * should be adapted for touch devices like mobiles and tablets.
+ */
+declare class ClientOutputTouchDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientOutputTouchDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClientOutputTouchDirective, "[graniteClientOutputTouch]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Directive used to tell components and their sub components that client input
+ * should be adapted for desktop devices, like personal computers.
+ */
+declare class ClientInputDesktopDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientInputDesktopDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClientInputDesktopDirective, "[graniteClientInputDesktop]", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Directive used to tell components and their sub components that client input
+ * should be adapted for touch devices, like mobiles and tablets.
+ */
+declare class ClientInputTouchDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientInputTouchDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClientInputTouchDirective, "[graniteClientInputTouch]", never, {}, {}, never, never, false, never>;
+}
+
+declare class GraniteHideOnOverflowDirective implements AfterViewInit, OnDestroy {
+    resizeObserver: ResizeObserver;
+    resizeSubscription: Subscription;
+    mutationObserver: MutationObserver;
+    private _elementRef;
+    private renderer;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    hideOnOverflow(): void;
+    observeResize(): void;
+    unObserveResize(): void;
+    subscribeToResize(): void;
+    observeContentChange(): void;
+    unObserveContentChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteHideOnOverflowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteHideOnOverflowDirective, "[graniteHideOnOverflow]", ["graniteHideOnOverflow"], {}, {}, never, never, false, never>;
+}
+
+declare class GraniteCoreModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteCoreModule, [typeof ClientOutputDesktopDirective, typeof ClientOutputTouchDirective, typeof ClientInputDesktopDirective, typeof ClientInputTouchDirective, typeof GraniteHideOnOverflowDirective, typeof GraniteOverlayTriggerForBaseDirective], never, [typeof ClientOutputDesktopDirective, typeof ClientOutputTouchDirective, typeof ClientInputDesktopDirective, typeof ClientInputTouchDirective, typeof GraniteHideOnOverflowDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteCoreModule>;
+}
+
+declare class GraniteProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteProgressBarModule, [typeof GraniteProgressBarComponent, typeof GraniteProgressBarLegendComponent, typeof GraniteProgressBarLegendTriggerForDirective], [typeof i2.CommonModule, typeof GraniteCoreModule, typeof i6.GraniteTooltipModule, typeof GraniteIconModule, typeof GraniteButtonModule], [typeof GraniteProgressBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteProgressBarModule>;
+}
+
+type Constructor<T> = new (...args: any[]) => T;
+declare const disabledMixin: <T extends Constructor<Record<string, unknown>>>(Base?: T) => {
+    new (...args: any[]): {
+        [x: string]: unknown;
+        disabled: boolean;
+        ngOnChanges(changes: SimpleChanges): void;
+    };
+} & T;
+
+declare class GraniteTitlePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteTitlePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GraniteTitlePipe, "graniteTitle", false>;
+}
+
+declare class PurePipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PurePipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PurePipesModule, [typeof GraniteTitlePipe], never, [typeof GraniteTitlePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PurePipesModule>;
+}
+
+declare class GraniteCardComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardComponent, "granite-card", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardListComponent {
+    /**Present cards in vertically or horizontally */
+    orientation: 'horizontal' | 'vertical';
+    wrap: 'wrap' | 'nowrap';
+    gap: 'small' | 'medium' | 'large';
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardListComponent, "granite-card-list", never, { "orientation": { "alias": "orientation"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardContentComponent, "granite-card-content", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardHeaderComponent, "granite-card-header", never, {}, {}, never, ["granite-card-header-title", "granite-card-header-sub-title", "*"], false, never>;
+}
+
+declare class GraniteCardActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardActionsComponent, "granite-card-actions", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardBodyComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardBodyComponent, "granite-card-body", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardFooterComponent, "granite-card-footer", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardAvatarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardAvatarComponent, "granite-card-avatar", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardHeaderTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardHeaderTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardHeaderTitleComponent, "granite-card-header-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardHeaderSubTitleComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardHeaderSubTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCardHeaderSubTitleComponent, "granite-card-header-sub-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class GraniteCardListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCardListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteCardListModule, [typeof GraniteCardComponent, typeof GraniteCardListComponent, typeof GraniteCardContentComponent, typeof GraniteCardHeaderComponent, typeof GraniteCardActionsComponent, typeof GraniteCardBodyComponent, typeof GraniteCardFooterComponent, typeof GraniteCardAvatarComponent, typeof GraniteCardHeaderTitleComponent, typeof GraniteCardHeaderSubTitleComponent], [typeof i2.CommonModule, typeof i12.ScrollingModule], [typeof GraniteCardComponent, typeof GraniteCardListComponent, typeof GraniteCardContentComponent, typeof GraniteCardHeaderComponent, typeof GraniteCardBodyComponent, typeof GraniteCardActionsComponent, typeof GraniteCardFooterComponent, typeof GraniteCardAvatarComponent, typeof GraniteCardHeaderTitleComponent, typeof GraniteCardHeaderSubTitleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteCardListModule>;
+}
+
+declare class GraniteCollapsibleConditionalBodyDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCollapsibleConditionalBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteCollapsibleConditionalBodyDirective, "[graniteCollapsibleGroupBody]", ["graniteCollapsibleGroupBody"], {}, {}, never, never, false, never>;
+}
+
+declare class GraniteCollapsibleConditionalHeaderDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCollapsibleConditionalHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraniteCollapsibleConditionalHeaderDirective, "[graniteCollapsibleGroupHeader]", ["graniteCollapsibleGroupHeader"], {}, {}, never, never, false, never>;
+}
+
+declare class GraniteCollapsibleGroupComponent {
+    collapsed: boolean;
+    id: string;
+    arialabel: string | null;
+    readonly collapsedChanged: EventEmitter<boolean>;
+    conditionalBodyContentRef: GraniteCollapsibleConditionalBodyDirective;
+    conditionalHeaderContentRef: GraniteCollapsibleConditionalHeaderDirective;
+    toggleCollapsibleGroup(): void;
+    _toogleCollapsing(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCollapsibleGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraniteCollapsibleGroupComponent, "granite-collapsible-group", never, { "collapsed": { "alias": "collapsed"; "required": false; }; "id": { "alias": "id"; "required": false; }; "arialabel": { "alias": "arialabel"; "required": false; }; }, { "collapsedChanged": "collapsedChanged"; }, ["conditionalBodyContentRef", "conditionalHeaderContentRef"], never, false, never>;
+}
+
+declare class GraniteCollapsibleGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraniteCollapsibleGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraniteCollapsibleGroupModule, [typeof GraniteCollapsibleGroupComponent, typeof GraniteCollapsibleConditionalHeaderDirective, typeof GraniteCollapsibleConditionalBodyDirective], [typeof i2.CommonModule, typeof GraniteIconModule], [typeof GraniteCollapsibleGroupComponent, typeof GraniteCollapsibleConditionalHeaderDirective, typeof GraniteCollapsibleConditionalBodyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraniteCollapsibleGroupModule>;
+}
+
+export { AVATAR_DEFAULT_STATUS, ButtonSelectors, CONTACT_DEFAULT_STATUS, ClientInputDesktopDirective, ClientInputTouchDirective, ClientOutputDesktopDirective, ClientOutputTouchDirective, ContactItemDefaultStatusComponent, GRANITE_CLIENT_INPUT, GRANITE_CLIENT_OUTPUT, GraniteAnchorComponent, GraniteArrangeGridComponent, GraniteArrangeGridItemComponent, GraniteArrangeGridModule, GraniteArrangeGridOrientation, GraniteAvatarComponent, GraniteAvatarDefaultStatusComponent, GraniteAvatarModule, GraniteBadgeComponent, GraniteBadgeHarness, GraniteBadgeModule, GraniteButtonComponent, GraniteButtonModule, GraniteCardActionsComponent, GraniteCardAvatarComponent, GraniteCardBodyComponent, GraniteCardComponent, GraniteCardContentComponent, GraniteCardFooterComponent, GraniteCardHeaderComponent, GraniteCardHeaderSubTitleComponent, GraniteCardHeaderTitleComponent, GraniteCardListComponent, GraniteCardListModule, GraniteCheckboxComponent, GraniteCheckboxGroupComponent, GraniteCheckboxModule, GraniteChipComponent, GraniteChipInputDirective, GraniteChipListComponent, GraniteChipSelectionChangeEvent, GraniteChipsModule, GraniteCollapsibleConditionalBodyDirective, GraniteCollapsibleConditionalHeaderDirective, GraniteCollapsibleGroupComponent, GraniteCollapsibleGroupModule, GraniteContactItemComponent, GraniteContactItemTitleComponent, GraniteContactsComponent, GraniteContactsModule, GraniteContactsProfileComponent, GraniteContactsTriggerForDirective, GraniteCoreModule, GraniteCustomAvatarStatusDirective, GraniteCustomProfileDirective, GraniteCustomStatusDirective, GraniteDividerDirective, GraniteEmptyAvatarComponent, GraniteGridComponent, GraniteGridItemComponent, GraniteGridModule, GraniteHideOnOverflowDirective, GraniteIconComponent, GraniteIconModule, GraniteInputFieldComponent, GraniteInputFieldModule, GraniteLabelComponent, GraniteLabelModule, GraniteMenuComponent, GraniteMenuCustomTemplateDirective, GraniteMenuHarness, GraniteMenuItemComponent, GraniteMenuItemHarness, GraniteMenuModule, GraniteMenuTouchCloseComponent, GraniteMenuTouchTitleItemComponent, GraniteMenuTriggerForDirective, GraniteProgressBarComponent, GraniteProgressBarModule, GraniteRadioButtonComponent, GraniteRadioButtonModule, GraniteRadioGroupComponent, GraniteTitleDirective, GraniteTitlePipe, GraniteToggleSwitchComponent, GraniteToggleSwitchModule, PurePipesModule, deviceDesktop, deviceTouch, disabledMixin, graniteMenuDesktopAnimations, graniteMenuTouchAnimations };
+export type { AvatarDefaultStatuses, ClientInputInterface, ClientOutputInterface, Contact, ContactDefaultStatuses, ContactOption, GraniteBadgeHarnessFilters, GraniteChipEvent, GraniteChipInputEvent, GraniteChipTextControl, GraniteMenuHarnessFilters, GraniteMenuItemHarnessFilters, GraniteProgressInterface, GraniteProgressLegendInterface, InputDeviceTypes, Layout, OutputDeviceTypes, Position, Profile, SelectedContact, StatusClasses };