import * as _angular_core from '@angular/core';
import { Signal, InjectionToken, PipeTransform } from '@angular/core';
import * as i1$1 from '@angular/common';
import * as i1 from '@angular/router';
import { Params } from '@angular/router';
import { SdStorage } from '@sdcorejs/angular/services';
import { SdViewport } from '@sdcorejs/angular/services/viewport';
import * as _sdcorejs_angular_modules_layout from '@sdcorejs/angular/modules/layout';
import { MaybeAsync } from '@sdcorejs/utils/models';
import { Observable } from 'rxjs';

declare class HomeRoutingModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HomeRoutingModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<HomeRoutingModule, never, [typeof i1.RouterModule], [typeof i1.RouterModule]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<HomeRoutingModule>;
}

declare class HomeModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HomeModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<HomeModule, never, [typeof i1$1.CommonModule, typeof HomeRoutingModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<HomeModule>;
}

declare class NotFoundModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotFoundModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NotFoundModule, never, [typeof i1$1.CommonModule, typeof i1.RouterModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NotFoundModule>;
}

declare class ForbiddenModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForbiddenModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ForbiddenModule, never, [typeof i1$1.CommonModule, typeof i1.RouterModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ForbiddenModule>;
}

type SdLayoutMenu = SdLayoutRootMenu | SdLayoutChildrenMenu;
type Menus = SdLayoutMenu[];
interface SdLayoutRootMenu {
    id?: string;
    path: string;
    queryParams?: Params;
    icon?: string;
    iconUrl?: string;
    title: string;
    permissionKey?: string;
    permission: string | string[] | boolean | (() => boolean);
    level?: number;
    tooltipTitle?: string;
}
interface SdLayoutChildrenMenu {
    id?: string;
    icon?: string;
    iconUrl?: string;
    title?: string;
    children?: (SdLayoutRootMenu | SdLayoutChildrenMenu)[];
    level?: number;
    tooltipTitle?: string;
}

declare class SdLayoutStorageService {
    #private;
    readonly isShowSidebar: SdStorage<boolean>;
    readonly menuLockStatus: SdStorage<boolean>;
    readonly lastActiveMenuGroupId: SdStorage<string>;
    readonly pinnedMenuGroup: SdStorage<SdLayoutChildrenMenu>;
    readonly pinnedMenuKeys: SdStorage<string[]>;
    readonly recentMenuKeys: SdStorage<string[]>;
    readonly versionStates: SdStorage<Record<string, SdLayoutVersionState>>;
    readPinnedMenuKeys(menus: SdLayoutMenu[]): string[];
    writePinnedMenuKeys(keys: string[]): void;
    readRecentMenuKeys(menus: SdLayoutMenu[], maximum?: number): string[];
    writeRecentMenuKeys(keys: string[]): void;
    readVersionState(version: 1 | 2 | 3): SdLayoutVersionState;
    patchVersionState(version: 1 | 2 | 3, patch: SdLayoutVersionState): SdLayoutVersionState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutStorageService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdLayoutStorageService>;
}
interface SdLayoutVersionState {
    activeGroupKey?: string;
    locked?: boolean;
    collapsed?: boolean;
}

type SdLayoutViewport = SdViewport;
declare const SD_LAYOUT_VIEWPORT: _angular_core.InjectionToken<SdViewport | null>;
/** @deprecated Prefer `SdViewportService` from `@sdcorejs/angular/services/viewport`. */
declare class SdLayoutResponsiveService {
    #private;
    readonly viewportWidth: _angular_core.Signal<number>;
    isMobile(breakpoint: number): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutResponsiveService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdLayoutResponsiveService>;
}

