import * as i0 from '@angular/core';
import { InjectionToken, Provider, OnDestroy, AfterViewInit, OnInit, Signal, Type, ViewContainerRef, ComponentRef, EventEmitter, ElementRef, ChangeDetectorRef } from '@angular/core';
import { Observable } from 'rxjs';
import * as _angular_cdk_overlay from '@angular/cdk/overlay';
import { ConnectedPosition } from '@angular/cdk/overlay';
import * as _foblex_m_render from '@foblex/m-render';
import { SafeResourceUrl, SafeHtml } from '@angular/platform-browser';
import MarkdownIt from 'markdown-it';
import container from 'markdown-it-container';
import { Router, Routes } from '@angular/router';
import { PlainTextLanguage, LanguageInput, 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>;
}

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;
    keywords?: string;
    robots?: string;
    twitter_card?: string;
    twitter_site?: string;
    twitter_creator?: string;
}

interface ISeoOverrides extends Partial<IMetaData> {
    og_type?: string;
    og_title?: string;
    og_description?: string;
    og_image?: string;
    twitter_card?: string;
    twitter_title?: string;
    twitter_description?: string;
    twitter_image?: string;
    noindex?: boolean;
    nofollow?: boolean;
}

declare class FMetaService {
    private readonly _location;
    private readonly _router;
    private readonly _headTag;
    private readonly _configuration;
    private _seoOverrides;
    private _lastPath;
    changes(): Observable<string>;
    applyMarkdownSeo(overrides: ISeoOverrides | null | undefined): void;
    dispose(): void;
    private _updateMetaByUrl;
    private _findDocGroupByUrl;
    private _findDocItemByUrl;
    private _buildAbsoluteUrl;
    private _toAbsoluteUrl;
    private _updateMetaTags;
    private _resolveRobots;
    private _normalizeCurrentPath;
    static ɵfac: i0.ɵɵFactoryDeclaration<FMetaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FMetaService>;
}

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: _foblex_m_render.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: _foblex_m_render.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: _foblex_m_render.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 {
    selector?: string;
    iframeUrl?: string;
    height?: string | number;
}

