import * as _angular_core from '@angular/core';
import { Provider, EnvironmentProviders, Signal, InjectionToken, OnInit, OnDestroy, PipeTransform, AfterViewInit, ElementRef } from '@angular/core';
import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot, MaybeAsync, Route } from '@angular/router';

declare class AlertComponent {
    readonly type: _angular_core.InputSignal<"General" | "Warning">;
    readonly closeable: _angular_core.InputSignal<boolean>;
    readonly containerClass: _angular_core.InputSignal<string>;
    readonly typeClass: _angular_core.Signal<string>;
    closed: _angular_core.OutputEmitterRef<boolean>;
    close(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "sdg-alert", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "closeable": { "alias": "closeable"; "required": false; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
}

interface AnalyticsFeature<KindT extends AnalyticsFeatureKind> {
    kind: KindT;
    providers: (Provider | EnvironmentProviders)[];
}
declare enum AnalyticsFeatureKind {
    GoogleAnalytic = 0
}

declare function provideAnalytics(...features: AnalyticsFeature<AnalyticsFeatureKind>[]): EnvironmentProviders;

interface IGoogleAnalyticsOptions {
    targetId: string;
    /**
     * See the config options https://developers.google.com/analytics/devguides/collection/ga4/reference/config
     * By default we set:
     *  - send_page_view to false
     *  - cookie_flags to SameSite=None;Secure
     **/
    config?: Record<string, unknown>;
}

declare function withGoogleAnalytics(options: IGoogleAnalyticsOptions): AnalyticsFeature<AnalyticsFeatureKind.GoogleAnalytic>;

declare class GoogleAnalyticsService {
    private router;
    private ngZone;
    private routerEvents$$?;
    initialize(): void;
    trackEvent(eventName: string, eventParams: Record<string, unknown>): void;
    trackFirstSSRPageView(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GoogleAnalyticsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GoogleAnalyticsService>;
}

type Label = string | Label[] | LabelObject | any;
interface LabelObject {
    [key: string]: Label;
}
declare function labelAttribute(value: Label | LabelObject | undefined, defaultValue?: Label | LabelObject): Label | LabelObject;

declare class WithLabels<T extends LabelObject> {
    labelsToken: T | null;
    defaultLabels: T | null;
    readonly modeLabels: _angular_core.ModelSignal<Partial<T> | null | undefined>;
    /**
     * Labels merged from defaults, injection token, and input binding.
     * Priority (highest wins): input binding > injection token > defaults.
     */
    readonly labels: Signal<T>;
    constructor(defaultLabels: T | undefined, labelsToken: InjectionToken<T>);
    private mergeLabels;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WithLabels<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WithLabels<any>, never, never, { "modeLabels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "modeLabels": "labelsChange"; }, never, never, true, never>;
}

declare class AnchorComponent {
    readonly path: _angular_core.InputSignal<string>;
    externalPath: Signal<boolean | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnchorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnchorComponent, "sdg-anchor", never, { "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface AnchorMenuLabels {
    title: string;
}
interface Anchor {
    text: string;
    htmlElementId: string;
}

declare const SDG_ANCHOR_MENU_LABELS: InjectionToken<AnchorMenuLabels>;
declare class AnchorMenuComponent extends WithLabels<AnchorMenuLabels> implements OnInit {
    private activatedRoute;
    private document;
    readonly anchors: _angular_core.InputSignal<Anchor[]>;
    constructor();
    ngOnInit(): void;
    private jumpToSection;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnchorMenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnchorMenuComponent, "sdg-anchor-menu", never, { "anchors": { "alias": "anchors"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare function findTitleAnchors(containerElement: HTMLElement): Anchor[];

interface BlockLinkLabels {
    seeMore: string;
}
type BlockLinkSections = BlockLinkSection[];
interface BlockLinkSection {
    icon?: string;
    title: string;
    path: string;
    description?: string;
    subsections?: BlockLinkSubsection[];
}
type BlockLinkSubsection = Pick<BlockLinkSection, 'title' | 'path'>;

declare class BlockLinkComponent {
    readonly section: _angular_core.InputSignal<BlockLinkSection>;
    readonly externalPath: Signal<boolean | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockLinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockLinkComponent, "sdg-block-link", never, { "section": { "alias": "section"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const SDG_BLOCK_LINK_LABELS: InjectionToken<BlockLinkLabels>;
declare class BlockLinkSeeMoreComponent extends WithLabels<BlockLinkLabels> {
    readonly path: _angular_core.InputSignal<string>;
    readonly externalPath: Signal<boolean | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockLinkSeeMoreComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockLinkSeeMoreComponent, "sdg-block-link-see-more", never, { "path": { "alias": "path"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

type AnyBreadcrumb = Breadcrumb | BreadcrumbMenu;
type Breadcrumbs = Breadcrumb[];
interface Breadcrumb extends BreadcrumbBase {
    title: string;
    url: string;
    redirectTo?: string | undefined;
}
interface BreadcrumbMenu extends BreadcrumbBase {
    menu: Breadcrumbs;
}
interface BreadcrumbBase {
    id: string;
    firstParent?: boolean;
}

declare abstract class BreadcrumbsBase {
    readonly hasBreadcrumbs: Signal<boolean>;
    abstract breadcrumbs: Signal<Breadcrumbs>;
    breadcrumbsList: Signal<AnyBreadcrumb[]>;
    isMenu(breadcrumb: AnyBreadcrumb): breadcrumb is BreadcrumbMenu;
    private getBreadcrumbs;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbsBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BreadcrumbsBase, never, never, {}, {}, never, never, true, never>;
}

declare class BreadcrumbsComponent extends BreadcrumbsBase {
    readonly breadcrumbs: _angular_core.InputSignal<Breadcrumbs>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbsComponent, "sdg-breadcrumbs", never, { "breadcrumbs": { "alias": "breadcrumbs"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class BreadcrumbsWithRouterComponent extends BreadcrumbsBase implements OnInit, OnDestroy {
    private activatedRoute;
    private router;
    private titleResolver;
    breadcrumbs: _angular_core.WritableSignal<Breadcrumbs>;
    private _takeUntil;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private findHomeRoute;
    private getPath;
    private resolveRoute;
    private getBreadsFromRouterSegments;
    private getRouterBreadcrumbs;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbsWithRouterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbsWithRouterComponent, "sdg-breadcrumbs-with-router", never, {}, {}, never, never, true, never>;
}

declare class CharterBannerComponent {
    readonly containerClass: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CharterBannerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CharterBannerComponent, "sdg-charter-banner", never, { "containerClass": { "alias": "containerClass"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IContact {
    name?: string;
    schedule?: string;
    hours?: string;
    phone?: string;
    address?: Address;
    email?: string;
    website?: string;
}
interface IContactData {
    name?: string;
    schedule?: Range<string>;
    hours?: Range<Time>;
    phone?: string;
    address?: Address;
    email?: string;
    website?: string;
}
interface Address {
    number: number;
    street: string;
    city: string;
    postalCode: string;
}
interface Range<T> {
    from: T;
    to: T;
}
interface Time {
    hours: number;
    minutes?: number;
}

declare class ContactComponent {
    readonly title: _angular_core.InputSignal<string>;
    readonly contact: _angular_core.InputSignal<IContact>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContactComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContactComponent, "sdg-contact", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "contact": { "alias": "contact"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class Contact implements IContact {
    name?: string;
    schedule?: string;
    hours?: string;
    phone?: string;
    address?: Address;
    email?: string;
    website?: string;
    constructor(contact: IContactData);
    protected formatScheduleLabel(schedule: Range<string>): string;
    protected formatHoursLabel(hours: Range<Time>): string;
    protected formatPhoneLabel(phone: string): string | undefined;
    protected formatPostalCodeLabel(address: Address): string | undefined;
}

declare class ExternalLinkComponent {
    readonly text: _angular_core.InputSignal<string>;
    readonly url: _angular_core.InputSignalWithTransform<string, string>;
    private urlValidation;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExternalLinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExternalLinkComponent, "sdg-external-link", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IFooterConfig {
    logo?: FooterNavLogo;
    title?: string;
    siteMapLinks?: SiteMapLinks;
    externalLinks?: SiteMapLinks;
    copyright: FooterCopyright;
}
interface FooterNavLogo {
    url: string;
    height: number;
}
type SiteMapLinks = SiteMapLink[];
interface SiteMapLink {
    title: string;
    path: string;
}
interface FooterCopyright {
    logo: string;
    logoUrl: string;
    copyrightUrl?: string;
    year?: number;
}

declare class FooterComponent {
    readonly title: _angular_core.InputSignal<string | undefined>;
    readonly logo: _angular_core.InputSignal<FooterNavLogo | undefined>;
    readonly siteMapLinks: _angular_core.InputSignal<SiteMapLinks | undefined>;
    readonly externalLinks: _angular_core.InputSignal<SiteMapLinks | undefined>;
    readonly copyright: _angular_core.InputSignal<FooterCopyright>;
    readonly containerClass: _angular_core.InputSignal<string>;
    readonly currentLanguage: _angular_core.InputSignal<string | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FooterComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FooterComponent, "sdg-footer", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "logo": { "alias": "logo"; "required": false; "isSignal": true; }; "siteMapLinks": { "alias": "siteMapLinks"; "required": false; "isSignal": true; }; "externalLinks": { "alias": "externalLinks"; "required": false; "isSignal": true; }; "copyright": { "alias": "copyright"; "required": true; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; "currentLanguage": { "alias": "currentLanguage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FormFieldLabelComponent {
    readonly controlId: _angular_core.InputSignal<string>;
    readonly formControlSize: _angular_core.InputSignal<"xs" | "sm" | "md" | "lg" | "xl" | "multi">;
    readonly label: _angular_core.InputSignal<string>;
    readonly clarification: _angular_core.InputSignal<string | undefined>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldLabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldLabelComponent, "sdg-form-field-label", never, { "controlId": { "alias": "controlId"; "required": true; "isSignal": true; }; "formControlSize": { "alias": "formControlSize"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "clarification": { "alias": "clarification"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface IHeaderLabels {
    contactUs: string;
}
interface IHeaderConfig {
    /** Default to the Quebec Government logo */
    logo?: IHeaderLogo;
    contactUsRoute?: string;
    languages?: IHeaderLanguages;
}
interface IHeaderLogo {
    src: string;
    href: string;
    alt?: string;
}
interface IHeaderContactUs {
    label: string;
    route: string;
}
interface IHeaderLanguages {
    /** For now, we take only two language */
    choices: [IHeaderLanguageChoice, IHeaderLanguageChoice];
    default: string;
}
interface IHeaderLanguageChoice {
    label: string;
    key: string;
}

declare const SDG_HEADER_LABELS: InjectionToken<IHeaderLabels>;
declare class HeaderComponent extends WithLabels<IHeaderLabels> {
    readonly title: _angular_core.InputSignal<string>;
    readonly logo: _angular_core.InputSignal<IHeaderLogo | undefined>;
    readonly contactUsRoute: _angular_core.InputSignal<string | undefined>;
    readonly languages: _angular_core.InputSignal<IHeaderLanguages | undefined>;
    readonly currentLanguage: _angular_core.InputSignal<string | undefined>;
    readonly containerClass: _angular_core.InputSignal<string | undefined>;
    readonly noHomeRouting: _angular_core.InputSignal<boolean | undefined>;
    readonly languageChange: _angular_core.OutputEmitterRef<string>;
    readonly isContactUsExternal: _angular_core.Signal<boolean>;
    constructor();
    get nextLanguage(): IHeaderLanguageChoice | undefined;
    changeLanguage(language: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeaderComponent, "sdg-header", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "logo": { "alias": "logo"; "required": false; "isSignal": true; }; "contactUsRoute": { "alias": "contactUsRoute"; "required": false; "isSignal": true; }; "languages": { "alias": "languages"; "required": false; "isSignal": true; }; "currentLanguage": { "alias": "currentLanguage"; "required": false; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; "noHomeRouting": { "alias": "noHomeRouting"; "required": false; "isSignal": true; }; }, { "languageChange": "languageChange"; }, never, never, true, never>;
}

type LateralMenuSections = LateralMenuItem[];
interface LateralMenuItem {
    title: string;
    path: string;
    items?: LateralMenuSection;
    opened?: boolean;
}
type LateralMenuSection = LateralMenuSectionItem[];
type LateralMenuSectionItem = Pick<LateralMenuItem, 'title' | 'path'>;

declare class LateralMenuComponent {
    private readonly router;
    private readonly destroyRef;
    readonly title: _angular_core.InputSignal<string>;
    readonly sections: _angular_core.InputSignal<LateralMenuSections>;
    opened: _angular_core.ModelSignal<boolean>;
    currentUrl: _angular_core.WritableSignal<string>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LateralMenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LateralMenuComponent, "sdg-lateral-menu", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "sections": { "alias": "sections"; "required": true; "isSignal": true; }; "opened": { "alias": "opened"; "required": false; "isSignal": true; }; }, { "opened": "openedChange"; }, never, never, true, never>;
}

declare class BreakpointService {
    private breakpointObserver;
    private _isHandset;
    get isHandset(): Signal<boolean>;
    constructor();
    private handsetBreakpoint;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreakpointService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BreakpointService>;
}

declare abstract class TitleResolver<T = string> implements Resolve<T> {
    abstract resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): MaybeAsync<T>;
    abstract resolveStatic(route: Route): string | undefined;
}

declare const RouteTitleKey = "RouteTitle";
declare const RouteTranslateKey = "TranslateKey";
declare function resolveTitle(config: Route, titleResolver?: TitleResolver | null): string | undefined;

type SdgRoutes = SdgRoute[];
interface SdgRoute extends Route {
    isHome?: boolean;
    description?: string;
    children?: SdgRoutes;
    /** Hidden in the primary tabs navigation and in the breadcrumbs */
    hidden?: boolean;
}

declare class TitleResolverPipe implements PipeTransform {
    private titleResolver;
    transform(value: SdgRoute): string | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TitleResolverPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TitleResolverPipe, "titleResolver", true>;
}

declare function pathIsExternal(path: string): boolean;
declare function isSafeUrl(url: string): boolean;

type INavigationLinks = INavigationLink[];
type INavigationLink = Required<Pick<SdgRoute, 'path'>> & {
    title: string;
};
interface INavigationOptions {
    title?: INavigationTitleOptions;
}
/**
 * Options for the page title of the HTML Document
 * */
interface INavigationTitleOptions {
    /** Suffix to the head title */
    suffix: string;
    separator: string;
}

/**
 * Provides a strategy for setting the page title after a router navigation.
 */
declare function provideNavigationTitle(options?: INavigationTitleOptions): EnvironmentProviders;

declare class NavigationComponent implements OnInit, AfterViewInit, OnDestroy {
    private host;
    private breakpointService;
    private platformId;
    readonly links: _angular_core.InputSignal<INavigationLinks>;
    readonly containerClass: _angular_core.InputSignal<string>;
    /**
     * Option to configure how to determine if the router link is active.
     * This options are passed to the RouterLinkActiveOptions exact property. Default to ''
     */
    readonly exactPathMatch: _angular_core.InputSignal<string>;
    linksInTabs: _angular_core.WritableSignal<INavigationLinks>;
    linksInMore: _angular_core.WritableSignal<INavigationLinks>;
    hasOverflow: _angular_core.WritableSignal<boolean>;
    hasActions: _angular_core.WritableSignal<boolean>;
    isHandset: Signal<boolean>;
    readonly isOnTwoLine: Signal<boolean>;
    private headerRow;
    private tabsSection;
    private tabsNavbarSection;
    private tabsLinks;
    private actionsSection;
    private _resizeObserver;
    private _resizeSubject;
    private _destroyed;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private handleResize;
    private findLastIndexToDisplay;
    private estimateLinkWidth;
    private hasTabsOverflow;
    private detectHandsetOverflow;
    private getTabsItemsWidth;
    private getActionsItemsWidth;
    private getItemsWidth;
    private observeHostResize;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationComponent, "sdg-navigation", never, { "links": { "alias": "links"; "required": true; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": true; "isSignal": true; }; "exactPathMatch": { "alias": "exactPathMatch"; "required": false; "isSignal": true; }; }, {}, never, ["[navigation-actions]", "*"], true, never>;
}

declare function isNavigationLink(link: SdgRoute): link is INavigationLink;

declare enum NoticeType {
    General = "general",
    Warning = "warning",
    Error = "error",
    Success = "success",
    Complementary = "complementary"
}

declare class NoticeComponent {
    NoticeType: typeof NoticeType;
    readonly type: _angular_core.InputSignal<"General" | "Warning" | "Error" | "Success" | "Complementary">;
    readonly icon: _angular_core.InputSignal<string | undefined>;
    readonly title: _angular_core.InputSignal<string>;
    readonly coloredZoneClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoticeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoticeComponent, "sdg-notice", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class PaginatorComponent implements OnInit {
    private document;
    private breakpointService;
    readonly listLength: _angular_core.InputSignal<number>;
    readonly pageSize: _angular_core.InputSignal<number>;
    readonly middlePagesMaxRange: _angular_core.InputSignal<number>;
    readonly initialPageIndex: _angular_core.InputSignal<number>;
    pageChange: _angular_core.OutputEmitterRef<number>;
    private isHandset;
    initialPageIndexFirstChange: boolean;
    currentPageIndex: number;
    nbOfPages: number;
    firstPagesIndexes: number[];
    middlePagesIndexes: number[];
    lastPagesIndexes: number[];
    pagesIndexes: number[];
    constructor();
    ngOnInit(): void;
    private getNbOfPages;
    private createPagesArray;
    private getPages;
    private getFirstPages;
    private getMiddlePages;
    private getLastPages;
    goToPreviousPage(): void;
    goToPage(pageIndex: number): void;
    goToNextPage(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "sdg-paginator", never, { "listLength": { "alias": "listLength"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": true; "isSignal": true; }; "middlePagesMaxRange": { "alias": "middlePagesMaxRange"; "required": false; "isSignal": true; }; "initialPageIndex": { "alias": "initialPageIndex"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
}

interface PopoverLabels {
    closeTooltip: string;
    openTooltip: string;
}
declare const SDG_POPOVER_LABELS: InjectionToken<PopoverLabels>;
type PopoverPosition = 'left' | 'right' | 'top' | 'bottom';
type PopoverIcon = 'info' | 'help';
declare class SdgPopover extends WithLabels<PopoverLabels> implements OnDestroy {
    private readonly overlay;
    private readonly scrollDispatcher;
    private readonly viewContainerRef;
    private readonly content;
    readonly position: _angular_core.InputSignal<PopoverPosition>;
    readonly icon: _angular_core.InputSignal<PopoverIcon>;
    readonly title: _angular_core.InputSignal<string | undefined>;
    readonly buttonTooltip: _angular_core.InputSignal<string | undefined>;
    readonly buttonAriaLabel: _angular_core.InputSignal<string | undefined>;
    protected readonly popoverId: string;
    protected readonly titleId: string;
    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
    protected readonly triggerAriaLabel: _angular_core.Signal<string>;
    protected readonly resolvedPosition: _angular_core.WritableSignal<PopoverPosition>;
    protected readonly arrowOffset: _angular_core.WritableSignal<string>;
    private overlayRef?;
    private subscription?;
    private triggerVisibilityObserver?;
    private triggerElement?;
    constructor();
    toggle(event: MouseEvent): void;
    close(options?: {
        restoreFocus?: boolean;
    }): void;
    ngOnDestroy(): void;
    private observeTriggerVisibility;
    private getPositions;
    private getPosition;
    private updateArrowOffset;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdgPopover, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdgPopover, "sdg-popover", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "buttonTooltip": { "alias": "buttonTooltip"; "required": false; "isSignal": true; }; "buttonAriaLabel": { "alias": "buttonAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

interface SearchBarLabels {
    placeholder: string;
}
declare const DEFAULT_SEARCH_BAR_LABELS: Required<SearchBarLabels>;
declare const SEARCH_BAR_LABELS: InjectionToken<SearchBarLabels>;
declare class SdgSearchBar extends WithLabels<SearchBarLabels> {
    private readonly destroyRef;
    readonly color: _angular_core.InputSignal<"dark" | "light">;
    readonly debounce: _angular_core.InputSignal<number>;
    readonly minLength: _angular_core.InputSignal<number>;
    /** Emits the search term when the user presses Enter or clicks the search button. */
    readonly searchSubmit: _angular_core.OutputEmitterRef<string>;
    /** Emits the search term (debounced) as the user types. */
    readonly searchChange: _angular_core.OutputEmitterRef<string>;
    readonly clear: _angular_core.OutputEmitterRef<void>;
    readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    readonly term: _angular_core.WritableSignal<string>;
    private readonly stream$;
    constructor();
    onKeyup(event: KeyboardEvent): void;
    onSearch(): void;
    onClear(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdgSearchBar, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdgSearchBar, "sdg-search-bar", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; }, { "searchSubmit": "searchSubmit"; "searchChange": "searchChange"; "clear": "clear"; }, never, never, true, never>;
}

interface ISeeAlsoLabels {
    title: string;
}
type SeeAlsoLinks = SeeAlsoLink[];
interface SeeAlsoLink {
    label: string;
    url: string;
}

declare const SDG_SEE_ALSO_LABELS: InjectionToken<ISeeAlsoLabels>;
declare class SeeAlsoComponent extends WithLabels<ISeeAlsoLabels> {
    readonly links: _angular_core.InputSignal<SeeAlsoLinks>;
    readonly files: _angular_core.InputSignal<SeeAlsoLinks>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SeeAlsoComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SeeAlsoComponent, "sdg-see-also", never, { "links": { "alias": "links"; "required": true; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface ISequentialLinksLabels {
    previous: string;
    next: string;
}
interface SequentialLink {
    text: string;
    url: string;
}

declare const SDG_SEQUENTIAL_LINKS_LABELS: InjectionToken<ISequentialLinksLabels>;
declare class SequentialLinksComponent extends WithLabels<ISequentialLinksLabels> {
    private router;
    private activatedRoute;
    readonly previousLink: _angular_core.InputSignal<SequentialLink | undefined>;
    readonly nextLink: _angular_core.InputSignal<SequentialLink | undefined>;
    constructor();
    goToLink(url: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SequentialLinksComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SequentialLinksComponent, "sdg-sequential-links", never, { "previousLink": { "alias": "previousLink"; "required": false; "isSignal": true; }; "nextLink": { "alias": "nextLink"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TileComponent {
    private router;
    readonly icon: _angular_core.InputSignal<string | undefined>;
    /** The icon needs to be registred via the MatIconRegistry */
    readonly iconSvg: _angular_core.InputSignal<string | undefined>;
    readonly title: _angular_core.InputSignalWithTransform<string, string>;
    readonly message: _angular_core.InputSignalWithTransform<string, string>;
    readonly href: _angular_core.InputSignal<string>;
    private titleValidation;
    private messageValidation;
    goToLink(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TileComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TileComponent, "sdg-tile", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSvg": { "alias": "iconSvg"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TopPageButtonComponent implements OnDestroy {
    private document;
    private viewportScroller;
    tooltip: _angular_core.InputSignal<string>;
    showButton: _angular_core.WritableSignal<boolean>;
    private currentScrollPositionY;
    constructor();
    private handleScroll;
    scrollToTop(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TopPageButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TopPageButtonComponent, "sdg-top-page-button", never, { "tooltip": { "alias": "tooltip"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { AlertComponent, AnalyticsFeatureKind, AnchorComponent, AnchorMenuComponent, BlockLinkComponent, BlockLinkSeeMoreComponent, BreadcrumbsComponent, BreadcrumbsWithRouterComponent, BreakpointService, CharterBannerComponent, Contact, ContactComponent, DEFAULT_SEARCH_BAR_LABELS, ExternalLinkComponent, FooterComponent, FormFieldLabelComponent, GoogleAnalyticsService, HeaderComponent, LateralMenuComponent, NavigationComponent, NoticeComponent, NoticeType, PaginatorComponent, RouteTitleKey, RouteTranslateKey, SDG_ANCHOR_MENU_LABELS, SDG_BLOCK_LINK_LABELS, SDG_HEADER_LABELS, SDG_POPOVER_LABELS, SDG_SEE_ALSO_LABELS, SDG_SEQUENTIAL_LINKS_LABELS, SEARCH_BAR_LABELS, SdgPopover, SdgSearchBar, SeeAlsoComponent, SequentialLinksComponent, TileComponent, TitleResolver, TitleResolverPipe, TopPageButtonComponent, WithLabels, findTitleAnchors, isNavigationLink, isSafeUrl, labelAttribute, pathIsExternal, provideAnalytics, provideNavigationTitle, resolveTitle, withGoogleAnalytics };
export type { Address, AnalyticsFeature, Anchor, AnchorMenuLabels, AnyBreadcrumb, BlockLinkLabels, BlockLinkSection, BlockLinkSections, BlockLinkSubsection, Breadcrumb, BreadcrumbMenu, Breadcrumbs, FooterCopyright, FooterNavLogo, IContact, IContactData, IFooterConfig, IGoogleAnalyticsOptions, IHeaderConfig, IHeaderContactUs, IHeaderLabels, IHeaderLanguageChoice, IHeaderLanguages, IHeaderLogo, INavigationLink, INavigationLinks, INavigationOptions, INavigationTitleOptions, ISeeAlsoLabels, ISequentialLinksLabels, Label, LabelObject, LateralMenuItem, LateralMenuSection, LateralMenuSectionItem, LateralMenuSections, PopoverIcon, PopoverLabels, PopoverPosition, Range, SdgRoute, SdgRoutes, SearchBarLabels, SeeAlsoLink, SeeAlsoLinks, SequentialLink, SiteMapLink, SiteMapLinks, Time };