/** Consumer-owned account action invoked without arguments by the shared user menu. */
type SdLayoutAccountAction = () => void | Promise<void>;
/** Notification badge source and the action that opens the consumer's notification experience. */
interface SdLayoutNotificationConfiguration {
    /**
     * Số lượng thông báo chưa đọc. Hỗ trợ giá trị tĩnh hoặc nguồn reactive dài hạn.
     */
    count: number | Signal<number> | Observable<number>;
    /**
     * Tác vụ do consumer xử lý khi người dùng chọn thông báo.
     */
    action: SdLayoutAccountAction;
}
interface ISdLayoutConfiguration {
    homeUrl?: string;
    mobileBreakpoint?: number;
    sidebar: ISdSidebarConfiguration | (() => MaybeAsync<ISdSidebarConfiguration>);
    userInfo: SdLayoutUserInfo | (() => MaybeAsync<SdLayoutUserInfo>);
    signout: SdLayoutAccountAction;
    changePassword?: SdLayoutAccountAction;
    /**
     * Tác vụ chỉnh sửa hồ sơ do consumer cung cấp.
     */
    updateProfile?: SdLayoutAccountAction;
    /**
     * Tác vụ mở thiết lập tài khoản do consumer cung cấp.
     */
    setting?: SdLayoutAccountAction;
    /**
     * Cấu hình số lượng và tác vụ thông báo của tài khoản.
     */
    notification?: SdLayoutNotificationConfiguration;
}
/** Optional role metadata rendered below the user's email when `text` is non-empty. */
interface SdLayoutUserRole {
    text: string;
    /** Icon name resolved by `SdIcon`. */
    icon?: string;
    /** CSS color applied to the role metadata. */
    color?: string;
}
interface SdLayoutUserInfo {
    /**
     * Tên đăng nhập hoặc tên định danh của người dùng.
     * Thường dùng làm định danh rút gọn hoặc fallback hiển thị nếu user chưa cập nhật fullName.
     */
    username?: string;
    /**
     * Địa chỉ thư điện tử của người dùng.
     * Thường được hiển thị bên dưới tên người dùng trong popup/menu thông tin tài khoản.
     */
    email?: string;
    /**
     * Họ và tên đầy đủ của người dùng.
     * Đây là thông tin được ưu tiên hiển thị chính trên giao diện (VD: góc phải màn hình, lời chào).
     */
    fullName?: string;
    /**
     * Hình đại diện (avatar) của người dùng.
     * Nếu để trống, hệ thống sẽ tự động lấy ký tự đầu tiên của fullName hoặc username để tạo avatar mặc định.
     * Hỗ trợ các định dạng: URL (http/https), chuỗi base64 (data:image), hoặc đường dẫn nội bộ.
     */
    avatar?: string;
    /**
     * Chức vụ hoặc vai trò hiển thị cùng thông tin người dùng.
     * Không render khi `text` rỗng.
     */
    role?: SdLayoutUserRole;
}
declare const DEFAULT_LAYOUT_MOBILE_BREAKPOINT = 1024;
interface SidebarConfigurationBase {
    brandColor?: string;
    brandLightColor?: string;
    logoUrl?: string;
    defaultTitle?: string;
    pin?: {
        enabled?: boolean;
    };
}
type ISdSidebarConfiguration = SidebarConfigurationV1 | SidebarConfigurationV2 | SidebarConfigurationV3;
interface SidebarConfigurationV1 extends SidebarConfigurationBase {
    version: 1;
    /**
     * Màu brand chính.
     * Nên sử dụng mã màu #HEX hoặc rgb để hỗ trợ opacity khi hover.
     * Ví dụ: #1890ff, rgb(24,144,255)
     */
    brandColor?: string;
    /**
     * Màu brand nhạt (light).
     * Dùng cho background, hover nhẹ.
     */
    brandLightColor?: string;
    /**
     * URL logo hiển thị ở sidebar.
     * Nên đặt trong thư mục public hoặc dùng URL CDN.
     */
    logoUrl?: string;
    /**
     * Title mặc định của hệ thống.
     * Nếu menu không truyền title thì sẽ dùng giá trị này.
     * @default "Back Office"
     */
    defaultTitle?: string;
    /**
     * Cấu hình tính năng ghim menu.
     * - `enabled`: bật/tắt tính năng ghim.
     * Hệ thống mặc định là false
     */
    pin?: {
        enabled?: boolean;
    };
}
interface SidebarConfigurationV2 extends SidebarConfigurationBase {
    version: 2;
    interaction?: 'click' | 'hover-lock';
    primaryMenuIds?: string[];
}
interface SidebarConfigurationV3 extends SidebarConfigurationBase {
    version: 3;
    defaultCollapsed?: boolean;
    recent?: {
        enabled?: boolean;
        maxItems?: number;
    };
}
interface ResolvedSidebarRecentConfiguration {
    enabled: boolean;
    maxItems: number;
}
declare function normalizeLayoutMobileBreakpoint(value: number | undefined): number;
declare function resolveSidebarV2Interaction(sidebar: SidebarConfigurationV2): 'click' | 'hover-lock';
declare function resolveSidebarV3Recent(sidebar: SidebarConfigurationV3): ResolvedSidebarRecentConfiguration;
declare function normalizeSidebarConfiguration(_sidebar: SidebarConfigurationV1): SidebarConfigurationV1;
declare function normalizeSidebarConfiguration(_sidebar: SidebarConfigurationV2): SidebarConfigurationV2;
declare function normalizeSidebarConfiguration(_sidebar: SidebarConfigurationV3): SidebarConfigurationV3;
declare const SD_LAYOUT_CONFIGURATION: InjectionToken<ISdLayoutConfiguration>;

