import * as i0 from '@angular/core';
import { TemplateRef, OnInit, Renderer2, ElementRef, ChangeDetectorRef, EventEmitter, Signal, AfterViewInit, QueryList, InjectionToken } from '@angular/core';
import { HasElementRef, Nullable } from '@fundamental-ngx/cdk/utils';
import { ToolbarComponent } from '@fundamental-ngx/core/toolbar';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import { BreadcrumbComponent } from '@fundamental-ngx/core/breadcrumb';
import { HeadingLevel, TabList } from '@fundamental-ngx/core/shared';
import { FlexibleColumnLayoutComponent } from '@fundamental-ngx/core/flexible-column-layout';
import { ScrollbarDirective } from '@fundamental-ngx/core/scrollbar';
import { FdLanguage } from '@fundamental-ngx/i18n';
import { Observable } from 'rxjs';

declare const DYNAMIC_PAGE_CLASS_NAME: {
    readonly dynamicPage: "fd-dynamic-page";
    readonly dynamicPageTitleArea: "fd-dynamic-page__title-area";
    readonly dynamicPageMainContainer: "fd-dynamic-page__main-container";
    readonly dynamicPageBreadcrumbTitleContainer: "fd-dynamic-page__breadcrumb-title-container";
    readonly dynamicPageTitleAreaCollapsed: "fd-dynamic-page__title-area--collapsed";
    readonly dynamicPageTitleContainer: "fd-dynamic-page__title-container";
    readonly dynamicPageTitle: "fd-dynamic-page__title";
    readonly dynamicPageBreadcrumb: "fd-dynamic-page__breadcrumb";
    readonly dynamicPageKeyInfo: "fd-dynamic-page__title-content";
    readonly dynamicPageToolbar: "fd-dynamic-page__toolbar";
    readonly dynamicPageLayoutActionsToolbar: "fd-dynamic-page__toolbar--actions";
    readonly dynamicPageLayoutContentToolbar: "fd-dynamic-page__toolbar--content";
    readonly dynamicPageHeader: "fd-dynamic-page__header";
    readonly dynamicPageCollapsibleHeader: "fd-dynamic-page__collapsible-header";
    readonly dynamicPageCollapsibleHeaderPinCollapseNoShadow: "fd-dynamic-page__collapsible-header-visibility-container--no-shadow";
    readonly dynamicPageTabs: "fd-dynamic-page__tabs";
    readonly dynamicPageTabsAddShadow: "fd-dynamic-page__tabs--add-shadow";
    readonly dynamicPageContent: "fd-dynamic-page__content";
    readonly dynamicPageSummarizedTitleArea: "fd-dynamic-page__summarized-title-area";
    readonly dynamicPageSummarizedTitleAreaExtraLarge: "fd-dynamic-page__summarized-title-area";
    readonly dynamicPageSummarizedTitleAreaNoShadow: "fd-dynamic-page__summarized-title-area--no-shadow";
    readonly dynamicPageSummarizedTitle: "fd-dynamic-page__summarized-title";
    readonly dynamicPageSummarizedTitleCollapsed: "fd-dynamic-page__summarized-title-area--collapsed";
};
type DynamicPageBackgroundType = 'solid' | 'list' | 'transparent';
type DynamicPageResponsiveSize = 'small' | 'medium' | 'large' | 'extra-large';

interface DynamicPageTitleDirectiveContext {
    /** Whether the header is collapsed */
    $implicit: boolean;
}

declare class DynamicPageHeaderSubtitleDirective {
    /** Template reference. */
    templateRef: TemplateRef<DynamicPageTitleDirectiveContext>;
    /** @hidden */
    static ngTemplateContextGuard(dir: DynamicPageHeaderSubtitleDirective, ctx: DynamicPageTitleDirectiveContext): ctx is DynamicPageTitleDirectiveContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageHeaderSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicPageHeaderSubtitleDirective, "[fdDynamicPageHeaderSubtitle]", never, {}, {}, never, never, true, never>;
}

