@foblex/m-render 2.7.7 → 2.7.8

package/index.d.ts

@@ -1,6 +1,1276 @@
-export * from './lib/analytics';
-export * from './lib/common';
-export * from './lib/documentation-page';
-export * from './lib/highlight';
-export * from './lib/home-page';
-export * from './lib/theme';
+import * as i0 from '@angular/core';
+import { Provider, InjectionToken, EventEmitter, ElementRef, ChangeDetectorRef, OnDestroy, AfterViewInit, OnInit, Type, ViewContainerRef, ComponentRef, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { SafeHtml } from '@angular/platform-browser';
+import MarkdownIt from 'markdown-it';
+import container from 'markdown-it-container';
+import * as _foblex_m_render from '@foblex/m-render';
+import { Router, Routes } from '@angular/router';
+import { ThemeInput } from '@shikijs/types';
+
+declare function provideGTag(config: GTagConfig): Provider[];
+interface GTagConfig {
+    id: string;
+    extraIds?: string[];
+    autoPageview?: boolean;
+    initialConsent?: ConsentState;
+}
+declare const GTAG_CONFIG: InjectionToken<GTagConfig>;
+type ConsentState = 'granted' | 'denied';
+
+declare class GTagService {
+    private readonly _config;
+    private readonly _document;
+    private readonly _router;
+    private _initialized;
+    private _configuredIds;
+    initialize(): void;
+    updateConsent(granted: boolean): void;
+    event(action: string, params?: Record<string, unknown>): void;
+    pageview(path?: string): void;
+    adsConversion(sendTo: string, params?: Record<string, unknown>): void;
+    private _setConsent;
+    private _appendScript;
+    private _configAll;
+    private _getConfiguredIds;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GTagService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GTagService>;
+}
+
+declare class FSearchButtonComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FSearchButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FSearchButtonComponent, "f-search-button", never, {}, {}, never, never, true, never>;
+}
+
+declare class FCheckboxComponent {
+    private changeDetectorRef;
+    id: string;
+    change: EventEmitter<boolean>;
+    private inputElement?;
+    labelElement?: ElementRef<HTMLLabelElement>;
+    get checked(): boolean;
+    set checked(value: boolean);
+    private isChecked;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    onInputClick(): void;
+    onTouchTargetClick(): void;
+    private handleInputClick;
+    private emitChangeEvent;
+    onInteractionEvent(event: Event): void;
+    preventBubblingFromLabel(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FCheckboxComponent, "f-checkbox", never, { "id": { "alias": "id"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_checked: unknown;
+}
+
+declare class FRadioButtonComponent {
+    id: i0.InputSignal<string>;
+    change: i0.OutputEmitterRef<boolean>;
+    checked: i0.InputSignal<boolean>;
+    protected labelElement: i0.Signal<ElementRef<any> | undefined>;
+    onInputClick(): void;
+    onTouchTargetClick(): void;
+    private _handleInputClick;
+    private _emitChangeEvent;
+    protected onInteractionEvent(event: Event): void;
+    protected preventBubblingFromLabel(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FRadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FRadioButtonComponent, "f-radio-button", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare class FMetaService {
+    private readonly _location;
+    private readonly _router;
+    private readonly _headTag;
+    private readonly _configuration;
+    changes(): Observable<string>;
+    dispose(): void;
+    private _findDocGroupByUrl;
+    private _findDocItemByUrl;
+    private _buildAbsoluteUrl;
+    private _toAbsoluteUrl;
+    private _updateMetaTags;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FMetaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FMetaService>;
+}
+
+interface IMetaData {
+    url: string;
+    canonical?: string;
+    type: string;
+    title: string;
+    app_name: string;
+    locale: string;
+    description: string;
+    image: string;
+    image_type: string;
+    image_width: number;
+    image_height: number;
+}
+
+declare class HamburgerButton {
+    private readonly _parent;
+    protected _onShowNavigation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HamburgerButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HamburgerButton, "button[hamburger-button]", never, {}, {}, never, never, true, never>;
+}
+
+interface IToggleNavigationComponent {
+    onToggleNavigation(value: boolean): void;
+}
+declare const TOGGLE_NAVIGATION_COMPONENT: InjectionToken<IToggleNavigationComponent>;
+
+declare class HeaderMenuBase {
+    private readonly _router;
+    private readonly _baseNav;
+    private readonly _url;
+    readonly navigation: i0.Signal<{
+        isActive: boolean;
+        active: string;
+        link: string;
+        text: string;
+    }[]>;
+    private _cleanPath;
+    private _isActive;
+}
+
+interface IHeaderMenuLink extends ILink {
+    active: string;
+}
+
+declare class InlineMenu extends HeaderMenuBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineMenu, "inline-menu", never, {}, {}, never, never, true, never>;
+}
+
+declare class DropdownMenu extends HeaderMenuBase implements OnDestroy {
+    protected readonly isOpen: i0.WritableSignal<boolean>;
+    protected readonly scrollStrategy: _angular_cdk_overlay.BlockScrollStrategy;
+    protected readonly positions: ConnectedPosition[];
+    private _hoverTimeout;
+    protected mouseEnter(): void;
+    protected mouseLeave(): void;
+    protected toggle(): void;
+    protected open(): void;
+    protected close(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownMenu, "dropdown-menu", never, {}, {}, never, never, true, never>;
+}
+
+interface IMediaLink {
+    link: string;
+    icon: string;
+}
+
+interface IMediaLinksProvider {
+    getMediaLinks(): IMediaLink[];
+}
+declare const MEDIA_LINKS_PROVIDER: InjectionToken<IMediaLink[]>;
+
+declare class MediaLinks {
+    protected links: IMediaLink[] | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaLinks, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MediaLinks, "media-links", never, {}, {}, never, never, true, never>;
+}
+
+declare class HeaderComponent implements AfterViewInit, OnDestroy {
+    protected title: string;
+    protected image: string;
+    protected config: IHeaderConfiguration;
+    protected readonly emptyNavigation: boolean;
+    private readonly _zone;
+    private readonly _containerRef;
+    private readonly _targetRef;
+    protected readonly overflowed: i0.WritableSignal<boolean>;
+    protected readonly initialized: i0.WritableSignal<boolean>;
+    private _rafId;
+    private _roContainer?;
+    private _roTarget?;
+    ngAfterViewInit(): void;
+    private _initObservers;
+    private _scheduleCheck;
+    private _checkOverflow;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "f-header", never, {}, {}, never, never, true, never>;
+}
+
+interface INavigationItemBadge {
+    text: string;
+    type: 'success' | 'danger' | 'warning' | 'info' | 'tip';
+}
+
+interface INavigationItem {
+    link: string;
+    text: string;
+    hideToc?: boolean;
+    pageTitle?: string;
+    description?: string;
+    canonical?: string;
+    image?: string;
+    image_dark?: string;
+    image_width?: number;
+    image_height?: number;
+    image_type?: string;
+    badge?: INavigationItemBadge;
+    date?: Date;
+}
+
+interface INavigationGroup {
+    text?: string;
+    items: INavigationItem[];
+}
+
+declare class NavigationGroupComponent {
+    readonly title: i0.InputSignal<string | undefined>;
+    protected readonly isCollapsed: i0.WritableSignal<boolean>;
+    protected toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationGroupComponent, "f-navigation-group", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FNavigationItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FNavigationItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FNavigationItemComponent, "a[f-navigation-item]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NavigationPanelComponent implements OnInit, AfterViewInit {
+    private readonly _provider;
+    private readonly _parent;
+    private readonly _router;
+    private readonly _changeDetectorRef;
+    private readonly _destroyRef;
+    private readonly _window;
+    protected value: string | undefined;
+    protected navigation: INavigationGroup[];
+    protected title: string;
+    protected image: string;
+    ngOnInit(): void;
+    private _deepClone;
+    private _normalizeLink;
+    private _isExternalLink;
+    ngAfterViewInit(): void;
+    private _subscribeOnRouteChanges;
+    private _highlightLink;
+    protected _onDocumentClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavigationPanelComponent, "f-navigation-panel", never, {}, {}, never, never, true, never>;
+}
+
+declare class GetPreviousNextPageNavigationRequest {
+    currentLink: string;
+    constructor(currentLink: string);
+}
+
+interface IMarkdownFooterLink {
+    text?: string;
+    link?: string;
+}
+
+declare class GetPreviousNextPageNavigationResponse {
+    previousLink: IMarkdownFooterLink | undefined;
+    nextLink: IMarkdownFooterLink | undefined;
+    constructor(previousLink: IMarkdownFooterLink | undefined, nextLink: IMarkdownFooterLink | undefined);
+}
+
+declare class CodeGroup {
+    readonly data: i0.WritableSignal<IParsedContainerData[]>;
+    protected readonly index: i0.WritableSignal<number>;
+    protected readonly containerType: typeof EParsedContainerType;
+    protected tabClick(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeGroup, "code-group", never, {}, {}, never, never, true, never>;
+}
+
+interface IExampleViewData {
+    value: string;
+    height?: string | number;
+}
+
+declare function coerceComponentHeight(value: string | number | undefined): string | undefined;
+
+declare function parseComponentTag(html: string): string | null;
+
+declare class ExternalComponent implements OnInit {
+    readonly data: i0.InputSignalWithTransform<IExampleViewData, IParsedContainerData>;
+    private readonly _mediatr;
+    private readonly _viewContainerRef;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalComponent, "external-component", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class PreviewCardBase {
+    abstract date?: Date;
+    abstract filterKey?: string;
+    abstract hostElement: HTMLElement;
+}
+
+declare class PreviewCard extends PreviewCardBase implements OnInit, OnDestroy {
+    private readonly _elementReference;
+    private readonly _fEnvironment;
+    private readonly _fPreviewGroupService;
+    private readonly _themeService;
+    private readonly _router;
+    private readonly _destroyRef;
+    item: string | undefined;
+    group: string | undefined;
+    protected viewModel: INavigationItem | undefined;
+    protected src: i0.WritableSignal<string | undefined>;
+    protected url: string | undefined;
+    get hostElement(): HTMLElement;
+    get filterKey(): string | undefined;
+    get date(): Date | undefined;
+    initialize(): void;
+    private _subscribeToThemeChanges;
+    ngOnInit(): void;
+    private _getNavigationGroup;
+    private _getNavigationItem;
+    private _updateTheme;
+    private _normalizeLink;
+    private _getUrlPrefix;
+    private _isExternalLink;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewCard, "a[preview-card]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PreviewActionBar implements AfterViewInit {
+    private readonly _allKey;
+    private _fEnvironment;
+    private _fPreviewGroupService;
+    protected filters: i0.WritableSignal<string[]>;
+    protected activeFilter: i0.WritableSignal<string>;
+    protected isSortByDateChecked: i0.WritableSignal<boolean>;
+    initialize(): void;
+    ngAfterViewInit(): void;
+    private _calculateFiltersMap;
+    protected onFilterChange(key: string): void;
+    protected onSortByDateChange(event: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewActionBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewActionBar, "div[preview-action-bar]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PreviewGroupService {
+    private _cards;
+    private _originalOrder;
+    add(card: PreviewCardBase): void;
+    remove(card: PreviewCardBase): void;
+    sortByDate(sort: boolean): void;
+    private _setOriginalOrder;
+    private _getOrderByDate;
+    private _applyByDateOrder;
+    private _applyOriginalOrder;
+    filterBy(filterKey: string, _allKey: string): void;
+    private _resetLastActiveFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreviewGroupService>;
+}
+
+interface IShowcaseItem {
+    name: string;
+    description: string;
+    imageUrl: string;
+    imageUrlDark?: string;
+    links: {
+        text: 'Website' | 'Demo' | 'Sources';
+        url: string;
+    }[];
+    tags?: string[];
+}
+
+declare class ShowcaseItem {
+    private readonly _themeService;
+    private readonly _themeChanges;
+    readonly model: i0.InputSignal<IShowcaseItem>;
+    protected readonly src: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowcaseItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ShowcaseItem, "showcase-item", never, { "model": { "alias": "model"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class Showcase {
+    private readonly _data;
+    protected readonly items: i0.Signal<IShowcaseItem[]>;
+    protected readonly tags: i0.Signal<Set<string>>;
+    protected readonly activeTag: i0.WritableSignal<string | null>;
+    protected tagClick(tag: string | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Showcase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Showcase, "showcase", never, {}, {}, never, never, true, never>;
+}
+
+declare function provideShowcase(showcaseItems: IShowcaseItem[]): Partial<IDocumentationConfiguration>;
+
+declare const SHOWCASE_DATA: InjectionToken<IShowcaseItem[]>;
+
+/**
+ * Interface for dynamic component instances.
+ * This interface can be implemented by any dynamic component to ensure it has an initialize method
+ * and can accept properties dynamically.
+ */
+interface IDynamicComponentInstance {
+    initialize?(): void;
+    [prop: string]: unknown | {
+        set(value: unknown): void;
+    };
+}
+
+interface IDynamicComponentItem {
+    selector: string;
+    component: Promise<Type<IDynamicComponentInstance>>;
+}
+
+declare const EXTERNAL_COMPONENT_PROVIDER: InjectionToken<IDynamicComponentItem[]>;
+
+declare class RenderDynamicComponentRequest {
+    readonly item: IDynamicComponentItem;
+    readonly viewContainerRef: ViewContainerRef;
+    readonly element?: HTMLElement | undefined;
+    static fToken: symbol;
+    constructor(item: IDynamicComponentItem, viewContainerRef: ViewContainerRef, element?: HTMLElement | undefined);
+}
+
+interface IHandler<TRequest, TResponse> {
+    handle(request: TRequest, ...args: unknown[]): TResponse | void;
+}
+
+type IExecution<TRequest, TResponse> = IHandler<TRequest, TResponse>;
+
+type Constructor<T = any> = new (...args: any[]) => T;
+declare function MExecution<TRequest, TResponse>(requestType: {
+    fToken: symbol;
+}): (constructor: Constructor<IExecution<TRequest, TResponse>>) => void;
+
+declare class Mediatr {
+    private readonly _injector;
+    private static _executions;
+    static register<TRequest, TResponse>(type: {
+        fToken: symbol;
+    }, handler: Type<IExecution<TRequest, TResponse>>): void;
+    execute<TResponse>(request: any): TResponse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Mediatr, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Mediatr>;
+}
+
+declare class RenderDynamicComponent implements IExecution<RenderDynamicComponentRequest, void> {
+    private readonly _dynamicStore;
+    handle({ item, viewContainerRef, element }: RenderDynamicComponentRequest): void;
+    private _renderComponent;
+    private _extractComponentRoot;
+    private _logComponentResolutionError;
+    private _logComponentLoadingError;
+    private _logError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderDynamicComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderDynamicComponent>;
+}
+
+declare class RenderExternalComponentRequest {
+    readonly selector: string;
+    readonly viewContainerRef: ViewContainerRef;
+    static fToken: symbol;
+    constructor(selector: string, viewContainerRef: ViewContainerRef);
+}
+
+declare class RenderExternalComponent implements IExecution<RenderExternalComponentRequest, void> {
+    private readonly _mediatr;
+    private readonly _componentsMap;
+    handle({ selector, viewContainerRef }: RenderExternalComponentRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderExternalComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderExternalComponent>;
+}
+
+declare class RenderInternalComponentsRequest {
+    readonly hostElement: HTMLElement;
+    readonly viewContainerRef: ViewContainerRef;
+    static fToken: symbol;
+    constructor(hostElement: HTMLElement, viewContainerRef: ViewContainerRef);
+}
+
+declare class RenderInternalComponents implements IExecution<RenderInternalComponentsRequest, void> {
+    private readonly _dynamicStore;
+    private readonly _mediatr;
+    private readonly _componentsMap;
+    handle({ hostElement, viewContainerRef }: RenderInternalComponentsRequest): void;
+    private _queryElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderInternalComponents, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderInternalComponents>;
+}
+
+declare class DynamicComponentsStore {
+    private _components;
+    dispose(): void;
+    addComponent(reference: ComponentRef<IDynamicComponentInstance>, element?: HTMLElement): void;
+    private _assignInputs;
+    private _parseDatasetValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentsStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentsStore>;
+}
+
+declare const DYNAMIC_COMPONENTS_MODULE_PROVIDERS: (typeof DynamicComponentsStore | typeof RenderDynamicComponent | typeof RenderExternalComponent | typeof PreviewGroupService | typeof RenderInternalComponents)[];
+
+declare class DocumentationStore implements IMediaLinksProvider, IHeaderConfigurationStore {
+    private readonly _configuration;
+    readonly tocData: i0.WritableSignal<TableOfContentData>;
+    getMarkdownUrl(markdown: string): string;
+    getLogo(): string;
+    getTitle(): string;
+    getHeaderNavigation(): IHeaderMenuLink[];
+    getComponents(): IDynamicComponentItem[];
+    getNavigation(): INavigationGroup[];
+    getFooterNavigation(): IMarkdownFooterNavigation;
+    getMediaLinks(): IMediaLink[];
+    getTableOfContent(): ITableOfContent | null;
+    getHeader(): IHeaderConfiguration | undefined;
+    getShowcaseItems(): IShowcaseItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentationStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentationStore>;
+}
+
+declare class GetPreviousNextPageNavigationHandler {
+    private _provider;
+    constructor(_provider: DocumentationStore);
+    handle(request: GetPreviousNextPageNavigationRequest): GetPreviousNextPageNavigationResponse;
+}
+
+interface IMarkdownFooterNavigation {
+    editLink?: {
+        pattern: string;
+        text?: string;
+    };
+    previous?: string;
+    next?: string;
+}
+
+declare class FooterNavigationButton {
+    description: string | undefined;
+    link: IMarkdownFooterLink;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterNavigationButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FooterNavigationButton, "a[footer-navigation-button]", never, { "description": { "alias": "description"; "required": true; }; "link": { "alias": "link"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownFooter {
+    private readonly _provider;
+    private readonly _router;
+    private readonly _activatedRoute;
+    private readonly _window;
+    protected readonly navigation: IMarkdownFooterNavigation;
+    private readonly _url;
+    private readonly _currentLink;
+    private readonly _prefix;
+    protected readonly editLink: i0.Signal<string | undefined>;
+    protected readonly previousLink: i0.Signal<IMarkdownFooterLink | undefined>;
+    protected readonly nextLink: i0.Signal<IMarkdownFooterLink | undefined>;
+    private _normalizeLink;
+    private _isExternal;
+    private _click;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkdownFooter, "markdown-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare enum EMarkdownContainerType {
+    CODE_GROUP = "code-group",
+    EXAMPLE_GROUP = "ng-component",
+    PREVIEW_GROUP = "preview-group",
+    SHOWCASE = "showcase",
+    ALERT_TIP = "tip",
+    ALERT_INFO = "info",
+    ALERT_WARNING = "warning",
+    ALERT_DANGER = "danger",
+    ALERT_SUCCESS = "success"
+}
+
+declare enum EParsedContainerType {
+    CODE = "code",
+    EXAMPLE = "ng-component"
+}
+
+interface IMarkdownItToken {
+    type: string;
+    tag: string;
+    attrs: Array<[string, string]> | null;
+    map: [number, number] | null;
+    nesting: -1 | 0 | 1;
+    level: number;
+    children: IMarkdownItToken[] | null;
+    content: string;
+    markup: string;
+    info: string;
+    meta: any;
+    block: boolean;
+    hidden: boolean;
+}
+
+interface IMarkdownContainerData {
+    tag: string;
+    height?: string;
+}
+
+interface IParsedContainerData {
+    tab: string;
+    type: EParsedContainerType;
+    height?: string | number;
+    value: string;
+    isLink?: boolean;
+    language?: string;
+}
+
+interface IPreviewNavigationGroup {
+    id?: string;
+    text: string;
+    items: [
+        {
+            link: string;
+        }
+    ];
+}
+
+interface IPreviewNavigationService<T extends IPreviewNavigationGroup> {
+    getNavigation(): T[];
+}
+declare const F_PREVIEW_NAVIGATION_PROVIDER: InjectionToken<IPreviewNavigationService<IPreviewNavigationGroup>>;
+
+declare class MarkdownService {
+    private readonly _markdown;
+    private readonly _httpClient;
+    private readonly _domSanitizer;
+    private readonly _router;
+    private readonly _provider;
+    constructor();
+    parseUrl(src: string): Observable<SafeHtml>;
+    parseText(value: string): Observable<SafeHtml>;
+    private _normalizeLinks;
+    private _isExternalLink;
+    private _cleanupEmptyParagraphs;
+    private _cleanupWasteParagraphFromExampleView;
+    private _cleanupWasteParagraphFromPreviewGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MarkdownService>;
+}
+
+type ContainerArgs$4 = [typeof container, string, {
+    render: any;
+}];
+declare class ParseAlerts {
+    render(type: string, markdown: MarkdownIt): ContainerArgs$4;
+}
+
+type ContainerArgs$3 = [typeof container, string, {
+    render: any;
+}];
+declare class ParseGroupedCodeItems {
+    render(): ContainerArgs$3;
+    private _generateData;
+    private _isClosingToken;
+    private _isCodeFenceToken;
+    private _openingExampleGroupHTML;
+    private _getCodeBlockTitle;
+    private _getCodeLanguage;
+}
+
+declare class ParseSingleCodeItem {
+    render(markdown: MarkdownIt): void;
+    private _getTokenData;
+    private _createCodeData;
+}
+
+type ContainerArgs$2 = [typeof container, string, {
+    render: any;
+}];
+declare class ParseAngularExampleWithCodeLinks {
+    render(): ContainerArgs$2;
+    private _opening;
+    private _collectData;
+    private _parseNgComponent;
+}
+
+type ContainerArgs$1 = [typeof container, string, {
+    render: any;
+}];
+declare class ParsePreviewGroup {
+    private _navigation;
+    constructor(_navigation: IPreviewNavigationGroup[]);
+    render(): ContainerArgs$1;
+    private _generateData;
+    private _parseData;
+    private _getGroupsHTML;
+    private _getGroupFiltersHTML;
+    private _getItemsHTML;
+}
+
+type ContainerArgs = [typeof container, string, {
+    render: any;
+}];
+declare class ParseShowcase {
+    render(): ContainerArgs;
+}
+
+declare function getContent(tokens: IMarkdownItToken[], index: number, eContainerType: string): string | undefined;
+declare function encodeDataAttr(data: unknown): string;
+declare function isOpeningToken(token: IMarkdownItToken): boolean;
+declare function isClosingToken(token: IMarkdownItToken): boolean;
+declare function parseFileLinkLine(line: string): {
+    fileName: string;
+    url: string;
+} | null;
+declare function parseSingleBracketText(line: string): string | null;
+
+declare class MarkdownRenderer implements OnInit, OnDestroy {
+    readonly value: i0.InputSignal<SafeHtml | undefined>;
+    private readonly _hostElement;
+    private readonly _router;
+    private readonly _injector;
+    private readonly _isBrowser;
+    private readonly _window;
+    private readonly _dynamicComponents;
+    private readonly _mediatr;
+    private readonly _viewContainerRef;
+    private readonly _scrollableContainer;
+    ngOnInit(): void;
+    private _setupValueEffect;
+    private _resetScroll;
+    private _schedulePostRenderWork;
+    private _renderDynamicComponents;
+    private _recalculateToc;
+    protected _onDocumentClick(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkdownRenderer, "markdown-renderer", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MarkdownRouter {
+    private readonly _router;
+    private readonly _activatedRoute;
+    private readonly _markdown;
+    private readonly _dataProvider;
+    protected readonly emptyNavigation: boolean;
+    private readonly _path$;
+    protected readonly html: i0.Signal<SafeHtml | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownRouter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkdownRouter, "markdown-router", never, {}, {}, never, never, true, never>;
+}
+
+declare const SCROLLABLE_CONTAINER: InjectionToken<IScrollableContainer>;
+interface IScrollableContainer {
+    htmlElement: HTMLElement & {
+        _ignoreProgrammatic?: boolean;
+    };
+}
+
+declare class ActivateTocByHashRequest {
+    hash: string | undefined;
+    static fToken: symbol;
+    constructor(hash: string | undefined);
+}
+
+declare class ActivateTocByHash implements IExecution<ActivateTocByHashRequest, void> {
+    private readonly _dataProvider;
+    handle(payload: ActivateTocByHashRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivateTocByHash, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActivateTocByHash>;
+}
+
+declare class CalculateTableOfContentRequest {
+    readonly hostElement: HTMLElement;
+    static fToken: symbol;
+    constructor(hostElement: HTMLElement);
+}
+
+declare class CalculateTableOfContent implements IExecution<CalculateTableOfContentRequest, void> {
+    private readonly _dataProvider;
+    private readonly _mediatr;
+    handle(request: CalculateTableOfContentRequest): void;
+    private _getNavigationSelectors;
+    private _createItem;
+    private _createNavigationId;
+    private _getLevel;
+    private _insertItemIntoTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateTableOfContent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateTableOfContent>;
+}
+
+declare class CalculateHashFromScrollPositionAndActivateToc implements IExecution<CalculateHashFromScrollPositionAndActivateTocRequest, number> {
+    private readonly _docElement;
+    private readonly _window;
+    private readonly _provider;
+    private readonly _scrollableContainer;
+    private readonly _mediatr;
+    handle(): void;
+    private _getContainerScrollTop;
+    private _getHeaderHeight;
+    private _calculateElementsTopPositions;
+    private _calculateAbsoluteTopToContainer;
+    private _isScrollAtBottom;
+    private _findTargetHashByPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateHashFromScrollPositionAndActivateToc, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateHashFromScrollPositionAndActivateToc>;
+}
+
+declare class CalculateHashFromScrollPositionAndActivateTocRequest {
+    static fToken: symbol;
+}
+
+declare class CalculateAbsoluteTopToContainerRequest {
+    element: HTMLElement;
+    static fToken: symbol;
+    constructor(element: HTMLElement);
+}
+
+declare class CalculateAbsoluteTopToContainer implements IExecution<CalculateAbsoluteTopToContainerRequest, number> {
+    private readonly _scrollableContainer;
+    handle(request: CalculateAbsoluteTopToContainerRequest): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateAbsoluteTopToContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateAbsoluteTopToContainer>;
+}
+
+declare class ScrollToElementInContainerRequest {
+    hash: string;
+    static fToken: symbol;
+    constructor(hash: string);
+}
+
+declare class ScrollToElementInContainer implements IExecution<ScrollToElementInContainerRequest, void> {
+    private readonly _scrollableContainer;
+    private readonly _window;
+    private readonly _docElement;
+    handle(payload: ScrollToElementInContainerRequest): void;
+    private _getHeaderHeight;
+    private _getScrollToElement;
+    private _getScrollTo;
+    private _isFirstElementInContainer;
+    private _calculateScrollTo;
+    private _getElementTop;
+    private _getContainerTop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToElementInContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollToElementInContainer>;
+}
+
+interface ITableOfContent {
+    title?: string;
+    range?: {
+        start: number;
+        end: number;
+    };
+}
+
+interface ITableOfContentItem {
+    element: HTMLElement;
+    hash: string;
+    title: string;
+    isActive?: boolean;
+    children: ITableOfContentItem[];
+}
+
+declare class TableOfContentData {
+    flat: ITableOfContentItem[];
+    tree: ITableOfContentItem[];
+    constructor(flat: ITableOfContentItem[], tree: ITableOfContentItem[]);
+}
+
+declare class TableOfContentItemsComponent {
+    readonly items: i0.InputSignal<ITableOfContentItem[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableOfContentItemsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableOfContentItemsComponent, "ul[f-table-of-content-items]", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const TABLE_OF_CONTENT_MODULE_PROVIDERS: (typeof ActivateTocByHash | typeof CalculateAbsoluteTopToContainer | typeof CalculateHashFromScrollPositionAndActivateToc | typeof CalculateTableOfContent | typeof ScrollToElementInContainer)[];
+
+declare class TableOfContent {
+    private readonly _hostElement;
+    private readonly _dataProvider;
+    private readonly _window;
+    private readonly _mediatr;
+    protected readonly tocData: i0.Signal<_foblex_m_render.TableOfContentData>;
+    protected readonly activeMarkerPosition: i0.Signal<number>;
+    protected readonly title: string | undefined;
+    private _getActiveMarkerPosition;
+    private _getToCItemHeight;
+    protected _click(event: MouseEvent): void;
+    private _scrollTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableOfContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableOfContent, "table-of-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScrollableContainer implements OnInit, IScrollableContainer {
+    private readonly _destroyRef;
+    private readonly _mediatr;
+    protected readonly tableOfContent: ITableOfContent | null;
+    readonly htmlElement: any;
+    ngOnInit(): void;
+    private _calculateHashAndActivate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollableContainer, "scrollable-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class HandleNavigationLinksRequest {
+    event: MouseEvent;
+    window: Window;
+    router: Router;
+    constructor(event: MouseEvent, window: Window, router: Router);
+}
+
+declare class HandleNavigationLinksHandler {
+    handle(request: HandleNavigationLinksRequest): void;
+    private _getTargetElement;
+    private _getClosestAnchorTag;
+    private _hasHref;
+    private _isExternalLink;
+    private _navigateInternalLink;
+}
+
+interface IDocumentationConfiguration extends ILanguageConfiguration, ITitleConfiguration, ILogoConfiguration, IHasHeaderConfiguration {
+    docsDir: string;
+    notFoundMarkdown: string;
+    navigation: INavigationGroup[];
+    blogNavigation?: boolean;
+    footer?: IDocumentationFooterConfiguration;
+    components?: IDynamicComponentItem[];
+    tableOfContent: ITableOfContent | null;
+    meta?: IMetaData;
+    showcaseItems?: IShowcaseItem[];
+}
+interface IDocumentationFooterConfiguration {
+    navigation?: IMarkdownFooterNavigation;
+}
+
+declare function provide404Markdown(notFoundMarkdown: string): Partial<IDocumentationConfiguration>;
+
+declare function defineLazyComponent(selector: string, loader: () => Promise<Record<string, unknown>>): IDynamicComponentItem;
+declare function provideComponents(components: IDynamicComponentItem[]): Partial<IDocumentationConfiguration>;
+declare function extractComponent(loader: () => Promise<Record<string, unknown>>): Promise<Type<any>>;
+
+declare function provideDirectory(docsDir: string): Partial<IDocumentationConfiguration>;
+
+declare function provideDocumentation(configuration: IProviderInstance$1): {
+    provide: InjectionToken<IDocumentationConfiguration>;
+    useValue: any;
+};
+declare const DOCUMENTATION_CONFIGURATION: InjectionToken<IDocumentationConfiguration>;
+interface IProviderInstance$1 {
+    providers: Partial<IDocumentationConfiguration>[];
+}
+
+declare function provideMeta(meta: IMetaData): Partial<IDocumentationConfiguration>;
+
+declare function provideFooterNavigation(navigation: IMarkdownFooterNavigation): Partial<IDocumentationConfiguration>;
+
+declare function provideNavigation(...navigation: INavigationGroup[]): Partial<IDocumentationConfiguration>;
+declare function defineNavigationGroup(name: string | undefined, items: INavigationItem[]): INavigationGroup;
+
+declare function provideTableOfContent(tableOfContent?: ITableOfContent | null): Partial<IDocumentationConfiguration>;
+
+declare function calculateMarkdownUrl(markdown: string, navigation: INavigationGroup[], docsDir: string, notFoundMd?: string): string;
+
+declare class Documentation implements IToggleNavigationComponent, OnInit, OnDestroy {
+    protected readonly isNavigationVisible: i0.WritableSignal<boolean>;
+    protected readonly popover: i0.Signal<string | null>;
+    private readonly _metaService;
+    private readonly _destroyRef;
+    private readonly _gTagService;
+    private readonly _themeService;
+    protected readonly emptyNavigation: boolean;
+    protected readonly isBrowser: boolean;
+    ngOnInit(): void;
+    onToggleNavigation(value: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Documentation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Documentation, "documentation", never, {}, {}, never, never, true, never>;
+}
+
+declare const DOCUMENTATION_ROUTES: Routes;
+
+declare function provideHeader(...configuration: Partial<IHeaderConfiguration>[]): Partial<IHasHeaderConfiguration>;
+interface IHeaderConfiguration {
+    search?: boolean;
+    navigation?: IHeaderMenuLink[];
+    mediaLinks?: IMediaLink[];
+}
+interface IHasHeaderConfiguration {
+    header?: IHeaderConfiguration;
+}
+
+declare function provideHeaderSearch(search?: boolean): Partial<IHeaderConfiguration>;
+
+declare function provideHeaderMediaLinks(mediaLinks: IMediaLink[]): Partial<IHeaderConfiguration>;
+
+declare function provideHeaderNavigation(navigation: IHeaderMenuLink[]): Partial<IHeaderConfiguration>;
+
+declare function provideLanguage(lang: string): ILanguageConfiguration;
+interface ILanguageConfiguration {
+    lang: string;
+}
+
+declare function provideLogo(logo: string): ILogoConfiguration;
+interface ILogoConfiguration {
+    logo: string;
+}
+
+declare function provideTitle(title: string): ITitleConfiguration;
+interface ITitleConfiguration {
+    title: string;
+}
+
+interface ILink {
+    link: string;
+    text: string;
+}
+
+declare const HEADER_CONFIGURATION_PROVIDER: InjectionToken<IHeaderConfiguration>;
+interface IHeaderConfigurationStore {
+    getHeader(): IHeaderConfiguration | undefined;
+}
+
+declare class PopoverService {
+    private readonly _message;
+    get message(): Signal<string | null>;
+    show(message: string, timeout?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PopoverService>;
+}
+
+declare class ThemeService {
+    private readonly _localStorage;
+    private readonly _window;
+    private readonly _theme;
+    private readonly _docElement;
+    get theme$(): Observable<void>;
+    initialize(): void;
+    updateTheme(): void;
+    getPreferredTheme(): string;
+    private _getItem;
+    private _matchMedia;
+    private _isDocumentContainsDarkTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare function copyToClipboard(value: string): Observable<any | undefined>;
+
+declare const DOCUMENT_ELEMENT: InjectionToken<HTMLElement>;
+
+declare const LOCAL_STORAGE: InjectionToken<Storage>;
+
+declare const LOCATION: InjectionToken<Location>;
+
+declare const IS_BROWSER_PLATFORM: InjectionToken<boolean>;
+
+declare const WINDOW: InjectionToken<Window>;
+
+declare class Highlight implements OnInit {
+    private readonly _highlightService;
+    private readonly _elementRef;
+    private readonly _destroyRef;
+    content: i0.InputSignal<string>;
+    language: i0.InputSignal<string>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Highlight, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Highlight, "highlight", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "language": { "alias": "language"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ContainerData {
+    height?: string | number;
+    value: string;
+    isLink?: boolean;
+    language?: string;
+}
+declare class CodeView implements OnInit {
+    private readonly _httpClient;
+    private readonly _destroyRef;
+    private readonly _popoverService;
+    readonly data: i0.InputSignal<ContainerData | undefined>;
+    protected readonly height: i0.Signal<string | undefined>;
+    protected readonly content: i0.WritableSignal<string>;
+    protected readonly visibleLanguage: i0.WritableSignal<string>;
+    protected readonly syntaxLanguage: i0.WritableSignal<string>;
+    ngOnInit(): void;
+    private _updateLanguage;
+    private _updateNotExistingData;
+    private _updateExistingData;
+    private _loadCodeByLink;
+    protected onCopyClick(): void;
+    private _copyContentToClipboard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeView, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeView, "code-view", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HighlightService {
+    /**
+     * Service for highlighting code blocks using Shiki.
+     * It supports syntax highlighting and post-processing for focused blocks.
+     */
+    private readonly _isBrowser;
+    private readonly _window;
+    private readonly _highlighter$;
+    highlight(element: HTMLElement, lang: string, content: string): Observable<HTMLElement>;
+    private _highlightCodeBlock;
+    private _renderCode;
+    private _preprocessFocus;
+    private _postProcess;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HighlightService>;
+}
+
+declare const AVAILABLE_LANGUAGES: string[];
+
+declare class MarkCodeFocusedBlocksPostProcessor {
+    private _window;
+    constructor(_window: Window);
+    handle(element: HTMLElement): Observable<HTMLElement>;
+    private _applyOpacity;
+    private _getElementColor;
+    private _createRgbaString;
+    private _getRgbValues;
+}
+
+declare const UNIVERSAL_THEME: ThemeInput;
+
+declare class FHomePageButtonsRowComponent {
+    protected viewModel: _foblex_m_render.IHomePageLink[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FHomePageButtonsRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FHomePageButtonsRowComponent, "f-home-page-buttons-row", never, {}, {}, never, never, true, never>;
+}
+
+declare class FHomePageFeaturesComponent {
+    protected viewModel: _foblex_m_render.IHomePageFeature[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FHomePageFeaturesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FHomePageFeaturesComponent, "f-home-page-features", never, {}, {}, never, never, true, never>;
+}
+
+declare class FHomePageFooterComponent {
+    protected viewModel: _foblex_m_render.IHomePageFooter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FHomePageFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FHomePageFooterComponent, "footer[f-home-page-footer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FHomePageHeaderComponent {
+    protected logo: string;
+    protected title: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FHomePageHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FHomePageHeaderComponent, "header[f-home-page-header]", never, {}, {}, never, never, true, never>;
+}
+
+declare class FHomePageHeroComponent {
+    protected viewModel: _foblex_m_render.IHomePageHero;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FHomePageHeroComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FHomePageHeroComponent, "f-home-page-hero", never, {}, {}, never, never, true, never>;
+}
+
+declare class FHomePageMembershipsComponent {
+    protected viewModel: _foblex_m_render.IHomePageMembership[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FHomePageMembershipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FHomePageMembershipsComponent, "f-home-page-memberships", never, {}, {}, never, never, true, never>;
+}
+
+interface IHomePageConfiguration extends ITitleConfiguration, ILogoConfiguration {
+    background?: Type<any>;
+    hero: IHomePageHero;
+    image?: Type<any>;
+    buttons?: IHomePageLink[];
+    features?: IHomePageFeature[];
+    footer: IHomePageFooter;
+}
+
+declare function provideBackground(background: Type<any>): Partial<IHomePageConfiguration>;
+
+declare function provideHero(hero: IHomePageHero): Partial<IHomePageConfiguration>;
+interface IHomePageHero {
+    headline?: string;
+    tagline1?: string;
+    tagline2?: string;
+    subDescription?: string;
+}
+
+declare function provideHomeButtons(buttons: IHomePageLink[]): Partial<IHomePageConfiguration>;
+interface IHomePageLink {
+    primary?: boolean;
+    routerLink?: string;
+    href?: string;
+    text: string;
+    icon?: string;
+}
+
+declare function provideHomeFeatures(features: IHomePageFeature[]): Partial<IHomePageConfiguration>;
+interface IHomePageFeature {
+    headline: string;
+    description: string;
+}
+
+declare function provideHomeFooter(footer: IHomePageFooter): Partial<IHomePageConfiguration>;
+interface IHomePageFooter {
+    text: string;
+}
+
+declare function provideHomePage(configuration: IProviderInstance): {
+    provide: InjectionToken<IHomePageConfiguration>;
+    useValue: any;
+}[];
+declare const HOME_PAGE_CONFIGURATION: InjectionToken<IHomePageConfiguration>;
+interface IProviderInstance {
+    providers: Partial<IHomePageConfiguration>[];
+}
+
+declare function provideImage(image: Type<any>): Partial<IHomePageConfiguration>;
+
+interface IHomePageMembership {
+    id: string;
+    name: string;
+    description: string;
+    benefits: string[];
+    period?: string;
+    buttonText?: string;
+    buttonRef?: string;
+}
+
+declare class HomeStore {
+    private readonly _configuration;
+    getLogo(): string;
+    getTitle(): string;
+    getHero(): IHomePageHero;
+    getButtons(): IHomePageLink[];
+    getFeatures(): IHomePageFeature[];
+    getMemberships(): IHomePageMembership[];
+    getFooter(): IHomePageFooter;
+    getBackgroundComponent(): Type<any> | undefined;
+    getImageComponent(): Type<any> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HomeStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HomeStore>;
+}
+
+declare class HomeRootComponent implements AfterViewInit, OnInit {
+    private readonly _environment;
+    private readonly _gTagService;
+    private readonly _themeService;
+    protected readonly isBrowser: boolean;
+    private _backgroundContainer;
+    private _heroImageContainer;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private _renderImageComponent;
+    private _renderBackgroundComponent;
+    private _getBackgroundComponentReference;
+    private _getImageComponentReference;
+    private _requestComponentRedraw;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HomeRootComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HomeRootComponent, "home-root", never, {}, {}, never, never, true, never>;
+}
+
+declare const HOME_ROUTES: Routes;
+
+declare class ThemeButtonComponent implements OnInit {
+    private readonly _renderer;
+    private readonly _themeService;
+    private readonly _localStorage;
+    private readonly _documentElement;
+    private readonly _isBrowser;
+    ngOnInit(): void;
+    private _isDocumentContainsDarkTheme;
+    protected _onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThemeButtonComponent, "button[theme-button]", never, {}, {}, never, never, true, never>;
+}
+
+declare function provideTheme(): Provider[];
+
+export { AVAILABLE_LANGUAGES, ActivateTocByHash, ActivateTocByHashRequest, CalculateAbsoluteTopToContainer, CalculateAbsoluteTopToContainerRequest, CalculateHashFromScrollPositionAndActivateToc, CalculateHashFromScrollPositionAndActivateTocRequest, CalculateTableOfContent, CalculateTableOfContentRequest, CodeGroup, CodeView, DOCUMENTATION_CONFIGURATION, DOCUMENTATION_ROUTES, DOCUMENT_ELEMENT, DYNAMIC_COMPONENTS_MODULE_PROVIDERS, Documentation, DocumentationStore, DropdownMenu, DynamicComponentsStore, EMarkdownContainerType, EParsedContainerType, EXTERNAL_COMPONENT_PROVIDER, ExternalComponent, FCheckboxComponent, FHomePageButtonsRowComponent, FHomePageFeaturesComponent, FHomePageFooterComponent, FHomePageHeaderComponent, FHomePageHeroComponent, FHomePageMembershipsComponent, FMetaService, FNavigationItemComponent, FRadioButtonComponent, FSearchButtonComponent, F_PREVIEW_NAVIGATION_PROVIDER, FooterNavigationButton, GTAG_CONFIG, GTagService, GetPreviousNextPageNavigationHandler, GetPreviousNextPageNavigationRequest, GetPreviousNextPageNavigationResponse, HEADER_CONFIGURATION_PROVIDER, HOME_PAGE_CONFIGURATION, HOME_ROUTES, HamburgerButton, HandleNavigationLinksHandler, HandleNavigationLinksRequest, HeaderComponent, HeaderMenuBase, Highlight, HighlightService, HomeRootComponent, HomeStore, IS_BROWSER_PLATFORM, InlineMenu, LOCAL_STORAGE, LOCATION, MEDIA_LINKS_PROVIDER, MExecution, MarkCodeFocusedBlocksPostProcessor, MarkdownFooter, MarkdownRenderer, MarkdownRouter, MarkdownService, MediaLinks, Mediatr, NavigationGroupComponent, NavigationPanelComponent, ParseAlerts, ParseAngularExampleWithCodeLinks, ParseGroupedCodeItems, ParsePreviewGroup, ParseShowcase, ParseSingleCodeItem, PopoverService, PreviewActionBar, PreviewCard, PreviewCardBase, PreviewGroupService, RenderDynamicComponent, RenderDynamicComponentRequest, RenderExternalComponent, RenderExternalComponentRequest, RenderInternalComponents, RenderInternalComponentsRequest, SCROLLABLE_CONTAINER, SHOWCASE_DATA, ScrollToElementInContainer, ScrollToElementInContainerRequest, ScrollableContainer, Showcase, ShowcaseItem, TABLE_OF_CONTENT_MODULE_PROVIDERS, TOGGLE_NAVIGATION_COMPONENT, TableOfContent, TableOfContentData, TableOfContentItemsComponent, ThemeButtonComponent, ThemeService, UNIVERSAL_THEME, WINDOW, calculateMarkdownUrl, coerceComponentHeight, copyToClipboard, defineLazyComponent, defineNavigationGroup, encodeDataAttr, extractComponent, getContent, isClosingToken, isOpeningToken, parseComponentTag, parseFileLinkLine, parseSingleBracketText, provide404Markdown, provideBackground, provideComponents, provideDirectory, provideDocumentation, provideFooterNavigation, provideGTag, provideHeader, provideHeaderMediaLinks, provideHeaderNavigation, provideHeaderSearch, provideHero, provideHomeButtons, provideHomeFeatures, provideHomeFooter, provideHomePage, provideImage, provideLanguage, provideLogo, provideMeta, provideNavigation, provideShowcase, provideTableOfContent, provideTheme, provideTitle };
+export type { ConsentState, GTagConfig, IDocumentationConfiguration, IDocumentationFooterConfiguration, IDynamicComponentInstance, IDynamicComponentItem, IExampleViewData, IExecution, IHandler, IHasHeaderConfiguration, IHeaderConfiguration, IHeaderConfigurationStore, IHeaderMenuLink, IHomePageConfiguration, IHomePageFeature, IHomePageFooter, IHomePageHero, IHomePageLink, IHomePageMembership, ILanguageConfiguration, ILink, ILogoConfiguration, IMarkdownContainerData, IMarkdownFooterLink, IMarkdownFooterNavigation, IMarkdownItToken, IMediaLink, IMediaLinksProvider, IMetaData, INavigationGroup, INavigationItem, INavigationItemBadge, IParsedContainerData, IPreviewNavigationGroup, IPreviewNavigationService, IScrollableContainer, IShowcaseItem, ITableOfContent, ITableOfContentItem, ITitleConfiguration, IToggleNavigationComponent };