declare class SdLayoutNavigationStateService {
    #private;
    readonly pinnedKeys: _angular_core.WritableSignal<string[]>;
    readonly recentKeys: _angular_core.WritableSignal<string[]>;
    readonly pinnedMenus: _angular_core.Signal<(_sdcorejs_angular_modules_layout.SdLayoutRootMenu | _sdcorejs_angular_modules_layout.SdLayoutChildrenMenu)[]>;
    readonly recentMenus: _angular_core.Signal<(_sdcorejs_angular_modules_layout.SdLayoutRootMenu | _sdcorejs_angular_modules_layout.SdLayoutChildrenMenu)[]>;
    hydrate(menus: SdLayoutMenu[], recentMaximum?: number): void;
    togglePinned(menu: SdLayoutMenu): void;
    recordRecent(menu: SdLayoutMenu, configuration: ResolvedSidebarRecentConfiguration): void;
    patchVersionState(version: 1 | 2 | 3, patch: SdLayoutVersionState): void;
    versionState(version: 1 | 2 | 3): SdLayoutVersionState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutNavigationStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdLayoutNavigationStateService>;
}

declare function getMenuStableKey(menu: SdLayoutMenu | null | undefined, ancestors?: string[]): string;
declare function searchMenuLeaves(menus: SdLayoutMenu[], query: string): SdLayoutRootMenu[];
declare function selectPrimaryMenuGroups(menus: SdLayoutMenu[], requestedIds: string[] | undefined, maximum?: number): SdLayoutMenu[];
declare function resolveMenuKeys(menus: SdLayoutMenu[], keys: string[]): (SdLayoutRootMenu | SdLayoutChildrenMenu)[];
declare function flattenMenuLeaves(menus: SdLayoutMenu[]): SdLayoutRootMenu[];

declare class SdLayoutService {
    #private;
    userInfo: _angular_core.WritableSignal<SdLayoutUserInfo | undefined>;
    sidebar: _angular_core.WritableSignal<ISdSidebarConfiguration | undefined>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdLayoutService>;
}

declare class SdPageComponent {
    private el;
    title: _angular_core.InputSignal<string>;
    description: _angular_core.InputSignal<string>;
    noHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdPageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdPageComponent, "sd-page", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "noHeader": { "alias": "noHeader"; "required": false; "isSignal": true; }; }, {}, never, ["[headerLeft]", "[headerRight]", "*"], true, never>;
}