declare class DynamicPageHeaderTitleDirective {
    /** Template reference. */
    templateRef: TemplateRef<DynamicPageTitleDirectiveContext>;
    /** @hidden */
    static ngTemplateContextGuard(dir: DynamicPageHeaderTitleDirective, ctx: DynamicPageTitleDirectiveContext): ctx is DynamicPageTitleDirectiveContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageHeaderTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicPageHeaderTitleDirective, "[fdDynamicPageHeaderTitle]", never, {}, {}, never, never, true, never>;
}

declare class DynamicPageContentComponent implements OnInit {
    readonly _renderer: Renderer2;
    readonly elementRef: ElementRef<HTMLElement>;
    private readonly _cdr;
    /**
     * label for the tab. If label is provided, tab navigation will be internally set up.
     */
    tabLabel: string;
    /**
     * a unique identifier for this content
     */
    id: string;
    /** @hidden */
    _showSpacer: boolean;
    /** @hidden */
    constructor(_renderer: Renderer2, elementRef: ElementRef<HTMLElement>, _cdr: ChangeDetectorRef);
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    _toggleSpacer(state: boolean): void;
    /** @hidden */
    private _addClassNameToHostElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageContentComponent, "fd-dynamic-page-content", never, { "tabLabel": { "alias": "tabLabel"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class DynamicPageFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageFooterComponent, "fd-dynamic-page-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class DynamicPageBaseActions implements HasElementRef {
    /** Element reference to the host element. */
    readonly elementRef: ElementRef<any>;
    /**
     * Adds a CSS class to the toolbar element within this component.
     * @param _class The CSS class name to add to the toolbar.
     */
    addClassToToolbar(_class: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageBaseActions, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicPageBaseActions, never, never, {}, {}, never, never, true, never>;
}

declare class DynamicPageGlobalActionsComponent extends DynamicPageBaseActions {
    /** @hidden */
    protected readonly _toolbarComponent: i0.Signal<ToolbarComponent | undefined>;
    /** Whether the toolbar should show overflow (size is small). */
    protected readonly shouldOverflow: i0.Signal<boolean>;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly _dynamicPageService;
    constructor();
    /** @hidden */
    private _handleOverflow;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageGlobalActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageGlobalActionsComponent, "fd-dynamic-page-global-actions", never, {}, {}, ["_toolbarComponent"], ["*"], true, never>;
}

declare class DynamicPageLayoutActionsComponent extends DynamicPageBaseActions {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageLayoutActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageLayoutActionsComponent, "fd-dynamic-page-layout-actions", never, {}, {}, never, ["*"], true, never>;
}

declare class DynamicPageTitleContentComponent {
    /** @hidden */
    protected readonly _contentDensityObserver: ContentDensityObserver;
    /** Whether the current size is small. */
    protected readonly _isSmall: i0.Signal<boolean>;
    /** @hidden */
    private readonly _dynamicPageService;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageTitleContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageTitleContentComponent, "fd-dynamic-page-title-content", never, {}, {}, never, ["*"], true, never>;
}

declare class DynamicPageBreadcrumbComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageBreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageBreadcrumbComponent, "fd-dynamic-page-breadcrumb", never, {}, {}, never, ["*"], true, never>;
}

declare class DynamicPageService {
    /** @hidden */
    readonly collapsed: i0.WritableSignal<boolean>;
    /** @hidden */
    readonly pinned: i0.WritableSignal<boolean>;
    /** @hidden */
    readonly pixelsSizeChanged: i0.WritableSignal<number>;
    /**
     * Manual size override. When set, takes precedence over auto-computed size.
     * Used when autoResponsive is false and size is set manually via input.
     */
    readonly manualSizeOverride: i0.WritableSignal<DynamicPageResponsiveSize | null>;
    /**
     * Computed responsive size based on pixel width or manual override.
     * Returns 'small', 'medium', 'large', or 'extra-large'.
     */
    readonly responsiveSize: i0.Signal<DynamicPageResponsiveSize>;
    /** @hidden */
    toggleCollapsed(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicPageService>;
}

declare const ActionSquashBreakpointPx = 1280;
declare class DynamicPageHeaderComponent implements OnInit {
    /**
     * The title text displayed in the dynamic page header.
     * @default ''
     */
    readonly title: i0.InputSignal<string>;
    /**
     * Whether the title text should wrap to multiple lines instead of truncating with ellipsis.
     * @default false
     */
    readonly titleWrap: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * The subtitle text displayed below the title in the dynamic page header.
     * @default ''
     */
    readonly subtitle: i0.InputSignal<string>;
    /**
     * Whether the subtitle text should wrap to multiple lines instead of truncating with ellipsis.
     * @default false
     */
    readonly subtitleWrap: i0.InputSignalWithTransform<boolean, unknown>;
    /**
     * The heading level (h1-h6) for the dynamic page title.
     * Determines the semantic hierarchy for accessibility and SEO.
     * @default 2
     */
    readonly headingLevel: i0.InputSignal<HeadingLevel>;
    /**
     * The heading level (h1-h6) for the dynamic page subtitle.
     * When provided, the subtitle will be rendered as a semantic heading with role="heading".
     * When not provided (undefined/null), the subtitle is rendered as plain text without a heading role.
     * @default undefined
     */
    readonly subtitleHeadingLevel: i0.InputSignal<HeadingLevel | null | undefined>;
    /**
     * The unique ID for the dynamic page title element.
     * Used for ARIA relationships and programmatic reference.
     * @default 'fd-dynamic-page-title-id-{auto-increment}'
     */
    readonly titleId: i0.InputSignal<string>;
    /**
     * @hidden
     * Content child query for custom subtitle template.
     * When provided via fdDynamicPageHeaderSubtitle directive, overrides the subtitle text input.
     */
    readonly _subtitleTemplate: i0.Signal<DynamicPageHeaderSubtitleDirective | undefined>;
    /**
     * @hidden
     * Content child query for custom title template.
     * When provided via fdDynamicPageHeaderTitle directive, overrides the title text input.
     */
    readonly _titleTemplate: i0.Signal<DynamicPageHeaderTitleDirective | undefined>;
    /** @hidden */
    readonly _dynamicPageBreadcrumbComponent: i0.Signal<DynamicPageBreadcrumbComponent | undefined>;
    /** @hidden */
    readonly _breadcrumbComponent: i0.Signal<BreadcrumbComponent | undefined>;
    /** @hidden */
    readonly _globalActions: i0.Signal<DynamicPageGlobalActionsComponent | undefined>;
    /** @hidden */
    readonly _layoutActions: i0.Signal<DynamicPageLayoutActionsComponent | undefined>;
    /** @hidden */
    readonly _contentToolbar: i0.Signal<DynamicPageTitleContentComponent | undefined>;
    /**
     * @hidden
     * Computed signal indicating whether actions should be displayed in collapsed/squashed mode.
     * True when viewport width is below the ActionSquashBreakpointPx threshold (1280px).
     */
    readonly _actionsSquashed: i0.Signal<boolean>;
    /**
     * @hidden
     * Computed numeric heading level extracted from the headingLevel input.
     * Strips non-digit characters and returns integer value.
     */
    readonly _headingLevel: i0.Signal<number>;
    /**
     * @hidden
     * Tracks the current responsive size of the dynamic page.
     * Updated by effect when DynamicPageService.responsiveSize changes.
     */
    _size: DynamicPageResponsiveSize;
    /** @hidden */
    readonly _dynamicPageService: DynamicPageService;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnInit(): void;
    /**
     * @hidden
     * Prevents click events from bubbling up to parent elements.
     * Used to stop the header collapse toggle when interacting with header content.
     */
    stopPropagation(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageHeaderComponent, "fd-dynamic-page-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "titleWrap": { "alias": "titleWrap"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "subtitleWrap": { "alias": "subtitleWrap"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "subtitleHeadingLevel": { "alias": "subtitleHeadingLevel"; "required": false; "isSignal": true; }; "titleId": { "alias": "titleId"; "required": false; "isSignal": true; }; }, {}, ["_subtitleTemplate", "_titleTemplate", "_dynamicPageBreadcrumbComponent", "_breadcrumbComponent", "_globalActions", "_layoutActions", "_contentToolbar"], ["fd-dynamic-page-breadcrumb", "fd-facet", "fd-dynamic-page-title-content", "fd-dynamic-page-global-actions", "fd-dynamic-page-layout-actions"], true, never>;
}

declare class DynamicPageSubheaderComponent {
    readonly _dynamicPageService: DynamicPageService;
    /**
     * whether the header can be collapsed. True by default. If set to false, both pin/collapse buttons disappear
     * and the header stays visible
     */
    collapsible: boolean;
    /**
     * whether the header should be allowed to be pinned or unpinned. When set, the pin button shows up.
     * Pinning the header will make the header stay visible and the collapse button(if present) will disappear until unpinned.
     */
    pinnable: boolean;
    /**
     * the initial state of the header. Set to true if header should be collapsed.
     */
    set collapsed(collapsed: boolean);
    get collapsed(): boolean;
    /**
     * ARIA label for button when the header is collapsed
     */
    expandLabel: string;
    /**
     * ARIA label for button when the header is expanded
     */
    collapseLabel: string;
    /**
     * id for header
     */
    id: string;
    /**
     * aria label for header
     */
    headerAriaLabel: Nullable<string>;
    /**
     * aria label for pin state of pin button
     */
    pinAriaLabel: string;
    /**
     * aria label for unpin state of pin button
     */
    unpinAriaLabel: string;
    /** Collapse/Expand change event raised */
    collapsedChange: EventEmitter<boolean>;
    /** Reference to page header content */
    pinCollapseContainer: ElementRef<HTMLElement>;
    /**
     * id for collapsible header
     */
    collapsibleHeaderId: string;
    /**
     * Aria Label for the toggle button
     * @hidden
     **/
    get _toggleButtonAriaLabel(): string;
    /**
     * Aria Label for the pin button
     * @hidden
     **/
    get _pinButtonAriaLabel(): string;
    /**
     * tracking if pin button is pinned
     */
    _pinned: boolean;
    /**
     * @hidden
     * tracking expand/collapse button
     */
    private _collapsed;
    /** @hidden */
    private _resolveTranslationSignal;
    /** @hidden */
    private _defaultExpandLabel;
    /** @hidden */
    private _defaultCollapseLabel;
    /** @hidden */
    private _defaultPinLabel;
    /** @hidden */
    private _defaultUnpinLabel;
    /** @hidden */
    constructor(_dynamicPageService: DynamicPageService);
    /**
     * toggles the state of the header and
     * handles expanded/collapsed event
     */
    toggleCollapse(): void;
    /**
     * @hidden
     * click action on pin button
     */
    togglePinned(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageSubheaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageSubheaderComponent, "fd-dynamic-page-subheader", never, { "collapsible": { "alias": "collapsible"; "required": false; }; "pinnable": { "alias": "pinnable"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "expandLabel": { "alias": "expandLabel"; "required": false; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; }; "id": { "alias": "id"; "required": false; }; "headerAriaLabel": { "alias": "headerAriaLabel"; "required": false; }; "pinAriaLabel": { "alias": "pinAriaLabel"; "required": false; }; "unpinAriaLabel": { "alias": "unpinAriaLabel"; "required": false; }; }, { "collapsedChange": "collapsedChange"; }, never, ["*"], true, never>;
}

declare class DynamicPageWrapperDirective {
    elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    constructor(elementRef: ElementRef<HTMLElement>);
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageWrapperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicPageWrapperDirective, "[fdDynamicPageWrapper], [fd-dynamic-page-wrapper]", never, {}, {}, never, never, true, never>;
}

interface DynamicPage {
    disableSnapOnScroll: boolean;
    ariaLabel: Nullable<string>;
    background: DynamicPageBackgroundType;
    autoResponsive: boolean;
    size: DynamicPageResponsiveSize;
    offset: number;
    expandContent: boolean;
    collapsed: Signal<boolean>;
    /** toggle the visibility of the header on click of title area. */
    toggleCollapse(): void;
    /**
     * Triggers recheck for spacing and sizing of elements inside DynamicPage.
     */
    refreshSize(): void;
}

declare class DynamicPageComponent implements AfterViewInit, DynamicPage {
    protected _cd: ChangeDetectorRef;
    private _elementRef;
    private _renderer;
    private _dynamicPageService;
    private _columnLayout;
    private _dynamicPageWrapper;
    /** Whether DynamicPage should snap on scroll */
    disableSnapOnScroll: boolean;
    /** aria label for the page */
    ariaLabel: Nullable<string>;
    /**
     * aria roledescription for the page
     * default: "Dynamic Page"
     *
     */
    ariaRoledescription: string;
    /**
     * sets background for content to `list`, `transparent`, or `solid` background color.
     * Default is `solid`.
     */
    background: DynamicPageBackgroundType;
    /** Whether DynamicPage should have responsive sides spacing changing with Page window width.
     * max-width: 599px                         - small
     * min-width: 600px and max-width: 1023px   - medium
     * min-width: 1024px and max-width: 1439px  - large
     * min-width: 1440px                        - extra large
     */
    autoResponsive: boolean;
    /**
     * sets size which in turn adds corresponding padding for the size type.
     * size can be `small`, `medium`, `large`, or `extra-large`.
     */
    set size(size: DynamicPageResponsiveSize);
    get size(): DynamicPageResponsiveSize;
    /** Offset in PX
     * Should be added, when there is something else at the bottom and dynamic page is not expanded to bottom's corners
     */
    offset: number;
    /**
     * Whether dynamic page should be expanded in whole page.
     */
    expandContent: boolean;
    /**
     * Whether dynamic page has position relative.
     * This is needed in cases where Dynamic Page is used in Flexible Column Layout and has a floating footer
     */
    positionRelative: boolean;
    /** @hidden reference to header component  */
    _pageSubheaderComponent: DynamicPageSubheaderComponent;
    /** @hidden reference to title component  */
    _headerComponent: DynamicPageHeaderComponent;
    /** @hidden reference to content component  */
    _contentComponent: QueryList<DynamicPageContentComponent>;
    /** @hidden reference to footer component  */
    _footerComponent: DynamicPageContentComponent;
    /** @hidden reference to tab component */
    _tabComponent: TabList;
    /** @hidden */
    _dynamicPageElement: ElementRef;
    /** @hidden */
    _scrollbar: ScrollbarDirective;
    /** Whether the dynamic page is collapsed */
    collapsed: i0.Signal<boolean>;
    /** @hidden */
    _size: DynamicPageResponsiveSize;
    /** @hidden */
    _headerCollapsible: boolean;
    /** @hidden */
    _isExpanded: i0.Signal<boolean>;
    /** @hidden */
    private _headerButton;
    /** @hidden **/
    private readonly _destroyRef;
    /** @hidden */
    constructor(_cd: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2, _dynamicPageService: DynamicPageService, _columnLayout: FlexibleColumnLayoutComponent, _dynamicPageWrapper: DynamicPageWrapperDirective);
    /** @hidden */
    ngAfterViewInit(): void;
    /** toggle the visibility of the header on click of title area. */
    toggleCollapse(): void;
    /**
     * Triggers recheck for spacing and sizing of elements inside DynamicPage.
     */
    refreshSize(): void;
    /** @hidden */
    _getScrollElement(): HTMLElement | null;
    /** @hidden */
    private _propagatePropertiesToChildren;
    /** @hidden */
    private _getCalculatedFullHeight;
    /** @hidden */
    private _sizeChangeHandle;
    /** @hidden */
    private _addScrollListeners;
    /** @hidden Listen for window resize and adjust tab and content positions accordingly */
    private _listenOnResize;
    /** @hidden */
    private _listenToWrapperResize;
    /** @hidden */
    private _listenToWindowResize;
    /** @hidden Sets the dynamic page height to fill available viewport space. */
    private _updateDynamicPageHeight;
    /** @hidden */
    private _removeShadowWhenTabComponent;
    /** @hidden */
    private _setContentFooterSpacer;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageComponent, [null, null, null, null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicPageComponent, "fd-dynamic-page", never, { "disableSnapOnScroll": { "alias": "disableSnapOnScroll"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRoledescription": { "alias": "ariaRoledescription"; "required": false; }; "background": { "alias": "background"; "required": false; }; "autoResponsive": { "alias": "autoResponsive"; "required": false; }; "size": { "alias": "size"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "expandContent": { "alias": "expandContent"; "required": false; }; "positionRelative": { "alias": "positionRelative"; "required": false; }; }, {}, ["_pageSubheaderComponent", "_headerComponent", "_footerComponent", "_tabComponent", "_contentComponent"], ["fd-dynamic-page-header", "fd-dynamic-page-subheader", "fd-tab-list", "fd-wizard", "fdp-icon-tab-bar", "fd-dynamic-page-content", "fd-dynamic-page-content", "fd-dynamic-page-footer"], true, never>;
}

/**
 * Default options for core dynamic-page
 * @deprecated use i18n coreDynamicPage key instead
 */
declare class DynamicPageConfig {
    /**
     * aria label for expand/collapse button when the Dynamic Page is collapsed
     */
    expandLabel: string;
    /**
     * aria label for expand/collapse button when the Dynamic Page is expanded
     */
    collapseLabel: string;
    /**
     * aria label for pin button when the Dynamic Page should be pinned
     */
    pinLabel: string;
    /**
     * aria label for pin button when the Panel should be unpinned
     */
    unpinLabel: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicPageConfig>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class DynamicPageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DynamicPageModule, never, [typeof DynamicPageComponent, typeof DynamicPageHeaderComponent, typeof DynamicPageGlobalActionsComponent, typeof DynamicPageLayoutActionsComponent, typeof DynamicPageSubheaderComponent, typeof DynamicPageContentComponent, typeof DynamicPageFooterComponent, typeof DynamicPageTitleContentComponent, typeof DynamicPageWrapperDirective, typeof DynamicPageHeaderSubtitleDirective, typeof DynamicPageHeaderTitleDirective, typeof DynamicPageBreadcrumbComponent], [typeof DynamicPageComponent, typeof DynamicPageHeaderComponent, typeof DynamicPageGlobalActionsComponent, typeof DynamicPageLayoutActionsComponent, typeof DynamicPageSubheaderComponent, typeof DynamicPageContentComponent, typeof DynamicPageFooterComponent, typeof DynamicPageTitleContentComponent, typeof DynamicPageWrapperDirective, typeof DynamicPageHeaderSubtitleDirective, typeof DynamicPageHeaderTitleDirective, typeof DynamicPageBreadcrumbComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DynamicPageModule>;
}

declare const FD_DYNAMIC_PAGE: InjectionToken<DynamicPage>;

/**
 * Patch header i18n texts
 */
declare function patchHeaderI18nTexts(config?: DynamicPageConfig): Observable<FdLanguage>;

declare const FD_DYNAMIC_PAGE_BREADCRUMB_COMPONENT: InjectionToken<unknown>;

declare const addClassNameToElement: (renderer: Renderer2, element: Element, className: string) => void;
/** @hidden Returns dynamic page size based on width
 * @param width - dynamic page window width
 **/
declare function dynamicPageWidthToSize(width: number): DynamicPageResponsiveSize;

export { ActionSquashBreakpointPx, DYNAMIC_PAGE_CLASS_NAME, DynamicPageBaseActions, DynamicPageBreadcrumbComponent, DynamicPageComponent, DynamicPageConfig, DynamicPageContentComponent, DynamicPageFooterComponent, DynamicPageGlobalActionsComponent, DynamicPageHeaderComponent, DynamicPageHeaderSubtitleDirective, DynamicPageHeaderTitleDirective, DynamicPageLayoutActionsComponent, DynamicPageModule, DynamicPageService, DynamicPageSubheaderComponent, DynamicPageTitleContentComponent, DynamicPageWrapperDirective, FD_DYNAMIC_PAGE, FD_DYNAMIC_PAGE_BREADCRUMB_COMPONENT, addClassNameToElement, dynamicPageWidthToSize, patchHeaderI18nTexts };
export type { DynamicPage, DynamicPageBackgroundType, DynamicPageResponsiveSize, DynamicPageTitleDirectiveContext };
