@theseam/ui-common 0.4.30 → 1.0.0-beta.0

package/framework/index.d.ts

@@ -1,5 +1,1372 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/framework" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef, TemplateRef, OnInit, InjectionToken, OnDestroy, EventEmitter, ComponentRef, EmbeddedViewRef, AfterViewInit, QueryList, ViewContainerRef, AfterContentInit } from '@angular/core';
+import { HasElementRef, CanDisableCtor } from '@theseam/ui-common/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { TemplatePortal, ComponentType, ComponentPortal, BasePortalOutlet, Portal, CdkPortalOutletAttachedRef } from '@angular/cdk/portal';
+import { MediaQueryAliases, TheSeamLayoutService } from '@theseam/ui-common/layout';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { TheSeamElementResizedEvent } from '@theseam/ui-common/shared';
+import { SeamIcon } from '@theseam/ui-common/icon';
+import { ThemeTypes } from '@theseam/ui-common/models';
+import * as i3 from '@angular/router';
+import { UrlCreationOptions, IsActiveMatchOptions, Router, ActivatedRoute, RouterOutlet, Resolve, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { MenuComponent } from '@theseam/ui-common/menu';
+import * as _angular_animations from '@angular/animations';
+import * as i2 from '@angular/common';
+import * as i2$1 from '@ajsf/core';
+import { JsonSchemaFormService, isArray, TitleMapItem, Framework } from '@ajsf/core';
+import { AbstractControl } from '@angular/forms';
+import { TheSeamTiledSelectItem, TheSeamTiledSelectLayout } from '@theseam/ui-common/tiled-select';
+
+declare class BaseLayoutContentFooterDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutContentFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutContentFooterDirective, "[seamBaseLayoutContentFooter]", ["seamBaseLayoutContentFooter"], {}, {}, never, never, true, never>;
+}
+
+declare class BaseLayoutContentHeaderDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutContentHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutContentHeaderDirective, "[seamBaseLayoutContentHeader]", ["seamBaseLayoutContentHeader"], {}, {}, never, never, true, never>;
+}
+
+declare class BaseLayoutContentDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutContentDirective, "[seamBaseLayoutContent]", ["seamBaseLayoutContent"], {}, {}, never, never, true, never>;
+}
+
+interface TheSeamBaseLayoutActionBase {
+    type: string;
+    /**
+     * This needs to be unique to identify the specific action.
+     */
+    name: string;
+    /**
+     * Will be used when the UI needs text to represent the action.
+     */
+    label: string;
+    disabled?: boolean;
+}
+interface TheSeamBaseLayoutActionButton extends TheSeamBaseLayoutActionBase {
+    type: 'button';
+    exec: () => Promise<void> | Observable<void> | void;
+}
+interface TheSeamBaseLayoutActionRouterLink extends TheSeamBaseLayoutActionBase {
+    type: 'router-link';
+    url: string;
+}
+interface TheSeamBaseLayoutActionHref extends TheSeamBaseLayoutActionBase {
+    type: 'href';
+    url: string;
+}
+interface TheSeamBaseLayoutActionTemplate extends TheSeamBaseLayoutActionBase {
+    type: 'template';
+    template: TemplateRef<any>;
+}
+type TheSeamBaseLayoutAction = TheSeamBaseLayoutActionButton | TheSeamBaseLayoutActionRouterLink | TheSeamBaseLayoutActionHref | TheSeamBaseLayoutActionTemplate;
+
+/**
+ * A class implementing this interface can be registered as a nav with the
+ * `TheSeamBaseLayoutComponent`.
+ *
+ * A benefit to registering the nav is that the base layout can control the
+ * expand state.
+ */
+interface TheSeamBaseLayoutNav {
+    /** Is nav expanded. */
+    expanded$: Observable<boolean>;
+    /** Expand the nav. */
+    expand: () => void;
+    /** Collapse the nav. */
+    collapse: () => void;
+    /** Toggle the expand state. */
+    toggle: () => void;
+}
+
+interface TheSeamBaseLayoutRef {
+    readonly registeredNav: TheSeamBaseLayoutNav | undefined;
+    readonly registeredActions: TheSeamBaseLayoutAction[];
+    readonly registeredNav$: Observable<TheSeamBaseLayoutNav | undefined>;
+    readonly registeredActions$: Observable<TheSeamBaseLayoutAction[]>;
+    registerNav(nav: TheSeamBaseLayoutNav): void;
+    unregisterNav(nav: TheSeamBaseLayoutNav): void;
+    registerAction(action: TheSeamBaseLayoutAction): void;
+    unregisterAction(action: TheSeamBaseLayoutAction | string): void;
+    isActionRegistered(actionName: string): boolean;
+}
+
+/**
+ * Can be used to toggle the expand state of the registered nav.
+ */
+declare class TheSeamBaseLayoutNavToggleDirective implements OnInit {
+    private readonly _cdr;
+    private readonly _baseLayout;
+    baseLayout: TheSeamBaseLayoutRef | undefined;
+    get _attrType(): string | null | undefined;
+    type: string | undefined | null;
+    get _attrAriaLabel(): string | null;
+    /** Screenreader label for the button. */
+    ariaLabel: string | undefined | null;
+    _toggleClass: boolean;
+    _expandedClass: boolean;
+    _onClick(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamBaseLayoutNavToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamBaseLayoutNavToggleDirective, "button[seamBaseLayoutNavToggle]", ["seamBaseLayoutNavToggle"], { "type": { "alias": "type"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BaseLayoutSideBarFooterDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutSideBarFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutSideBarFooterDirective, "[seamBaseLayoutSideBarFooter]", ["seamBaseLayoutSideBarFooter"], {}, {}, never, never, true, never>;
+}
+
+declare class BaseLayoutSideBarDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutSideBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutSideBarDirective, "[seamBaseLayoutSideBar]", ["seamBaseLayoutSideBar"], {}, {}, never, never, true, never>;
+}
+
+declare class BaseLayoutTopBarDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutTopBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutTopBarDirective, "[seamBaseLayoutTopBar]", ["seamBaseLayoutTopBar"], {}, {}, never, never, true, never>;
+}
+
+declare class BaseLayoutSideBarHeaderDirective implements HasElementRef {
+    readonly _elementRef: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayoutSideBarHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseLayoutSideBarHeaderDirective, "[seamBaseLayoutSideBarHeader]", ["seamBaseLayoutSideBarHeader"], {}, {}, never, never, true, never>;
+}
+
+declare const THE_SEAM_BASE_LAYOUT: any;
+declare class TheSeamBaseLayoutComponent implements OnInit, TheSeamBaseLayoutRef {
+    private readonly _viewContainerRef;
+    private readonly _layout;
+    readonly faAngleDoubleRight: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly faAngleDoubleLeft: _fortawesome_fontawesome_common_types.IconDefinition;
+    overlayNav: boolean;
+    mobileBreakpoint: MediaQueryAliases | undefined;
+    showSidebar: boolean | undefined;
+    _topBarTpl?: TemplateRef<any> | null;
+    _sideBarTpl?: TemplateRef<any> | null;
+    _contentTpl?: TemplateRef<any> | null;
+    _contentHeaderTpl?: TemplateRef<any> | null;
+    _contentFooterTpl?: TemplateRef<any> | null;
+    _topBarPortal?: TemplatePortal;
+    _sideBarPortal?: TemplatePortal;
+    _contentPortal?: TemplatePortal;
+    _contentHeaderPortal?: TemplatePortal;
+    _contentFooterPortal?: TemplatePortal;
+    private readonly _hasSideBar;
+    readonly hasSideBar$: Observable<boolean>;
+    readonly isMobile$: Observable<boolean>;
+    get registeredNav(): TheSeamBaseLayoutNav | undefined;
+    private readonly _registeredNav;
+    readonly registeredNav$: Observable<TheSeamBaseLayoutNav | undefined>;
+    get registeredActions(): TheSeamBaseLayoutAction[];
+    private readonly _registeredActions;
+    readonly registeredActions$: Observable<TheSeamBaseLayoutAction[]>;
+    constructor();
+    ngOnInit(): void;
+    registerNav(nav: TheSeamBaseLayoutNav): void;
+    unregisterNav(nav: TheSeamBaseLayoutNav): void;
+    registerAction(action: TheSeamBaseLayoutAction): void;
+    unregisterAction(action: TheSeamBaseLayoutAction | string): void;
+    isActionRegistered(actionName: string): boolean;
+    _handleButtonAction(action: TheSeamBaseLayoutActionButton): void;
+    _execButtonAction(action: TheSeamBaseLayoutActionButton): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamBaseLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamBaseLayoutComponent, "seam-base-layout", never, { "overlayNav": { "alias": "overlayNav"; "required": false; }; "mobileBreakpoint": { "alias": "mobileBreakpoint"; "required": false; }; "showSidebar": { "alias": "showSidebar"; "required": false; }; }, {}, ["_topBarTpl", "_sideBarTpl", "_contentTpl", "_contentHeaderTpl", "_contentFooterTpl"], never, true, never>;
+}
+
+declare class TheSeamBaseLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamBaseLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamBaseLayoutModule, never, [typeof TheSeamBaseLayoutComponent, typeof BaseLayoutContentDirective, typeof BaseLayoutSideBarDirective, typeof BaseLayoutSideBarFooterDirective, typeof BaseLayoutSideBarHeaderDirective, typeof BaseLayoutTopBarDirective, typeof TheSeamBaseLayoutNavToggleDirective, typeof BaseLayoutContentHeaderDirective, typeof BaseLayoutContentFooterDirective], [typeof TheSeamBaseLayoutComponent, typeof BaseLayoutContentDirective, typeof BaseLayoutSideBarDirective, typeof BaseLayoutSideBarFooterDirective, typeof BaseLayoutSideBarHeaderDirective, typeof BaseLayoutTopBarDirective, typeof TheSeamBaseLayoutNavToggleDirective, typeof BaseLayoutContentHeaderDirective, typeof BaseLayoutContentFooterDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamBaseLayoutModule>;
+}
+
+declare const THESEAM_BASE_LAYOUT_REF: InjectionToken<TheSeamBaseLayoutRef>;
+
+interface IDashboardWidgetsItemDef<T = any> {
+    widgetId: string;
+    col?: number;
+    order?: number;
+    component: ComponentType<T> | string;
+}
+interface IDashboardWidgetsItem<T = any> {
+    widgetId: string;
+    col: number;
+    order: number;
+    portal: ComponentPortal<T>;
+    __itemDef: IDashboardWidgetsItemDef;
+}
+interface IDashboardWidgetsColumnRecord {
+    column: number;
+    items: IDashboardWidgetsItem[];
+}
+interface IDashboardWidgetItemLayout {
+    readonly name: string;
+    /**
+     * If not provided, the name will be used for the label.
+     */
+    readonly label?: string;
+    readonly items: IDashboardWidgetsItem[];
+}
+interface IDashboardWidgetsItemSerialized {
+    readonly widgetId: string;
+    readonly col: number;
+    readonly order: number;
+}
+interface IDashboardWidgetItemLayoutPreference {
+    readonly name: string;
+    /**
+     * If not provided, the name will be used for the label.
+     */
+    readonly label?: string;
+    readonly items: IDashboardWidgetsItemSerialized[];
+}
+interface IDashboardWidgetsPreferences {
+    layouts?: IDashboardWidgetItemLayoutPreference[];
+}
+
+declare class DashboardWidgetContainerComponent {
+    def: IDashboardWidgetsItemDef | undefined | null;
+    templateRef?: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardWidgetContainerComponent, "seam-dashboard-widget-container", never, { "def": { "alias": "def"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class DashboardWidgetTemplateContainerComponent {
+    private readonly _dashboardWidgetsComponent;
+    item: IDashboardWidgetsItem | undefined | null;
+    readonly template$: Observable<TemplateRef<any> | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetTemplateContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardWidgetTemplateContainerComponent, "seam-dashboard-widget-template-container", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Mostly copied from
+ * `https://github.com/angular/components/blob/master/src/cdk/portal/portal-directives.ts`
+ * until I can figure out how to hold off removing the DOM nodes with the
+ * cdkPortalOutlet. When we update to Angular 9 I may be able to do this better
+ * with the new DomPortal.
+ *
+ * Directive version of a PortalOutlet. Because the directive *is* a
+ * PortalOutlet, portals can be directly attached to it, enabling declarative
+ * use.
+ *
+ * Usage: `<ng-template [cdkPortalOutlet]="greeting"></ng-template>`
+ */
+declare class DashboardWidgetPortalOutletDirective extends BasePortalOutlet implements OnInit, OnDestroy {
+    private readonly _viewContainerRef;
+    /** Whether the portal component is initialized. */
+    private _isInitialized;
+    /** Reference to the currently-attached component/view ref. */
+    private _attachedRef?;
+    /** Portal associated with the Portal outlet. */
+    get portal(): Portal<any> | null;
+    set portal(portal: Portal<any> | null);
+    /** Emits when a portal is attached to the outlet. */
+    attached: EventEmitter<CdkPortalOutletAttachedRef>;
+    /** Component or view reference that is attached to the portal. */
+    get attachedRef(): CdkPortalOutletAttachedRef | undefined;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Attach the given ComponentPortal to this PortalOutlet.
+     *
+     * @param portal Portal to be attached to the portal outlet.
+     * @returns Reference to the created component.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /**
+     * Attach the given TemplatePortal to this PortlHost as an embedded View.
+     * @param portal Portal to be attached.
+     * @returns Reference to the created embedded view.
+     */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetPortalOutletDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DashboardWidgetPortalOutletDirective, "[seamDashboardWidgetPortalOutlet]", ["seamDashboardWidgetPortalOutlet"], { "portal": { "alias": "seamDashboardWidgetPortalOutlet"; "required": false; }; }, { "attached": "attached"; }, never, never, true, never>;
+}
+
+interface ITheSeamDashboardWidgetsPreferencesAccessor {
+    /**
+     * Gets a preference.
+     */
+    get(name: string): Observable<string>;
+    /**
+     * Update a preference.
+     */
+    update(name: string, value: string): Observable<string>;
+    /**
+     * Delete a preference.
+     */
+    delete(name: string): Observable<boolean>;
+}
+
+declare const THESEAM_DASHBOARD_WIDGETS_PREFERENCES_ACCESSOR: InjectionToken<ITheSeamDashboardWidgetsPreferencesAccessor>;
+
+interface IDashboardWidgetsPreferencesMapRecord {
+    observable: Observable<IDashboardWidgetsPreferences>;
+    refresh: Subject<void>;
+}
+/**
+ * Manages anything dealing with retrieving and updating dashboard widget
+ * preference data from the provided accessor.
+ */
+declare class DashboardWidgetsPreferencesService {
+    private readonly _prefsAccessor;
+    private readonly _tablePrefsMap;
+    preferences(preferenceKey: string): Observable<IDashboardWidgetsPreferences>;
+    private _createObservable;
+    refresh(preferenceKey: string): Observable<void>;
+    selectLayout(preferenceKey: string, layoutName: string): Observable<IDashboardWidgetItemLayoutPreference | undefined>;
+    updateLayout(preferenceKey: string, layout: IDashboardWidgetItemLayout): Observable<void>;
+    toSerializeableLayout(layout: IDashboardWidgetItemLayout): IDashboardWidgetItemLayoutPreference;
+    /**
+     * Returns the serializable widget items as objects that can be serialized to
+     * a JSON string for storage.
+     */
+    toSerializeableItems(widgets: IDashboardWidgetsItem[]): IDashboardWidgetsItemSerialized[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetsPreferencesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardWidgetsPreferencesService>;
+}
+
+interface DashboardWidgetsAccessor {
+    containers$: Observable<DashboardWidgetContainerComponent[]>;
+}
+
+declare class DashboardWidgetsComponent implements OnInit, OnDestroy, AfterViewInit, DashboardWidgetsAccessor {
+    static ngAcceptInputType_gapSize: NumberInput;
+    static ngAcceptInputType_numColumns: NumberInput;
+    static ngAcceptInputType_widgetsDraggable: BooleanInput;
+    static ngAcceptInputType_dragToggleVisible: BooleanInput;
+    static ngAcceptInputType_widgets: IDashboardWidgetsItemDef[] | undefined | null;
+    private readonly _dashboardWidgets;
+    private readonly _viewContainerRef;
+    private readonly _cdr;
+    private readonly _baseLayoutRef;
+    readonly faLock: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly faUnlock: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly _actionWidgetDragToggleName = "widget-drag-toggle";
+    private readonly _ngUnsubscribe;
+    get gapSize(): number;
+    set gapSize(val: number);
+    private readonly _gapSize;
+    widgetsDraggable: boolean;
+    get dragToggleVisible(): boolean;
+    set dragToggleVisible(val: boolean);
+    private _dragToggleVisible;
+    get numColumns(): number;
+    set numColumns(val: number);
+    set widgets(value: IDashboardWidgetsItemDef[]);
+    get widgets(): IDashboardWidgetsItemDef[];
+    readonly widgetItems$: Observable<IDashboardWidgetsItem[]>;
+    readonly widgetColumns$: Observable<IDashboardWidgetsColumnRecord[]>;
+    readonly containers$: Observable<DashboardWidgetContainerComponent[]>;
+    readonly _gapStyleSize$: Observable<number>;
+    containers?: QueryList<DashboardWidgetContainerComponent>;
+    cdkDragDirectives?: QueryList<CdkDrag>;
+    _toggleBtnTpl?: TemplateRef<any>;
+    private readonly _containers;
+    private readonly _layoutChange;
+    readonly widgetsChange: EventEmitter<IDashboardWidgetsItem<any>[]>;
+    private readonly _widthChange;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    private _registerToggleAction;
+    private _unregisterToggleAction;
+    private _isActionToggleActionRegistered;
+    drop(event: CdkDragDrop<string[]>): void;
+    _containerTrackByFn(index: number, item: IDashboardWidgetsItem): string;
+    _columnsTrackByFn(index: number, record: IDashboardWidgetsColumnRecord): number;
+    toggleDragging(): void;
+    _resized(event: TheSeamElementResizedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardWidgetsComponent, "seam-dashboard-widgets", never, { "gapSize": { "alias": "gapSize"; "required": false; }; "widgetsDraggable": { "alias": "widgetsDraggable"; "required": false; }; "dragToggleVisible": { "alias": "dragToggleVisible"; "required": false; }; "numColumns": { "alias": "numColumns"; "required": false; }; "widgets": { "alias": "widgets"; "required": false; }; }, { "widgetsChange": "widgetsChange"; }, never, never, true, never>;
+}
+
+declare class DashboardWidgetsService {
+    private readonly _dynamicComponentLoaderModule;
+    private readonly _preferences;
+    readonly preferenceKey: string;
+    readonly defaultNumColumns: number;
+    /** Used for operations, such as 'addWidget', if the column is not specified. */
+    readonly defaultColumn: number;
+    get widgets(): IDashboardWidgetsItemDef[];
+    set widgets(value: IDashboardWidgetsItemDef[]);
+    private readonly _widgets;
+    get numColumns(): number;
+    set numColumns(value: number);
+    private readonly _numColumns;
+    readonly numColumns$: Observable<number>;
+    readonly widgetItems$: Observable<IDashboardWidgetsItem[]>;
+    readonly widgetColumns$: Observable<IDashboardWidgetsColumnRecord[]>;
+    private readonly _viewContainerRefSubject;
+    constructor();
+    private _layoutName;
+    setViewContainerRef(vcr: ViewContainerRef | undefined): void;
+    createWidgetItems(defs: IDashboardWidgetsItemDef[], vcr?: ViewContainerRef): Observable<IDashboardWidgetsItem[]>;
+    createWidgetItem(def: IDashboardWidgetsItemDef, vcr?: ViewContainerRef): Observable<IDashboardWidgetsItem | undefined>;
+    createWidgetPortal(def: IDashboardWidgetsItemDef, vcr?: ViewContainerRef): Observable<ComponentPortal<any>>;
+    updateOrder(): Observable<void>;
+    toColumnRecords(items: IDashboardWidgetsItem[]): IDashboardWidgetsColumnRecord[];
+    withLayoutPreferences(items: IDashboardWidgetsItem[], layout: IDashboardWidgetItemLayoutPreference): IDashboardWidgetsItem[];
+    savePreferences(): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardWidgetsService>;
+}
+
+declare class DashboardComponent {
+    widgets: IDashboardWidgetsItemDef[] | undefined | null;
+    widgetsDraggable: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "seam-dashboard", never, { "widgets": { "alias": "widgets"; "required": false; }; "widgetsDraggable": { "alias": "widgetsDraggable"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamDashboardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDashboardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamDashboardModule, never, [typeof DashboardComponent, typeof DashboardWidgetsComponent, typeof DashboardWidgetContainerComponent, typeof DashboardWidgetTemplateContainerComponent, typeof DashboardWidgetPortalOutletDirective], [typeof DashboardComponent, typeof DashboardWidgetsComponent, typeof DashboardWidgetPortalOutletDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamDashboardModule>;
+}
+
+interface SideNavAccessor {
+    overlay: boolean;
+    collapse(): void;
+}
+declare const THESEAM_SIDE_NAV_ACCESSOR: InjectionToken<SideNavAccessor>;
+interface SideNavConfig {
+    /**
+     * Default: false
+     */
+    activeNavigatable: boolean;
+}
+declare const THESEAM_SIDE_NAV_CONFIG: InjectionToken<SideNavConfig>;
+declare const DEFAULT_SIDE_NAV_CONFIG: SideNavConfig;
+
+interface ISideNavItemState {
+    active: boolean;
+    expanded: boolean;
+}
+interface SideNavItemCanHaveState {
+    /**
+     * This prop is managed by the SideNav. If manually set it will be overwritten.
+     *
+     * @ignore
+     */
+    __state?: ISideNavItemState;
+}
+interface SideNavItemCanBeActive {
+    /**
+     * Can navigate, when active.
+     *
+     * Enable if you need to receive events when the item is already active, such
+     * as observing `NavigationSkipped` router events.
+     *
+     * Default: false
+     */
+    activeNavigatable?: boolean;
+}
+interface SideNavItemCanHaveChildren {
+    children?: ISideNavItem[];
+}
+interface ISideNavItemBase<T extends string> extends SideNavItemCanHaveState {
+    /**
+     * default: 'route'
+     */
+    itemType?: T;
+    badge?: ISideNavBadge;
+}
+interface ISideNavTitle extends ISideNavItemBase<'title'> {
+    label?: string;
+}
+interface ISideNavDivider extends ISideNavItemBase<'divider'> {
+    label?: string;
+}
+interface ISideNavBadge {
+    text?: string;
+    theme?: ThemeTypes;
+    /**
+     * Content to provide to assistive technology, such as screen readers.
+     */
+    srContent?: string;
+    tooltip?: string | SideNavItemBadgeTooltip;
+}
+interface ISideNavBasic extends ISideNavItemBase<'basic'>, SideNavItemCanHaveChildren {
+    icon?: SeamIcon;
+    label: string;
+}
+interface ISideNavLink extends ISideNavItemBase<'link'>, Partial<Pick<UrlCreationOptions, 'queryParams' | 'fragment' | 'queryParamsHandling' | 'preserveFragment'>>, SideNavItemCanHaveChildren, SideNavItemCanBeActive {
+    icon?: SeamIcon;
+    label: string;
+    link?: any[] | string;
+    /**
+     * Default: { paths: 'subset', queryParams: 'subset', fragment: 'ignored', matrixParams: 'ignored' }
+     */
+    matchOptions?: Partial<IsActiveMatchOptions>;
+}
+interface ISideNavButton extends ISideNavItemBase<'button'>, SideNavItemCanBeActive {
+    onClick: (event: MouseEvent) => void;
+}
+type ISideNavItem = ISideNavTitle | ISideNavDivider | ISideNavBasic | ISideNavLink | ISideNavButton;
+interface SideNavItemStateChanged {
+    item: ISideNavItem;
+    prop: string;
+    prevValue: any;
+    newValue: any;
+}
+interface SideNavItemBadgeTooltip {
+    tooltip?: string;
+    class?: string;
+    placement?: string;
+    container?: string;
+    disabled?: boolean;
+}
+/**
+ * When `never`, menu item tooltip is always disabled.
+ * When `always`, menu item tooltip is always enabled.
+ * When `collapseOnly`, menu item tooltip is enabled only when the sidenav is collapsed.
+ */
+type SideNavItemMenuItemTooltipBehavior = 'never' | 'always' | 'collapseOnly';
+interface SideNavItemMenuItemTooltipConfig {
+    class?: string;
+    placement?: string;
+    container?: string;
+    behavior?: SideNavItemMenuItemTooltipBehavior;
+}
+
+declare class SideNavItemComponent implements OnDestroy {
+    private readonly _sideNav;
+    static ngAcceptInputType_hierLevel: NumberInput;
+    static ngAcceptInputType_indentSize: NumberInput;
+    static ngAcceptInputType_expanded: BooleanInput;
+    static ngAcceptInputType_compact: BooleanInput;
+    static ngAcceptInputType_active: BooleanInput;
+    private readonly _ngUnsubscribe;
+    readonly faAngleLeft: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly _linkHistoryState: {
+        seamReload: boolean;
+        triggeredByNavBar: boolean;
+    };
+    itemType: 'divider' | 'basic' | 'link' | 'button' | 'title' | undefined | null;
+    icon: SeamIcon | undefined | null;
+    hideEmptyIcon: boolean | undefined | null;
+    label: string | undefined | null;
+    active: boolean;
+    activeNavigatable: boolean;
+    set link(value: string | undefined | null);
+    get link(): string | undefined | null;
+    private readonly _link;
+    readonly link$: Observable<string | null | undefined>;
+    queryParams: {
+        [k: string]: any;
+    } | undefined | null;
+    children: ISideNavItem[] | undefined | null;
+    hierLevel: number;
+    indentSize: number;
+    set expanded(value: boolean);
+    get expanded(): boolean;
+    private readonly _expanded;
+    readonly expanded$: Observable<boolean>;
+    set compact(value: boolean);
+    get compact(): boolean;
+    private readonly _compact;
+    readonly compact$: Observable<boolean>;
+    isMobile: boolean | undefined | null;
+    badgeText: string | undefined | null;
+    badgeTheme: ThemeTypes | undefined | null;
+    /**
+     * Content to provide to assistive technology, such as screen readers.
+     */
+    badgeSrContent: string | undefined | null;
+    get badgeTooltip(): string | SideNavItemBadgeTooltip | undefined | null;
+    set badgeTooltip(value: string | SideNavItemBadgeTooltip | undefined | null);
+    private _badgeTooltip;
+    menuItemTooltipConfig: SideNavItemMenuItemTooltipConfig | undefined | null;
+    menuItemTooltipDisabled: boolean | undefined | null;
+    get _isActiveCssClass(): boolean;
+    get _isClickableWhenActiveCssClass(): boolean;
+    get _attrDataHierLevel(): number;
+    readonly childGroupAnimState$: Observable<string>;
+    constructor(_sideNav: SideNavAccessor);
+    ngOnDestroy(): void;
+    get hasChildren(): boolean;
+    toggleChildren(): void;
+    _linkClicked(): void;
+    get showIconBlock(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideNavItemComponent, "seam-side-nav-item", ["seamSideNavItem"], { "itemType": { "alias": "itemType"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "hideEmptyIcon": { "alias": "hideEmptyIcon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "active": { "alias": "active"; "required": false; }; "activeNavigatable": { "alias": "activeNavigatable"; "required": false; }; "link": { "alias": "link"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "children": { "alias": "children"; "required": false; }; "hierLevel": { "alias": "hierLevel"; "required": false; }; "indentSize": { "alias": "indentSize"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "isMobile": { "alias": "isMobile"; "required": false; }; "badgeText": { "alias": "badgeText"; "required": false; }; "badgeTheme": { "alias": "badgeTheme"; "required": false; }; "badgeSrContent": { "alias": "badgeSrContent"; "required": false; }; "badgeTooltip": { "alias": "badgeTooltip"; "required": false; }; "menuItemTooltipConfig": { "alias": "menuItemTooltipConfig"; "required": false; }; "menuItemTooltipDisabled": { "alias": "menuItemTooltipDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SideNavToggleComponent {
+    static ngAcceptInputType_expanded: BooleanInput;
+    expanded: boolean;
+    toggleIcon: SeamIcon | undefined | null;
+    toggleTpl: TemplateRef<any> | undefined | null;
+    toggleExpand: EventEmitter<void>;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideNavToggleComponent, "seam-side-nav-toggle", never, { "expanded": { "alias": "expanded"; "required": false; }; "toggleIcon": { "alias": "toggleIcon"; "required": false; }; "toggleTpl": { "alias": "toggleTpl"; "required": false; }; }, { "toggleExpand": "toggleExpand"; }, never, ["*"], true, never>;
+}
+
+declare class TheSeamSideNavService {
+    private readonly _router;
+    private readonly _updatingCount;
+    readonly loading$: Observable<boolean>;
+    readonly itemChanged: Subject<SideNavItemStateChanged>;
+    constructor(_router: Router);
+    createItemsObservable(items: ISideNavItem[]): Observable<ISideNavItem[]>;
+    private _incUpdatingCount;
+    private _decrUpdatingCount;
+    updateItemsStates(items: ISideNavItem[]): void;
+    updateItemState(item: ISideNavItem): void;
+    private _updateItemsExpandedState;
+    private _updateItemExpandedState;
+    private _getNavExtras;
+    private _getUrl;
+    private _getMatchOptions;
+    setItemStateProp<K extends keyof ISideNavItemState>(item: ISideNavItem, prop: K, value: ISideNavItemState[K]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSideNavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamSideNavService>;
+}
+
+declare function sideNavExpandStateChangeFn(fromState: string, toState: string): boolean;
+declare class SideNavComponent implements OnInit, OnDestroy, TheSeamBaseLayoutNav {
+    private readonly _viewContainerRef;
+    private readonly _layout;
+    private readonly _sideNav;
+    private readonly _config?;
+    private readonly _baseLayoutRef?;
+    static ngAcceptInputType_hasHeaderToggle: BooleanInput;
+    private readonly _ngUnsubscribe;
+    faBars: _fortawesome_fontawesome_common_types.IconDefinition;
+    _sideNavExpand: string;
+    hasHeaderToggle: boolean;
+    toggleIcon: SeamIcon | null | undefined;
+    toggleTpl: TemplateRef<any> | undefined | null;
+    get items(): ISideNavItem[];
+    set items(value: ISideNavItem[]);
+    private _items;
+    readonly items$: Observable<ISideNavItem[]>;
+    hideEmptyIcon: boolean | null | undefined;
+    indentSize: number;
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    private _expanded;
+    readonly expanded$: Observable<boolean>;
+    expandOrigin: 'left' | 'right' | 'top' | 'bottom';
+    expandHeight: string;
+    expandWidth: string;
+    get overlay(): boolean;
+    set overlay(value: boolean);
+    private _overlay;
+    readonly overlay$: Observable<boolean>;
+    private _menuItemTooltipConfig;
+    get menuItemTooltipConfig(): SideNavItemMenuItemTooltipConfig | undefined | null;
+    set menuItemTooltipConfig(value: SideNavItemMenuItemTooltipConfig | undefined | null);
+    menuItemTooltipDisabled$: Observable<boolean> | undefined | null;
+    toggleExpand: EventEmitter<boolean>;
+    readonly isMobile$: Observable<boolean>;
+    readonly sideNavExpandedState$: Observable<string>;
+    _backdropHidden: BehaviorSubject<boolean>;
+    _sideBarHeaderTpl?: TemplateRef<any> | null;
+    _sideBarHeaderPortal?: TemplatePortal;
+    _sideBarFooterTpl?: TemplateRef<any> | null;
+    _sideBarFooterPortal?: TemplatePortal;
+    constructor(_viewContainerRef: ViewContainerRef, _layout: TheSeamLayoutService, _sideNav: TheSeamSideNavService, _config?: SideNavConfig | undefined, _baseLayoutRef?: TheSeamBaseLayoutRef | undefined);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    expand(): void;
+    collapse(): void;
+    toggle(): void;
+    animateStart(): void;
+    animateEnd(): void;
+    get expandOriginTransform(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavComponent, [null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideNavComponent, "seam-side-nav", never, { "hasHeaderToggle": { "alias": "hasHeaderToggle"; "required": false; }; "toggleIcon": { "alias": "toggleIcon"; "required": false; }; "toggleTpl": { "alias": "toggleTpl"; "required": false; }; "items": { "alias": "items"; "required": false; }; "hideEmptyIcon": { "alias": "hideEmptyIcon"; "required": false; }; "indentSize": { "alias": "indentSize"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "expandOrigin": { "alias": "expandOrigin"; "required": false; }; "expandHeight": { "alias": "expandHeight"; "required": false; }; "expandWidth": { "alias": "expandWidth"; "required": false; }; "overlay": { "alias": "overlay"; "required": false; }; "menuItemTooltipConfig": { "alias": "menuItemTooltipConfig"; "required": false; }; }, { "toggleExpand": "toggleExpand"; }, ["_sideBarHeaderTpl", "_sideBarFooterTpl"], never, true, never>;
+}
+
+declare class TheSeamSideNavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSideNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamSideNavModule, never, [typeof SideNavItemComponent, typeof SideNavComponent, typeof SideNavToggleComponent], [typeof SideNavItemComponent, typeof SideNavComponent, typeof SideNavToggleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamSideNavModule>;
+}
+
+interface NavItemTypeMap {
+    title: ISideNavTitle;
+    divider: ISideNavDivider;
+    basic: ISideNavBasic;
+    link: ISideNavLink;
+    button: ISideNavButton;
+}
+declare function isNavItemType<T extends keyof NavItemTypeMap>(item: ISideNavItem, type: T): item is NavItemTypeMap[T];
+declare function isNavItemActive(item: ISideNavItem): boolean;
+declare function isExpanded(item: ISideNavItem): boolean;
+declare function hasChildren(item: ISideNavItem): item is (ISideNavBasic | ISideNavLink) & Required<SideNavItemCanHaveChildren>;
+declare function canHaveChildren(item: ISideNavItem): item is (ISideNavBasic | ISideNavLink);
+declare function hasActiveChild(item: ISideNavItem): boolean;
+declare function hasExpandedChild(item: ISideNavItem): boolean;
+declare function canBeActive(item: ISideNavItem): item is (ISideNavButton | ISideNavLink);
+declare function canExpand(item: ISideNavItem): item is (ISideNavBasic | ISideNavLink);
+declare function findLinkItems(items: ISideNavItem[]): ISideNavLink[];
+declare function setItemStateProp<K extends keyof ISideNavItemState>(item: ISideNavItem, prop: K, value: ISideNavItemState[K]): void;
+declare function getItemStateProp<K extends keyof ISideNavItemState>(item: ISideNavItem, prop: K): ISideNavItemState[K];
+declare function setDefaultState(item: ISideNavItem): ISideNavItem & Required<SideNavItemCanHaveState>;
+declare function applyItemConfig(item: ISideNavItem, config: SideNavConfig): ISideNavItem;
+
+declare class TopBarMenuButtonBase {
+}
+declare const _TopBarMenuButtonMixinBase: CanDisableCtor & typeof TopBarMenuButtonBase;
+declare class TopBarMenuButtonComponent extends _TopBarMenuButtonMixinBase {
+    static ngAcceptInputType_compact: BooleanInput;
+    faAngleDown: _fortawesome_fontawesome_common_types.IconDefinition;
+    /** Custom template to show in desktop mode. No default. */
+    detailTpl: TemplateRef<any> | undefined | null;
+    /** Custom template to show in mobile mode. Defaults to icon. */
+    compactDetailTpl: TemplateRef<any> | undefined | null;
+    compact: boolean;
+    /** Icon to display on mobile to activate profile dropdown. Defaults to faUserCircle. */
+    profileIcon: SeamIcon | undefined | null;
+    get _hasCompactClass(): boolean;
+    get _hasPadding0Class(): boolean;
+    get _hasRoundedClass(): boolean;
+    get _hasBtnLinkClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarMenuButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TopBarMenuButtonComponent, "button[seamTopBarMenuButton]", ["seamButton"], { "disabled": { "alias": "disabled"; "required": false; }; "detailTpl": { "alias": "detailTpl"; "required": false; }; "compactDetailTpl": { "alias": "compactDetailTpl"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "profileIcon": { "alias": "profileIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TopBarTitleComponent {
+    titleText: string | undefined | null;
+    subTitleText: string | undefined | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TopBarTitleComponent, "seam-top-bar-title", never, { "titleText": { "alias": "titleText"; "required": false; }; "subTitleText": { "alias": "subTitleText"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TopBarCompactMenuBtnDetailDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarCompactMenuBtnDetailDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TopBarCompactMenuBtnDetailDirective, "[seamTopBarCompactMenuBtnDetail]", ["seamTopBarCompactMenuBtnDetail"], {}, {}, never, never, true, never>;
+}
+
+declare class TopBarNavToggleBtnDetailDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarNavToggleBtnDetailDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TopBarNavToggleBtnDetailDirective, "[seamTopBarNavToggleBtnDetail]", ["seamTopBarNavToggleBtnDetail"], {}, {}, never, never, true, never>;
+}
+
+type TopBarPosition = 'left' | 'right' | 'center';
+declare class TopBarItemDirective {
+    readonly template: TemplateRef<any>;
+    position: TopBarPosition;
+    set seamTopBarItem(value: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TopBarItemDirective, "[seamTopBarItem]", ["seamTopBarItem"], { "seamTopBarItem": { "alias": "seamTopBarItem"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TopBarMenuBtnDetailDirective {
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarMenuBtnDetailDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TopBarMenuBtnDetailDirective, "[seamTopBarMenuBtnDetail]", ["seamTopBarMenuBtnDetail"], {}, {}, never, never, true, never>;
+}
+
+declare class TopBarMenuDirective {
+    readonly menu: MenuComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopBarMenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TopBarMenuDirective, "seam-menu[seamTopBarMenu]", ["seamTopBarMenu"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Top bar of an app.
+ *
+ * The top bar is fairly opinionated, so most parts are not intended to be
+ * customized unless there is an input.
+ *
+ * > If you have to make a change and apply it externally with a css class or js
+ * > make sure there is an issue to get the feature changed, so we don't have
+ * > different modifications across our apps. Also, this will help make sure
+ * > your change should have even been done.
+ */
+declare class TheSeamTopBarComponent implements OnDestroy, AfterContentInit {
+    private readonly _layout;
+    static ngAcceptInputType_hasTitle: BooleanInput;
+    /** @ignore */
+    private readonly _ngUnsubscribe;
+    /** @ignore */
+    readonly faBars: _fortawesome_fontawesome_common_types.IconDefinition;
+    /** @ignore */
+    _topBarMenu?: TopBarMenuDirective | null;
+    /** @ignore */
+    _topBarItems?: QueryList<TopBarItemDirective>;
+    /** @ignore */
+    _topBarMenuBtnDetailTpl?: TopBarMenuBtnDetailDirective | null;
+    /** @ignore */
+    _topBarCompactMenuBtnDetailTpl?: TopBarCompactMenuBtnDetailDirective | null;
+    /** @ignore */
+    _topBarNavToggleBtnDetailTpl?: TopBarNavToggleBtnDetailDirective | null;
+    /** Logo displayed on the top bar. */
+    logo: string | undefined | null;
+    /** Logo displayed on the top bar when a smaller logo is needed. */
+    logoSm: string | undefined | null;
+    /** External url to link to when `logo` is clicked. */
+    logoHref?: string | null;
+    /** Link target used when `logoHref` is specified. Defaults to `"_blank"` */
+    logoHrefTarget: string;
+    /** Route to link to when `logo` is clicked. Defaults to `/`. */
+    logoRoute: string;
+    /** Determines if the title should be displayed. */
+    hasTitle: boolean;
+    /** Title text displayed when `hasTitle` is true. */
+    titleText: string | undefined | null;
+    /** Sub Title text displayed when `hasTitle` is true. The sub title will be less prominent. */
+    subTitleText: string | undefined | null;
+    /** Determines if the top bar button should be displayed. */
+    hasTopBarMenuButton: boolean;
+    /** Icon to display on mobile to activate profile dropdown. Defaults to faUserCircle. */
+    profileIcon: SeamIcon | undefined | null;
+    /** Icon to display for mobile nav toggle. Defaults to faBars. */
+    toggleIcon: SeamIcon | undefined | null;
+    /** Display nav toggle on either left or right side of top bar. Defaults to left. */
+    navToggleAlign: 'left' | 'right' | undefined | null;
+    /** @ignore */
+    readonly _leftItems: BehaviorSubject<TopBarItemDirective[]>;
+    /** Additional templates to display on left side of top bar */
+    readonly leftItems$: Observable<TopBarItemDirective[]>;
+    /** @ignore */
+    readonly _centerItems: BehaviorSubject<TopBarItemDirective[]>;
+    /** Additional templates to display in center of top bar */
+    readonly centerItems$: Observable<TopBarItemDirective[]>;
+    /** @ignore */
+    readonly _rightItems: BehaviorSubject<TopBarItemDirective[]>;
+    /** Additional templates to display on right side of top bar */
+    readonly rightItems$: Observable<TopBarItemDirective[]>;
+    /** @ignore */
+    readonly isMobile$: Observable<boolean>;
+    constructor(_layout: TheSeamLayoutService);
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTopBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamTopBarComponent, "seam-top-bar", ["seamTopBar"], { "logo": { "alias": "logo"; "required": false; }; "logoSm": { "alias": "logoSm"; "required": false; }; "logoHref": { "alias": "logoHref"; "required": false; }; "logoHrefTarget": { "alias": "logoHrefTarget"; "required": false; }; "logoRoute": { "alias": "logoRoute"; "required": false; }; "hasTitle": { "alias": "hasTitle"; "required": false; }; "titleText": { "alias": "titleText"; "required": false; }; "subTitleText": { "alias": "subTitleText"; "required": false; }; "hasTopBarMenuButton": { "alias": "hasTopBarMenuButton"; "required": false; }; "profileIcon": { "alias": "profileIcon"; "required": false; }; "toggleIcon": { "alias": "toggleIcon"; "required": false; }; "navToggleAlign": { "alias": "navToggleAlign"; "required": false; }; }, {}, ["_topBarMenu", "_topBarMenuBtnDetailTpl", "_topBarCompactMenuBtnDetailTpl", "_topBarNavToggleBtnDetailTpl", "_topBarItems"], never, true, never>;
+}
+
+declare class TheSeamTopBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTopBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamTopBarModule, never, [typeof TheSeamTopBarComponent, typeof TopBarTitleComponent, typeof TopBarMenuButtonComponent, typeof TopBarMenuDirective, typeof TopBarItemDirective, typeof TopBarMenuBtnDetailDirective, typeof TopBarCompactMenuBtnDetailDirective, typeof TopBarNavToggleBtnDetailDirective], [typeof TheSeamTopBarComponent, typeof TopBarMenuButtonComponent, typeof TopBarMenuDirective, typeof TopBarItemDirective, typeof TopBarMenuBtnDetailDirective, typeof TopBarCompactMenuBtnDetailDirective, typeof TopBarNavToggleBtnDetailDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamTopBarModule>;
+}
+
+declare const fader: _angular_animations.AnimationTriggerMetadata;
+declare const slider: _angular_animations.AnimationTriggerMetadata;
+declare const transformer: _angular_animations.AnimationTriggerMetadata;
+declare const stepper: _angular_animations.AnimationTriggerMetadata;
+declare const sideToSide: _angular_animations.AnimationTriggerMetadata;
+
+declare function routeChanges(router: Router): rxjs.Observable<{
+    url: any;
+}>;
+declare class HierarchyRouterOutletComponent implements OnDestroy {
+    private _route;
+    private _router;
+    private _uid;
+    private readonly _ngUnsubscribe;
+    animState: string;
+    outletActive: boolean;
+    ngContentVisible: boolean;
+    constructor(_route: ActivatedRoute, _router: Router);
+    ngOnDestroy(): void;
+    private _hasChildren;
+    prepareRoute(outlet: RouterOutlet): string | undefined;
+    outletActivate(event: any): void;
+    outletDeactivate(event: any): void;
+    routeAnimationsStart(event: any): void;
+    routeAnimationsDone(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HierarchyRouterOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HierarchyRouterOutletComponent, "seam-hierarchy-router-outlet", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HierarchyLevelResolver implements Resolve<number> {
+    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<number> | Promise<number> | number;
+    private _getMaxHierLevel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HierarchyLevelResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HierarchyLevelResolver>;
+}
+
+interface IDynamicRouteDef {
+    path?: string;
+    component?: string;
+    data?: {
+        [name: string]: any;
+    };
+    children?: IDynamicRouteDef[];
+}
+
+declare class TheSeamDynamicRouterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDynamicRouterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamDynamicRouterModule, [typeof HierarchyRouterOutletComponent], [typeof i2.CommonModule, typeof i3.RouterModule], [typeof HierarchyRouterOutletComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamDynamicRouterModule>;
+}
+
+declare class TheSeamSchemaFormCheckboxComponent implements OnInit, TheSeamSchemaFormControlWidget {
+    private readonly _jsf;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    trueValue: boolean;
+    falseValue: boolean;
+    constructor(_jsf: JsonSchemaFormService);
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    get isChecked(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormCheckboxComponent, "seam-schema-form-checkbox", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormInputComponent implements OnInit, TheSeamSchemaFormControlWidget {
+    private readonly _jsf;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    autoCompleteList: string[];
+    constructor(_jsf: JsonSchemaFormService);
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormInputComponent, "seam-schema-form-input", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormNumberComponent implements OnInit, TheSeamSchemaFormControlWidget {
+    private jsf;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    allowNegative: boolean;
+    allowDecimal: boolean;
+    allowExponents: boolean;
+    lastValidNumber: string;
+    constructor(jsf: JsonSchemaFormService);
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormNumberComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormNumberComponent, "seam-schema-form-number", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormSelectComponent implements OnInit, TheSeamSchemaFormControlWidget {
+    private readonly _jsf;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    selectList: any[];
+    isArray: typeof isArray;
+    constructor(_jsf: JsonSchemaFormService);
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormSelectComponent, "seam-schema-form-select", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TheSeamSchemaFormSubmitSplitItem = TitleMapItem;
+declare class TheSeamSchemaFormSubmitSplitComponent implements OnInit, OnDestroy, TheSeamSchemaFormControlWidget {
+    private readonly _jsf;
+    /** @ignore */
+    private readonly _ngUnsubscribe;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    _buttonLabel: string;
+    _dropdownObj: any;
+    _dropdownDisabled: boolean;
+    _selectList: TheSeamSchemaFormSubmitSplitItem[];
+    _selectedItem?: TheSeamSchemaFormSubmitSplitItem;
+    constructor(_jsf: JsonSchemaFormService);
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    updateValue(event: any): void;
+    private _initDropdown;
+    private _getDropdownControl;
+    private _setSelectListCheckedProp;
+    private _getSelectedItem;
+    _setDropdownValue(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormSubmitSplitComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormSubmitSplitComponent, "seam-schema-form-submit-split", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormDividerComponent implements OnInit, TheSeamSchemaFormWidget {
+    options: TheSeamSchemaFormWidget['options'];
+    layoutNode: any;
+    layoutIndex: number[] | undefined | null;
+    dataIndex: number[] | undefined | null;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormDividerComponent, "seam-schema-form-divider", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormTelComponent implements OnInit, TheSeamSchemaFormControlWidget {
+    private readonly _jsf;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    autoCompleteList: string[];
+    constructor(_jsf: JsonSchemaFormService);
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormTelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormTelComponent, "seam-schema-form-tel", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormTiledSelectComponent implements OnInit, TheSeamSchemaFormControlWidget {
+    private readonly _jsf;
+    private readonly _platform;
+    formControl?: AbstractControl;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled: boolean;
+    boundControl: boolean;
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    layoutNode: TheSeamSchemaFormControlWidget['layoutNode'];
+    layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex'];
+    dataIndex: TheSeamSchemaFormControlWidget['dataIndex'];
+    tiles: TheSeamTiledSelectItem[];
+    layout: TheSeamTiledSelectLayout;
+    multiple: boolean;
+    selectionToggleable: boolean;
+    tileBackdrop: boolean;
+    showSelectedIcon: boolean;
+    animationsDisabled: boolean;
+    ngOnInit(): void;
+    updateValue(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormTiledSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormTiledSelectComponent, "seam-schema-form-tiled-select", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamSchemaFormFrameworkComponent {
+    layoutNode: any;
+    layoutIndex: number[] | undefined | null;
+    dataIndex: number[] | undefined | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormFrameworkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamSchemaFormFrameworkComponent, "seam-schema-form-framework", never, { "layoutNode": { "alias": "layoutNode"; "required": false; }; "layoutIndex": { "alias": "layoutIndex"; "required": false; }; "dataIndex": { "alias": "dataIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TheSeamSchemaFormFrameworkOverrides = Omit<Framework, 'name' | 'framework' | 'stylesheet' | 'scripts'>;
+declare const THESEAM_SCHEMA_FRAMEWORK_OVERRIDES: InjectionToken<TheSeamSchemaFormFrameworkOverrides>;
+declare function extendFramework(toExtend: Framework, extendFrameworkOrName: Framework | string): void;
+declare class TheSeamFramework extends Framework {
+    name: string;
+    framework: typeof TheSeamSchemaFormFrameworkComponent;
+    widgets: {
+        checkbox: typeof TheSeamSchemaFormCheckboxComponent;
+        submit: typeof TheSeamSchemaFormSubmitSplitComponent;
+        text: typeof TheSeamSchemaFormInputComponent;
+        number: typeof TheSeamSchemaFormNumberComponent;
+        select: typeof TheSeamSchemaFormSelectComponent;
+        divider: typeof TheSeamSchemaFormDividerComponent;
+        tel: typeof TheSeamSchemaFormTelComponent;
+        'tiled-select': typeof TheSeamSchemaFormTiledSelectComponent;
+    };
+    constructor(_overrides?: TheSeamSchemaFormFrameworkOverrides[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamFramework, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamFramework>;
+}
+
+declare class TheSeamSchemaFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSchemaFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamSchemaFormModule, never, [typeof i2.CommonModule, typeof i2$1.JsonSchemaFormModule, typeof i2$1.WidgetLibraryModule, typeof TheSeamSchemaFormFrameworkComponent], [typeof TheSeamSchemaFormFrameworkComponent, typeof i2$1.JsonSchemaFormModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamSchemaFormModule>;
+}
+
+interface TheSeamSchemaFormWidgetLayoutNodeOptions {
+    errorMessage: any;
+    validationMessages: any;
+    showErrors: boolean;
+    /**
+     * ?
+     */
+    copyValueTo: any[];
+    title: string;
+    [key: string]: any;
+}
+/**
+ * Interface to represent the properties set on a widget component instance by
+ * '@ajsf/core'.
+ *
+ * NOTE: I am not positive this is completely accurate.
+ */
+interface TheSeamSchemaFormWidget {
+    options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+    /**
+     * Node from the json schema.
+     */
+    layoutNode?: {
+        options?: TheSeamSchemaFormWidgetLayoutNodeOptions;
+        name: string;
+        value: any;
+        dataPointer: string;
+        type: string;
+        dataType?: string;
+        items?: any[];
+        _id?: string;
+    } | null;
+    layoutIndex: number[] | undefined | null;
+    dataIndex: number[] | undefined | null;
+}
+/**
+ * Interface to represent the properties set on a widget component instance by
+ * '@ajsf/core', when calling `initializeControl`.
+ *
+ * Some properties, such as `options` can be set before calling
+ * `initializeControl` and will affect how it works.
+ *
+ * NOTE: I am not positive this is completely accurate.
+ */
+interface TheSeamSchemaFormControlWidget extends TheSeamSchemaFormWidget {
+    formOptions?: {
+        validateOnRender: boolean;
+    };
+    /**
+     * The form control for a widget.
+     */
+    formControl?: AbstractControl;
+    /**
+     * ?
+     */
+    boundControl?: boolean;
+    controlName?: string;
+    controlValue?: any;
+    controlDisabled?: boolean;
+}
+
+interface INavItemState {
+    active: boolean;
+    expanded: boolean;
+    focused: boolean;
+}
+interface NavItemCanHaveState {
+    /**
+     * This prop is managed by the Nav. If manually set it will be overwritten.
+     *
+     * @ignore
+     */
+    __state?: INavItemState;
+}
+interface NavItemCanHaveChildren {
+    children?: INavItem[];
+}
+interface INavItemBase<T extends string> extends NavItemCanHaveState {
+    /**
+     * default: 'route'
+     */
+    itemType?: T;
+    badge?: INavBadge;
+}
+interface INavTitle extends INavItemBase<'title'> {
+    label?: string;
+}
+interface INavDivider extends INavItemBase<'divider'> {
+    label?: string;
+}
+interface INavBadge {
+    text?: string;
+    theme?: ThemeTypes;
+    /**
+     * Content to provide to assistive technology, such as screen readers.
+     */
+    srContent?: string;
+    tooltip?: string | NavItemBadgeTooltip;
+}
+interface INavBasic extends INavItemBase<'basic'>, NavItemCanHaveChildren {
+    icon?: SeamIcon;
+    label: string;
+}
+interface INavLink extends INavItemBase<'link'>, Partial<Pick<UrlCreationOptions, 'queryParams' | 'fragment' | 'queryParamsHandling' | 'preserveFragment'>>, NavItemCanHaveChildren {
+    icon?: SeamIcon;
+    label: string;
+    link?: any[] | string;
+    /**
+     * Default: { paths: 'subset', queryParams: 'subset', fragment: 'ignored', matrixParams: 'ignored' }
+     */
+    matchOptions?: Partial<IsActiveMatchOptions>;
+}
+interface INavButton extends INavItemBase<'button'> {
+    onClick: (event: MouseEvent) => void;
+}
+type INavItem = INavTitle | INavDivider | INavBasic | INavLink | INavButton;
+interface NavItemStateChanged {
+    item: INavItem;
+    prop: keyof INavItemState;
+    prevValue: any;
+    newValue: any;
+}
+interface NavItemBadgeTooltip {
+    tooltip?: string;
+    class?: string;
+    placement?: string;
+    container?: string;
+    disabled?: boolean;
+}
+type NavItemChildAction = 'menu' | 'expand' | 'none' | null | undefined;
+type NavItemExpandAction = 'toggle' | 'expandOnly' | null | undefined;
+interface NavItemExpandedEvent {
+    navItem: INavItem;
+    expanded: boolean;
+}
+
+declare class NavItemComponent implements OnDestroy {
+    static ngAcceptInputType_hierLevel: NumberInput;
+    static ngAcceptInputType_indentSize: NumberInput;
+    static ngAcceptInputType_expanded: BooleanInput;
+    static ngAcceptInputType_compact: BooleanInput;
+    static ngAcceptInputType_active: BooleanInput;
+    private readonly _nav;
+    private readonly _ngUnsubscribe;
+    readonly faAngleLeft: _fortawesome_fontawesome_common_types.IconDefinition;
+    item: INavItem | undefined | null;
+    itemType: 'divider' | 'basic' | 'link' | 'button' | 'title' | undefined | null;
+    icon: SeamIcon | undefined | null;
+    hideEmptyIcon: boolean | undefined | null;
+    label: string | undefined | null;
+    active: boolean;
+    set link(value: string | undefined | null);
+    get link(): string | undefined | null;
+    private readonly _link;
+    readonly link$: rxjs.Observable<string | null | undefined>;
+    queryParams: {
+        [k: string]: any;
+    } | undefined | null;
+    children: INavItem[] | undefined | null;
+    hierLevel: number;
+    indentSize: number;
+    set expanded(value: boolean);
+    get expanded(): boolean;
+    private readonly _expanded;
+    readonly expanded$: rxjs.Observable<boolean>;
+    set compact(value: boolean);
+    get compact(): boolean;
+    private readonly _compact;
+    readonly compact$: rxjs.Observable<boolean>;
+    focused: boolean;
+    badgeText: string | undefined | null;
+    badgeTheme: ThemeTypes | undefined | null;
+    /**
+     * Content to provide to assistive technology, such as screen readers.
+     */
+    badgeSrContent: string | undefined | null;
+    get badgeTooltip(): string | NavItemBadgeTooltip | undefined | null;
+    set badgeTooltip(value: string | NavItemBadgeTooltip | undefined | null);
+    private _badgeTooltip;
+    childAction: NavItemChildAction;
+    expandAction: NavItemExpandAction;
+    navItemExpanded: EventEmitter<boolean>;
+    get _isActiveCssClass(): boolean;
+    get _isChildActiveCssClass(): boolean;
+    get _isExpandedCssClass(): boolean;
+    get _isFocusedCssClass(): boolean;
+    get _attrDataHierLevel(): number;
+    _menu?: MenuComponent;
+    _navItems?: NavItemComponent[];
+    ngOnDestroy(): void;
+    get hasChildren(): boolean;
+    get hasActiveChild(): boolean;
+    get hasMenuToggle(): boolean;
+    get menuTpl(): MenuComponent | undefined;
+    get hasExpandingChildren(): boolean;
+    _toggleChildren(event: Event): void;
+    _menuEvent(menuExpanded: any): void;
+    get showIconBlock(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavItemComponent, "seam-nav-item", ["seamNavItem"], { "item": { "alias": "item"; "required": false; }; "itemType": { "alias": "itemType"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "hideEmptyIcon": { "alias": "hideEmptyIcon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "active": { "alias": "active"; "required": false; }; "link": { "alias": "link"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "children": { "alias": "children"; "required": false; }; "hierLevel": { "alias": "hierLevel"; "required": false; }; "indentSize": { "alias": "indentSize"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; "badgeText": { "alias": "badgeText"; "required": false; }; "badgeTheme": { "alias": "badgeTheme"; "required": false; }; "badgeSrContent": { "alias": "badgeSrContent"; "required": false; }; "badgeTooltip": { "alias": "badgeTooltip"; "required": false; }; "childAction": { "alias": "childAction"; "required": false; }; "expandAction": { "alias": "expandAction"; "required": false; }; }, { "navItemExpanded": "navItemExpanded"; }, never, never, true, never>;
+}
+
+declare class HorizontalNavComponent implements OnDestroy {
+    static ngAcceptInputType_hasHeaderToggle: BooleanInput;
+    private readonly _nav;
+    private readonly _ngUnsubscribe;
+    get items(): INavItem[];
+    set items(value: INavItem[]);
+    private _items;
+    readonly items$: Observable<INavItem[]>;
+    hideEmptyIcon: boolean | undefined | null;
+    hierLevel: number;
+    childAction: NavItemChildAction;
+    expandAction: NavItemExpandAction;
+    navItemExpanded: EventEmitter<NavItemExpandedEvent>;
+    constructor();
+    ngOnDestroy(): void;
+    _navItemExpanded(item: INavItem, expanded: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HorizontalNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HorizontalNavComponent, "seam-horizontal-nav", never, { "items": { "alias": "items"; "required": false; }; "hideEmptyIcon": { "alias": "hideEmptyIcon"; "required": false; }; "hierLevel": { "alias": "hierLevel"; "required": false; }; "childAction": { "alias": "childAction"; "required": false; }; "expandAction": { "alias": "expandAction"; "required": false; }; }, { "navItemExpanded": "navItemExpanded"; }, never, never, true, never>;
+}
+
+declare class TheSeamNavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamNavModule, never, [typeof NavItemComponent, typeof HorizontalNavComponent], [typeof NavItemComponent, typeof HorizontalNavComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamNavModule>;
+}
+
+declare function isHorizontalNavItemType(item: INavItem, type: 'title'): item is INavTitle;
+declare function isHorizontalNavItemType(item: INavItem, type: 'divider'): item is INavDivider;
+declare function isHorizontalNavItemType(item: INavItem, type: 'basic'): item is INavBasic;
+declare function isHorizontalNavItemType(item: INavItem, type: 'link'): item is INavLink;
+declare function isHorizontalNavItemType(item: INavItem, type: 'button'): item is INavButton;
+declare function isHorizontalNavItemActive(item: INavItem): boolean;
+declare function isHorizontalNavItemExpanded(item: INavItem): boolean;
+declare function isHorizontalNavItemFocused(item: INavItem): boolean;
+declare function horizontalNavItemHasChildren(item: INavItem): item is (INavBasic | INavLink) & Required<NavItemCanHaveChildren>;
+declare function horizontalNavItemCanHaveChildren(item: INavItem): item is (INavBasic | INavLink);
+declare function horizontalNavItemHasActiveChild(item: INavItem): boolean;
+declare function horizontalNavItemHasExpandedChild(item: INavItem): boolean;
+declare function horizontalNavItemCanBeActive(item: INavItem): item is (INavBasic | INavLink);
+declare function horizontalNavItemCanExpand(item: INavItem): item is (INavBasic | INavLink);
+declare function findHorizontalNavLinkItems(items: INavItem[]): INavLink[];
+declare function setHorizontalNavItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K, value: INavItemState[K]): void;
+declare function getHorizontalNavItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K): INavItemState[K];
+declare function setDefaultHorizontalNavItemState(item: INavItem): INavItem & Required<NavItemCanHaveState>;
+declare function areSameHorizontalNavItem(item1: INavItem | undefined, item2: INavItem | undefined): boolean;
+
+export { BaseLayoutContentDirective, BaseLayoutContentFooterDirective, BaseLayoutContentHeaderDirective, BaseLayoutSideBarDirective, BaseLayoutSideBarFooterDirective, BaseLayoutSideBarHeaderDirective, BaseLayoutTopBarDirective, DEFAULT_SIDE_NAV_CONFIG, DashboardComponent, DashboardWidgetContainerComponent, DashboardWidgetPortalOutletDirective, DashboardWidgetTemplateContainerComponent, DashboardWidgetsComponent, DashboardWidgetsPreferencesService, DashboardWidgetsService, HierarchyLevelResolver, HierarchyRouterOutletComponent, HorizontalNavComponent, NavItemComponent, SideNavComponent, SideNavItemComponent, SideNavToggleComponent, THESEAM_BASE_LAYOUT_REF, THESEAM_DASHBOARD_WIDGETS_PREFERENCES_ACCESSOR, THESEAM_SCHEMA_FRAMEWORK_OVERRIDES, THESEAM_SIDE_NAV_ACCESSOR, THESEAM_SIDE_NAV_CONFIG, THE_SEAM_BASE_LAYOUT, TheSeamBaseLayoutComponent, TheSeamBaseLayoutModule, TheSeamBaseLayoutNavToggleDirective, TheSeamDashboardModule, TheSeamDynamicRouterModule, TheSeamFramework, TheSeamNavModule, TheSeamSchemaFormFrameworkComponent, TheSeamSchemaFormModule, TheSeamSideNavModule, TheSeamTopBarComponent, TheSeamTopBarModule, TopBarCompactMenuBtnDetailDirective, TopBarItemDirective, TopBarMenuBtnDetailDirective, TopBarMenuButtonComponent, TopBarMenuDirective, TopBarNavToggleBtnDetailDirective, TopBarTitleComponent, applyItemConfig, areSameHorizontalNavItem, canBeActive, canExpand, canHaveChildren, extendFramework, fader, findHorizontalNavLinkItems, findLinkItems, getHorizontalNavItemStateProp, getItemStateProp, hasActiveChild, hasChildren, hasExpandedChild, horizontalNavItemCanBeActive, horizontalNavItemCanExpand, horizontalNavItemCanHaveChildren, horizontalNavItemHasActiveChild, horizontalNavItemHasChildren, horizontalNavItemHasExpandedChild, isExpanded, isHorizontalNavItemActive, isHorizontalNavItemExpanded, isHorizontalNavItemFocused, isHorizontalNavItemType, isNavItemActive, isNavItemType, routeChanges, setDefaultHorizontalNavItemState, setDefaultState, setHorizontalNavItemStateProp, setItemStateProp, sideNavExpandStateChangeFn, sideToSide, slider, stepper, transformer };
+export type { IDashboardWidgetItemLayout, IDashboardWidgetItemLayoutPreference, IDashboardWidgetsColumnRecord, IDashboardWidgetsItem, IDashboardWidgetsItemDef, IDashboardWidgetsItemSerialized, IDashboardWidgetsPreferences, IDashboardWidgetsPreferencesMapRecord, IDynamicRouteDef, INavBadge, INavBasic, INavButton, INavDivider, INavItem, INavItemBase, INavItemState, INavLink, INavTitle, ISideNavBadge, ISideNavBasic, ISideNavButton, ISideNavDivider, ISideNavItem, ISideNavItemBase, ISideNavItemState, ISideNavLink, ISideNavTitle, ITheSeamDashboardWidgetsPreferencesAccessor, NavItemBadgeTooltip, NavItemCanHaveChildren, NavItemCanHaveState, NavItemChildAction, NavItemExpandAction, NavItemExpandedEvent, NavItemStateChanged, SideNavAccessor, SideNavConfig, SideNavItemBadgeTooltip, SideNavItemCanBeActive, SideNavItemCanHaveChildren, SideNavItemCanHaveState, SideNavItemMenuItemTooltipBehavior, SideNavItemMenuItemTooltipConfig, SideNavItemStateChanged, TheSeamBaseLayoutAction, TheSeamBaseLayoutActionBase, TheSeamBaseLayoutActionButton, TheSeamBaseLayoutActionHref, TheSeamBaseLayoutActionRouterLink, TheSeamBaseLayoutActionTemplate, TheSeamBaseLayoutNav, TheSeamBaseLayoutRef, TheSeamSchemaFormControlWidget, TheSeamSchemaFormFrameworkOverrides, TheSeamSchemaFormWidget, TheSeamSchemaFormWidgetLayoutNodeOptions, TopBarPosition };