declare class SdLayoutComponent {
    #private;
    menusInput: _angular_core.InputSignal<SdLayoutMenu[]>;
    menus: _angular_core.Signal<SdLayoutMenu[]>;
    userInfo: _angular_core.WritableSignal<_sdcorejs_angular_modules_layout.SdLayoutUserInfo | undefined>;
    sidebar: _angular_core.WritableSignal<_sdcorejs_angular_modules_layout.ISdSidebarConfiguration | undefined>;
    sidebarV1: _angular_core.Signal<SidebarConfigurationV1 | undefined>;
    sidebarV2: _angular_core.Signal<SidebarConfigurationV2 | undefined>;
    sidebarV3: _angular_core.Signal<SidebarConfigurationV3 | undefined>;
    mobileBreakpoint: number;
    isMobile: _angular_core.Signal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdLayoutComponent, "sd-layout", never, { "menusInput": { "alias": "menus"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SidebarMobileV1Component {
    #private;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    sidebar: _angular_core.InputSignal<SidebarConfigurationV1>;
    isShowSidebar: _angular_core.WritableSignal<boolean>;
    titleMenuGroup: _angular_core.WritableSignal<string | undefined>;
    constructor();
    openSidebar: () => void;
    onToggle: (_data: boolean | null) => void;
    onPopupOfSideBarOpened: () => void;
    onPopupOfSideBarClosed: () => void;
    onExpandSideBar: () => void;
    onMouseleaveSideBar: () => void;
    onTitleMenuGroupChanged: (title: string | undefined) => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarMobileV1Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarMobileV1Component, "sidebar-mobile-v1", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "sidebar": { "alias": "sidebar"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SidebarMobileOverlayComponent {
    #private;
    isShowSidebar: _angular_core.InputSignal<boolean>;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    sidebar: _angular_core.InputSignal<SidebarConfigurationV1>;
    showSideBar: _angular_core.OutputEmitterRef<boolean | null>;
    expandSideBar: _angular_core.OutputEmitterRef<void>;
    popupUserMenuOpened: _angular_core.OutputEmitterRef<void>;
    popupUserMenuClosed: _angular_core.OutputEmitterRef<void>;
    titleMenuGroupChanged: _angular_core.OutputEmitterRef<string | undefined>;
    titleMenuGroup: _angular_core.WritableSignal<string | undefined>;
    currentPath: _angular_core.WritableSignal<string>;
    expandedMobileGroups: _angular_core.WritableSignal<Set<string>>;
    constructor();
    toggleMobileGroup(groupId: string | undefined): void;
    isExpanded(groupId: string | undefined): boolean;
    navigate(args: {
        path?: string;
        queryParams?: Params;
    }): void;
    onClose(): void;
    hasChildren(menu: SdLayoutMenu): boolean;
    getChildren(menu: SdLayoutMenu): SdLayoutMenu[];
    getPath(menu: SdLayoutMenu): string | undefined;
    getQueryParams(menu: SdLayoutMenu): Params;
    onUserMenuOpened: () => void;
    onUserMenuClosed: () => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarMobileOverlayComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarMobileOverlayComponent, "sd-sidebar-mobile-overlay", never, { "isShowSidebar": { "alias": "isShowSidebar"; "required": false; "isSignal": true; }; "menus": { "alias": "menus"; "required": true; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "sidebar": { "alias": "sidebar"; "required": true; "isSignal": true; }; }, { "showSideBar": "showSideBar"; "expandSideBar": "expandSideBar"; "popupUserMenuOpened": "popupUserMenuOpened"; "popupUserMenuClosed": "popupUserMenuClosed"; "titleMenuGroupChanged": "titleMenuGroupChanged"; }, never, never, true, never>;
}

interface SdLayoutMenuTreeNode {
    menu: SdLayoutMenu;
    key: string;
    title: string;
    depth: number;
    paddingLeft: number;
    isGroup: boolean;
    isActive: boolean;
    isPinned: boolean;
    isPinVisible: boolean;
}
declare class SdLayoutMenuTreeComponent {
    #private;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    query: _angular_core.InputSignal<string>;
    activePath: _angular_core.InputSignal<string>;
    pinnedKeys: _angular_core.InputSignal<string[]>;
    showPin: _angular_core.InputSignal<boolean>;
    pinVisibility: _angular_core.InputSignal<"hover" | "always">;
    navigate: _angular_core.OutputEmitterRef<SdLayoutRootMenu>;
    togglePinned: _angular_core.OutputEmitterRef<SdLayoutMenu>;
    nodes: _angular_core.Signal<SdLayoutMenuTreeNode[]>;
    constructor();
    onNavigate(menu: SdLayoutMenu): void;
    onTogglePinned(event: MouseEvent, menu: SdLayoutMenu): void;
    onPinHoverStart(key: string): void;
    onPinHoverEnd(key: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutMenuTreeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdLayoutMenuTreeComponent, "sd-layout-menu-tree", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "activePath": { "alias": "activePath"; "required": false; "isSignal": true; }; "pinnedKeys": { "alias": "pinnedKeys"; "required": false; "isSignal": true; }; "showPin": { "alias": "showPin"; "required": false; "isSignal": true; }; "pinVisibility": { "alias": "pinVisibility"; "required": false; "isSignal": true; }; }, { "navigate": "navigate"; "togglePinned": "togglePinned"; }, never, never, true, never>;
}

declare class SdLayoutUserMenuComponent {
    #private;
    private readonly trigger;
    private readonly menu;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    signout: _angular_core.InputSignal<SdLayoutAccountAction | undefined>;
    changePassword: _angular_core.InputSignal<SdLayoutAccountAction | undefined>;
    updateProfile: _angular_core.InputSignal<SdLayoutAccountAction | undefined>;
    setting: _angular_core.InputSignal<SdLayoutAccountAction | undefined>;
    notification: _angular_core.InputSignal<SdLayoutNotificationConfiguration | undefined>;
    compact: _angular_core.InputSignal<boolean>;
    presentation: _angular_core.InputSignal<"disclosure" | "mobile" | "mobile-inline">;
    opened: _angular_core.OutputEmitterRef<void>;
    closed: _angular_core.OutputEmitterRef<void>;
    isOpen: _angular_core.WritableSignal<boolean>;
    avatar: _angular_core.Signal<string | undefined>;
    displayName: _angular_core.Signal<string>;
    role: _angular_core.Signal<{
        text: string;
        icon?: string;
        color?: string;
    } | undefined>;
    signoutAction: _angular_core.Signal<SdLayoutAccountAction | undefined>;
    changePasswordAction: _angular_core.Signal<SdLayoutAccountAction | undefined>;
    updateProfileAction: _angular_core.Signal<SdLayoutAccountAction | undefined>;
    settingAction: _angular_core.Signal<SdLayoutAccountAction | undefined>;
    notificationConfiguration: _angular_core.Signal<SdLayoutNotificationConfiguration | undefined>;
    notificationAction: _angular_core.Signal<SdLayoutAccountAction | undefined>;
    notificationCount: _angular_core.Signal<number>;
    notificationBadge: _angular_core.Signal<string | undefined>;
    constructor();
    open(): void;
    toggle(): void;
    close(restoreFocus?: boolean): void;
    onMenuKeydown(event: KeyboardEvent): void;
    runChangePassword(): void;
    runSignout(): void;
    runUpdateProfile(): void;
    runSetting(): void;
    runNotification(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutUserMenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SdLayoutUserMenuComponent, "sd-layout-user-menu", never, { "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "signout": { "alias": "signout"; "required": false; "isSignal": true; }; "changePassword": { "alias": "changePassword"; "required": false; "isSignal": true; }; "updateProfile": { "alias": "updateProfile"; "required": false; "isSignal": true; }; "setting": { "alias": "setting"; "required": false; "isSignal": true; }; "notification": { "alias": "notification"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "presentation": { "alias": "presentation"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
}

interface SidebarV2RailItem {
    menu: SdLayoutMenu;
    key: string;
    title: string;
}
declare class SidebarV2Component {
    #private;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    sidebar: _angular_core.InputSignal<SidebarConfigurationV2>;
    activeGroupKey: _angular_core.WritableSignal<string>;
    isFlyoutOpen: _angular_core.WritableSignal<boolean>;
    isFlyoutLocked: _angular_core.WritableSignal<boolean>;
    searchText: _angular_core.WritableSignal<string>;
    activePath: _angular_core.WritableSignal<string>;
    interaction: _angular_core.Signal<"click" | "hover-lock">;
    railItems: _angular_core.Signal<SidebarV2RailItem[]>;
    activeGroup: _angular_core.Signal<SdLayoutMenu | undefined>;
    contextMenus: _angular_core.Signal<SdLayoutMenu[]>;
    pinnedKeys: _angular_core.WritableSignal<string[]>;
    constructor();
    selectGroup(menu: SdLayoutMenu): void;
    previewGroup(menu: SdLayoutMenu): void;
    leaveFlyout(): void;
    closeFromBackdrop(): void;
    closeFromEscape(): void;
    closeFromNavigation(): void;
    onNavigate(menu: SdLayoutMenu): void;
    onTogglePinned(menu: SdLayoutMenu): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarV2Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarV2Component, "sidebar-v2", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "sidebar": { "alias": "sidebar"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SidebarMobileV2Component {
    #private;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    sidebar: _angular_core.InputSignal<SidebarConfigurationV2>;
    primaryMenus: _angular_core.Signal<SdLayoutMenu[]>;
    overflowMenus: _angular_core.Signal<SdLayoutMenu[]>;
    isSheetOpen: _angular_core.WritableSignal<boolean>;
    sheetGroupKey: _angular_core.WritableSignal<string>;
    sheetTitle: _angular_core.WritableSignal<string>;
    sheetMenus: _angular_core.WritableSignal<SdLayoutMenu[]>;
    searchText: _angular_core.WritableSignal<string>;
    activePath: _angular_core.WritableSignal<string>;
    pinnedKeys: _angular_core.WritableSignal<string[]>;
    constructor();
    openMore(trigger?: EventTarget | null): void;
    activateMenu(menu: SdLayoutMenu, trigger?: EventTarget | null): void;
    closeSheet(restoreFocus?: boolean): void;
    onSheetKeydown(event: KeyboardEvent): void;
    onNavigate(menu: SdLayoutMenu): void;
    onTogglePinned(menu: SdLayoutMenu): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarMobileV2Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarMobileV2Component, "sidebar-mobile-v2", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "sidebar": { "alias": "sidebar"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SidebarV3Component {
    #private;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    sidebar: _angular_core.InputSignal<SidebarConfigurationV3>;
    isCollapsed: _angular_core.WritableSignal<boolean>;
    searchText: _angular_core.WritableSignal<string>;
    activePath: _angular_core.WritableSignal<string>;
    searchResults: _angular_core.Signal<SdLayoutRootMenu[]>;
    recentConfiguration: _angular_core.Signal<_sdcorejs_angular_modules_layout.ResolvedSidebarRecentConfiguration>;
    pinnedKeys: _angular_core.WritableSignal<string[]>;
    pinnedMenus: _angular_core.Signal<(SdLayoutRootMenu | _sdcorejs_angular_modules_layout.SdLayoutChildrenMenu)[]>;
    recentMenus: _angular_core.Signal<(SdLayoutRootMenu | _sdcorejs_angular_modules_layout.SdLayoutChildrenMenu)[]>;
    collapsedItems: _angular_core.Signal<{
        menu: SdLayoutMenu;
        key: string;
        title: string;
    }[]>;
    constructor();
    toggleCollapsed(): void;
    activateCollapsedMenu(menu: SdLayoutMenu): void;
    navigateMenu(menu: SdLayoutMenu): void;
    onTogglePinned(menu: SdLayoutMenu): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarV3Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarV3Component, "sidebar-v3", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "sidebar": { "alias": "sidebar"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class SidebarMobileV3Component {
    #private;
    private readonly trigger;
    menus: _angular_core.InputSignal<SdLayoutMenu[]>;
    userInfo: _angular_core.InputSignal<SdLayoutUserInfo>;
    sidebar: _angular_core.InputSignal<SidebarConfigurationV3>;
    isDrawerOpen: _angular_core.WritableSignal<boolean>;
    searchText: _angular_core.WritableSignal<string>;
    activePath: _angular_core.WritableSignal<string>;
    searchResults: _angular_core.Signal<SdLayoutRootMenu[]>;
    recentConfiguration: _angular_core.Signal<_sdcorejs_angular_modules_layout.ResolvedSidebarRecentConfiguration>;
    pinnedKeys: _angular_core.WritableSignal<string[]>;
    pinnedMenus: _angular_core.Signal<(SdLayoutRootMenu | _sdcorejs_angular_modules_layout.SdLayoutChildrenMenu)[]>;
    recentMenus: _angular_core.Signal<(SdLayoutRootMenu | _sdcorejs_angular_modules_layout.SdLayoutChildrenMenu)[]>;
    constructor();
    openDrawer(trigger?: EventTarget | null): void;
    closeFromBackdrop(): void;
    closeFromEscape(): void;
    closeFromNavigation(): void;
    onDrawerKeydown(event: KeyboardEvent): void;
    navigateMenu(menu: SdLayoutMenu): void;
    onTogglePinned(menu: SdLayoutMenu): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarMobileV3Component, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarMobileV3Component, "sidebar-mobile-v3", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "userInfo": { "alias": "userInfo"; "required": true; "isSignal": true; }; "sidebar": { "alias": "sidebar"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class MenuPipe implements PipeTransform {
    #private;
    private permissionService;
    /** Inserted by Angular inject() migration for backwards compatibility */
    constructor(...args: unknown[]);
    transform(menus: SdLayoutMenu[]): SdLayoutMenu[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<MenuPipe, "menu", true>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuPipe>;
}

declare class MenuFocusPipe implements PipeTransform {
    #private;
    transform(routePath: string, menuItem: SdLayoutMenu): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuFocusPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<MenuFocusPipe, "menuFocus", true>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuFocusPipe>;
}

declare class HighlightSearchPipe implements PipeTransform {
    #private;
    transform(value: string, keyword: string, args?: {
        color?: string;
    }): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HighlightSearchPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HighlightSearchPipe, "highLightSearch", true>;
}

declare class SdLayoutModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdLayoutModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SdLayoutModule, never, [typeof i1.RouterModule], never>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SdLayoutModule>;
}

export { DEFAULT_LAYOUT_MOBILE_BREAKPOINT, ForbiddenModule, HighlightSearchPipe, HomeModule, MenuFocusPipe, MenuPipe, NotFoundModule, SD_LAYOUT_CONFIGURATION, SD_LAYOUT_VIEWPORT, SdLayoutComponent, SdLayoutMenuTreeComponent, SdLayoutModule, SdLayoutNavigationStateService, SdLayoutResponsiveService, SdLayoutService, SdLayoutStorageService, SdLayoutUserMenuComponent, SdPageComponent, SidebarMobileOverlayComponent, SidebarMobileV1Component, SidebarMobileV2Component, SidebarMobileV3Component, SidebarV2Component, SidebarV3Component, flattenMenuLeaves, getMenuStableKey, normalizeLayoutMobileBreakpoint, normalizeSidebarConfiguration, resolveMenuKeys, resolveSidebarV2Interaction, resolveSidebarV3Recent, searchMenuLeaves, selectPrimaryMenuGroups };
export type { ISdLayoutConfiguration, ISdSidebarConfiguration, Menus, ResolvedSidebarRecentConfiguration, SdLayoutAccountAction, SdLayoutChildrenMenu, SdLayoutMenu, SdLayoutNotificationConfiguration, SdLayoutRootMenu, SdLayoutUserInfo, SdLayoutUserRole, SdLayoutVersionState, SdLayoutViewport, SidebarConfigurationBase, SidebarConfigurationV1, SidebarConfigurationV2, SidebarConfigurationV3 };