interface IExampleView {
    readonly isFullscreen: Signal<boolean>;
    readonly isLoading: Signal<boolean>;
    showLoading(): void;
    hideLoading(): void;
}
declare const EXAMPLE_VIEW: InjectionToken<IExampleView>;
declare class ExampleViewController implements IExampleView {
    private readonly _isFullscreen;
    private readonly _loadingCount;
    readonly isFullscreen: Signal<boolean>;
    readonly isLoading: Signal<boolean>;
    showLoading(): void;
    hideLoading(): void;
    setFullscreen(value: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExampleViewController, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ExampleViewController>;
}

declare function coerceComponentHeight(value: string | number | undefined): string | undefined;

declare function parseIframeUrl(value: string): string | null;

declare function parseComponentTag(html: string): string | null;

declare class ExternalComponent implements OnInit {
    private _defaultLoadingTimeout;
    readonly data: i0.InputSignalWithTransform<IExampleViewData, IParsedContainerData>;
    protected readonly iframeUrl: i0.Signal<string | undefined>;
    protected readonly iframeResourceUrl: i0.Signal<SafeResourceUrl | undefined>;
    protected readonly hasContent: i0.Signal<boolean>;
    protected readonly canToggleFullscreen: i0.Signal<boolean>;
    protected readonly fullscreenLabel: i0.Signal<"Exit full screen" | "Full screen">;
    private readonly _document;
    private readonly _destroyRef;
    private readonly _exampleViewController;
    private readonly _hostElement;
    private readonly _isBrowser;
    private readonly _mediatr;
    private readonly _viewContainerRef;
    private readonly _sanitizer;
    protected readonly isFullscreen: i0.Signal<boolean>;
    protected readonly isLoading: i0.Signal<boolean>;
    ngOnInit(): void;
    protected toggleFullscreen(): Promise<void>;
    protected onFullscreenChange(): void;
    private _isCurrentElementInFullscreen;
    private _startDefaultLoading;
    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 readonly filterGroupName: string;
    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;
    private readonly _allFilterLabel;
    protected readonly filterGroupName: string;
    protected readonly items: i0.Signal<IShowcaseItem[]>;
    protected readonly filterOptions: i0.Signal<({
        label: string;
        value: string;
    } | {
        label: string;
        value: null;
    })[]>;
    protected readonly activeTag: i0.WritableSignal<string | null>;
    protected onFilterChange(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 readonly requestToken: unique 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: Type<TRequest>): (constructor: Constructor<IExecution<TRequest, TResponse>>) => void;

declare class Mediatr {
    private readonly _injector;
    private static _executions;
    static register<TRequest, TResponse>(type: any, 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 readonly requestToken: unique 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 readonly requestToken: unique 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: _foblex_m_render.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;
    protected _click(event: MouseEvent): void;
    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 {
    value: string;
    height?: string | number;
}

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>>;

interface IMarkdownPageLayoutOptions {
    hideTableOfContent: boolean;
    expandContentWithoutTableOfContent: boolean;
}
interface IMarkdownOriginData {
    url: string;
    label: string;
}
interface IMarkdownFrontMatterData {
    layout: IMarkdownPageLayoutOptions;
    seo: ISeoOverrides | null;
    origin: IMarkdownOriginData | null;
}
interface IMarkdownFrontMatterParseResult {
    markdown: string;
    data: IMarkdownFrontMatterData;
}
declare const DEFAULT_MARKDOWN_PAGE_LAYOUT_OPTIONS: IMarkdownPageLayoutOptions;

declare class MarkdownService {
    private readonly _markdown;
    private readonly _httpClient;
    private readonly _domSanitizer;
    private readonly _router;
    private readonly _provider;
    private readonly _pageLayout;
    private readonly _pageSeo;
    private readonly _pageOrigin;
    readonly pageLayout: i0.Signal<IMarkdownPageLayoutOptions>;
    readonly pageSeo: i0.Signal<ISeoOverrides | null>;
    readonly pageOrigin: i0.Signal<IMarkdownOriginData | null>;
    constructor();
    parseUrl(src: string): Observable<SafeHtml>;
    parseText(value: string): Observable<SafeHtml>;
    private _normalizeLinks;
    private _appendLinkClasses;
    private _isExternalLink;
    private _cleanupEmptyParagraphs;
    private _cleanupWasteParagraphFromExampleView;
    private _cleanupWasteParagraphFromPreviewGroup;
    private _renderMarkdownWithPageContext;
    private _parseFrontMatter;
    private _parseFrontMatterData;
    private _parseFrontMatterLine;
    private _normalizeFrontMatterValue;
    private _parseBoolean;
    private _applyLayoutKey;
    private _applySeoKey;
    private _applyOriginKey;
    private _normalizeOriginUrl;
    private _resolveOrigin;
    private _getOriginLabel;
    private _parseNumberOrDefault;
    private _applyPageContext;
    private _resetPageContext;
    private _getDefaultFrontMatterData;
    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;
    private _parseHeight;
}

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>;
    readonly origin: i0.InputSignal<IMarkdownOriginData | null>;
    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; }; "origin": { "alias": "origin"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MarkdownRouter {
    private readonly _router;
    private readonly _activatedRoute;
    private readonly _markdown;
    private readonly _dataProvider;
    private readonly _metaService;
    protected readonly emptyNavigation: boolean;
    protected readonly pageOrigin: i0.Signal<_foblex_m_render.IMarkdownOriginData | null>;
    protected readonly shouldExpandContent: i0.Signal<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 ScrollableContainer implements OnInit, IScrollableContainer {
    private readonly _destroyRef;
    private readonly _injector;
    private readonly _markdown;
    protected readonly tableOfContent: _foblex_m_render.ITableOfContent | null;
    protected readonly canShowTableOfContent: i0.Signal<boolean>;
    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 ActivateTocByHashRequest {
    hash: string | undefined;
    static readonly requestToken: unique 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 readonly requestToken: unique symbol;
    constructor(hostElement: HTMLElement);
}

declare class CalculateTableOfContent implements IExecution<CalculateTableOfContentRequest, void> {
    private readonly _dataProvider;
    private readonly _injector;
    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 CalculateHashFromScrollPosition implements IExecution<void, void> {
    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<CalculateHashFromScrollPosition, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateHashFromScrollPosition>;
}

declare class CalculateAbsoluteTopToContainerRequest {
    element: HTMLElement;
    static readonly requestToken: unique 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 readonly requestToken: unique 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 CalculateHashFromScrollPosition | 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 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;
    searchConfiguration?: IHeaderSearchConfiguration;
    navigation?: IHeaderMenuLink[];
    mediaLinks?: IMediaLink[];
}
interface IHasHeaderConfiguration {
    header?: IHeaderConfiguration;
}
interface IHeaderSearchConfiguration {
    appId: string;
    apiKey: string;
    indexName: string;
    placeholder?: string;
    insights?: boolean;
    searchParameters?: Record<string, unknown>;
}

declare function provideHeaderSearch(search?: boolean): Partial<IHeaderConfiguration>;

declare function provideHeaderSearchAlgolia(configuration: IHeaderSearchConfiguration): 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 _copyFeedbackTimeout;
    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>;
    protected readonly isCopied: i0.WritableSignal<boolean>;
    protected readonly copyButtonLabel: i0.Signal<"Copied" | "Copy">;
    constructor();
    ngOnInit(): void;
    private _updateLanguage;
    private _updateNotExistingData;
    private _updateExistingData;
    private _loadCodeByLink;
    protected onCopyClick(): void;
    private _copyContentToClipboard;
    private _setCopiedFeedback;
    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 _languageLoadingTasks;
    private readonly _highlighter$;
    highlight(element: HTMLElement, lang: string, content: string): Observable<HTMLElement>;
    private _highlightCodeBlock;
    private _renderCode;
    private _preprocessFocus;
    private _createHighlighter;
    private _ensureLanguageLoaded;
    private _scheduleRender;
    private _postProcess;
    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HighlightService>;
}

type ShikiLanguage = 'javascript' | 'typescript' | 'angular-html' | 'angular-ts' | 'shell' | 'html' | 'bash' | 'css' | 'scss' | 'markdown';
type HighlightLanguage = ShikiLanguage | PlainTextLanguage;
declare const AVAILABLE_LANGUAGES: readonly HighlightLanguage[];
declare function resolveHighlightLanguage(lang?: string): HighlightLanguage;
declare function getLanguageLoader(lang: HighlightLanguage): LanguageInput | null;

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 FBrandLinkComponent {
    readonly title: i0.InputSignal<string>;
    readonly logo: i0.InputSignal<string>;
    readonly ariaLabel: i0.InputSignal<string>;
    readonly logoAlt: i0.InputSignal<string>;
    readonly href: i0.InputSignal<string>;
    readonly routerLink: i0.InputSignal<string | readonly unknown[] | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FBrandLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FBrandLinkComponent, "f-brand-link", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "logo": { "alias": "logo"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "logoAlt": { "alias": "logoAlt"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FSearchButtonComponent implements AfterViewInit, OnDestroy {
    readonly configuration: i0.InputSignal<IHeaderSearchConfiguration | undefined>;
    private readonly _isBrowser;
    private readonly _document;
    private readonly _containerRef;
    private _instance;
    ngAfterViewInit(): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FSearchButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FSearchButtonComponent, "f-search-button", never, { "configuration": { "alias": "configuration"; "required": false; "isSignal": true; }; }, {}, 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>;
    name: i0.InputSignal<string | null>;
    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; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

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, CalculateHashFromScrollPosition, CalculateTableOfContent, CalculateTableOfContentRequest, CodeGroup, CodeView, DEFAULT_MARKDOWN_PAGE_LAYOUT_OPTIONS, DOCUMENTATION_CONFIGURATION, DOCUMENTATION_ROUTES, DOCUMENT_ELEMENT, DYNAMIC_COMPONENTS_MODULE_PROVIDERS, Documentation, DocumentationStore, DropdownMenu, DynamicComponentsStore, EMarkdownContainerType, EParsedContainerType, EXAMPLE_VIEW, EXTERNAL_COMPONENT_PROVIDER, ExampleViewController, ExternalComponent, FBrandLinkComponent, 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, getLanguageLoader, isClosingToken, isOpeningToken, parseComponentTag, parseFileLinkLine, parseIframeUrl, parseSingleBracketText, provide404Markdown, provideBackground, provideComponents, provideDirectory, provideDocumentation, provideFooterNavigation, provideGTag, provideHeader, provideHeaderMediaLinks, provideHeaderNavigation, provideHeaderSearch, provideHeaderSearchAlgolia, provideHero, provideHomeButtons, provideHomeFeatures, provideHomeFooter, provideHomePage, provideImage, provideLanguage, provideLogo, provideMeta, provideNavigation, provideShowcase, provideTableOfContent, provideTheme, provideTitle, resolveHighlightLanguage };
export type { ConsentState, GTagConfig, HighlightLanguage, IDocumentationConfiguration, IDocumentationFooterConfiguration, IDynamicComponentInstance, IDynamicComponentItem, IExampleView, IExampleViewData, IExecution, IHandler, IHasHeaderConfiguration, IHeaderConfiguration, IHeaderConfigurationStore, IHeaderMenuLink, IHeaderSearchConfiguration, IHomePageConfiguration, IHomePageFeature, IHomePageFooter, IHomePageHero, IHomePageLink, IHomePageMembership, ILanguageConfiguration, ILink, ILogoConfiguration, IMarkdownContainerData, IMarkdownFooterLink, IMarkdownFooterNavigation, IMarkdownFrontMatterData, IMarkdownFrontMatterParseResult, IMarkdownItToken, IMarkdownOriginData, IMarkdownPageLayoutOptions, IMediaLink, IMediaLinksProvider, IMetaData, INavigationGroup, INavigationItem, INavigationItemBadge, IParsedContainerData, IPreviewNavigationGroup, IPreviewNavigationService, IScrollableContainer, ISeoOverrides, IShowcaseItem, ITableOfContent, ITableOfContentItem, ITitleConfiguration, IToggleNavigationComponent };