@blackbaud/skyux-lib-stache/types/blackbaud-skyux-lib-stache.d.ts

This library was generated with [Nx](https://nx.dev).

import * as i0 from '@angular/core';
import { InjectionToken, OnDestroy, OnInit, OnChanges, AfterViewInit, ElementRef, Renderer2, ModuleWithProviders, AfterContentInit, ChangeDetectorRef, TemplateRef, AfterViewChecked } from '@angular/core';
import * as i2 from '@angular/common';
import { LocationStrategy } from '@angular/common';
import * as i3$1 from '@skyux/layout';
import * as i4 from '@skyux/lookup';
import * as rxjs from 'rxjs';
import { Observable, Subject, BehaviorSubject } from 'rxjs';
import * as i3 from '@angular/router';
import { Router, Routes, ActivatedRoute } from '@angular/router';
import * as i1 from '@skyux/i18n';
import { SkyLibResourcesService } from '@skyux/i18n';
import { SkyAppConfig } from '@skyux/config';
import * as i3$2 from '@skyux/icon';
import { SkyMediaQueryService } from '@skyux/core';

interface StacheNavLink {
    name: string;
    path: string[] | string;
    order?: number;
    offsetTop?: number;
    children?: StacheNavLink[];
    fragment?: string;
    icon?: string;
    summary?: string;
    isActive?: boolean;
    isCurrent?: boolean;
    showInNav?: boolean;
    restricted?: boolean;
}

/**
 * @deprecated Use SKY UX action buttons instead: https://developer.blackbaud.com/skyux/components/action-button
 */
declare class StacheActionButtonsComponent {
    #private;
    set routes(value: StacheNavLink[] | undefined);
    get routes(): StacheNavLink[] | undefined;
    set showSearch(value: boolean | string | undefined);
    get showSearch(): boolean;
    filteredRoutes: StacheNavLink[];
    searchText: string;
    onKeyUp(event: KeyboardEvent): void;
    searchApplied(searchText: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheActionButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheActionButtonsComponent, "stache-action-buttons", never, { "routes": { "alias": "routes"; "required": false; }; "showSearch": { "alias": "showSearch"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StacheAuthService {
    readonly isAuthenticated: rxjs.Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheAuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheAuthService>;
}

declare const STACHE_ROUTE_OPTIONS: InjectionToken<StacheRouteOptions>;
interface StacheRouteOptions {
    basePath?: string;
}

/**
 * The StacheRouteService assumes the consuming application's routes are "flat", without children.
 * For example:
 * ```
 * const routes: Routes = [
 *   {
 *     path: '',
 *     component: HomeComponent,
 *   },
 *   {
 *     path: 'design',
 *     component: DesignPlaygroundComponent,
 *     data: {
 *       stache: {
 *         name: 'Design',
 *       },
 *     },
 *   },
 *   {
 *     path: 'design/styles',
 *     component: StylesPlaygroundComponent,
 *     data: {
 *       stache: {
 *         name: 'Styles',
 *       },
 *     },
 *   },
 * ];
 * ```
 * Import the StacheRouterModule into lazy-loaded modules to give the Stache route service the desired route config.
 * For example:
 * ```
 * @NgModule({
 *   import: [
 *     RouterModule.forChild({...}),
 *     StacheRouterModule.forChild('my-top-level-route')
 *   ]
 * })
 * export class MyLazyLoadedModule {}
 * ```
 * Lazy loaded components will lose the context provided by StacheRouterModule.forChild(...)
 * You may override the StacheRouteOptions via a route provider to wire lazy components into navigation
 * ```
 *  const routes: Routes = [
 *  {
 *    path: 'lazy',
 *    loadComponent: () => import('./path/to/lazy.component'),
 *    providers: [
 *      { provide: STACHE_ROUTE_OPTIONS, useValue: {basePath: 'nested'}}
 *    ]
 *    data: {
 *      stache: {
 *        name: 'Lazy',
 *      },
 *    },
 *  },
 * ];
 * ```
 */
declare class StacheRouteService implements OnDestroy {
    #private;
    constructor(router: Router, routes?: Routes, options?: StacheRouteOptions);
    ngOnDestroy(): void;
    getActiveRoutes(): StacheNavLink[];
    getActiveUrl(): string;
    clearActiveRoutes(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheRouteService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheRouteService>;
}

interface StacheNav {
    routes?: StacheNavLink[];
}

declare class StacheNavComponent implements OnDestroy, OnInit, StacheNav {
    #private;
    set routes(value: StacheNavLink[] | undefined);
    get routes(): StacheNavLink[] | undefined;
    set navType(value: string | undefined);
    get navType(): string | undefined;
    className: string | undefined;
    filteredRoutes: StacheNavLink[] | undefined;
    constructor(routeSvc: StacheRouteService, authSvc: StacheAuthService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheNavComponent, "stache-nav", never, { "routes": { "alias": "routes"; "required": false; }; "navType": { "alias": "navType"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * @internal
 */
declare class StacheWindowRef {
    #private;
    get nativeWindow(): any;
    get onResizeStream(): Observable<Window>;
    scrollEventStream: Observable<Event>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheWindowRef, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheWindowRef>;
}

type StacheRoute = Omit<StacheNavLink, 'name'>;
declare class StacheNavService {
    #private;
    constructor(router: Router, windowRef: StacheWindowRef);
    navigate(route: StacheRoute): void;
    isExternal(route: StacheRoute | string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheNavService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheNavService>;
}

declare class StacheRouterLinkDirective implements OnChanges, AfterViewInit {
    #private;
    set stacheRouterLink(value: string | string[] | undefined);
    get stacheRouterLink(): string;
    fragment: string | undefined;
    href: string | undefined;
    constructor(navSvc: StacheNavService, routerSvc: StacheRouteService, elementRef: ElementRef, locationStrategy: LocationStrategy, renderer: Renderer2);
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    navigate(event: MouseEvent): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheRouterLinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StacheRouterLinkDirective, "a[stacheRouterLink], [stacheRouterLink]", never, { "stacheRouterLink": { "alias": "stacheRouterLink"; "required": false; }; "fragment": { "alias": "fragment"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * Import into any component library module that needs to use resource strings.
 */
declare class SkyStacheResourcesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SkyStacheResourcesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SkyStacheResourcesModule, never, never, [typeof i1.SkyI18nModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SkyStacheResourcesModule>;
}

declare class StacheRouterModule {
    static forChild(basePath: string): ModuleWithProviders<StacheRouterModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheRouterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheRouterModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheRouterModule>;
}

declare class StacheNavModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheNavModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheNavModule, [typeof StacheNavComponent, typeof StacheRouterLinkDirective], [typeof i2.CommonModule, typeof i3.RouterModule, typeof SkyStacheResourcesModule, typeof StacheRouterModule], [typeof StacheNavComponent, typeof StacheRouterLinkDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheNavModule>;
}

declare class StacheActionButtonsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheActionButtonsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheActionButtonsModule, [typeof StacheActionButtonsComponent], [typeof i2.CommonModule, typeof i3$1.SkyActionButtonModule, typeof i3$1.SkyFluidGridModule, typeof i4.SkySearchModule, typeof StacheNavModule], [typeof StacheActionButtonsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheActionButtonsModule>;
}

declare class StacheViewportAdapterService {
    #private;
    checkForViewportAdjustment(): void;
    getHeight(): number;
    viewportAdjusted(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheViewportAdapterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheViewportAdapterService>;
}

declare class StacheAffixTopDirective implements AfterContentInit, AfterViewInit {
    #private;
    isAffixed: boolean;
    constructor(renderer: Renderer2, elementRef: ElementRef, viewportService: StacheViewportAdapterService, windowRef: StacheWindowRef);
    ngAfterViewInit(): void;
    ngAfterContentInit(): void;
    onWindowScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheAffixTopDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StacheAffixTopDirective, "[stacheAffixTop]", never, {}, {}, never, never, false, never>;
}

declare class StacheAffixComponent implements AfterViewInit, OnDestroy {
    #private;
    wrapper: ElementRef | undefined;
    minHeightFormatted: string | undefined;
    maxWidthFormatted: string | undefined;
    affixTopDirective: StacheAffixTopDirective | undefined;
    constructor(windowRef: StacheWindowRef, changeDetector: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    getStyles(): Record<string, string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheAffixComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheAffixComponent, "stache-affix", never, {}, {}, never, ["*"], false, never>;
}

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

declare class StacheGoogleAnalyticsDirective implements OnInit {
    #private;
    private windowRef;
    private configService;
    private router;
    private tagManagerContainerId;
    private analyticsClientId;
    private isEnabled;
    private appName;
    constructor(windowRef: StacheWindowRef, configService: SkyAppConfig, router: Router);
    ngOnInit(): void;
    addGoogleTagManagerScript(): void;
    /**
     * Because GTM adds the Google Analytics script to the page outside of our control,
     * instead of loading the GA script twice, we extract the 'ga' window method out so we can
     * subscribe to our router events and track SPA page views.
     */
    initGoogleAnalytics(): void;
    bindPageViewsToRouter(): void;
    private updateDefaultConfigs;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheGoogleAnalyticsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StacheGoogleAnalyticsDirective, "[stacheGoogleAnalytics]", never, {}, {}, never, never, false, never>;
}

declare class StacheAnalyticsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheAnalyticsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheAnalyticsModule, [typeof StacheGoogleAnalyticsDirective], [typeof i3.RouterModule], [typeof StacheGoogleAnalyticsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheAnalyticsModule>;
}

declare class StacheBackToTopComponent {
    #private;
    set offset(value: number | string | undefined);
    get offset(): number;
    isHidden: boolean;
    constructor(windowRef: StacheWindowRef);
    onWindowScroll(): void;
    scrollToTop(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheBackToTopComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheBackToTopComponent, "stache-back-to-top", never, { "offset": { "alias": "offset"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StacheBackToTopModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheBackToTopModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheBackToTopModule, [typeof StacheBackToTopComponent], [typeof i2.CommonModule, typeof i3$2.SkyIconModule, typeof SkyStacheResourcesModule], [typeof StacheBackToTopComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheBackToTopModule>;
}

declare class StacheBlockquoteComponent implements OnInit {
    author: string | undefined;
    quoteSource: string | undefined;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheBlockquoteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheBlockquoteComponent, "stache-blockquote", never, { "author": { "alias": "author"; "required": false; }; "quoteSource": { "alias": "quoteSource"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class StacheBlockquoteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheBlockquoteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheBlockquoteModule, [typeof StacheBlockquoteComponent], [typeof i2.CommonModule, typeof i3$2.SkyIconModule], [typeof StacheBlockquoteComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheBlockquoteModule>;
}

declare class StacheBreadcrumbsComponent implements StacheNav, OnInit {
    #private;
    routes: StacheNavLink[] | undefined;
    constructor(routeSvc: StacheRouteService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheBreadcrumbsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheBreadcrumbsComponent, "stache-breadcrumbs", never, { "routes": { "alias": "routes"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class StacheEditButtonComponent implements OnInit {
    #private;
    editButtonText: string | undefined;
    url: string | undefined;
    constructor(config: SkyAppConfig, routeSvc: StacheRouteService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheEditButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheEditButtonComponent, "stache-edit-button", never, {}, {}, never, never, false, never>;
}

declare class StacheEditButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheEditButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheEditButtonModule, [typeof StacheEditButtonComponent], [typeof i2.CommonModule, typeof i3$2.SkyIconModule], [typeof StacheEditButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheEditButtonModule>;
}

declare class StacheFooterComponent implements OnInit {
    #private;
    copyrightDate: Date | undefined;
    copyrightLabel: string | undefined;
    siteName: string | undefined;
    footerLinks: StacheNavLink[] | undefined;
    constructor(configSvc: SkyAppConfig, resourcesSvc: SkyLibResourcesService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheFooterComponent, "stache-footer", never, {}, {}, never, never, false, never>;
}

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

declare class StacheHideFromSearchComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheHideFromSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheHideFromSearchComponent, "stache-hide-from-search", never, {}, {}, never, ["*"], false, never>;
}

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

declare const STACHE_JSON_DATA_SERVICE_CONFIG: InjectionToken<any>;

type JSON_DATA = any;
declare class StacheJsonDataService {
    #private;
    constructor(jsonData?: JSON_DATA);
    getAll(): JSON_DATA;
    getByName(name: string): JSON_DATA;
    getNestedData(keys: string[]): JSON_DATA | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheJsonDataService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheJsonDataService>;
}

interface StacheLayout {
    pageTitle?: string;
    breadcrumbsRoutes?: StacheNavLink[];
    inPageRoutes?: StacheNavLink[];
    showBackToTop?: boolean | string;
    showBreadcrumbs?: boolean | string;
    showEditButton?: boolean | string;
    showTableOfContents?: boolean | string;
    sidebarRoutes?: StacheNavLink[];
}

type StacheLayoutType = 'blank' | 'container' | 'sidebar' | 'sidebar-no-margins';

declare class StacheLayoutComponent implements OnInit, OnChanges, StacheLayout {
    #private;
    pageTitle: string | undefined;
    set layoutType(value: StacheLayoutType | undefined);
    get layoutType(): string;
    inPageRoutes: StacheNavLink[] | undefined;
    showTableOfContents: boolean | undefined;
    sidebarRoutes: StacheNavLink[] | undefined;
    breadcrumbsRoutes: StacheNavLink[] | undefined;
    showBreadcrumbs: boolean | undefined;
    showEditButton: boolean | undefined;
    showBackToTop: boolean | undefined;
    templateRef: TemplateRef<unknown> | undefined;
    blankTemplateRef: TemplateRef<unknown> | undefined;
    containerTemplateRef: TemplateRef<unknown> | undefined;
    sidebarTemplateRef: TemplateRef<unknown> | undefined;
    constructor(elementRef: ElementRef, renderer: Renderer2, windowRef: StacheWindowRef);
    ngOnInit(): void;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheLayoutComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheLayoutComponent, "stache-layout", never, { "pageTitle": { "alias": "pageTitle"; "required": false; }; "layoutType": { "alias": "layoutType"; "required": false; }; "inPageRoutes": { "alias": "inPageRoutes"; "required": false; }; "showTableOfContents": { "alias": "showTableOfContents"; "required": false; }; "sidebarRoutes": { "alias": "sidebarRoutes"; "required": false; }; "breadcrumbsRoutes": { "alias": "breadcrumbsRoutes"; "required": false; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; }; "showEditButton": { "alias": "showEditButton"; "required": false; }; "showBackToTop": { "alias": "showBackToTop"; "required": false; }; }, {}, never, ["*", "[stachePageSummary]", "stache-page-summary"], false, never>;
}

declare class StacheLayoutBlankComponent implements OnInit {
    #private;
    set identifier(value: string | undefined);
    get identifier(): string;
    className: string | undefined;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheLayoutBlankComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheLayoutBlankComponent, "stache-layout-blank", never, { "identifier": { "alias": "identifier"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class StacheLayoutContainerComponent implements StacheLayout {
    #private;
    pageTitle: string | undefined;
    breadcrumbsRoutes: StacheNavLink[] | undefined;
    inPageRoutes: StacheNavLink[] | undefined;
    set showBackToTop(value: boolean | string | undefined);
    get showBackToTop(): boolean;
    set showBreadcrumbs(value: boolean | string | undefined);
    get showBreadcrumbs(): boolean;
    set showEditButton(value: boolean | string | undefined);
    get showEditButton(): boolean;
    set showTableOfContents(value: boolean | string | undefined);
    get showTableOfContents(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheLayoutContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheLayoutContainerComponent, "stache-layout-container", never, { "pageTitle": { "alias": "pageTitle"; "required": false; }; "breadcrumbsRoutes": { "alias": "breadcrumbsRoutes"; "required": false; }; "inPageRoutes": { "alias": "inPageRoutes"; "required": false; }; "showBackToTop": { "alias": "showBackToTop"; "required": false; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; }; "showEditButton": { "alias": "showEditButton"; "required": false; }; "showTableOfContents": { "alias": "showTableOfContents"; "required": false; }; }, {}, never, ["[stachePageSummary]", "stache-page-summary", "*"], false, never>;
}

declare class StacheLayoutSidebarComponent implements StacheLayout {
    #private;
    pageTitle: string | undefined;
    breadcrumbsRoutes: StacheNavLink[] | undefined;
    inPageRoutes: StacheNavLink[] | undefined;
    sidebarRoutes: StacheNavLink[] | undefined;
    set showBackToTop(value: boolean | string | undefined);
    get showBackToTop(): boolean;
    set showBreadcrumbs(value: boolean | string | undefined);
    get showBreadcrumbs(): boolean;
    set showEditButton(value: boolean | string | undefined);
    get showEditButton(): boolean;
    set showTableOfContents(value: boolean | string | undefined);
    get showTableOfContents(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheLayoutSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheLayoutSidebarComponent, "stache-layout-sidebar", never, { "pageTitle": { "alias": "pageTitle"; "required": false; }; "breadcrumbsRoutes": { "alias": "breadcrumbsRoutes"; "required": false; }; "inPageRoutes": { "alias": "inPageRoutes"; "required": false; }; "sidebarRoutes": { "alias": "sidebarRoutes"; "required": false; }; "showBackToTop": { "alias": "showBackToTop"; "required": false; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; }; "showEditButton": { "alias": "showEditButton"; "required": false; }; "showTableOfContents": { "alias": "showTableOfContents"; "required": false; }; }, {}, never, ["[stachePageSummary]", "stache-page-summary", "*"], false, never>;
}

declare class StacheContainerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheContainerComponent, "stache-container", never, {}, {}, never, ["*"], false, never>;
}

declare class StacheSidebarComponent implements StacheNav, OnInit {
    #private;
    set routes(value: StacheNavLink[] | undefined);
    childRoutes: StacheNavLink[] | undefined;
    heading: string | undefined;
    headingRoute: string | string[] | undefined;
    isHeadingActive: boolean;
    sidebarHeadingElementId: string;
    constructor(routeSvc: StacheRouteService, navSvc: StacheNavService);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheSidebarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheSidebarComponent, "stache-sidebar", never, { "routes": { "alias": "routes"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StacheSidebarWrapperComponent implements OnDestroy, AfterViewInit {
    #private;
    sidebarRoutes: StacheNavLink[] | undefined;
    sidebarOpen: boolean;
    sidebarLabel: string;
    elementId: string;
    constructor(renderer: Renderer2, windowRef: StacheWindowRef, mediaQuerySvc: SkyMediaQueryService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    toggleSidebar(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheSidebarWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheSidebarWrapperComponent, "stache-sidebar-wrapper", never, { "sidebarRoutes": { "alias": "sidebarRoutes"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StacheSidebarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheSidebarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheSidebarModule, [typeof StacheSidebarComponent, typeof StacheSidebarWrapperComponent], [typeof i2.CommonModule, typeof StacheNavModule, typeof i3$2.SkyIconModule, typeof SkyStacheResourcesModule], [typeof StacheSidebarComponent, typeof StacheSidebarWrapperComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheSidebarModule>;
}

declare class StacheTableOfContentsWrapperComponent implements AfterViewInit, OnDestroy {
    #private;
    tocRoutes: StacheNavLink[] | undefined;
    constructor(renderer: Renderer2, windowRef: StacheWindowRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTableOfContentsWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTableOfContentsWrapperComponent, "stache-table-of-contents-wrapper", never, { "tocRoutes": { "alias": "tocRoutes"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StacheTableOfContentsComponent implements OnDestroy {
    #private;
    routes: StacheNavLink[] | undefined;
    constructor(windowRef: StacheWindowRef, viewportSvc: StacheViewportAdapterService);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTableOfContentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTableOfContentsComponent, "stache-table-of-contents", never, { "routes": { "alias": "routes"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StacheTableOfContentsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTableOfContentsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheTableOfContentsModule, [typeof StacheTableOfContentsWrapperComponent, typeof StacheTableOfContentsComponent], [typeof i2.CommonModule, typeof StacheNavModule, typeof StacheAffixModule, typeof SkyStacheResourcesModule], [typeof StacheTableOfContentsWrapperComponent, typeof StacheTableOfContentsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheTableOfContentsModule>;
}

declare class StachePageSummaryComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StachePageSummaryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StachePageSummaryComponent, "stache-page-summary", never, {}, {}, never, ["*"], false, never>;
}

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

declare class StachePageHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StachePageHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StachePageHeaderComponent, "stache-page-header", never, {}, {}, never, ["*"], false, never>;
}

declare class StachePageTitleComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StachePageTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StachePageTitleComponent, "stache-page-title", never, {}, {}, never, ["*"], false, never>;
}

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

declare class StachePageAnchorService implements OnDestroy {
    private windowRef;
    pageAnchorsStream: Subject<StacheNavLink[]>;
    pageAnchors: BehaviorSubject<StacheNavLink>[];
    refreshRequestedStream: Subject<void>;
    private ngUnsubscribe;
    constructor(windowRef: StacheWindowRef);
    addAnchor(anchorStream: BehaviorSubject<StacheNavLink>): void;
    ngOnDestroy(): void;
    refreshAnchors(): void;
    scrollToAnchor(elementId: string): void;
    private removeAnchor;
    private updateAnchorStream;
    private sortPageAnchors;
    static ɵfac: i0.ɵɵFactoryDeclaration<StachePageAnchorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StachePageAnchorService>;
}

declare class StachePageAnchorComponent implements StacheNavLink, OnDestroy, AfterViewInit, OnInit, AfterViewChecked, AfterContentInit {
    private elementRef;
    private anchorService;
    private changeDetectorRef;
    private routeService;
    name: string;
    fragment: string;
    path: string[];
    offsetTop: number;
    anchorStream: BehaviorSubject<StacheNavLink>;
    anchorId?: string;
    private textContent;
    private ngUnsubscribe;
    constructor(elementRef: ElementRef, anchorService: StachePageAnchorService, changeDetectorRef: ChangeDetectorRef, routeService: StacheRouteService);
    scrollToAnchor(): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngAfterContentInit(): void;
    ngAfterViewChecked(): void;
    private setValues;
    private updatePageAnchor;
    private getOffset;
    private getName;
    private getFragment;
    static ɵfac: i0.ɵɵFactoryDeclaration<StachePageAnchorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StachePageAnchorComponent, "stache-page-anchor", never, { "anchorId": { "alias": "anchorId"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class StachePageAnchorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StachePageAnchorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StachePageAnchorModule, [typeof StachePageAnchorComponent], [typeof i2.CommonModule, typeof i3.RouterModule, typeof i3$2.SkyIconModule], [typeof StachePageAnchorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StachePageAnchorModule>;
}

declare class StacheLayoutModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheLayoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheLayoutModule, [typeof StacheLayoutComponent, typeof StacheLayoutBlankComponent, typeof StacheLayoutContainerComponent, typeof StacheLayoutSidebarComponent, typeof StacheContainerComponent], [typeof i2.CommonModule, typeof StacheActionButtonsModule, typeof StacheAffixModule, typeof StacheBackToTopModule, typeof StacheNavModule, typeof StacheBreadcrumbsModule, typeof StacheEditButtonModule, typeof StacheSidebarModule, typeof StacheTableOfContentsModule, typeof StachePageSummaryModule, typeof StachePageHeaderModule, typeof StachePageAnchorModule], [typeof StacheLayoutComponent, typeof StacheContainerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheLayoutModule>;
}

declare class StacheTutorialStepComponent {
    #private;
    set showNumber(value: boolean | string | undefined);
    get showNumber(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTutorialStepComponent, "stache-tutorial-step", never, { "showNumber": { "alias": "showNumber"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class StacheTutorialStepBodyComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialStepBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTutorialStepBodyComponent, "stache-tutorial-step-body", never, {}, {}, never, ["*"], false, never>;
}

declare class StacheTutorialStepHeadingComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialStepHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTutorialStepHeadingComponent, "stache-tutorial-step-heading", never, {}, {}, never, ["*"], false, never>;
}

declare class StacheTutorialStepModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialStepModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheTutorialStepModule, [typeof StacheTutorialStepComponent, typeof StacheTutorialStepBodyComponent, typeof StacheTutorialStepHeadingComponent], [typeof i2.CommonModule, typeof StachePageAnchorModule, typeof StacheRouterModule], [typeof StacheTutorialStepComponent, typeof StacheTutorialStepBodyComponent, typeof StacheTutorialStepHeadingComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheTutorialStepModule>;
}

declare class StacheTutorialComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTutorialComponent, "stache-tutorial", never, {}, {}, never, ["*"], false, never>;
}

declare class StacheTutorialHeadingComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTutorialHeadingComponent, "stache-tutorial-heading", never, {}, {}, never, ["*"], false, never>;
}

declare class StacheTutorialSummaryComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialSummaryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheTutorialSummaryComponent, "stache-tutorial-summary", never, {}, {}, never, ["*"], false, never>;
}

declare class StacheTutorialModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTutorialModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheTutorialModule, [typeof StacheTutorialComponent, typeof StacheTutorialHeadingComponent, typeof StacheTutorialSummaryComponent], never, [typeof StacheTutorialComponent, typeof StacheTutorialHeadingComponent, typeof StacheTutorialSummaryComponent, typeof StacheTutorialStepModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheTutorialModule>;
}

declare class StacheTitleService {
    #private;
    setTitle(...parts: string[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheTitleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StacheTitleService>;
}

declare class StacheWrapperComponent implements OnInit, AfterViewInit, OnDestroy {
    #private;
    private config;
    private dataService;
    private pageAnchorService;
    private titleService;
    private route;
    private navService;
    private windowRef;
    private changeDetectorRef;
    private viewportService;
    pageTitle: string;
    windowTitle: string;
    navTitle: string;
    layout: StacheLayoutType;
    sidebarRoutes: StacheNavLink[];
    breadcrumbsRoutes: StacheNavLink[];
    showBreadcrumbs: boolean;
    showEditButton: boolean;
    set showFooter(value: boolean | string | undefined);
    get showFooter(): boolean;
    showTableOfContents: boolean;
    showBackToTop: boolean;
    showInNav: boolean;
    inPageRoutes: StacheNavLink[] | undefined;
    jsonData: any;
    private ngUnsubscribe;
    constructor(config: SkyAppConfig, dataService: StacheJsonDataService, pageAnchorService: StachePageAnchorService, titleService: StacheTitleService, route: ActivatedRoute, navService: StacheNavService, windowRef: StacheWindowRef, changeDetectorRef: ChangeDetectorRef, viewportService: StacheViewportAdapterService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private getPreferredDocumentTitle;
    private getTutorialHeader;
    private checkEditButtonUrl;
    private checkFooterData;
    private checkRouteHash;
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StacheWrapperComponent, "stache", never, { "pageTitle": { "alias": "pageTitle"; "required": false; }; "windowTitle": { "alias": "windowTitle"; "required": false; }; "navTitle": { "alias": "navTitle"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "sidebarRoutes": { "alias": "sidebarRoutes"; "required": false; }; "breadcrumbsRoutes": { "alias": "breadcrumbsRoutes"; "required": false; }; "showBreadcrumbs": { "alias": "showBreadcrumbs"; "required": false; }; "showEditButton": { "alias": "showEditButton"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "showTableOfContents": { "alias": "showTableOfContents"; "required": false; }; "showBackToTop": { "alias": "showBackToTop"; "required": false; }; "showInNav": { "alias": "showInNav"; "required": false; }; "inPageRoutes": { "alias": "inPageRoutes"; "required": false; }; }, {}, never, ["stache-page-summary", "*"], false, never>;
}

declare class StacheWrapperModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheWrapperModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheWrapperModule, [typeof StacheWrapperComponent], [typeof i2.CommonModule, typeof i3.RouterModule, typeof StacheAnalyticsModule, typeof StachePageAnchorModule, typeof StacheLayoutModule, typeof StacheFooterModule], [typeof StacheWrapperComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheWrapperModule>;
}

declare class StacheModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StacheModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StacheModule, never, never, [typeof StacheActionButtonsModule, typeof StacheAffixModule, typeof StacheAnalyticsModule, typeof StacheBackToTopModule, typeof StacheBlockquoteModule, typeof StacheBreadcrumbsModule, typeof StacheEditButtonModule, typeof StacheFooterModule, typeof StacheHideFromSearchModule, typeof StacheLayoutModule, typeof StacheNavModule, typeof StachePageAnchorModule, typeof StachePageHeaderModule, typeof StachePageSummaryModule, typeof StacheRouterModule, typeof StacheSidebarModule, typeof StacheTableOfContentsModule, typeof StacheTutorialModule, typeof StacheWrapperModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StacheModule>;
}

export { STACHE_JSON_DATA_SERVICE_CONFIG, STACHE_ROUTE_OPTIONS, StacheActionButtonsModule, StacheAffixModule, StacheAnalyticsModule, StacheAuthService, StacheBackToTopModule, StacheBlockquoteModule, StacheBreadcrumbsModule, StacheEditButtonModule, StacheFooterModule, StacheHideFromSearchModule, StacheJsonDataService, StacheLayoutModule, StacheModule, StacheNavModule, StachePageAnchorModule, StachePageHeaderModule, StachePageSummaryModule, StacheRouteService, StacheRouterModule, StacheSidebarModule, StacheTableOfContentsModule, StacheTutorialModule, StacheTutorialStepModule, StacheWrapperModule, StacheRouterLinkDirective as λ1, StacheEditButtonComponent as λ10, StacheFooterComponent as λ11, StacheHideFromSearchComponent as λ12, StacheSidebarComponent as λ14, StacheSidebarWrapperComponent as λ15, StacheTableOfContentsComponent as λ16, StacheTableOfContentsWrapperComponent as λ17, StachePageHeaderComponent as λ18, StachePageTitleComponent as λ19, StacheNavComponent as λ2, StachePageAnchorComponent as λ20, StachePageSummaryComponent as λ21, StacheLayoutComponent as λ22, StacheTutorialStepComponent as λ24, StacheTutorialStepBodyComponent as λ25, StacheTutorialStepHeadingComponent as λ26, StacheTutorialHeadingComponent as λ27, StacheTutorialSummaryComponent as λ28, StacheTutorialComponent as λ29, StacheActionButtonsComponent as λ3, StacheWrapperComponent as λ30, StacheContainerComponent as λ31, StacheAffixTopDirective as λ4, StacheAffixComponent as λ5, StacheGoogleAnalyticsDirective as λ6, StacheBackToTopComponent as λ7, StacheBlockquoteComponent as λ8, StacheBreadcrumbsComponent as λ9 };
export type { StacheNavLink, StacheRouteOptions };