platform-core-ng 21.1.0

package/types/platform-core-ng.d.ts

@@ -0,0 +1,3217 @@
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { CanActivateFn } from '@angular/router';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, OnInit, ChangeDetectorRef, Signal, WritableSignal, ErrorHandler, Injector, EnvironmentProviders, Type, AfterViewInit, TemplateRef, ViewContainerRef, ElementRef, OnChanges, Renderer2, SimpleChanges, ComponentRef, PipeTransform } from '@angular/core';
+import { BaseListEntity, BaseCrudService, PaginationResponse, PageRequestDTO } from 'platform-core-ts';
+import { HttpRequest, HttpHandlerFn, HttpEvent, HttpContextToken, HttpContext } from '@angular/common/http';
+import * as platform_core_ng from 'platform-core-ng';
+import * as lucide_angular from 'lucide-angular';
+import { LucideIconData } from 'lucide-angular';
+import { Listbox, Option } from '@angular/aria/listbox';
+import { Combobox } from '@angular/aria/combobox';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { CdkOverlayOrigin, ConnectedPosition, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';
+import { MenuTrigger, Menu } from '@angular/aria/menu';
+
+interface ElectronRequestBridge {
+    get<T>(url: string, option: string): Promise<T>;
+    post<T>(url: string, data: unknown): Promise<T>;
+    delete<T>(url: string, option: string): Promise<T>;
+    put<T>(url: string, data: unknown): Promise<T>;
+}
+declare global {
+    interface Window {
+        electronRequest: ElectronRequestBridge;
+    }
+}
+/**
+ * @description 用于在 Electron 环境中发送IPC请求
+ * @param url 请求 URL
+ * @param option 请求选项
+ * @author Chen Yu
+ * @returns 响应数据
+ */
+declare class ElectronRequest {
+    /**
+     * 发送 GET 请求
+     * @param url 请求 URL
+     * @param option 请求选项
+     * @returns 响应数据
+     */
+    get<T>(url: string, option: string): Observable<T>;
+    /**
+     * 发送 POST 请求
+     * @param url 请求 URL
+     * @param data 请求数据
+     * @returns 响应数据
+     */
+    post<T>(url: string, data: unknown): Observable<T>;
+    /**
+     * 发送 DELETE 请求
+     * @param url 请求 URL
+     * @param option 请求选项
+     * @returns 响应数据
+     */
+    delete<T>(url: string, option: string): Observable<T>;
+    /**
+     * 发送 PUT 请求
+     * @param url 请求 URL
+     * @param data 请求数据
+     * @returns 响应数据
+     */
+    put<T>(url: string, data: unknown): Observable<T>;
+}
+
+declare const coreAuthGuard: CanActivateFn;
+declare const coreGuestOnlyGuard: CanActivateFn;
+
+type AuthenticatedStateGetter = () => boolean;
+interface CoreAuthGuardConfig {
+    readonly loginPath?: string;
+    readonly authenticatedRedirectPath?: string;
+}
+declare const AUTHENTICATED_STATE_GETTER: InjectionToken<AuthenticatedStateGetter>;
+declare const CORE_AUTH_GUARD_CONFIG: InjectionToken<CoreAuthGuardConfig>;
+declare function provideAuthenticatedStateGetter(getterFactory: () => AuthenticatedStateGetter): Provider;
+declare function provideCoreAuthGuardConfig(config: CoreAuthGuardConfig): Provider;
+
+declare abstract class BaseListComponent<T extends BaseListEntity, S extends BaseCrudService<T>> implements OnInit {
+    protected service: S;
+    protected cd: ChangeDetectorRef;
+    protected readonly isLoading: Signal<boolean>;
+    paginationResponse: WritableSignal<PaginationResponse<T>>;
+    private readonly pageRequestRevision;
+    private pageRequestValue;
+    get pageRequestDTO(): PageRequestDTO;
+    set pageRequestDTO(value: PageRequestDTO);
+    checkedAll: boolean;
+    indeterminate: boolean;
+    protected readonly rows: Signal<T[]>;
+    protected readonly pagedRows: Signal<T[]>;
+    protected readonly totalItems: Signal<number>;
+    protected readonly currentPage: Signal<number>;
+    protected readonly pageSize: Signal<number>;
+    protected readonly selectedItems: Signal<T[]>;
+    protected readonly hasSelection: Signal<boolean>;
+    protected constructor(service: S, cd: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    protected abstract fetchList(pageRequestDTO: PageRequestDTO): Promise<PaginationResponse<T>>;
+    loadData(): Promise<void>;
+    trackByPropertyKey(_index: number, item: T, propertyKey: keyof T): unknown;
+    onCheckedChange(checked: boolean, _event?: unknown): void;
+    onRowCheckedChange(item: T, checked: boolean): void;
+    protected getSelectedItem(): T | undefined;
+    protected getSelectedItemOr(item?: T): T | undefined;
+    protected getSelectedIds<TKey extends keyof T>(propertyKey: TKey): Array<NonNullable<T[TKey]>>;
+    protected buildSelectedIds<TKey extends keyof T>(propertyKey: TKey): Signal<Array<NonNullable<T[TKey]>>>;
+    protected buildCountSummary(unit: string, prefix?: string): Signal<string>;
+    protected changePage(page: number): Promise<void>;
+    protected changePageSize(size: number): Promise<void>;
+    protected reloadFirstPage(): Promise<void>;
+    protected updateCheckState(): void;
+    deleteSelected(ids?: number[], _list?: T[], _propertyKey?: string): Promise<void>;
+    protected resetList(pageRequestDTO?: PageRequestDTO): Promise<void>;
+    resetSearch(pageRequestDTO?: PageRequestDTO): Promise<void>;
+    private markPageRequestChanged;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseListComponent<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseListComponent<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class GlobalErrorHandler implements ErrorHandler {
+    private injector;
+    /**
+     * 全局错误处理服务
+     * @param injector
+     */
+    constructor(injector: Injector);
+    /**
+     * 全局错误处理
+     * @param error 错误信息
+     */
+    handleError(error: unknown): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlobalErrorHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GlobalErrorHandler>;
+}
+/**
+ * 提供全局错误处理服务
+ * @returns 全局错误处理服务
+ */
+declare function provideGlobalErrorHandler(): {
+    provide: typeof ErrorHandler;
+    useClass: typeof GlobalErrorHandler;
+};
+
+declare function ThrowException(ErrorType: new (message?: string) => Error, message?: string): (_target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+declare function responseInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;
+
+/**
+ * HTTP请求拦截器
+ * 功能：
+ * 1. 增加加载状态计数
+ * 2. 处理基础URL拼接
+ * 3. 为符合条件的请求添加认证Token
+ */
+
+/**
+ * 请求拦截器函数
+ * @param req - 原始HTTP请求对象
+ * @param next - 下一个请求处理器函数
+ * @returns 处理后的HTTP事件 Observable
+ */
+declare function requestInterceptor(req: HttpRequest<unknown>, next: HttpHandlerFn): Observable<HttpEvent<unknown>>;
+
+/**
+ * @description 路由 outlets 模型，用于路由导航时指定 outlets
+ * @param primary 主路由 outlets
+ * @param appPrompt 应用提示路由 outlets
+ * @author ChenYu
+ * @version 1.0.0
+ */
+declare class Outlets {
+    /**
+     * 主路由 outlets
+     */
+    primary: string[];
+    /**
+     * 应用提示路由 outlets
+     */
+    appPrompt: string[];
+    /**
+     * 路由 outlets 模型
+     * @param primary 主路由 outlets
+     * @param appPrompt 应用提示路由 outlets
+     */
+    constructor(primary: string[], appPrompt: string[]);
+}
+
+interface WorkspaceRefreshable {
+    refreshWorkspaceTab(): void | Promise<void>;
+}
+
+type AppRuntimeHost = 'main' | 'standalone' | (string & {});
+interface AppRuntimeContext {
+    readonly host: AppRuntimeHost;
+    readonly appCode?: string;
+    readonly appName?: string;
+    readonly tenantId?: string;
+    readonly userId?: string;
+    readonly permissions: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+declare const DEFAULT_APP_RUNTIME_CONTEXT: AppRuntimeContext;
+declare const APP_RUNTIME_CONTEXT: InjectionToken<AppRuntimeContext>;
+
+declare function provideRuntimeContext(context: Partial<AppRuntimeContext>): EnvironmentProviders;
+
+declare class RuntimeService {
+    private readonly initialContext;
+    private readonly contextState;
+    readonly context: _angular_core.Signal<AppRuntimeContext>;
+    readonly host: _angular_core.Signal<platform_core_ng.AppRuntimeHost>;
+    readonly appCode: _angular_core.Signal<string>;
+    readonly permissions: _angular_core.Signal<readonly string[]>;
+    readonly permissionSet: _angular_core.Signal<Set<string>>;
+    readonly isMainHost: _angular_core.Signal<boolean>;
+    readonly isStandalone: _angular_core.Signal<boolean>;
+    setContext(context: Partial<AppRuntimeContext>): void;
+    setPermissions(permissions: readonly string[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RuntimeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RuntimeService>;
+}
+
+type PermissionInput = string | readonly string[];
+type OptionalPermissionInput = PermissionInput | null | undefined;
+declare class PermissionService {
+    private readonly runtime;
+    readonly permissions: _angular_core.Signal<readonly string[]>;
+    has(permission: string): boolean;
+    hasPermission(permissions: OptionalPermissionInput): boolean;
+    hasAny(permissions: PermissionInput): boolean;
+    hasAll(permissions: PermissionInput): boolean;
+    setPermissions(permissions: readonly string[]): void;
+    private normalize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PermissionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PermissionService>;
+}
+
+type RequiredPermissions = PermissionInput | null | undefined;
+declare class HasPermissionDirective {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly permissionService;
+    readonly hasPermission: _angular_core.InputSignal<RequiredPermissions>;
+    readonly vHasPermission: _angular_core.InputSignal<RequiredPermissions>;
+    readonly vHasPermissionKebab: _angular_core.InputSignal<RequiredPermissions>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HasPermissionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HasPermissionDirective, "[hasPermission],[vHasPermission],[v-has-permission]", never, { "hasPermission": { "alias": "hasPermission"; "required": false; "isSignal": true; }; "vHasPermission": { "alias": "vHasPermission"; "required": false; "isSignal": true; }; "vHasPermissionKebab": { "alias": "v-has-permission"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 是否正在加载
+ * @author Chen Yu
+ * @version 1.0.0
+ */
+declare const isLoading: _angular_core.Signal<boolean>;
+/**
+ * @description 每个请求开始 -> 计数 +1
+ * @author Chen Yu
+ * @version 1.0.0
+ */
+declare function increaseLoading(): void;
+/**
+ * @description 每个请求结束 -> 计数 -1
+ * @author Chen Yu
+ * @version 1.0.0
+ */
+declare function decreaseLoading(): void;
+
+declare class HttpConfig {
+    baseUrl: string;
+    clientId: string | null;
+    constructor(appBaseApi?: string, clientId?: string | null);
+}
+declare const HTTP_CONFIG: InjectionToken<HttpConfig>;
+/**
+ * 设置请求参数
+ * @param httpConfig
+ */
+declare function provideHttpConfig(httpConfig: HttpConfig): {
+    provide: InjectionToken<HttpConfig>;
+    useValue: {
+        baseUrl: string;
+        clientId: string;
+    };
+};
+type HttpSuccessMessageMethod = 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface HttpSuccessMessageOptions {
+    message?: string;
+    title?: string;
+    enabled?: boolean;
+}
+type HttpSuccessMessageInput = string | false | HttpSuccessMessageOptions;
+interface HttpSuccessMessageConfig {
+    enabled: boolean;
+    methods: readonly HttpSuccessMessageMethod[];
+    messages: Readonly<Record<HttpSuccessMessageMethod, string>>;
+}
+interface HttpSuccessMessageConfigInput {
+    enabled?: boolean;
+    methods?: readonly HttpSuccessMessageMethod[];
+    messages?: Partial<Record<HttpSuccessMessageMethod, string>>;
+}
+declare const HTTP_SUCCESS_MESSAGE: HttpContextToken<HttpSuccessMessageInput>;
+declare function withHttpSuccessMessage(message?: HttpSuccessMessageInput, context?: HttpContext): HttpContext;
+declare function withoutHttpSuccessMessage(context?: HttpContext): HttpContext;
+interface HttpResponseInterceptorConfig {
+    timeoutMs: number;
+    minResponseDelayMs: number;
+    logErrors: boolean;
+    logRequestHeaders: boolean;
+    logRequestBody: boolean;
+    logResponseBody: boolean;
+    redactedValue: string;
+    sensitiveHeaderNames: readonly string[];
+    sensitiveBodyKeys: readonly string[];
+    successMessage: HttpSuccessMessageConfig;
+}
+interface HttpResponseInterceptorConfigInput extends Partial<Omit<HttpResponseInterceptorConfig, 'successMessage'>> {
+    successMessage?: HttpSuccessMessageConfigInput;
+}
+declare const DEFAULT_HTTP_SUCCESS_MESSAGES: Readonly<Record<HttpSuccessMessageMethod, string>>;
+declare const DEFAULT_HTTP_RESPONSE_INTERCEPTOR_CONFIG: HttpResponseInterceptorConfig;
+declare const HTTP_RESPONSE_INTERCEPTOR_CONFIG: InjectionToken<HttpResponseInterceptorConfig>;
+declare function provideHttpResponseInterceptorConfig(config: HttpResponseInterceptorConfigInput): Provider;
+
+/**
+ * HTTP认证Token相关的类型和注入令牌定义
+ * 用于在Angular应用中提供和获取认证Token
+ */
+
+/**
+ * 认证Token获取函数类型
+ * @returns 返回认证Token字符串，或者null（如果没有Token）
+ */
+type HttpAuthTokenGetter = () => string | null;
+/**
+ * HTTP认证Token获取器的注入令牌
+ * 用于在应用中注入Token获取函数
+ */
+declare const HTTP_AUTH_TOKEN_GETTER: InjectionToken<HttpAuthTokenGetter>;
+/**
+ * 提供HTTP认证Token获取器的函数
+ * @param getterFactory - 用于创建Token获取函数的工厂函数
+ * @returns 包含提供者配置的对象
+ */
+declare function provideHttpAuthTokenGetter(getterFactory: () => HttpAuthTokenGetter): {
+    provide: InjectionToken<HttpAuthTokenGetter>;
+    useFactory: () => HttpAuthTokenGetter;
+};
+
+type HttpUnauthorizedHandler = () => void | Promise<void>;
+declare const HTTP_UNAUTHORIZED_HANDLER: InjectionToken<HttpUnauthorizedHandler>;
+declare function provideHttpUnauthorizedHandler(handlerFactory: () => HttpUnauthorizedHandler): {
+    provide: InjectionToken<HttpUnauthorizedHandler>;
+    useFactory: () => HttpUnauthorizedHandler;
+};
+
+/**
+ * 消息服务
+ */
+interface IMessageService {
+    error(message: string, title?: string): unknown;
+    success?(message: string, title?: string): unknown;
+}
+/**
+ * 消息提示key
+ */
+declare const MESSAGE_SERVICE: InjectionToken<IMessageService>;
+/**
+ * 为 platform-core-ng 提供消息服务的适配器。
+ *
+ * 将业务项目中的 MessageService 绑定到库内部使用的 MESSAGE_SERVICE 注入 Token，
+ * 以便在全局错误处理、HTTP 拦截器等场景中复用业务侧的消息提示实现。
+ *
+ * 该方法使用 useExisting，不会创建新的实例，而是复用已注册的 MessageService 单例。
+ *
+ * @param messageService 业务项目中实现了 IMessageService 的 Angular 服务类
+ */
+declare function provideIMessageService(messageService: Type<IMessageService>): {
+    provide: InjectionToken<IMessageService>;
+    useExisting: Type<IMessageService>;
+};
+
+/**
+ * Shell配置相关的类型定义和工具函数
+ * 用于配置应用的整体布局和界面元素
+ */
+
+/**
+ * 品牌配置接口
+ * 用于设置应用的品牌信息
+ */
+interface ShellBrandConfig {
+    /** 品牌标题 */
+    title: string;
+}
+/**
+ * 搜索分类接口
+ * 用于定义搜索功能中的分类选项
+ */
+interface ShellSearchCategory {
+    /** 分类ID */
+    id: string;
+    /** 分类标签 */
+    label: string;
+}
+/**
+ * 搜索结果接口
+ * 用于定义搜索功能中的结果项
+ */
+interface ShellSearchResult {
+    /** 结果标题 */
+    title: string;
+    /** 结果元数据 */
+    meta: string;
+    /** 结果所有者 */
+    owner: string;
+}
+/**
+ * 头部操作按钮配置接口
+ * 用于定义头部的操作按钮
+ */
+interface ShellHeaderActionConfig {
+    /** 按钮标签 */
+    label: string;
+    /** 无障碍标签 */
+    ariaLabel?: string;
+    /** 点击回调函数 */
+    onClick: () => void;
+}
+/**
+ * 头部工具项类型
+ * 定义头部工具栏中项目的类型
+ */
+type ShellHeaderUtilityKind = 'language' | 'theme' | 'notifications' | 'fullscreen' | 'custom';
+/**
+ * 头部语言选项接口
+ * 用于定义语言选择功能中的语言选项
+ */
+interface ShellHeaderLanguageOption {
+    /** 语言代码 */
+    code: string;
+    /** 语言标签 */
+    label: string;
+}
+/**
+ * 头部通知项接口
+ * 用于定义通知功能中的通知项
+ */
+interface ShellHeaderNotificationItem {
+    /** 通知标题 */
+    title: string;
+    /** 通知描述 */
+    description: string;
+    /** 通知时间 */
+    time: string;
+}
+/**
+ * 头部工具项接口
+ * 用于定义头部工具栏中的项目
+ */
+interface ShellHeaderUtilityItem {
+    /** 工具项类型 */
+    kind?: ShellHeaderUtilityKind;
+    /** 图标文本 */
+    iconText: string;
+    /** 图标名称 */
+    iconName?: string;
+    /** 无障碍标签 */
+    ariaLabel: string;
+    /** 徽章文本或数字 */
+    badge?: string | number;
+    /** 点击回调函数 */
+    onClick?: () => void;
+}
+/**
+ * 头部配置接口
+ * 用于配置应用头部的各种功能和元素
+ */
+interface ShellHeaderConfig {
+    /** 触发搜索的标签 */
+    triggerLabel: string;
+    /** 搜索对话框标签 */
+    dialogLabel: string;
+    /** 搜索输入框占位符 */
+    inputPlaceholder: string;
+    /** 关闭按钮标签 */
+    closeLabel: string;
+    /** 搜索分类列表 */
+    categories: ShellSearchCategory[];
+    /** 搜索结果列表 */
+    results: ShellSearchResult[];
+    /** 语言选项列表 */
+    languages?: ShellHeaderLanguageOption[];
+    /** 通知列表 */
+    notifications?: ShellHeaderNotificationItem[];
+    /** 状态文本函数 */
+    statusText?: () => string;
+    /** 个人资料徽章文本函数 */
+    profileBadgeText?: () => string;
+    /** 工具项列表 */
+    utilityItems?: ShellHeaderUtilityItem[];
+    /** 操作按钮配置 */
+    actionButton?: ShellHeaderActionConfig;
+}
+/**
+ * 导航项接口
+ * 用于定义侧边栏中的导航项
+ */
+interface ShellNavItem {
+    /** 路由路径 */
+    route: string;
+    /** 图标CSS类 */
+    iconClass?: string;
+    /** 图标名称 */
+    iconName?: string;
+    /** 导航标签 */
+    label: string;
+}
+/**
+ * 侧边栏配置接口
+ * 用于配置应用侧边栏的各种元素
+ */
+interface ShellSidebarConfig {
+    /** 头像图片源 */
+    avatarSrc?: string;
+    /** 头像替代文本 */
+    avatarAlt?: string;
+    /** 导航项列表 */
+    items: ShellNavItem[];
+    /** 设置按钮无障碍标签 */
+    settingsAriaLabel?: string;
+}
+/**
+ * 头部变体类型
+ * 定义头部的不同样式变体
+ */
+type ShellHeaderVariant = 'standard' | 'minimal' | 'top-nav';
+/**
+ * 底部变体类型
+ * 定义底部的不同样式变体
+ */
+type ShellFooterVariant = 'standard' | 'empty';
+/**
+ * 侧边栏变体类型
+ * 定义侧边栏的不同样式变体
+ */
+type ShellSidebarVariant = 'standard' | 'none';
+/**
+ * 布局模式类型
+ * 定义应用的整体布局模式
+ */
+type ShellLayoutMode = 'sidebar-header' | 'top-nav' | 'workbench';
+/**
+ * 基础Shell配置接口
+ * 包含所有布局模式共用的配置项
+ */
+interface BaseShellConfig {
+    /** 品牌配置 */
+    brand: ShellBrandConfig;
+    /** 头部配置 */
+    header: ShellHeaderConfig;
+    /** 侧边栏配置 */
+    sidebar: ShellSidebarConfig;
+}
+/**
+ * 侧边栏头部布局的部分配置接口
+ * 用于配置侧边栏头部布局模式下的各个部分
+ */
+interface SidebarHeaderPartConfig {
+    /** 头部变体 */
+    header?: 'standard' | 'minimal' | 'top-nav';
+    /** 底部变体 */
+    footer?: 'standard' | 'empty';
+    /** 侧边栏变体 */
+    sidebar?: 'standard' | 'none';
+}
+/**
+ * 顶部导航布局的部分配置接口
+ * 用于配置顶部导航布局模式下的各个部分
+ */
+interface TopNavPartConfig {
+    /** 头部变体 */
+    header?: 'top-nav' | 'minimal' | 'standard';
+    /** 底部变体 */
+    footer?: 'standard' | 'empty';
+    /** 侧边栏变体 */
+    sidebar?: 'none';
+}
+/**
+ * 工作台布局的部分配置接口
+ * 用于配置工作台布局模式下的各个部分
+ */
+interface WorkbenchPartConfig {
+    /** 头部变体 */
+    header?: 'minimal';
+    /** 底部变体 */
+    footer?: 'empty';
+    /** 侧边栏变体 */
+    sidebar?: 'none';
+}
+/**
+ * 侧边栏头部布局的Shell配置接口
+ * 用于配置侧边栏头部布局模式的完整配置
+ */
+interface SidebarHeaderShellConfig extends BaseShellConfig {
+    /** 布局模式 */
+    layoutMode: 'sidebar-header';
+    /** 部分配置 */
+    parts?: SidebarHeaderPartConfig;
+}
+/**
+ * 顶部导航布局的Shell配置接口
+ * 用于配置顶部导航布局模式的完整配置
+ */
+interface TopNavShellConfig extends BaseShellConfig {
+    /** 布局模式 */
+    layoutMode: 'top-nav';
+    /** 部分配置 */
+    parts?: TopNavPartConfig;
+}
+/**
+ * 工作台布局的Shell配置接口
+ * 用于配置工作台布局模式的完整配置
+ */
+interface WorkbenchShellConfig extends BaseShellConfig {
+    /** 布局模式 */
+    layoutMode: 'workbench';
+    /** 部分配置 */
+    parts?: WorkbenchPartConfig;
+}
+/**
+ * Shell配置类型
+ * 包含所有布局模式的配置类型
+ */
+type ShellConfig = SidebarHeaderShellConfig | TopNavShellConfig | WorkbenchShellConfig;
+/**
+ * 解析后的Shell部分配置接口
+ * 用于表示最终应用的布局部分配置
+ */
+interface ResolvedShellPartConfig {
+    /** 头部变体 */
+    header: ShellHeaderVariant;
+    /** 底部变体 */
+    footer: ShellFooterVariant;
+    /** 侧边栏变体 */
+    sidebar: ShellSidebarVariant;
+}
+/**
+ * Shell配置的注入令牌
+ * 用于在应用中注入和访问Shell配置
+ */
+declare const SHELL_CONFIG: InjectionToken<ShellConfig>;
+/**
+ * 提供Shell配置的函数
+ * @param config - Shell配置对象
+ * @returns 包含提供者配置的对象
+ */
+declare function provideShellConfig(config: ShellConfig): Provider;
+/**
+ * 通过工厂函数提供Shell配置的函数
+ * @param factory - 用于创建Shell配置的工厂函数
+ * @returns 包含提供者配置的对象
+ */
+declare function provideShellConfigFactory(factory: () => ShellConfig): Provider;
+/**
+ * 注入Shell配置的函数
+ * @returns Shell配置对象
+ */
+declare function injectShellConfig(): ShellConfig;
+/**
+ * 解析Shell部分配置的函数
+ * 结合默认配置和用户配置，生成最终的部分配置
+ * @param config - Shell配置对象
+ * @returns 解析后的Shell部分配置
+ */
+declare function resolveShellParts(config: ShellConfig): ResolvedShellPartConfig;
+
+/**
+ * Shell布局组件
+ * 用于根据配置的布局模式渲染对应的布局组件
+ */
+declare class ShellLayout {
+    /**
+     * 注入shell配置
+     */
+    private readonly shellConfig;
+    /**
+     * 计算属性：获取布局模式
+     * 如果配置中未指定布局模式，则默认为'sidebar-header'
+     */
+    protected readonly layoutMode: _angular_core.Signal<"top-nav" | "sidebar-header" | "workbench">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShellLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShellLayout, "s-shell-layout", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarHeaderLayout {
+    private readonly shellConfig;
+    protected readonly parts: _angular_core.Signal<platform_core_ng.ResolvedShellPartConfig>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarHeaderLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarHeaderLayout, "p-sidebar-header-layout", never, {}, {}, never, never, true, never>;
+}
+
+declare class TopNavLayout {
+    private readonly shellConfig;
+    protected readonly parts: _angular_core.Signal<platform_core_ng.ResolvedShellPartConfig>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TopNavLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TopNavLayout, "p-top-nav-layout", never, {}, {}, never, never, true, never>;
+}
+
+declare class AppShell {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppShell, "s-shell", never, {}, {}, never, ["[sShellHeader]", "[sShellSidebar]", "[sShellContent]", "[sShellFooter]"], true, never>;
+}
+
+declare class Content {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Content, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Content, "s-content", never, {}, {}, never, never, true, never>;
+}
+
+declare class AppFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppFooter, "p-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface NotificationCenterItem {
+    id?: string;
+    title: string;
+    description?: string;
+    time?: string;
+    unread?: boolean;
+}
+declare class NotificationCenter {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly items: _angular_core.InputSignal<NotificationCenterItem[]>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly showActions: _angular_core.InputSignal<boolean>;
+    readonly showMarkAll: _angular_core.InputSignal<boolean>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<NotificationCenterItem>;
+    readonly clearAll: _angular_core.OutputEmitterRef<void>;
+    readonly markAllAsRead: _angular_core.OutputEmitterRef<void>;
+    protected onSelect(item: NotificationCenterItem): void;
+    protected onMarkAll(): void;
+    protected onClear(): void;
+    protected trackByItem: (_index: number, item: NotificationCenterItem) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationCenter, "s-notification-center", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "showActions": { "alias": "showActions"; "required": false; "isSignal": true; }; "showMarkAll": { "alias": "showMarkAll"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; "clearAll": "clearAll"; "markAllAsRead": "markAllAsRead"; }, never, never, true, never>;
+}
+
+type HeaderNotificationItem = ShellHeaderNotificationItem & NotificationCenterItem;
+declare class AppHeader {
+    private readonly shellConfig;
+    private readonly document;
+    protected readonly brand: platform_core_ng.ShellBrandConfig;
+    protected readonly headerConfig: platform_core_ng.ShellHeaderConfig;
+    protected readonly utilityItems: ShellHeaderUtilityItem[];
+    protected readonly languageOptions: ShellHeaderLanguageOption[];
+    protected readonly notificationItems: _angular_core.WritableSignal<HeaderNotificationItem[]>;
+    protected readonly filteredNotifications: _angular_core.Signal<HeaderNotificationItem[]>;
+    protected readonly unreadNotificationCount: _angular_core.Signal<number>;
+    protected readonly isSearchOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly searchKeyword: _angular_core.WritableSignal<string>;
+    protected readonly activeCategory: _angular_core.WritableSignal<string>;
+    protected readonly openUtilityPanel: _angular_core.WritableSignal<"language" | "notifications">;
+    protected readonly isMobileUtilityMenuOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly currentLanguage: _angular_core.WritableSignal<string>;
+    protected readonly isDarkTheme: _angular_core.WritableSignal<boolean>;
+    protected readonly isFullscreen: _angular_core.WritableSignal<boolean>;
+    protected readonly searchIcon: LucideIconData;
+    protected readonly closeIcon: LucideIconData;
+    protected readonly moreIcon: LucideIconData;
+    protected readonly utilityIcons: Record<string, LucideIconData>;
+    constructor();
+    protected openSearchDialog(): void;
+    protected closeSearchDialog(): void;
+    protected setCategory(categoryId: string): void;
+    protected onSearchInput(event: Event): void;
+    protected onEscape(): void;
+    protected onFullscreenChange(): void;
+    protected runHeaderAction(): void;
+    protected runUtilityAction(item: ShellHeaderUtilityItem): void;
+    protected toggleMobileUtilityMenu(): void;
+    protected runMobileUtilityAction(item: ShellHeaderUtilityItem): void;
+    protected headerStatusText(): string | null;
+    protected profileBadge(value: string): string;
+    protected utilityButtonText(item: ShellHeaderUtilityItem): string;
+    protected utilityButtonIcon(item: ShellHeaderUtilityItem): LucideIconData | null;
+    protected utilityBadge(item: ShellHeaderUtilityItem): string | number | undefined;
+    protected isUtilityPanelOpen(panel: 'language' | 'notifications'): boolean;
+    protected selectLanguage(code: string): void;
+    protected onNotificationSelect(item: NotificationCenterItem): void;
+    protected onNotificationMarkAll(): void;
+    protected onNotificationClear(): void;
+    private toggleUtilityPanel;
+    private toggleTheme;
+    private toggleFullscreen;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppHeader, "p-header", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 侧边栏组件
+ * 实现了导航项的显示、图标管理和首字母获取功能
+ */
+declare class Aside {
+    /**
+     * 侧边栏配置
+     * 从shell配置中获取
+     */
+    protected readonly sidebarConfig: platform_core_ng.ShellSidebarConfig;
+    /**
+     * 设置图标
+     */
+    protected readonly settingsIcon: LucideIconData;
+    /**
+     * 导航图标映射
+     * 用于根据图标名称获取对应的Lucide图标组件
+     */
+    private readonly navIcons;
+    /**
+     * 获取导航项标签的首字母
+     * @param label - 导航项标签
+     * @returns 首字母，若标签为空则返回'?'
+     */
+    protected navInitial(label: string): string;
+    /**
+     * 获取导航项的图标
+     * @param iconName - 图标名称
+     * @returns 对应的Lucide图标组件，若未找到则返回null
+     */
+    protected navIcon(iconName?: string): LucideIconData | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Aside, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Aside, "p-aside", never, {}, {}, never, never, true, never>;
+}
+
+declare class EmptyFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyFooter, "p-empty-footer", never, {}, {}, never, never, true, never>;
+}
+
+declare class MinimalHeader {
+    protected readonly brand: platform_core_ng.ShellBrandConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MinimalHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MinimalHeader, "p-minimal-header", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 顶部导航栏头部组件
+ * 实现了搜索功能、分类选择和键盘事件处理
+ */
+declare class TopNavHeader {
+    /**
+     * 注入shell配置
+     */
+    private readonly shellConfig;
+    /**
+     * 搜索对话框是否打开
+     */
+    protected isSearchOpen: boolean;
+    /**
+     * 搜索关键词
+     */
+    protected searchKeyword: string;
+    /**
+     * 当前激活的分类ID
+     * 默认使用配置中的第一个分类，如果没有则使用'all'
+     */
+    protected activeCategory: string;
+    /**
+     * 品牌配置
+     */
+    protected readonly brand: platform_core_ng.ShellBrandConfig;
+    /**
+     * 头部配置
+     */
+    protected readonly headerConfig: platform_core_ng.ShellHeaderConfig;
+    /**
+     * 导航菜单项
+     */
+    protected readonly navItems: platform_core_ng.ShellNavItem[];
+    /**
+     * 打开搜索对话框
+     */
+    protected openSearchDialog(): void;
+    /**
+     * 关闭搜索对话框
+     */
+    protected closeSearchDialog(): void;
+    /**
+     * 设置激活的分类
+     * @param categoryId - 分类ID
+     */
+    protected setCategory(categoryId: string): void;
+    /**
+     * 处理Escape键事件
+     * 如果搜索对话框打开，则关闭它
+     */
+    protected onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TopNavHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TopNavHeader, "p-top-nav-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class EmptySidebar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptySidebar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptySidebar, "p-empty-sidebar", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 操作菜单项接口
+ * 定义菜单项的属性
+ */
+interface ActionMenuItem {
+    /** 菜单项ID */
+    id: string;
+    /** 菜单项标签文本 */
+    label: string;
+    /** 无障碍标签 */
+    ariaLabel?: string;
+    /** 菜单项色调，默认为'default'，可选'danger'表示危险操作 */
+    tone?: 'default' | 'danger';
+}
+/**
+ * 操作菜单组件
+ * 实现了菜单的显示/隐藏、点击操作、键盘事件处理等功能
+ */
+declare class ActionMenuComponent {
+    /**
+     * 注入宿主元素引用
+     * 用于检测点击事件是否发生在组件外部
+     */
+    private readonly hostElement;
+    /**
+     * 输入属性：菜单项列表
+     * 默认为空数组
+     */
+    readonly items: _angular_core.InputSignal<readonly ActionMenuItem[]>;
+    /**
+     * 输入属性：触发按钮的无障碍标签
+     * 默认为'打开操作菜单'
+     */
+    readonly triggerAriaLabel: _angular_core.InputSignal<string>;
+    /**
+     * 输出事件：当选择菜单项时触发
+     * 传递选中的菜单项ID
+     */
+    readonly actionSelected: _angular_core.OutputEmitterRef<string>;
+    /**
+     * 信号：菜单是否打开
+     * 默认为false（关闭状态）
+     */
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * 监听文档的Escape键事件
+     * 当按下Escape键时关闭菜单
+     */
+    protected onEscape(): void;
+    /**
+     * 监听文档的点击事件
+     * 当点击发生在组件外部时关闭菜单
+     * @param event - 点击事件对象
+     */
+    protected onDocumentClick(event: Event): void;
+    /**
+     * 切换菜单的打开/关闭状态
+     */
+    protected toggleMenu(): void;
+    /**
+     * 处理菜单项选择事件
+     * 关闭菜单并触发actionSelected事件
+     * @param actionId - 选中的菜单项ID
+     */
+    protected onActionSelected(actionId: string): void;
+    /**
+     * 轨道函数，用于ngFor指令
+     * 根据菜单项ID进行跟踪，提高渲染性能
+     * @param _index - 索引（未使用）
+     * @param item - 菜单项对象
+     * @returns 菜单项ID
+     */
+    protected trackByActionId(_index: number, item: ActionMenuItem): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionMenuComponent, "s-action-menu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "triggerAriaLabel": { "alias": "triggerAriaLabel"; "required": false; "isSignal": true; }; }, { "actionSelected": "actionSelected"; }, never, never, true, never>;
+}
+
+/**
+ * 头像形状类型
+ * square: 方形
+ * circle: 圆形
+ */
+type AvatarShape = 'square' | 'circle';
+/**
+ * 头像状态类型
+ * default: 默认状态
+ * disabled: 禁用状态
+ */
+type AvatarStatus = 'default' | 'disabled';
+/**
+ * 头像指示器类型
+ * dot: 点状指示器
+ * count: 数字计数指示器
+ */
+type AvatarIndicatorType = 'dot' | 'count';
+/**
+ * 头像组件
+ * 支持显示图片、文本或默认图标，可配置形状、大小、状态和指示器
+ */
+declare class Avatar {
+    /**
+     * 输入属性：头像图片源
+     * 默认为null，表示不使用图片
+     */
+    readonly src: _angular_core.InputSignal<string>;
+    /**
+     * 输入属性：图片替代文本
+     * 默认为空字符串
+     */
+    readonly alt: _angular_core.InputSignal<string>;
+    /**
+     * 输入属性：头像文本
+     * 当没有图片时显示，默认为空字符串
+     */
+    readonly text: _angular_core.InputSignal<string>;
+    /**
+     * 输入属性：头像形状
+     * 默认为'square'（方形）
+     */
+    readonly shape: _angular_core.InputSignal<AvatarShape>;
+    /**
+     * 输入属性：头像状态
+     * 默认为'default'（默认状态）
+     */
+    readonly status: _angular_core.InputSignal<AvatarStatus>;
+    /**
+     * 输入属性：头像大小
+     * 默认为48px
+     */
+    readonly size: _angular_core.InputSignal<number>;
+    /**
+     * 输入属性：指示器值
+     * 可以是数字或null，null表示不显示指示器
+     */
+    readonly indicator: _angular_core.InputSignal<number>;
+    /**
+     * 输入属性：指示器类型
+     * 默认为'count'（数字计数）
+     */
+    readonly indicatorType: _angular_core.InputSignal<AvatarIndicatorType>;
+    readonly imageError: _angular_core.OutputEmitterRef<string>;
+    /**
+     * 用户图标组件
+     * 当没有图片且没有文本时显示
+     */
+    protected readonly userIcon: lucide_angular.LucideIconData;
+    /**
+     * 记录加载失败的图片地址，避免同一个失败地址反复触发请求
+     */
+    private readonly failedImageSrc;
+    /**
+     * 计算属性：显示文本
+     * 取text的前两个字符，去除首尾空格
+     */
+    protected readonly displayText: _angular_core.Signal<string>;
+    /**
+     * 计算属性：当前可显示的图片地址
+     */
+    protected readonly displayImageSrc: _angular_core.Signal<string>;
+    /**
+     * 图片加载错误处理函数
+     * 当图片加载失败时记录失败地址并通知外层组件
+     */
+    protected onImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Avatar, "s-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "indicatorType": { "alias": "indicatorType"; "required": false; "isSignal": true; }; }, { "imageError": "imageError"; }, never, never, true, never>;
+}
+
+/**
+ * 头像组项接口
+ * 定义头像组中每个头像的属性
+ */
+interface AvatarGroupItem {
+    /** 头像项ID */
+    id: string;
+    /** 头像图片源 */
+    src?: string | null;
+    /** 图片替代文本 */
+    alt?: string;
+    /** 头像文本 */
+    text?: string;
+    /** 头像形状 */
+    shape?: AvatarShape;
+    /** 头像状态 */
+    status?: AvatarStatus;
+    /** 指示器值 */
+    indicator?: number | null;
+    /** 指示器类型 */
+    indicatorType?: AvatarIndicatorType;
+}
+/**
+ * 头像组组件
+ * 显示多个头像，支持限制最大显示数量，并显示隐藏的头像数量
+ */
+declare class AvatarGroup {
+    /**
+     * 输入属性：头像项列表
+     * 默认为空数组
+     */
+    readonly items: _angular_core.InputSignal<readonly AvatarGroupItem[]>;
+    /**
+     * 输入属性：头像大小
+     * 默认为48px
+     */
+    readonly size: _angular_core.InputSignal<number>;
+    /**
+     * 输入属性：最大显示数量
+     * 默认为4个
+     */
+    readonly max: _angular_core.InputSignal<number>;
+    /**
+     * 计算属性：可见的头像项
+     * 取items的前max个项
+     */
+    protected readonly visibleItems: _angular_core.Signal<AvatarGroupItem[]>;
+    /**
+     * 计算属性：隐藏的头像数量
+     * 计算items长度与max的差值，确保结果不小于0
+     */
+    protected readonly hiddenCount: _angular_core.Signal<number>;
+    /**
+     * 轨道函数，用于ngFor指令
+     * 根据头像项ID进行跟踪，提高渲染性能
+     * @param _index - 索引（未使用）
+     * @param item - 头像项对象
+     * @returns 头像项ID
+     */
+    protected trackById(_index: number, item: AvatarGroupItem): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroup, "s-avatar-group", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 徽章值类型
+ * 支持数字、字符串或null
+ */
+type BadgeValue = number | string | null;
+/**
+ * 徽章组件
+ * 支持显示数字、字符串、点状指示器，可配置位置偏移和溢出处理
+ */
+declare class Badge {
+    /**
+     * 输入属性：徽章显示的值
+     * 支持数字、字符串或null
+     * 默认为null
+     */
+    readonly count: _angular_core.InputSignal<BadgeValue>;
+    /**
+     * 输入属性：是否以点状显示
+     * 默认为false
+     */
+    readonly dot: _angular_core.InputSignal<boolean>;
+    /**
+     * 输入属性：是否独立显示
+     * 默认为false
+     */
+    readonly standalone: _angular_core.InputSignal<boolean>;
+    /**
+     * 输入属性：是否显示值为0的徽章
+     * 默认为false
+     */
+    readonly showZero: _angular_core.InputSignal<boolean>;
+    /**
+     * 输入属性：溢出计数阈值
+     * 当值超过此阈值时显示为"N+"
+     * 默认为99
+     */
+    readonly overflowCount: _angular_core.InputSignal<number>;
+    /**
+     * 输入属性：X轴位置偏移
+     * 默认为0
+     */
+    readonly offsetX: _angular_core.InputSignal<number>;
+    /**
+     * 输入属性：Y轴位置偏移
+     * 默认为0
+     */
+    readonly offsetY: _angular_core.InputSignal<number>;
+    /**
+     * 计算属性：徽章是否隐藏
+     * 逻辑：
+     * 1. 点状模式始终显示
+     * 2. 值为null或空字符串时隐藏
+     * 3. 值为0且showZero为false时隐藏
+     * 4. 其他情况显示
+     */
+    protected readonly isHidden: _angular_core.Signal<boolean>;
+    /**
+     * 计算属性：徽章显示的值
+     * 逻辑：
+     * 1. 值为null时显示为空
+     * 2. 数字值超过溢出阈值时显示为"N+"
+     * 3. 其他情况直接显示值
+     */
+    protected readonly displayValue: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "s-badge", never, { "count": { "alias": "count"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "standalone": { "alias": "standalone"; "required": false; "isSignal": true; }; "showZero": { "alias": "showZero"; "required": false; "isSignal": true; }; "overflowCount": { "alias": "overflowCount"; "required": false; "isSignal": true; }; "offsetX": { "alias": "offsetX"; "required": false; "isSignal": true; }; "offsetY": { "alias": "offsetY"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type MTabItemTone = 'default' | 'primary';
+interface MTabItem {
+    id: string | number;
+    label: string;
+    icon?: LucideIconData;
+    disabled?: boolean;
+    route?: string | null;
+    tone?: MTabItemTone;
+}
+declare class MTabs {
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly items: _angular_core.InputSignal<readonly MTabItem[]>;
+    readonly selectedItemId: _angular_core.InputSignal<string | number>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<MTabItem>;
+    protected onSelect(item: MTabItem): void;
+    protected trackByItemId(_index: number, item: MTabItem): string | number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MTabs, "m-tabs", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+type BottomNavItem = MTabItem;
+declare class BottomNav {
+    private readonly router;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly items: _angular_core.InputSignal<readonly MTabItem[]>;
+    readonly selectedItemId: _angular_core.InputSignal<string | number>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<MTabItem>;
+    protected onSelect(item: BottomNavItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BottomNav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BottomNav, "m-bottom-nav", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+interface BreadcrumbOption {
+    id: string;
+    label: string;
+}
+interface BreadcrumbItem {
+    id: string;
+    label: string;
+    icon?: LucideIconData;
+    active?: boolean;
+    url?: string;
+    disabled?: boolean;
+    options?: readonly BreadcrumbOption[];
+}
+interface BreadcrumbSelectEvent {
+    item: BreadcrumbItem;
+    option?: BreadcrumbOption;
+}
+type BreadcrumbSeparator = 'chevron' | 'slash' | 'dot' | 'arrow';
+type BreadcrumbRenderItem = BreadcrumbItem & {
+    template?: TemplateRef<unknown>;
+};
+type BreadcrumbRenderEntry = {
+    type: 'item';
+    item: BreadcrumbRenderItem;
+    originalIndex: number;
+} | {
+    type: 'ellipsis';
+    id: string;
+    items: readonly BreadcrumbRenderItem[];
+};
+declare class BreadcrumbItemComponent {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<LucideIconData>;
+    readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly url: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly options: _angular_core.InputSignal<readonly BreadcrumbOption[]>;
+    readonly template: _angular_core.Signal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbItemComponent, "s-breadcrumb-item", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class Breadcrumb implements AfterViewInit {
+    private readonly hostElement;
+    private readonly destroyRef;
+    private readonly ngRouter;
+    readonly items: _angular_core.InputSignal<readonly BreadcrumbItem[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly separator: _angular_core.InputSignal<BreadcrumbSeparator>;
+    readonly separatorTemplate: _angular_core.InputSignal<TemplateRef<unknown>>;
+    readonly collapse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly maxItems: _angular_core.InputSignal<number | "auto">;
+    readonly router: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<BreadcrumbSelectEvent>;
+    protected readonly projectedItems: _angular_core.Signal<readonly BreadcrumbItemComponent[]>;
+    protected readonly openMenuItemId: _angular_core.WritableSignal<string>;
+    protected readonly containerWidth: _angular_core.WritableSignal<number>;
+    protected readonly resolvedItems: _angular_core.Signal<readonly BreadcrumbRenderItem[]>;
+    protected readonly visibleEntries: _angular_core.Signal<readonly BreadcrumbRenderEntry[]>;
+    protected readonly hasItems: _angular_core.Signal<boolean>;
+    ngAfterViewInit(): void;
+    protected isLast(index: number): boolean;
+    protected isCurrent(item: BreadcrumbItem, index: number): boolean;
+    protected isMenuOpen(itemId: string): boolean;
+    protected hasOptions(item: BreadcrumbItem): boolean;
+    protected onItemClick(item: BreadcrumbItem, index: number, event: Event): void;
+    protected onOverflowClick(event: Event): void;
+    protected onOverflowItemClick(item: BreadcrumbItem, event: Event): void;
+    protected onOptionClick(item: BreadcrumbItem, option: BreadcrumbOption, event: Event): void;
+    protected onDocumentClick(event: Event): void;
+    protected closeMenu(): void;
+    protected trackByEntryId(index: number, entry: BreadcrumbRenderEntry): string;
+    protected trackByOptionId(_index: number, option: BreadcrumbOption): string;
+    private visibleItemLimit;
+    private routerItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Breadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Breadcrumb, "s-breadcrumb", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "separatorTemplate": { "alias": "separatorTemplate"; "required": false; "isSignal": true; }; "collapse": { "alias": "collapse"; "required": false; "isSignal": true; }; "maxItems": { "alias": "maxItems"; "required": false; "isSignal": true; }; "router": { "alias": "router"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, ["projectedItems"], never, true, never>;
+}
+
+declare class BsBaseList {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsBaseList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsBaseList, "s-base-list", never, {}, {}, never, ["[list-actions]", "[list-table]", "[list-pagination]"], true, never>;
+}
+
+type BsMessageType = 'info' | 'success' | 'warning' | 'error' | 'help' | 'loading';
+type BsMessageVariant = 'soft' | 'solid';
+type BsMessageActionTone = 'default' | 'primary';
+interface BsMessageAction {
+    id: string;
+    label: string;
+    tone?: BsMessageActionTone;
+    handler?: () => void;
+}
+interface BsMessageOptions {
+    duration?: number;
+    closable?: boolean;
+    title?: string;
+    description?: string;
+    detailText?: string;
+    onDetail?: () => void;
+    actions?: readonly BsMessageAction[];
+    variant?: BsMessageVariant;
+    showIcon?: boolean;
+    viewContainerRef?: ViewContainerRef;
+}
+interface BsMessageItem {
+    id: string;
+    type: BsMessageType;
+    title: string;
+    description?: string;
+    detailText?: string;
+    closable: boolean;
+    createdAt: number;
+    duration: number;
+    actions: readonly BsMessageAction[];
+    variant: BsMessageVariant;
+    showIcon: boolean;
+    repeatCount: number;
+    onDetail?: () => void;
+}
+declare class BsMessageService {
+    private readonly injector;
+    private readonly zone;
+    private readonly document;
+    private readonly overlayHost;
+    private attachedRef;
+    private containerRef;
+    private readonly items;
+    private readonly timers;
+    __unsafe_items(): BsMessageItem[];
+    constructor();
+    private exposeGlobalApiOnce;
+    private ensureContainer;
+    private syncContainer;
+    private handleDetail;
+    private handleAction;
+    private isSameMessage;
+    private scheduleRemoval;
+    private clearTimer;
+    show(type: BsMessageType, content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    info(content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    success(content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    warning(content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    error(content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    help(content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    loading(content: string, options?: BsMessageOptions): {
+        id: string;
+        close: () => void;
+    };
+    remove(id: string): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsMessageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BsMessageService>;
+}
+
+/**
+ * 消息组件
+ * 作为消息容器的包装器，提供兼容模式支持
+ */
+declare class BsMessage {
+    /**
+     * 注入消息服务
+     * 用于获取消息列表和处理消息操作
+     */
+    private readonly message;
+    /**
+     * 计算属性：消息项列表
+     * 兼容模式：如果业务仍手动放了 <s-message>，这里也能显示
+     * 通过消息服务的__unsafe_items()方法获取消息列表
+     */
+    readonly items: _angular_core.Signal<BsMessageItem[]>;
+    /**
+     * 关闭消息
+     * @param id - 消息ID
+     */
+    close(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsMessage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsMessage, "s-message", never, {}, {}, never, never, true, never>;
+}
+
+interface BsSelectOption<T = unknown> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+    placeholder?: boolean;
+}
+declare class BsSelect implements ControlValueAccessor {
+    protected readonly listBox: _angular_core.Signal<Listbox<unknown>>;
+    protected readonly optionRefs: _angular_core.Signal<readonly Option<unknown>[]>;
+    protected readonly combobox: _angular_core.Signal<Combobox<unknown>>;
+    protected readonly plusIcon: lucide_angular.LucideIconData;
+    protected readonly closeIcon: lucide_angular.LucideIconData;
+    readonly labels: _angular_core.InputSignal<string[]>;
+    readonly options: _angular_core.InputSignal<BsSelectOption<unknown>[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly matchTriggerWidth: _angular_core.InputSignal<boolean>;
+    protected readonly displayValue: _angular_core.Signal<string>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected readonly normalizedOptions: _angular_core.Signal<BsSelectOption<unknown>[]>;
+    private readonly selectedOption;
+    protected readonly selectedOptions: _angular_core.Signal<BsSelectOption<unknown>[]>;
+    protected readonly visibleSelectedOptions: _angular_core.Signal<BsSelectOption<unknown>[]>;
+    protected readonly hiddenSelectedCount: _angular_core.Signal<number>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly selectedValues: _angular_core.WritableSignal<unknown[]>;
+    private readonly disabledFromCva;
+    private onChange;
+    private onTouched;
+    constructor();
+    protected onListboxValueChange(values: unknown[]): void;
+    protected onOptionClick(option: BsSelectOption<unknown>): void;
+    protected openCombobox(event: Event): void;
+    protected removeSelectedValue(value: unknown, event: Event): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private scheduleClose;
+    private isEmptyValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsSelect, "s-select", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface CardMenuItem {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface CardIconAction {
+    id: string;
+    icon: LucideIconData;
+    ariaLabel: string;
+    disabled?: boolean;
+}
+interface CardActionEvent {
+    id: string;
+}
+declare class Card {
+    private readonly hostElement;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly content: _angular_core.InputSignal<string>;
+    readonly hoverable: _angular_core.InputSignal<boolean>;
+    readonly actionText: _angular_core.InputSignal<string>;
+    readonly actionTextAriaLabel: _angular_core.InputSignal<string>;
+    readonly menuItems: _angular_core.InputSignal<readonly CardMenuItem[]>;
+    readonly iconActions: _angular_core.InputSignal<readonly CardIconAction[]>;
+    readonly actionTriggered: _angular_core.OutputEmitterRef<CardActionEvent>;
+    readonly menuItemSelected: _angular_core.OutputEmitterRef<CardActionEvent>;
+    readonly iconActionSelected: _angular_core.OutputEmitterRef<CardActionEvent>;
+    protected readonly moreIcon: LucideIconData;
+    protected readonly hasMenu: _angular_core.Signal<boolean>;
+    protected readonly hasIconActions: _angular_core.Signal<boolean>;
+    protected readonly hasHeaderActions: _angular_core.Signal<boolean>;
+    protected readonly hasHeader: _angular_core.Signal<boolean>;
+    protected readonly isMenuOpen: _angular_core.WritableSignal<boolean>;
+    protected onActionTextClick(): void;
+    protected onMenuTriggerClick(event: Event): void;
+    protected onMenuItemClick(item: CardMenuItem): void;
+    protected onIconActionClick(action: CardIconAction): void;
+    protected closeMenu(): void;
+    protected onDocumentClick(event: Event): void;
+    protected trackByMenuId(_index: number, item: CardMenuItem): string;
+    protected trackByActionId(_index: number, action: CardIconAction): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Card, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Card, "s-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "actionText": { "alias": "actionText"; "required": false; "isSignal": true; }; "actionTextAriaLabel": { "alias": "actionTextAriaLabel"; "required": false; "isSignal": true; }; "menuItems": { "alias": "menuItems"; "required": false; "isSignal": true; }; "iconActions": { "alias": "iconActions"; "required": false; "isSignal": true; }; }, { "actionTriggered": "actionTriggered"; "menuItemSelected": "menuItemSelected"; "iconActionSelected": "iconActionSelected"; }, never, ["[cardCover]", "[cardHeaderStart]", "[cardHeaderEnd]", "[cardSubheader]", "[cardBody]", "*", "[cardAside]", "[cardFooter]"], true, never>;
+}
+
+interface CalendarCell {
+    date: Date;
+    label: number;
+    iso: string;
+    inCurrentMonth: boolean;
+    isToday: boolean;
+    isDisabled: boolean;
+}
+interface CalendarRow {
+    id: string;
+    cells: CalendarCell[];
+}
+interface MonthCell {
+    month: number;
+    label: string;
+    date: Date;
+}
+interface QuarterCell {
+    quarter: 1 | 2 | 3 | 4;
+    label: string;
+    date: Date;
+}
+interface DatePickerPanelPosition {
+    readonly top: number;
+    readonly left: number;
+}
+interface DateRangeValue {
+    start: Date | null;
+    end: Date | null;
+}
+type DatePickerMode = 'date' | 'week' | 'month' | 'quarter' | 'range';
+declare class DatePicker {
+    private readonly hostElement;
+    readonly value: _angular_core.ModelSignal<Date>;
+    readonly rangeValue: _angular_core.ModelSignal<DateRangeValue>;
+    readonly mode: _angular_core.InputSignal<DatePickerMode>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly rangeSeparator: _angular_core.InputSignal<string>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly minDate: _angular_core.InputSignal<Date>;
+    readonly maxDate: _angular_core.InputSignal<Date>;
+    readonly confirmText: _angular_core.InputSignal<string>;
+    readonly cancelText: _angular_core.InputSignal<string>;
+    readonly todayText: _angular_core.InputSignal<string>;
+    readonly thisYearText: _angular_core.InputSignal<string>;
+    readonly startPlaceholder: _angular_core.InputSignal<string>;
+    readonly endPlaceholder: _angular_core.InputSignal<string>;
+    readonly iconSize: _angular_core.InputSignal<number>;
+    readonly weekDayLabels: _angular_core.InputSignal<readonly string[]>;
+    protected readonly calendarIcon: lucide_angular.LucideIconData;
+    protected readonly prevIcon: lucide_angular.LucideIconData;
+    protected readonly nextIcon: lucide_angular.LucideIconData;
+    protected readonly clearIcon: lucide_angular.LucideIconData;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly panelPosition: _angular_core.WritableSignal<DatePickerPanelPosition>;
+    protected readonly hasSelection: _angular_core.Signal<boolean>;
+    protected readonly shouldShowClear: _angular_core.Signal<boolean>;
+    private readonly today;
+    private readonly pendingDate;
+    private readonly pendingRange;
+    private readonly rangeHoverDate;
+    private readonly rangeSelectingPart;
+    private readonly viewDate;
+    protected readonly displayValue: _angular_core.Signal<string>;
+    protected readonly title: _angular_core.Signal<string>;
+    protected readonly cells: _angular_core.Signal<{
+        date: Date;
+        label: number;
+        iso: string;
+        inCurrentMonth: boolean;
+        isToday: boolean;
+        isDisabled: boolean;
+    }[]>;
+    protected readonly rows: _angular_core.Signal<CalendarRow[]>;
+    protected readonly monthCells: _angular_core.Signal<MonthCell[]>;
+    protected readonly quarterCells: _angular_core.Signal<QuarterCell[]>;
+    protected toggle(): void;
+    protected clearSelection(event: Event): void;
+    protected selectDate(date: Date): void;
+    protected selectWeek(row: CalendarRow): void;
+    protected selectMonth(cell: MonthCell): void;
+    protected selectQuarter(cell: QuarterCell): void;
+    protected selectToday(): void;
+    protected selectThisYear(): void;
+    protected confirm(): void;
+    protected cancel(): void;
+    protected prev(): void;
+    protected next(): void;
+    protected isSelected(cell: CalendarCell): boolean;
+    protected isWeekSelected(row: CalendarRow): boolean;
+    protected isWeekAnchor(cell: CalendarCell): boolean;
+    protected isTodayCell(cell: CalendarCell): boolean;
+    protected isMonthSelected(cell: MonthCell): boolean;
+    protected isQuarterSelected(cell: QuarterCell): boolean;
+    protected isRangeStart(cell: CalendarCell): boolean;
+    protected isRangeEnd(cell: CalendarCell): boolean;
+    protected isRangeInBetween(cell: CalendarCell): boolean;
+    protected hasRangePreviewEnd(): boolean;
+    protected trackByIso(_index: number, cell: CalendarCell): string;
+    protected trackByRow(_index: number, row: CalendarRow): string;
+    protected onCellHover(date: Date | null): void;
+    protected onDocumentClick(event: Event): void;
+    protected onDocumentKeydown(event: KeyboardEvent): void;
+    protected onWindowResize(): void;
+    private selectRangeDate;
+    private getRangePreview;
+    private isDateDisabled;
+    private syncPendingStateFromValue;
+    private getInitialViewDate;
+    private closePanel;
+    private updatePanelPosition;
+    private toCssPixelValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePicker, "s-date-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "rangeValue": { "alias": "rangeValue"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rangeSeparator": { "alias": "rangeSeparator"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "todayText": { "alias": "todayText"; "required": false; "isSignal": true; }; "thisYearText": { "alias": "thisYearText"; "required": false; "isSignal": true; }; "startPlaceholder": { "alias": "startPlaceholder"; "required": false; "isSignal": true; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "weekDayLabels": { "alias": "weekDayLabels"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "rangeValue": "rangeValueChange"; }, never, never, true, never>;
+}
+
+type PlatformDrawerSectionLayout = 'grid' | 'plain';
+type PlatformDrawerFieldVariant = 'default' | 'switch';
+declare class PlatformDrawerForm {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerForm, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerForm, "platform-drawer-form", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerSection {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly layout: _angular_core.InputSignal<PlatformDrawerSectionLayout>;
+    readonly muted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerSection, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerSection, "platform-drawer-section", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "muted": { "alias": "muted"; "required": false; "isSignal": true; }; }, {}, never, ["[platformDrawerSectionAction]", "*"], true, never>;
+}
+declare class PlatformDrawerField {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly full: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly variant: _angular_core.InputSignal<PlatformDrawerFieldVariant>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerField, "platform-drawer-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "full": { "alias": "full"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerFooter, "platform-drawer-footer", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerError {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerError, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerError, "platform-drawer-error", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformPrefixedInput {
+    readonly prefix: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformPrefixedInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformPrefixedInput, "platform-prefixed-input", never, { "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerCheckboxGroup {
+    readonly panel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerCheckboxGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerCheckboxGroup, "platform-drawer-checkbox-group", never, { "panel": { "alias": "panel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerCheckbox {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerCheckbox, "platform-drawer-checkbox", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerEmpty, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerEmpty, "platform-drawer-empty", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerTable {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerTable, "platform-drawer-table", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerInputAction {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerInputAction, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerInputAction, "platform-drawer-input-action", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerInputActionButton {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerInputActionButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PlatformDrawerInputActionButton, "button[platformDrawerInputActionButton]", never, {}, {}, never, never, true, never>;
+}
+declare class PlatformDrawerToolbar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerToolbar, "platform-drawer-toolbar", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerTree {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerTree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerTree, "platform-drawer-tree", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerTreeItem {
+    readonly level: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerTreeItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerTreeItem, "platform-drawer-tree-item", never, { "level": { "alias": "level"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerTreeToggle {
+    readonly hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerTreeToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PlatformDrawerTreeToggle, "button[platformDrawerTreeToggle]", never, { "hidden": { "alias": "platformDrawerTreeToggleHidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class PlatformDrawerComponentBar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerComponentBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerComponentBar, "platform-drawer-component-bar", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerComponentList {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerComponentList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerComponentList, "platform-drawer-component-list", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformDrawerComponentItem {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerComponentItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformDrawerComponentItem, "platform-drawer-component-item", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PlatformSwitch implements ControlValueAccessor {
+    private readonly changeDetectorRef;
+    private onChange;
+    private onTouched;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected checked: boolean;
+    protected disabled: boolean;
+    protected get isDisabled(): boolean;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected handleChange(checked: boolean): void;
+    protected handleInputChange(event: Event): void;
+    protected handleTouched(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformSwitch, "platform-switch", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PlatformDrawerFormModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformDrawerFormModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<PlatformDrawerFormModule, never, [typeof PlatformDrawerForm, typeof PlatformDrawerSection, typeof PlatformDrawerField, typeof PlatformDrawerFooter, typeof PlatformDrawerError, typeof PlatformPrefixedInput, typeof PlatformDrawerCheckboxGroup, typeof PlatformDrawerCheckbox, typeof PlatformDrawerEmpty, typeof PlatformDrawerTable, typeof PlatformDrawerInputAction, typeof PlatformDrawerInputActionButton, typeof PlatformDrawerToolbar, typeof PlatformDrawerTree, typeof PlatformDrawerTreeItem, typeof PlatformDrawerTreeToggle, typeof PlatformDrawerComponentBar, typeof PlatformDrawerComponentList, typeof PlatformDrawerComponentItem, typeof PlatformSwitch], [typeof PlatformDrawerForm, typeof PlatformDrawerSection, typeof PlatformDrawerField, typeof PlatformDrawerFooter, typeof PlatformDrawerError, typeof PlatformPrefixedInput, typeof PlatformDrawerCheckboxGroup, typeof PlatformDrawerCheckbox, typeof PlatformDrawerEmpty, typeof PlatformDrawerTable, typeof PlatformDrawerInputAction, typeof PlatformDrawerInputActionButton, typeof PlatformDrawerToolbar, typeof PlatformDrawerTree, typeof PlatformDrawerTreeItem, typeof PlatformDrawerTreeToggle, typeof PlatformDrawerComponentBar, typeof PlatformDrawerComponentList, typeof PlatformDrawerComponentItem, typeof PlatformSwitch]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<PlatformDrawerFormModule>;
+}
+
+interface EmojiPickerOption {
+    readonly label: string;
+    readonly value: string;
+    readonly group?: string;
+}
+interface EmojiPickerTab {
+    readonly label: string;
+    readonly value: string;
+    readonly icon: string;
+}
+declare const DEFAULT_EMOJI_PICKER_OPTIONS: readonly EmojiPickerOption[];
+declare const DEFAULT_EMOJI_PICKER_TABS: readonly EmojiPickerTab[];
+declare class EmojiPicker {
+    readonly panelId: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly headerLabel: _angular_core.InputSignal<string>;
+    readonly gridLabel: _angular_core.InputSignal<string>;
+    readonly tabsLabel: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<readonly EmojiPickerOption[]>;
+    readonly tabs: _angular_core.InputSignal<readonly EmojiPickerTab[]>;
+    readonly emojiSelected: _angular_core.OutputEmitterRef<string>;
+    readonly tabSelected: _angular_core.OutputEmitterRef<string>;
+    protected readonly activeTab: _angular_core.WritableSignal<string>;
+    protected readonly activeOptions: _angular_core.Signal<readonly EmojiPickerOption[]>;
+    protected selectEmoji(value: string): void;
+    protected selectTab(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmojiPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmojiPicker, "s-emoji-picker", never, { "panelId": { "alias": "panelId"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "headerLabel": { "alias": "headerLabel"; "required": false; "isSignal": true; }; "gridLabel": { "alias": "gridLabel"; "required": false; "isSignal": true; }; "tabsLabel": { "alias": "tabsLabel"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; }, { "emojiSelected": "emojiSelected"; "tabSelected": "tabSelected"; }, never, never, true, never>;
+}
+
+interface FilterSummaryChip {
+    id: string | number;
+    label: string;
+    removable?: boolean;
+    ariaLabel?: string;
+}
+declare class FilterSummary {
+    readonly summary: _angular_core.InputSignal<string>;
+    readonly chips: _angular_core.ModelSignal<readonly FilterSummaryChip[]>;
+    readonly chipsAriaLabel: _angular_core.InputSignal<string>;
+    readonly resetLabel: _angular_core.InputSignal<string>;
+    readonly showReset: _angular_core.InputSignal<boolean>;
+    readonly chipRemoved: _angular_core.OutputEmitterRef<FilterSummaryChip>;
+    readonly resetClicked: _angular_core.OutputEmitterRef<void>;
+    protected readonly closeIcon: lucide_angular.LucideIconData;
+    protected readonly hasChips: _angular_core.Signal<boolean>;
+    protected readonly shouldShowReset: _angular_core.Signal<boolean>;
+    protected removeChip(chip: FilterSummaryChip): void;
+    protected emitReset(): void;
+    protected trackByChipId(_index: number, chip: FilterSummaryChip): string | number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterSummary, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterSummary, "s-filter-summary", never, { "summary": { "alias": "summary"; "required": false; "isSignal": true; }; "chips": { "alias": "chips"; "required": false; "isSignal": true; }; "chipsAriaLabel": { "alias": "chipsAriaLabel"; "required": false; "isSignal": true; }; "resetLabel": { "alias": "resetLabel"; "required": false; "isSignal": true; }; "showReset": { "alias": "showReset"; "required": false; "isSignal": true; }; }, { "chips": "chipsChange"; "chipRemoved": "chipRemoved"; "resetClicked": "resetClicked"; }, never, never, true, never>;
+}
+
+interface FileUploadButtonSelectedEvent {
+    files: File[];
+}
+declare class FileUploadButtonComponent {
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly buttonClass: _angular_core.InputSignal<string>;
+    readonly ariaBusy: _angular_core.InputSignal<string | boolean>;
+    readonly filesSelected: _angular_core.OutputEmitterRef<FileUploadButtonSelectedEvent>;
+    protected readonly fileInput: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected openFileDialog(): void;
+    protected onFileChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploadButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploadButtonComponent, "s-file-upload-button", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "buttonClass": { "alias": "buttonClass"; "required": false; "isSignal": true; }; "ariaBusy": { "alias": "ariaBusy"; "required": false; "isSignal": true; }; }, { "filesSelected": "filesSelected"; }, never, ["*"], true, never>;
+}
+
+type HeaderTitleAlign = 'left' | 'center';
+type HeaderSize = 'default' | 'large' | 'conversation';
+type HeaderSurface = 'transparent' | 'white';
+type HeaderInset = 'none' | 'page';
+interface HeaderAction {
+    id: string;
+    label?: string;
+    ariaLabel?: string;
+    icon?: LucideIconData;
+    tone?: 'default' | 'primary';
+    disabled?: boolean;
+}
+interface HeaderActionEvent {
+    id: string;
+}
+declare class Header {
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
+    readonly titleAlign: _angular_core.InputSignal<HeaderTitleAlign>;
+    readonly size: _angular_core.InputSignal<HeaderSize>;
+    readonly surface: _angular_core.InputSignal<HeaderSurface>;
+    readonly inset: _angular_core.InputSignal<HeaderInset>;
+    readonly showBack: _angular_core.InputSignal<boolean>;
+    readonly showDropdown: _angular_core.InputSignal<boolean>;
+    readonly showDescriptionDropdown: _angular_core.InputSignal<boolean>;
+    readonly showStatusBar: _angular_core.InputSignal<boolean>;
+    readonly statusTime: _angular_core.InputSignal<string>;
+    readonly actions: _angular_core.InputSignal<readonly HeaderAction[]>;
+    readonly backClicked: _angular_core.OutputEmitterRef<void>;
+    readonly titleClicked: _angular_core.OutputEmitterRef<void>;
+    readonly actionSelected: _angular_core.OutputEmitterRef<HeaderActionEvent>;
+    protected readonly backIcon: LucideIconData;
+    protected readonly downIcon: LucideIconData;
+    protected readonly signalIcon: LucideIconData;
+    protected readonly wifiIcon: LucideIconData;
+    protected readonly batteryIcon: LucideIconData;
+    protected readonly hasActions: _angular_core.Signal<boolean>;
+    protected readonly hasStart: _angular_core.Signal<boolean>;
+    protected readonly isTitleInteractive: _angular_core.Signal<boolean>;
+    protected readonly titleButtonAriaLabel: _angular_core.Signal<string>;
+    protected onBackClick(): void;
+    protected onTitleClick(): void;
+    protected onTitleKeydown(event: Event): void;
+    protected onActionClick(action: HeaderAction): void;
+    protected trackByActionId(_index: number, action: HeaderAction): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Header, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Header, "m-header", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "titleAlign": { "alias": "titleAlign"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "surface": { "alias": "surface"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "showBack": { "alias": "showBack"; "required": false; "isSignal": true; }; "showDropdown": { "alias": "showDropdown"; "required": false; "isSignal": true; }; "showDescriptionDropdown": { "alias": "showDescriptionDropdown"; "required": false; "isSignal": true; }; "showStatusBar": { "alias": "showStatusBar"; "required": false; "isSignal": true; }; "statusTime": { "alias": "statusTime"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; }, { "backClicked": "backClicked"; "titleClicked": "titleClicked"; "actionSelected": "actionSelected"; }, never, ["[mHeaderStart]", "[header-left]", "[mHeaderTitle]", "[header-title]", "[mHeaderDescription]", "[mHeaderMeta]", "[header-right]", "[mHeaderActions]", "[mHeaderToolbarStart]", "[toolbar-left]", "m-toolbar", "[mHeaderToolbar]", "[mHeaderToolbarCenter]", "[toolbar-center]", "[mHeaderToolbarActions]", "[toolbar-right]"], true, never>;
+}
+
+declare class ListPageSidebarSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageSidebarSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageSidebarSlotDirective, "[SListPageSidebar]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageSidebarComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPageSidebarComponent, "s-list-page-sidebar", never, {}, {}, never, ["*"], true, never>;
+}
+declare class ListPageSidebarSearchDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageSidebarSearchDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageSidebarSearchDirective, "[SListPageSidebarSearch]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageSidebarTreeDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageSidebarTreeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageSidebarTreeDirective, "[SListPageSidebarTree]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageHeaderSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageHeaderSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageHeaderSlotDirective, "[SListPageHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageHeaderComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPageHeaderComponent, "s-list-page-header", never, {}, {}, never, ["*"], true, never>;
+}
+declare class ListPageHeaderRowComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageHeaderRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPageHeaderRowComponent, "s-list-page-header-row", never, {}, {}, never, ["*"], true, never>;
+}
+declare class ListPageHeaderLayoutDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageHeaderLayoutDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageHeaderLayoutDirective, "[SListPageHeaderLayout]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageHeaderFiltersDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageHeaderFiltersDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageHeaderFiltersDirective, "[SListPageHeaderFilters]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageHeaderActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageHeaderActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageHeaderActionsDirective, "[SListPageHeaderActions]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageSummarySlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageSummarySlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageSummarySlotDirective, "[SListPageSummary]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageContentDesktopSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageContentDesktopSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageContentDesktopSlotDirective, "[SListPageContentDesktop]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageFilterPanelComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFilterPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPageFilterPanelComponent, "s-list-page-filter-panel", never, {}, {}, never, ["*"], true, never>;
+}
+declare class ListPageContentDesktopComponent {
+    readonly withTabs: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly minHeight: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageContentDesktopComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPageContentDesktopComponent, "s-list-page-content-desktop", never, { "withTabs": { "alias": "withTabs"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ListPagePaginationSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPagePaginationSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPagePaginationSlotDirective, "[SListPagePagination]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPagePaginationComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPagePaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPagePaginationComponent, "s-list-page-pagination", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ListPageFilterGridDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFilterGridDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageFilterGridDirective, "[SListPageFilterGrid]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageFilterFieldDirective {
+    readonly dateRange: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFilterFieldDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageFilterFieldDirective, "[SListPageFilterField]", never, { "dateRange": { "alias": "SListPageFilterFieldDateRange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ListPageFilterLabelDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFilterLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageFilterLabelDirective, "[SListPageFilterLabel]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageFilterControlDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFilterControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageFilterControlDirective, "[SListPageFilterControl]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageFilterActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFilterActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageFilterActionsDirective, "[SListPageFilterActions]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListPageTableWrapDirective {
+    readonly withTabs: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly minHeight: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTableWrapDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTableWrapDirective, "[SListPageTableWrap]", never, { "withTabs": { "alias": "withTabs"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ListPageTableDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTableDirective, "table[SListPageTable]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageTableScrollDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTableScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTableScrollDirective, "[SListPageTableScroll]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageCheckboxColDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageCheckboxColDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageCheckboxColDirective, "[SListPageCheckboxCol]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageActionColDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageActionColDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageActionColDirective, "[SListPageActionCol]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageColumnDirective {
+    readonly width: _angular_core.InputSignal<string>;
+    readonly align: _angular_core.InputSignal<"center" | "left" | "right">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageColumnDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageColumnDirective, "[SListPageColumn]", never, { "width": { "alias": "SListPageColumn"; "required": false; "isSignal": true; }; "align": { "alias": "SListPageColumnAlign"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ListPageCellTextDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageCellTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageCellTextDirective, "[SListPageCellText]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListPageEmptyDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageEmptyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageEmptyDirective, "[SListPageEmpty]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageTabsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTabsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTabsDirective, "[SListPageTabs]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageTabDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTabDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTabDirective, "[SListPageTab]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageRowActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageRowActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageRowActionsDirective, "[SListPageRowActions]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageRowActionTriggerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageRowActionTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageRowActionTriggerDirective, "[SListPageRowActionTrigger]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageRowActionDangerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageRowActionDangerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageRowActionDangerDirective, "[SListPageRowActionDanger]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageIconButtonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageIconButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageIconButtonDirective, "[SListPageIconButton]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageFileActionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageFileActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageFileActionDirective, "[SListPageFileAction]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageTreeToggleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTreeToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTreeToggleDirective, "[SListPageTreeToggle]", never, {}, {}, never, never, true, never>;
+}
+declare class ListPageTreeIndentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageTreeIndentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ListPageTreeIndentDirective, "[SListPageTreeIndent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ListPageLayoutComponent {
+    protected readonly sidebarSlot: _angular_core.Signal<ListPageSidebarSlotDirective>;
+    protected readonly sidebarComponent: _angular_core.Signal<ListPageSidebarComponent>;
+    protected readonly paginationTemplate: _angular_core.Signal<TemplateRef<any>>;
+    protected readonly paginationComponent: _angular_core.Signal<ListPagePaginationComponent>;
+    protected readonly desktopContentTemplate: _angular_core.Signal<TemplateRef<any>>;
+    protected readonly hasSidebar: _angular_core.Signal<boolean>;
+    protected readonly hasPagination: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListPageLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListPageLayoutComponent, "s-list-page-layout", never, {}, {}, ["sidebarSlot", "sidebarComponent", "paginationTemplate", "paginationComponent", "desktopContentTemplate"], ["[SListPageHeader]", "s-list-page-header", "[SListPageSummary]", "s-filter-summary", "[SListPageSidebar]", "s-list-page-sidebar", "s-list-page-content-desktop", "s-list-page-pagination"], true, never>;
+}
+
+declare class ListSearchPanel {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly triggerText: _angular_core.InputSignal<string>;
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly searchIconClass: _angular_core.InputSignal<string>;
+    readonly keyword: _angular_core.ModelSignal<string>;
+    readonly search: _angular_core.OutputEmitterRef<void>;
+    readonly reset: _angular_core.OutputEmitterRef<void>;
+    protected readonly isMobileSearchOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly searchIcon: lucide_angular.LucideIconData;
+    protected readonly closeIcon: lucide_angular.LucideIconData;
+    private readonly mobileMediaQuery;
+    protected openMobileSearchDialog(): void;
+    protected openMobileSearchDialogOnSmallScreen(event: Event): void;
+    protected closeMobileSearchDialog(): void;
+    protected emitSearch(): void;
+    protected emitReset(): void;
+    private isMobileViewport;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListSearchPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListSearchPanel, "s-list-search-panel", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "triggerText": { "alias": "triggerText"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "searchIconClass": { "alias": "searchIconClass"; "required": false; "isSignal": true; }; "keyword": { "alias": "keyword"; "required": false; "isSignal": true; }; }, { "keyword": "keywordChange"; "search": "search"; "reset": "reset"; }, never, never, true, never>;
+}
+
+interface PlatformLoginFeature {
+    readonly label: string;
+    readonly description?: string;
+    readonly icon?: LucideIconData;
+    readonly toneClass?: string;
+}
+interface PlatformLoginSocialProvider {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: LucideIconData;
+    readonly toneClass?: string;
+    readonly disabled?: boolean;
+}
+interface PlatformLoginSubmitEvent {
+    readonly username: string;
+    readonly password: string;
+    readonly rememberMe: boolean;
+}
+declare class PlatformLoginPage implements OnInit {
+    readonly brandMark: _angular_core.InputSignal<string>;
+    readonly brandName: _angular_core.InputSignal<string>;
+    readonly productName: _angular_core.InputSignal<string>;
+    readonly heroAriaLabel: _angular_core.InputSignal<string>;
+    readonly heroEyebrow: _angular_core.InputSignal<string>;
+    readonly heroTitle: _angular_core.InputSignal<string>;
+    readonly heroText: _angular_core.InputSignal<string>;
+    readonly features: _angular_core.InputSignal<readonly PlatformLoginFeature[]>;
+    readonly showLanguageSwitcher: _angular_core.InputSignal<boolean>;
+    readonly languageLabel: _angular_core.InputSignal<string>;
+    readonly panelEyebrow: _angular_core.InputSignal<string>;
+    readonly panelTitle: _angular_core.InputSignal<string>;
+    readonly panelSubtitle: _angular_core.InputSignal<string>;
+    readonly usernameLabel: _angular_core.InputSignal<string>;
+    readonly passwordLabel: _angular_core.InputSignal<string>;
+    readonly usernamePlaceholder: _angular_core.InputSignal<string>;
+    readonly passwordPlaceholder: _angular_core.InputSignal<string>;
+    readonly rememberLabel: _angular_core.InputSignal<string>;
+    readonly forgotPasswordText: _angular_core.InputSignal<string>;
+    readonly dividerText: _angular_core.InputSignal<string>;
+    readonly registerPrompt: _angular_core.InputSignal<string>;
+    readonly registerText: _angular_core.InputSignal<string>;
+    readonly metaText: _angular_core.InputSignal<string>;
+    readonly submitText: _angular_core.InputSignal<string>;
+    readonly submittingText: _angular_core.InputSignal<string>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    readonly submitting: _angular_core.InputSignal<boolean>;
+    readonly defaultUsername: _angular_core.InputSignal<string>;
+    readonly rememberDefault: _angular_core.InputSignal<boolean>;
+    readonly showForgotPassword: _angular_core.InputSignal<boolean>;
+    readonly showRegister: _angular_core.InputSignal<boolean>;
+    readonly socialProviders: _angular_core.InputSignal<readonly PlatformLoginSocialProvider[]>;
+    readonly loginSubmit: _angular_core.OutputEmitterRef<PlatformLoginSubmitEvent>;
+    readonly forgotPasswordClick: _angular_core.OutputEmitterRef<void>;
+    readonly registerClick: _angular_core.OutputEmitterRef<void>;
+    readonly languageClick: _angular_core.OutputEmitterRef<void>;
+    readonly socialLogin: _angular_core.OutputEmitterRef<PlatformLoginSocialProvider>;
+    protected readonly userIcon: LucideIconData;
+    protected readonly keyIcon: LucideIconData;
+    protected readonly eyeIcon: LucideIconData;
+    protected readonly eyeOffIcon: LucideIconData;
+    protected readonly languagesIcon: LucideIconData;
+    protected readonly chevronDownIcon: LucideIconData;
+    protected readonly username: _angular_core.WritableSignal<string>;
+    protected readonly password: _angular_core.WritableSignal<string>;
+    protected readonly rememberMe: _angular_core.WritableSignal<boolean>;
+    protected readonly showPassword: _angular_core.WritableSignal<boolean>;
+    protected readonly localErrorMessage: _angular_core.WritableSignal<string>;
+    protected readonly visibleErrorMessage: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    protected togglePassword(): void;
+    protected submit(): void;
+    protected emitForgotPassword(): void;
+    protected emitRegister(): void;
+    protected emitLanguageClick(): void;
+    protected emitSocialLogin(provider: PlatformLoginSocialProvider): void;
+    protected featureClass(toneClass: string | undefined): string;
+    protected socialProviderClass(toneClass: string | undefined): string;
+    protected socialProviderInitial(provider: PlatformLoginSocialProvider): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformLoginPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformLoginPage, "s-login-page", never, { "brandMark": { "alias": "brandMark"; "required": false; "isSignal": true; }; "brandName": { "alias": "brandName"; "required": false; "isSignal": true; }; "productName": { "alias": "productName"; "required": false; "isSignal": true; }; "heroAriaLabel": { "alias": "heroAriaLabel"; "required": false; "isSignal": true; }; "heroEyebrow": { "alias": "heroEyebrow"; "required": false; "isSignal": true; }; "heroTitle": { "alias": "heroTitle"; "required": false; "isSignal": true; }; "heroText": { "alias": "heroText"; "required": false; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "showLanguageSwitcher": { "alias": "showLanguageSwitcher"; "required": false; "isSignal": true; }; "languageLabel": { "alias": "languageLabel"; "required": false; "isSignal": true; }; "panelEyebrow": { "alias": "panelEyebrow"; "required": false; "isSignal": true; }; "panelTitle": { "alias": "panelTitle"; "required": false; "isSignal": true; }; "panelSubtitle": { "alias": "panelSubtitle"; "required": false; "isSignal": true; }; "usernameLabel": { "alias": "usernameLabel"; "required": false; "isSignal": true; }; "passwordLabel": { "alias": "passwordLabel"; "required": false; "isSignal": true; }; "usernamePlaceholder": { "alias": "usernamePlaceholder"; "required": false; "isSignal": true; }; "passwordPlaceholder": { "alias": "passwordPlaceholder"; "required": false; "isSignal": true; }; "rememberLabel": { "alias": "rememberLabel"; "required": false; "isSignal": true; }; "forgotPasswordText": { "alias": "forgotPasswordText"; "required": false; "isSignal": true; }; "dividerText": { "alias": "dividerText"; "required": false; "isSignal": true; }; "registerPrompt": { "alias": "registerPrompt"; "required": false; "isSignal": true; }; "registerText": { "alias": "registerText"; "required": false; "isSignal": true; }; "metaText": { "alias": "metaText"; "required": false; "isSignal": true; }; "submitText": { "alias": "submitText"; "required": false; "isSignal": true; }; "submittingText": { "alias": "submittingText"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "submitting": { "alias": "submitting"; "required": false; "isSignal": true; }; "defaultUsername": { "alias": "defaultUsername"; "required": false; "isSignal": true; }; "rememberDefault": { "alias": "rememberDefault"; "required": false; "isSignal": true; }; "showForgotPassword": { "alias": "showForgotPassword"; "required": false; "isSignal": true; }; "showRegister": { "alias": "showRegister"; "required": false; "isSignal": true; }; "socialProviders": { "alias": "socialProviders"; "required": false; "isSignal": true; }; }, { "loginSubmit": "loginSubmit"; "forgotPasswordClick": "forgotPasswordClick"; "registerClick": "registerClick"; "languageClick": "languageClick"; "socialLogin": "socialLogin"; }, never, never, true, never>;
+}
+
+type AppMenuIcon = string | LucideIconData;
+declare class MenuItemComponent {
+    private closeMenu;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly tone: _angular_core.InputSignal<"default" | "danger">;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<AppMenuIcon>;
+    readonly select: _angular_core.OutputEmitterRef<void>;
+    private readonly menuItem;
+    setCloseMenu(closeMenu: (() => void) | null): void;
+    protected isTextIcon(icon: AppMenuIcon): icon is string;
+    protected handleSelect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "s-menu-item", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, ["*"], true, never>;
+}
+declare class MenuComponent {
+    readonly origin: _angular_core.InputSignal<ElementRef<HTMLElement> | CdkOverlayOrigin>;
+    readonly trigger: _angular_core.InputSignal<MenuTrigger<string>>;
+    readonly positions: _angular_core.InputSignal<ConnectedPosition[]>;
+    readonly panelWidth: _angular_core.InputSignal<string>;
+    readonly formatMenu: _angular_core.Signal<Menu<string>>;
+    readonly menuItems: _angular_core.Signal<readonly MenuItemComponent[]>;
+    readonly hasItems: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "s-menu", never, { "origin": { "alias": "origin"; "required": true; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": true; "isSignal": true; }; "positions": { "alias": "positions"; "required": false; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; }, {}, ["menuItems"], ["*"], true, never>;
+}
+
+type MerchantCardChipTone = 'neutral' | 'success' | 'warning' | 'danger' | 'info';
+interface MerchantCardChip {
+    label: string;
+    tone?: MerchantCardChipTone;
+    icon?: LucideIconData;
+}
+declare class MerchantCard {
+    readonly imageUrl: _angular_core.InputSignal<string>;
+    readonly imageAlt: _angular_core.InputSignal<string>;
+    readonly imageBadge: _angular_core.InputSignal<string>;
+    readonly showMoreButton: _angular_core.InputSignal<boolean>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly content: _angular_core.InputSignal<string>;
+    readonly badge: _angular_core.InputSignal<string>;
+    readonly badgeTone: _angular_core.InputSignal<MerchantCardChipTone>;
+    readonly tags: _angular_core.InputSignal<readonly MerchantCardChip[]>;
+    readonly moreAriaLabel: _angular_core.InputSignal<string>;
+    readonly moreClick: _angular_core.OutputEmitterRef<Event>;
+    protected readonly moreIcon: LucideIconData;
+    protected trackByChipLabel(_index: number, chip: MerchantCardChip): string;
+    protected onMoreClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MerchantCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MerchantCard, "s-merchant-card", never, { "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "imageAlt": { "alias": "imageAlt"; "required": false; "isSignal": true; }; "imageBadge": { "alias": "imageBadge"; "required": false; "isSignal": true; }; "showMoreButton": { "alias": "showMoreButton"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "badgeTone": { "alias": "badgeTone"; "required": false; "isSignal": true; }; "tags": { "alias": "tags"; "required": false; "isSignal": true; }; "moreAriaLabel": { "alias": "moreAriaLabel"; "required": false; "isSignal": true; }; }, { "moreClick": "moreClick"; }, never, ["[merchantCardMediaOverlay]", "[merchantCardActions]"], true, never>;
+}
+
+declare const M_ALPHABET_DEFAULT_LETTERS: string[];
+type MAlphabetPlacement = 'inline' | 'edge';
+declare class MAlphabet {
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly letters: _angular_core.InputSignal<readonly string[]>;
+    readonly placement: _angular_core.InputSignal<MAlphabetPlacement>;
+    protected trackByLetter(_index: number, letter: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MAlphabet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MAlphabet, "m-alphabet", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "letters": { "alias": "letters"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type MItemStandardTone = 'amber' | 'blue' | 'cyan' | 'green' | 'mint' | 'orange' | 'purple' | 'rose' | 'sky' | 'slate' | 'warm';
+type MItemAvatarIconShape = 'circle' | 'rounded-square' | 'square';
+declare class MItemProfileAvatarDirective {
+    readonly mItemProfileAvatar: _angular_core.InputSignalWithTransform<MItemStandardTone, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemProfileAvatarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemProfileAvatarDirective, "[mItemProfileAvatar]", never, { "mItemProfileAvatar": { "alias": "mItemProfileAvatar"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MItemProfileTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemProfileTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemProfileTitleDirective, "[mItemProfileTitle]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemProfileNameDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemProfileNameDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemProfileNameDirective, "[mItemProfileName]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemPresenceDirective {
+    readonly mItemPresence: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemPresenceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemPresenceDirective, "[mItemPresence]", never, { "mItemPresence": { "alias": "mItemPresence"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MItemAvatarFrameDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemAvatarFrameDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemAvatarFrameDirective, "[mItemAvatarFrame]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemAvatarPortraitDirective {
+    readonly mItemAvatarPortrait: _angular_core.InputSignalWithTransform<MItemStandardTone, string>;
+    protected readonly resolvedTone: _angular_core.Signal<MItemStandardTone>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemAvatarPortraitDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemAvatarPortraitDirective, "[mItemAvatarPortrait]", never, { "mItemAvatarPortrait": { "alias": "mItemAvatarPortrait"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MItemAvatarGroupDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemAvatarGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemAvatarGroupDirective, "[mItemAvatarGroup]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemAvatarFaceDirective {
+    readonly mItemAvatarFace: _angular_core.InputSignalWithTransform<MItemStandardTone, string>;
+    protected readonly resolvedTone: _angular_core.Signal<MItemStandardTone>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemAvatarFaceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemAvatarFaceDirective, "[mItemAvatarFace]", never, { "mItemAvatarFace": { "alias": "mItemAvatarFace"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MItemAvatarIconDirective {
+    readonly mItemAvatarIcon: _angular_core.InputSignalWithTransform<MItemStandardTone, string>;
+    readonly mItemAvatarIconShape: _angular_core.InputSignalWithTransform<MItemAvatarIconShape, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemAvatarIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemAvatarIconDirective, "[mItemAvatarIcon]", never, { "mItemAvatarIcon": { "alias": "mItemAvatarIcon"; "required": false; "isSignal": true; }; "mItemAvatarIconShape": { "alias": "mItemAvatarIconShape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MItemIndicatorDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemIndicatorDirective, "[mItemIndicator]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemBadgeDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemBadgeDirective, "[mItemBadge]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemUnreadDotDirective {
+    protected readonly unreadLabel = "\u672A\u8BFB";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemUnreadDotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemUnreadDotDirective, "[mItemUnreadDot]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemMarkerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemMarkerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemMarkerDirective, "[mItemMarker]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemMenuIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemMenuIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemMenuIconDirective, "[mItemMenuIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemMenuChevronDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemMenuChevronDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemMenuChevronDirective, "[mItemMenuChevron]", never, {}, {}, never, never, true, never>;
+}
+declare const M_ITEM_APPEARANCE_DIRECTIVES: readonly [typeof MItemProfileAvatarDirective, typeof MItemProfileTitleDirective, typeof MItemProfileNameDirective, typeof MItemPresenceDirective, typeof MItemAvatarFrameDirective, typeof MItemAvatarPortraitDirective, typeof MItemAvatarGroupDirective, typeof MItemAvatarFaceDirective, typeof MItemAvatarIconDirective, typeof MItemIndicatorDirective, typeof MItemBadgeDirective, typeof MItemUnreadDotDirective, typeof MItemMarkerDirective, typeof MItemMenuIconDirective, typeof MItemMenuChevronDirective];
+
+declare class MItemPrefixSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemPrefixSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemPrefixSlot, "ng-template[MItemPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemAvatarSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemAvatarSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemAvatarSlot, "ng-template[MItemAvatar]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemTitleSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemTitleSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemTitleSlot, "ng-template[MItemTitle]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemSummarySlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemSummarySlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemSummarySlot, "ng-template[MItemSummary]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemMetaSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemMetaSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemMetaSlot, "ng-template[MItemMeta]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemFooterSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemFooterSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemFooterSlot, "ng-template[MItemFooter]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemTrailingSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemTrailingSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemTrailingSlot, "ng-template[MItemTrailing]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemStatusSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemStatusSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemStatusSlot, "ng-template[MItemStatus]", never, {}, {}, never, never, true, never>;
+}
+declare class MItemActionsSlot {
+    readonly template: TemplateRef<unknown>;
+    constructor(template: TemplateRef<unknown>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItemActionsSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MItemActionsSlot, "ng-template[MItemActions]", never, {}, {}, never, never, true, never>;
+}
+declare const M_ITEM_SLOT_DIRECTIVES: readonly [typeof MItemPrefixSlot, typeof MItemAvatarSlot, typeof MItemTitleSlot, typeof MItemSummarySlot, typeof MItemMetaSlot, typeof MItemFooterSlot, typeof MItemTrailingSlot, typeof MItemStatusSlot, typeof MItemActionsSlot];
+
+type MListVariant = 'plain' | 'card' | 'isolated' | 'feed' | 'menu' | 'request' | 'profile' | 'shortcut';
+type MListDensity = 'compact' | 'default' | 'comfortable';
+type MListDivider = 'none' | 'inset' | 'full';
+type MItemVariant = 'message' | 'workflow' | 'mail' | 'activity' | 'menu' | 'request' | 'shortcut';
+type MItemLayout = 'one-line' | 'two-line' | 'three-line';
+type MItemStatus = 'none' | 'unread' | 'read' | 'todo' | 'processing' | 'warning';
+
+declare class MItem {
+    readonly variant: _angular_core.InputSignal<MItemVariant>;
+    readonly layout: _angular_core.InputSignal<MItemLayout>;
+    readonly status: _angular_core.InputSignal<MItemStatus>;
+    readonly statusLabel: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly time: _angular_core.InputSignal<string>;
+    readonly content: _angular_core.InputSignal<string>;
+    readonly extra: _angular_core.InputSignal<string>;
+    readonly subtitle: _angular_core.InputSignal<string>;
+    readonly avatarSrc: _angular_core.InputSignal<string>;
+    readonly avatarText: _angular_core.InputSignal<string>;
+    readonly avatarAlt: _angular_core.InputSignal<string>;
+    readonly avatarSize: _angular_core.InputSignalWithTransform<number, string | number>;
+    readonly avatarShape: _angular_core.InputSignal<AvatarShape>;
+    readonly avatarIndicator: _angular_core.InputSignal<number>;
+    readonly avatarIndicatorType: _angular_core.InputSignal<AvatarIndicatorType>;
+    readonly clickable: _angular_core.InputSignal<boolean>;
+    readonly bordered: _angular_core.InputSignal<boolean>;
+    readonly compact: _angular_core.InputSignal<boolean>;
+    readonly showFooter: _angular_core.InputSignal<boolean>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    readonly selected: _angular_core.InputSignal<boolean>;
+    readonly active: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly itemClick: _angular_core.OutputEmitterRef<Event>;
+    protected prefixSlot?: MItemPrefixSlot;
+    protected avatarSlot?: MItemAvatarSlot;
+    protected titleSlot?: MItemTitleSlot;
+    protected summarySlot?: MItemSummarySlot;
+    protected metaSlot?: MItemMetaSlot;
+    protected footerSlot?: MItemFooterSlot;
+    protected trailingSlot?: MItemTrailingSlot;
+    protected statusSlot?: MItemStatusSlot;
+    protected actionsSlot?: MItemActionsSlot;
+    protected onActivate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MItem, "m-item", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "statusLabel": { "alias": "statusLabel"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "time": { "alias": "time"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "extra": { "alias": "extra"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "avatarSrc": { "alias": "avatarSrc"; "required": false; "isSignal": true; }; "avatarText": { "alias": "avatarText"; "required": false; "isSignal": true; }; "avatarAlt": { "alias": "avatarAlt"; "required": false; "isSignal": true; }; "avatarSize": { "alias": "avatarSize"; "required": false; "isSignal": true; }; "avatarShape": { "alias": "avatarShape"; "required": false; "isSignal": true; }; "avatarIndicator": { "alias": "avatarIndicator"; "required": false; "isSignal": true; }; "avatarIndicatorType": { "alias": "avatarIndicatorType"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, ["prefixSlot", "avatarSlot", "titleSlot", "summarySlot", "metaSlot", "footerSlot", "trailingSlot", "statusSlot", "actionsSlot"], ["[m-item-prefix]", "[mItemPrefix]", "[m-item-start]", "[mItemStart]", "[m-item-avatar]", "[mItemAvatar]", "[m-item-title]", "[mItemTitle]", "[m-item-title-text]", "[mItemTitleText]", "[m-item-meta]", "[mItemMeta]", "[m-item-time]", "[mItemTime]", "[m-item-description]", "[mItemDescription]", "[m-item-content]", "[mItemContent]", "[m-item-content-text]", "[mItemContentText]", "[m-item-actions]", "[mItemActions]", "[m-item-end]", "[mItemEnd]", "[m-item-extra]", "[mItemExtra]", "[m-item-extra-text]", "[mItemExtraText]", "[m-item-append]", "[mItemAppend]", "[m-item-footer]", "[mItemFooter]"], true, never>;
+}
+
+declare class MList {
+    private readonly defaultSectionTitleId;
+    readonly variant: _angular_core.InputSignal<MListVariant>;
+    readonly density: _angular_core.InputSignal<MListDensity>;
+    readonly divider: _angular_core.InputSignal<MListDivider>;
+    readonly card: _angular_core.InputSignal<boolean>;
+    readonly compact: _angular_core.InputSignal<boolean>;
+    readonly isolated: _angular_core.InputSignal<boolean>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly empty: _angular_core.InputSignal<boolean>;
+    readonly emptyText: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly sectionTitle: _angular_core.InputSignal<string>;
+    readonly sectionTitleId: _angular_core.InputSignal<string>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    protected readonly resolvedSectionTitleId: _angular_core.Signal<string>;
+    protected readonly isCard: _angular_core.Signal<boolean>;
+    protected readonly isCompact: _angular_core.Signal<boolean>;
+    protected readonly isComfortable: _angular_core.Signal<boolean>;
+    protected readonly isIsolated: _angular_core.Signal<boolean>;
+    protected readonly isFeed: _angular_core.Signal<boolean>;
+    protected readonly isMenu: _angular_core.Signal<boolean>;
+    protected readonly isRequest: _angular_core.Signal<boolean>;
+    protected readonly isProfile: _angular_core.Signal<boolean>;
+    protected readonly isShortcut: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MList, "m-list", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "card": { "alias": "card"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "isolated": { "alias": "isolated"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "empty": { "alias": "empty"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "sectionTitle": { "alias": "sectionTitle"; "required": false; "isSignal": true; }; "sectionTitleId": { "alias": "sectionTitleId"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MobilePageHeaderSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobilePageHeaderSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MobilePageHeaderSlotDirective, "[mPageHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class MobilePageContentSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobilePageContentSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MobilePageContentSlotDirective, "[mPageContent]", never, {}, {}, never, never, true, never>;
+}
+declare class MobilePageFooterSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobilePageFooterSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MobilePageFooterSlotDirective, "[mPageFooter]", never, {}, {}, never, never, true, never>;
+}
+declare class MobilePageLayoutComponent {
+    protected readonly headerSlot: _angular_core.Signal<MobilePageHeaderSlotDirective>;
+    protected readonly contentSlot: _angular_core.Signal<MobilePageContentSlotDirective>;
+    protected readonly footerSlot: _angular_core.Signal<MobilePageFooterSlotDirective>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobilePageLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobilePageLayoutComponent, "m-page-layout", never, {}, {}, ["headerSlot", "contentSlot", "footerSlot"], ["[mPageHeader]", "[mPageContent]", "[mPageFooter]"], true, never>;
+}
+
+declare class MToolbar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MToolbar, "m-toolbar", never, {}, {}, never, ["*"], true, never>;
+}
+declare class MContent {
+    readonly stack: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly gap: _angular_core.InputSignalWithTransform<number, string | number>;
+    readonly padding: _angular_core.InputSignal<string>;
+    protected contentDisplay(): string | null;
+    protected contentFlexDirection(): string | null;
+    protected contentGap(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MContent, "m-content", never, { "stack": { "alias": "stack"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class MFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MFooter, "m-footer", never, {}, {}, never, ["*"], true, never>;
+}
+declare class MPage {
+    readonly padding: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MPage, "m-page", never, { "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["m-header,[mPageHeader]", "m-content,[mPageContent]", "m-footer,[mPageFooter]", "*"], true, never>;
+}
+
+declare class PPageHeaderSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PPageHeaderSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PPageHeaderSlotDirective, "[pPageHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class PPageSidebarSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PPageSidebarSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PPageSidebarSlotDirective, "[pPageSidebar]", never, {}, {}, never, never, true, never>;
+}
+declare class PPageContentSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PPageContentSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PPageContentSlotDirective, "[pPageContent]", never, {}, {}, never, never, true, never>;
+}
+declare class PPageFooterSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PPageFooterSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PPageFooterSlotDirective, "[pPageFooter]", never, {}, {}, never, never, true, never>;
+}
+declare class PToolbar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PToolbar, "p-toolbar", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PSidebar {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PSidebar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PSidebar, "p-sidebar", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PContent {
+    readonly stack: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly gap: _angular_core.InputSignalWithTransform<number, string | number>;
+    protected contentDisplay(): string | null;
+    protected contentFlexDirection(): string | null;
+    protected contentGap(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PContent, "p-content", never, { "stack": { "alias": "stack"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class PFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PFooter, "p-footer", never, {}, {}, never, ["*"], true, never>;
+}
+declare class PPage {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PPage, "p-page", never, {}, {}, never, ["p-toolbar,[pPageHeader]", "p-sidebar,[pPageSidebar]", "p-content,[pPageContent]", "p-footer,[pPageFooter]", "*"], true, never>;
+}
+
+declare class MPersonCardMobileLayer {
+    readonly active: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MPersonCardMobileLayer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MPersonCardMobileLayer, "m-person-card-mobile-layer", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class MPersonCardDesktopLayer {
+    readonly active: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly closeAriaLabel: _angular_core.InputSignal<string>;
+    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MPersonCardDesktopLayer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MPersonCardDesktopLayer, "m-person-card-desktop-layer", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeAriaLabel": { "alias": "closeAriaLabel"; "required": false; "isSignal": true; }; }, { "closeRequested": "closeRequested"; }, never, ["*"], true, never>;
+}
+
+declare class MProductShellRailSlot {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MProductShellRailSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MProductShellRailSlot, "[mProductShellRail]", never, {}, {}, never, never, true, never>;
+}
+declare class MProductShellMainSlot {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MProductShellMainSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MProductShellMainSlot, "[mProductShellMain]", never, {}, {}, never, never, true, never>;
+}
+declare class MProductShellBottomSlot {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MProductShellBottomSlot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MProductShellBottomSlot, "[mProductShellBottom]", never, {}, {}, never, never, true, never>;
+}
+declare class MProductShell {
+    readonly hosted: _angular_core.InputSignal<boolean>;
+    readonly mobile: _angular_core.InputSignal<boolean>;
+    readonly mobileSubpage: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MProductShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MProductShell, "m-product-shell", never, { "hosted": { "alias": "hosted"; "required": false; "isSignal": true; }; "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "mobileSubpage": { "alias": "mobileSubpage"; "required": false; "isSignal": true; }; }, {}, never, ["[mProductShellRail]", "[mProductShellMain]", "[mProductShellBottom]"], true, never>;
+}
+
+type PaginationVariant = 'default' | 'compact';
+declare class Pagination {
+    private readonly destroyRef;
+    currentPage: _angular_core.ModelSignal<number>;
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    readonly totalItems: _angular_core.InputSignalWithTransform<number, string | number>;
+    readonly maxVisiblePages: _angular_core.InputSignalWithTransform<number, string | number>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly variant: _angular_core.InputSignalWithTransform<PaginationVariant, string>;
+    readonly showSizeChanger: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showQuickJumper: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pageSizeControl: FormControl<number>;
+    readonly quickJumpControl: FormControl<string>;
+    private readonly selectedPageSize;
+    readonly pageChange: _angular_core.OutputEmitterRef<number>;
+    readonly pageSizeChange: _angular_core.OutputEmitterRef<number>;
+    protected readonly prevIcon: lucide_angular.LucideIconData;
+    protected readonly nextIcon: lucide_angular.LucideIconData;
+    readonly totalPages: _angular_core.Signal<number>;
+    readonly pages: _angular_core.Signal<(string | number)[]>;
+    readonly isCompact: _angular_core.Signal<boolean>;
+    readonly canGoPrev: _angular_core.Signal<boolean>;
+    readonly canGoNext: _angular_core.Signal<boolean>;
+    readonly pageSizeSelectOptions: _angular_core.Signal<BsSelectOption<number>[]>;
+    constructor();
+    goToPage(page: number | string): void;
+    prevPage(): void;
+    nextPage(): void;
+    quickJump(): void;
+    trackPage(index: number, page: number | string): number | string;
+    private syncControlDisabledState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Pagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Pagination, "s-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "maxVisiblePages": { "alias": "maxVisiblePages"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showSizeChanger": { "alias": "showSizeChanger"; "required": false; "isSignal": true; }; "showQuickJumper": { "alias": "showQuickJumper"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
+}
+
+interface MRailNavItem extends MTabItem {
+    readonly badge?: number | string | null;
+    readonly route?: string | null;
+}
+declare class MRailNav {
+    private readonly router;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly actionAriaLabel: _angular_core.InputSignal<string>;
+    readonly actionIcon: _angular_core.InputSignal<LucideIconData>;
+    readonly items: _angular_core.InputSignal<readonly MRailNavItem[]>;
+    readonly selectedItemId: _angular_core.InputSignal<string | number>;
+    readonly actionSelected: _angular_core.OutputEmitterRef<void>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<MRailNavItem>;
+    protected onSelect(item: MRailNavItem): void;
+    protected trackByItemId(_index: number, item: MRailNavItem): string | number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MRailNav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MRailNav, "m-rail-nav", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "actionAriaLabel": { "alias": "actionAriaLabel"; "required": false; "isSignal": true; }; "actionIcon": { "alias": "actionIcon"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; "isSignal": true; }; }, { "actionSelected": "actionSelected"; "itemSelected": "itemSelected"; }, never, never, true, never>;
+}
+
+declare class RoutePlaceholderPageComponent {
+    readonly title: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RoutePlaceholderPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RoutePlaceholderPageComponent, "s-route-placeholder-page", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SectionNavItem {
+    id: string | number;
+    label: string;
+    disabled?: boolean;
+    meta?: Record<string, unknown>;
+}
+interface SectionNavGroup {
+    id: string | number;
+    label: string;
+    icon?: LucideIconData;
+    items: readonly SectionNavItem[];
+    collapsible?: boolean;
+}
+interface SectionNavSelectChange {
+    group: SectionNavGroup;
+    item: SectionNavItem;
+}
+interface SectionNavToggleChange {
+    group: SectionNavGroup;
+    expanded: boolean;
+}
+declare class SectionNav {
+    private readonly expandedStateTouched;
+    readonly groups: _angular_core.InputSignal<readonly SectionNavGroup[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly selectedItemId: _angular_core.ModelSignal<string | number>;
+    readonly expandedGroupIds: _angular_core.ModelSignal<readonly (string | number)[]>;
+    readonly expandAllByDefault: _angular_core.InputSignal<boolean>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<SectionNavSelectChange>;
+    readonly groupToggled: _angular_core.OutputEmitterRef<SectionNavToggleChange>;
+    protected readonly chevronIcon: LucideIconData;
+    protected readonly resolvedExpandedGroupIds: _angular_core.Signal<readonly (string | number)[]>;
+    protected isExpanded(group: SectionNavGroup): boolean;
+    protected isSelected(item: SectionNavItem): boolean;
+    protected toggleGroup(group: SectionNavGroup): void;
+    protected selectItem(group: SectionNavGroup, item: SectionNavItem): void;
+    protected trackByGroupId(_index: number, group: SectionNavGroup): string | number;
+    protected trackByItemId(_index: number, item: SectionNavItem): string | number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SectionNav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SectionNav, "s-section-nav", never, { "groups": { "alias": "groups"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; "isSignal": true; }; "expandedGroupIds": { "alias": "expandedGroupIds"; "required": false; "isSignal": true; }; "expandAllByDefault": { "alias": "expandAllByDefault"; "required": false; "isSignal": true; }; }, { "selectedItemId": "selectedItemIdChange"; "expandedGroupIds": "expandedGroupIdsChange"; "itemSelected": "itemSelected"; "groupToggled": "groupToggled"; }, never, never, true, never>;
+}
+
+interface SegmentedOption {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface SegmentedSelectEvent {
+    option: SegmentedOption;
+}
+declare class Segmented {
+    readonly options: _angular_core.InputSignal<readonly SegmentedOption[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly selectedId: _angular_core.ModelSignal<string>;
+    readonly optionSelected: _angular_core.OutputEmitterRef<SegmentedSelectEvent>;
+    protected readonly hasOptions: _angular_core.Signal<boolean>;
+    constructor();
+    protected isSelected(optionId: string): boolean;
+    protected onSelect(option: SegmentedOption): void;
+    protected trackByOptionId(_index: number, option: SegmentedOption): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Segmented, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Segmented, "s-segmented", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectedId": { "alias": "selectedId"; "required": false; "isSignal": true; }; }, { "selectedId": "selectedIdChange"; "optionSelected": "optionSelected"; }, never, never, true, never>;
+}
+
+type PlatformSearchAppearance = 'default' | 'soft' | 'topbar';
+declare class PlatformSearchComponent {
+    readonly keyword: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly appearance: _angular_core.InputSignal<PlatformSearchAppearance>;
+    protected readonly searchIcon: lucide_angular.LucideIconData;
+    protected updateKeyword(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlatformSearchComponent, "s-search", never, { "keyword": { "alias": "keyword"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, { "keyword": "keywordChange"; }, never, never, true, never>;
+}
+
+interface SearchBarSubmitEvent {
+    value: string;
+}
+declare class SearchBar {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly cancelText: _angular_core.InputSignal<string>;
+    readonly showCancel: _angular_core.InputSignal<boolean>;
+    readonly showBack: _angular_core.InputSignal<boolean>;
+    readonly autofocus: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly backClicked: _angular_core.OutputEmitterRef<void>;
+    readonly cancelClicked: _angular_core.OutputEmitterRef<void>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    readonly submitted: _angular_core.OutputEmitterRef<SearchBarSubmitEvent>;
+    protected readonly searchIcon: lucide_angular.LucideIconData;
+    protected readonly backIcon: lucide_angular.LucideIconData;
+    protected readonly clearIcon: lucide_angular.LucideIconData;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected updateValue(event: Event): void;
+    protected clearValue(): void;
+    protected onBackClick(): void;
+    protected onCancelClick(): void;
+    protected onSubmit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchBar, "m-search-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "cancelText": { "alias": "cancelText"; "required": false; "isSignal": true; }; "showCancel": { "alias": "showCancel"; "required": false; "isSignal": true; }; "showBack": { "alias": "showBack"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "backClicked": "backClicked"; "cancelClicked": "cancelClicked"; "cleared": "cleared"; "submitted": "submitted"; }, never, never, true, never>;
+}
+
+type StatusDotStatus = 'success' | 'error' | 'default' | 'processing' | 'warning';
+type StatusDotSize = 'sm' | 'md';
+declare class StatusDot {
+    readonly status: _angular_core.InputSignal<StatusDotStatus>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<StatusDotSize>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusDot, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusDot, "s-status-dot", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+type StepsVariant = 'default' | 'dot' | 'navigation';
+type StepsOrientation = 'horizontal' | 'vertical';
+type StepsSize = 'default' | 'small';
+interface StepItem {
+    id: string;
+    title: string;
+    description?: string;
+    status?: StepStatus;
+    icon?: LucideIconData;
+}
+declare class Steps {
+    readonly items: _angular_core.InputSignal<readonly StepItem[]>;
+    readonly current: _angular_core.InputSignal<number>;
+    readonly variant: _angular_core.InputSignal<StepsVariant>;
+    readonly orientation: _angular_core.InputSignal<StepsOrientation>;
+    readonly size: _angular_core.InputSignal<StepsSize>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly normalizedItems: _angular_core.Signal<{
+        index: number;
+        status: StepStatus;
+        isLast: boolean;
+        id: string;
+        title: string;
+        description?: string;
+        icon?: LucideIconData;
+    }[]>;
+    protected isDefault(): boolean;
+    protected isDot(): boolean;
+    protected isNavigation(): boolean;
+    protected isVertical(): boolean;
+    protected isSmall(): boolean;
+    protected trackById(_index: number, item: StepItem): string;
+    private resolveStatus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Steps, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Steps, "s-steps", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type TabsVariant = 'contained' | 'line';
+interface TabItem {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface TabChangeEvent {
+    item: TabItem;
+}
+declare class Tabs implements AfterViewInit {
+    private readonly destroyRef;
+    private readonly hostElement;
+    readonly tabs: _angular_core.InputSignal<readonly TabItem[]>;
+    readonly variant: _angular_core.InputSignal<TabsVariant>;
+    readonly showOverflowActions: _angular_core.InputSignal<boolean>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly activeId: _angular_core.ModelSignal<string>;
+    readonly tabChanged: _angular_core.OutputEmitterRef<TabChangeEvent>;
+    protected readonly scrollContainer: _angular_core.Signal<ElementRef<HTMLElement>>;
+    protected readonly canScrollPrev: _angular_core.WritableSignal<boolean>;
+    protected readonly canScrollNext: _angular_core.WritableSignal<boolean>;
+    protected readonly overflowTabIds: _angular_core.WritableSignal<string[]>;
+    protected readonly overflowMenuOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly leftIcon: lucide_angular.LucideIconData;
+    protected readonly rightIcon: lucide_angular.LucideIconData;
+    protected readonly moreIcon: lucide_angular.LucideIconData;
+    protected readonly isContained: _angular_core.Signal<boolean>;
+    protected readonly visibleTabs: _angular_core.Signal<TabItem[]>;
+    protected readonly overflowTabs: _angular_core.Signal<TabItem[]>;
+    constructor();
+    ngAfterViewInit(): void;
+    protected isActive(tabId: string): boolean;
+    protected selectTab(tab: TabItem): void;
+    protected toggleOverflowMenu(event: Event): void;
+    protected scrollPrev(): void;
+    protected scrollNext(): void;
+    protected trackById(_index: number, tab: TabItem): string;
+    protected onDocumentClick(event: Event): void;
+    private scrollTabsBy;
+    private updateOverflowState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tabs, "s-tabs", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "showOverflowActions": { "alias": "showOverflowActions"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "activeId": { "alias": "activeId"; "required": false; "isSignal": true; }; }, { "activeId": "activeIdChange"; "tabChanged": "tabChanged"; }, never, never, true, never>;
+}
+
+type STagVariant = 'soft' | 'solid' | 'outline' | 'ghost' | 'text';
+type STagColor = 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+type STagSize = 'xs' | 'sm' | 'md' | 'lg';
+type STagShape = 'default' | 'round';
+type TagTone = STagColor;
+type TagVariant = STagVariant | 'outlined';
+declare class Tag {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<STagColor>;
+    readonly tone: _angular_core.InputSignal<STagColor>;
+    readonly variant: _angular_core.InputSignal<TagVariant>;
+    readonly size: _angular_core.InputSignal<STagSize>;
+    readonly shape: _angular_core.InputSignal<STagShape>;
+    readonly closable: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly href: _angular_core.InputSignal<string>;
+    readonly target: _angular_core.InputSignal<string>;
+    readonly rel: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly tagClicked: _angular_core.OutputEmitterRef<void>;
+    readonly closeClicked: _angular_core.OutputEmitterRef<void>;
+    protected readonly closeIcon: lucide_angular.LucideIconData;
+    protected readonly externalLinkIcon: lucide_angular.LucideIconData;
+    protected readonly isLink: _angular_core.Signal<boolean>;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    protected readonly resolvedColor: _angular_core.Signal<STagColor>;
+    protected readonly resolvedVariant: _angular_core.Signal<STagVariant>;
+    protected readonly hostClass: _angular_core.Signal<string>;
+    protected emitTagClicked(): void;
+    protected emitCloseClicked(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tag, "s-tag", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "rel": { "alias": "rel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "tagClicked": "tagClicked"; "closeClicked": "closeClicked"; }, never, ["*", "*"], true, never>;
+}
+
+type TimelineStatus = 'wait' | 'process' | 'finish' | 'error';
+type TimelineVariant = 'dot' | 'default';
+interface TimelineItem {
+    id: string;
+    title: string;
+    description?: string;
+    status?: TimelineStatus;
+    icon?: LucideIconData;
+}
+declare class Timeline {
+    readonly items: _angular_core.InputSignal<readonly TimelineItem[]>;
+    readonly current: _angular_core.InputSignal<number>;
+    readonly variant: _angular_core.InputSignal<TimelineVariant>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly normalizedItems: _angular_core.Signal<{
+        index: number;
+        status: TimelineStatus;
+        isLast: boolean;
+        id: string;
+        title: string;
+        description?: string;
+        icon?: LucideIconData;
+    }[]>;
+    protected isDot(): boolean;
+    protected trackById(_index: number, item: TimelineItem): string;
+    private resolveStatus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Timeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Timeline, "s-timeline", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TreeNode {
+    id: string | number;
+    label: string;
+    count?: number;
+    trailingText?: string;
+    avatarText?: string;
+    children?: readonly TreeNode[];
+    selectable?: boolean;
+    meta?: Record<string, unknown>;
+}
+interface TreeToggleChange {
+    node: TreeNode;
+    expanded: boolean;
+}
+declare class Tree {
+    readonly nodes: _angular_core.InputSignal<readonly TreeNode[]>;
+    readonly selectedId: _angular_core.InputSignal<string | number>;
+    readonly expandedIds: _angular_core.InputSignal<readonly (string | number)[]>;
+    readonly level: _angular_core.InputSignal<number>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<TreeNode>;
+    readonly toggleChange: _angular_core.OutputEmitterRef<TreeToggleChange>;
+    protected readonly expandIcon: lucide_angular.LucideIconData;
+    protected readonly collapseIcon: lucide_angular.LucideIconData;
+    protected hasChildren(node: TreeNode): boolean;
+    protected isExpanded(node: TreeNode): boolean;
+    protected isSelected(node: TreeNode): boolean;
+    protected onRowClick(node: TreeNode, event?: Event): void;
+    protected onToggleClick(node: TreeNode, event: Event): void;
+    protected onChildSelection(node: TreeNode): void;
+    protected onChildToggle(change: TreeToggleChange): void;
+    protected onKeydown(node: TreeNode, event: KeyboardEvent): void;
+    protected trackByNodeId(_index: number, node: TreeNode): string | number;
+    private toggle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tree, "s-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "selectedId": { "alias": "selectedId"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "toggleChange": "toggleChange"; }, never, never, true, never>;
+}
+
+declare class TreeSelect implements ControlValueAccessor {
+    private readonly trigger;
+    readonly nodes: _angular_core.InputSignal<readonly TreeNode[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly matchTriggerWidth: _angular_core.InputSignal<boolean>;
+    readonly expandedIds: _angular_core.InputSignal<readonly (string | number)[]>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<TreeNode>;
+    readonly expandedIdsChange: _angular_core.OutputEmitterRef<readonly (string | number)[]>;
+    protected readonly opened: _angular_core.WritableSignal<boolean>;
+    protected readonly selectedId: _angular_core.WritableSignal<string | number>;
+    protected readonly currentExpandedIds: _angular_core.WritableSignal<readonly (string | number)[]>;
+    protected readonly triggerWidth: _angular_core.WritableSignal<number>;
+    private readonly disabledFromCva;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly selectedNode: _angular_core.Signal<TreeNode>;
+    protected readonly displayValue: _angular_core.Signal<string>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected readonly overlayWidth: _angular_core.Signal<string | number>;
+    private onChange;
+    private onTouched;
+    constructor();
+    protected togglePopup(): void;
+    protected openPopup(): void;
+    protected closePopup(): void;
+    protected onNodeSelected(node: TreeNode): void;
+    protected onTreeToggle(change: TreeToggleChange): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    writeValue(value: string | number | null | undefined): void;
+    registerOnChange(fn: (value: string | number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private syncTriggerWidth;
+    private addExpandedId;
+    private findNodeById;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeSelect, "s-tree-select", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "expandedIdsChange": "expandedIdsChange"; }, never, never, true, never>;
+}
+
+type UploadItemStatus = 'done' | 'success' | 'uploading' | 'error';
+type UploadVariant = 'picture-card' | 'file-list' | 'dropzone' | 'button';
+type UploadButtonVariant = 'outline' | 'primary' | 'icon' | 'soft-icon';
+type UploadItemKind = 'image' | 'word' | 'pdf' | 'ppt' | 'sheet' | 'archive' | 'audio' | 'video' | 'file';
+type UploadSelectionSource = 'picker' | 'drop' | 'replace';
+interface UploadItem {
+    id: string;
+    name?: string;
+    size?: number;
+    sizeText?: string;
+    meta?: string;
+    fileType?: UploadItemKind | string;
+    thumbnailSrc?: string | null;
+    alt?: string;
+    status?: UploadItemStatus;
+    progress?: number;
+    errorText?: string;
+    disabled?: boolean;
+    active?: boolean;
+}
+interface UploadActionEvent {
+    item: UploadItem;
+}
+interface UploadFilesSelectedEvent {
+    files: File[];
+    source?: UploadSelectionSource;
+    item?: UploadItem;
+}
+declare class Upload {
+    readonly items: _angular_core.InputSignal<readonly UploadItem[]>;
+    readonly variant: _angular_core.InputSignal<UploadVariant>;
+    readonly buttonVariant: _angular_core.InputSignal<UploadButtonVariant>;
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly maxCount: _angular_core.InputSignal<number>;
+    readonly cardSize: _angular_core.InputSignal<number>;
+    readonly cardWidth: _angular_core.InputSignal<number>;
+    readonly cardHeight: _angular_core.InputSignal<number>;
+    readonly addLabel: _angular_core.InputSignal<string>;
+    readonly buttonLabel: _angular_core.InputSignal<string>;
+    readonly uploadingLabel: _angular_core.InputSignal<string>;
+    readonly errorFallbackText: _angular_core.InputSignal<string>;
+    readonly emptyFileName: _angular_core.InputSignal<string>;
+    readonly dropTitle: _angular_core.InputSignal<string>;
+    readonly dropDescription: _angular_core.InputSignal<string>;
+    readonly hint: _angular_core.InputSignal<string>;
+    readonly showHint: _angular_core.InputSignal<boolean>;
+    readonly showList: _angular_core.InputSignal<boolean>;
+    readonly showPreview: _angular_core.InputSignal<boolean>;
+    readonly showRemove: _angular_core.InputSignal<boolean>;
+    readonly showReplace: _angular_core.InputSignal<boolean>;
+    readonly showSuccessMark: _angular_core.InputSignal<boolean>;
+    readonly filesSelected: _angular_core.OutputEmitterRef<UploadFilesSelectedEvent>;
+    readonly itemPreview: _angular_core.OutputEmitterRef<UploadActionEvent>;
+    readonly itemRemove: _angular_core.OutputEmitterRef<UploadActionEvent>;
+    readonly itemRetry: _angular_core.OutputEmitterRef<UploadActionEvent>;
+    readonly itemReplace: _angular_core.OutputEmitterRef<UploadActionEvent>;
+    protected readonly fileInput: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected readonly dragOver: _angular_core.WritableSignal<boolean>;
+    protected readonly addIcon: lucide_angular.LucideIconData;
+    protected readonly checkIcon: lucide_angular.LucideIconData;
+    protected readonly closeIcon: lucide_angular.LucideIconData;
+    protected readonly fileIcon: lucide_angular.LucideIconData;
+    protected readonly imageIcon: lucide_angular.LucideIconData;
+    protected readonly previewIcon: lucide_angular.LucideIconData;
+    protected readonly removeIcon: lucide_angular.LucideIconData;
+    protected readonly replaceIcon: lucide_angular.LucideIconData;
+    protected readonly retryIcon: lucide_angular.LucideIconData;
+    protected readonly uploadIcon: lucide_angular.LucideIconData;
+    protected readonly canAddMore: _angular_core.Signal<boolean>;
+    private selectionSource;
+    private replacementItem;
+    protected trackById(_index: number, item: UploadItem): string;
+    protected itemStatus(item: UploadItem): UploadItemStatus;
+    protected isDoneStatus(item: UploadItem): boolean;
+    protected showPictureSuccessMark(item: UploadItem): boolean;
+    protected itemProgress(item: UploadItem): number;
+    protected itemErrorText(item: UploadItem): string;
+    protected itemName(item: UploadItem): string;
+    protected itemMeta(item: UploadItem): string;
+    protected itemKind(item: UploadItem): UploadItemKind;
+    protected itemKindLabel(item: UploadItem): string;
+    protected openFileDialog(): void;
+    protected openReplaceDialog(item: UploadItem, event?: Event): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected onFileChange(event: Event): void;
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    protected previewItem(item: UploadItem, event?: Event): void;
+    protected removeItem(item: UploadItem, event?: Event): void;
+    protected retryItem(item: UploadItem, event?: Event): void;
+    private openPicker;
+    private emitFiles;
+    private limitFiles;
+    private normalizeKind;
+    private formatSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Upload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Upload, "s-upload", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "buttonVariant": { "alias": "buttonVariant"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxCount": { "alias": "maxCount"; "required": false; "isSignal": true; }; "cardSize": { "alias": "cardSize"; "required": false; "isSignal": true; }; "cardWidth": { "alias": "cardWidth"; "required": false; "isSignal": true; }; "cardHeight": { "alias": "cardHeight"; "required": false; "isSignal": true; }; "addLabel": { "alias": "addLabel"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "uploadingLabel": { "alias": "uploadingLabel"; "required": false; "isSignal": true; }; "errorFallbackText": { "alias": "errorFallbackText"; "required": false; "isSignal": true; }; "emptyFileName": { "alias": "emptyFileName"; "required": false; "isSignal": true; }; "dropTitle": { "alias": "dropTitle"; "required": false; "isSignal": true; }; "dropDescription": { "alias": "dropDescription"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "showHint": { "alias": "showHint"; "required": false; "isSignal": true; }; "showList": { "alias": "showList"; "required": false; "isSignal": true; }; "showPreview": { "alias": "showPreview"; "required": false; "isSignal": true; }; "showRemove": { "alias": "showRemove"; "required": false; "isSignal": true; }; "showReplace": { "alias": "showReplace"; "required": false; "isSignal": true; }; "showSuccessMark": { "alias": "showSuccessMark"; "required": false; "isSignal": true; }; }, { "filesSelected": "filesSelected"; "itemPreview": "itemPreview"; "itemRemove": "itemRemove"; "itemRetry": "itemRetry"; "itemReplace": "itemReplace"; }, never, never, true, never>;
+}
+
+declare class FlexColumnFillDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlexColumnFillDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FlexColumnFillDirective, "[sFlexColumnFill]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BsLoadingDirective implements OnChanges {
+    private readonly el;
+    private readonly renderer;
+    loading: boolean;
+    private overlayEl?;
+    private overlayContainer?;
+    private previousMinHeight?;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnChanges(changes: SimpleChanges): void;
+    private showOverlay;
+    private hideOverlay;
+    private getOverlayContainer;
+    private ensureSpinKeyframes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsLoadingDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BsLoadingDirective, "[sLoading]", never, { "loading": { "alias": "sLoading"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type PlatformInputSize = 'sm' | 'md' | 'lg';
+type PlatformInputVariant = 'control' | 'bare' | 'soft';
+declare class PlatformInputDirective {
+    readonly size: _angular_core.InputSignal<PlatformInputSize>;
+    readonly variant: _angular_core.InputSignal<PlatformInputVariant>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PlatformInputDirective, "input[pInput], textarea[pInput]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ConfirmDialogVariant = 'danger' | 'warning' | 'confirm' | 'info' | 'success';
+interface ConfirmDialogDetail {
+    readonly label: string;
+    readonly value: string | number | null | undefined;
+}
+interface DeleteConfirmDialogData {
+    readonly variant?: ConfirmDialogVariant | null;
+    readonly type?: ConfirmDialogVariant | null;
+    readonly title?: string | null;
+    readonly name?: string | null;
+    readonly username?: string | null;
+    readonly message?: string | null;
+    readonly details?: readonly ConfirmDialogDetail[] | null;
+    readonly cancelText?: string | null;
+    readonly confirmText?: string | null;
+    readonly showCancel?: boolean | null;
+    readonly showClose?: boolean | null;
+}
+type ConfirmDialogData = DeleteConfirmDialogData;
+declare class DeleteConfirmDialogComponent {
+    static readonly dialogChrome = "content";
+    static readonly dialogSize = "small";
+    private readonly dialogRef;
+    private readonly data;
+    protected readonly name: string;
+    protected readonly variant: ConfirmDialogVariant;
+    protected readonly closeIcon: LucideIconData;
+    protected readonly icon: LucideIconData;
+    protected readonly title: string;
+    protected readonly message: string;
+    protected readonly details: readonly ConfirmDialogDetail[];
+    protected readonly cancelText: string;
+    protected readonly confirmText: string;
+    protected readonly showCancel: boolean;
+    protected readonly showClose: boolean;
+    protected readonly primaryButtonVariant: string;
+    protected cancel(): void;
+    protected confirm(): void;
+    private resolveVariant;
+    private defaultTitle;
+    private defaultMessage;
+    private normalizeDetails;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeleteConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DeleteConfirmDialogComponent, "s-delete-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogContainerRef<T = unknown> {
+    private readonly subject;
+    readonly afterClosed$: rxjs.Observable<T>;
+    close(result?: T): void;
+}
+
+type DialogContainerSize = 'small' | 'standard' | 'large';
+
+type DialogContainerChrome = 'default' | 'content';
+interface DialogContainerConfig {
+    title?: string;
+    data?: unknown;
+    viewContainerRef?: ViewContainerRef;
+    showHeader?: boolean;
+    size?: DialogContainerSize;
+}
+declare class DialogContainerService {
+    private readonly injector;
+    private readonly overlayHost;
+    open<T>(component: Type<T>, config?: DialogContainerConfig): DialogContainerRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogContainerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DialogContainerService>;
+}
+
+declare const DIALOG_DATA: InjectionToken<unknown>;
+
+declare const PLATFORM_OVERLAY_VIEW_CONTAINER_REF: InjectionToken<ViewContainerRef>;
+interface PlatformOverlayAttachOptions {
+    injector?: Injector | null;
+    viewContainerRef?: ViewContainerRef | null;
+    config?: OverlayConfig;
+}
+interface PlatformOverlayComponentRef<T> {
+    overlayRef: OverlayRef;
+    componentRef: ComponentRef<T>;
+    dispose: () => void;
+}
+declare class PlatformOverlayPortalHost {
+    private readonly document;
+    private readonly overlay;
+    private readonly defaultViewContainerRef;
+    attachComponent<T>(component: Type<T>, options?: PlatformOverlayAttachOptions): PlatformOverlayComponentRef<T> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlatformOverlayPortalHost, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlatformOverlayPortalHost>;
+}
+
+declare class SideDrawerRef<T = unknown> {
+    private readonly subject;
+    readonly afterClosed$: rxjs.Observable<T>;
+    close(result?: T): void;
+}
+
+interface SideDrawerConfig {
+    title?: string;
+    closeLabel?: string;
+    closeOnMask?: boolean;
+    drawerWidth?: string;
+    data?: unknown;
+    viewContainerRef?: ViewContainerRef;
+}
+declare class SideDrawerService {
+    private readonly injector;
+    private readonly overlayHost;
+    open<TComponent, TResult = unknown>(component: Type<TComponent>, config?: SideDrawerConfig): SideDrawerRef<TResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SideDrawerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SideDrawerService>;
+}
+
+declare const SIDE_DRAWER_DATA: InjectionToken<unknown>;
+
+declare class EnumPicePipe implements PipeTransform {
+    transform(key: string, values: Record<string, string>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnumPicePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EnumPicePipe, "enumPice", true>;
+}
+
+export { APP_RUNTIME_CONTEXT, AUTHENTICATED_STATE_GETTER, ActionMenuComponent, AppFooter, AppHeader, AppShell, Aside, Avatar, AvatarGroup, Badge, BaseListComponent, BottomNav, Breadcrumb, BreadcrumbItemComponent, BsBaseList, BsLoadingDirective, BsMessage, BsMessageService, BsSelect, CORE_AUTH_GUARD_CONFIG, Card, DeleteConfirmDialogComponent as ConfirmDialogComponent, Content, DEFAULT_APP_RUNTIME_CONTEXT, DEFAULT_EMOJI_PICKER_OPTIONS, DEFAULT_EMOJI_PICKER_TABS, DEFAULT_HTTP_RESPONSE_INTERCEPTOR_CONFIG, DEFAULT_HTTP_SUCCESS_MESSAGES, DIALOG_DATA, DatePicker, DeleteConfirmDialogComponent, DialogContainerRef, DialogContainerService, ElectronRequest, EmojiPicker, EmptyFooter, EmptySidebar, EnumPicePipe, FileUploadButtonComponent, FilterSummary, FlexColumnFillDirective, GlobalErrorHandler, HTTP_AUTH_TOKEN_GETTER, HTTP_CONFIG, HTTP_RESPONSE_INTERCEPTOR_CONFIG, HTTP_SUCCESS_MESSAGE, HTTP_UNAUTHORIZED_HANDLER, HasPermissionDirective, Header, HttpConfig, ListPageActionColDirective, ListPageCellTextDirective, ListPageCheckboxColDirective, ListPageColumnDirective, ListPageContentDesktopComponent, ListPageContentDesktopSlotDirective, ListPageEmptyDirective, ListPageFileActionDirective, ListPageFilterActionsDirective, ListPageFilterControlDirective, ListPageFilterFieldDirective, ListPageFilterGridDirective, ListPageFilterLabelDirective, ListPageFilterPanelComponent, ListPageHeaderActionsDirective, ListPageHeaderComponent, ListPageHeaderFiltersDirective, ListPageHeaderLayoutDirective, ListPageHeaderRowComponent, ListPageHeaderSlotDirective, ListPageIconButtonDirective, ListPageLayoutComponent, ListPagePaginationComponent, ListPagePaginationSlotDirective, ListPageRowActionDangerDirective, ListPageRowActionTriggerDirective, ListPageRowActionsDirective, ListPageSidebarComponent, ListPageSidebarSearchDirective, ListPageSidebarSlotDirective, ListPageSidebarTreeDirective, ListPageSummarySlotDirective, ListPageTabDirective, ListPageTableDirective, ListPageTableScrollDirective, ListPageTableWrapDirective, ListPageTabsDirective, ListPageTreeIndentDirective, ListPageTreeToggleDirective, ListSearchPanel, MAlphabet, MContent, MESSAGE_SERVICE, MFooter, MItem, MItemActionsSlot, MItemAvatarFaceDirective, MItemAvatarFrameDirective, MItemAvatarGroupDirective, MItemAvatarIconDirective, MItemAvatarPortraitDirective, MItemAvatarSlot, MItemBadgeDirective, MItemFooterSlot, MItemIndicatorDirective, MItemMarkerDirective, MItemMenuChevronDirective, MItemMenuIconDirective, MItemMetaSlot, MItemPrefixSlot, MItemPresenceDirective, MItemProfileAvatarDirective, MItemProfileNameDirective, MItemProfileTitleDirective, MItemStatusSlot, MItemSummarySlot, MItemTitleSlot, MItemTrailingSlot, MItemUnreadDotDirective, MList, MPage, MobilePageContentSlotDirective as MPageContentSlotDirective, MobilePageFooterSlotDirective as MPageFooterSlotDirective, MobilePageHeaderSlotDirective as MPageHeaderSlotDirective, MPersonCardDesktopLayer, MPersonCardMobileLayer, MProductShell, MProductShellBottomSlot, MProductShellMainSlot, MProductShellRailSlot, MRailNav, MTabs, MToolbar, M_ALPHABET_DEFAULT_LETTERS, M_ITEM_APPEARANCE_DIRECTIVES, M_ITEM_SLOT_DIRECTIVES, MenuComponent, MenuItemComponent, MerchantCard, MinimalHeader, MobilePageContentSlotDirective, MobilePageFooterSlotDirective, MobilePageHeaderSlotDirective, MobilePageLayoutComponent, NotificationCenter, Outlets, PContent, PFooter, PLATFORM_OVERLAY_VIEW_CONTAINER_REF, PPage, PPageContentSlotDirective, PPageFooterSlotDirective, PPageHeaderSlotDirective, PPageSidebarSlotDirective, PSidebar, PToolbar, Pagination, PermissionService, PlatformDrawerCheckbox, PlatformDrawerCheckboxGroup, PlatformDrawerComponentBar, PlatformDrawerComponentItem, PlatformDrawerComponentList, PlatformDrawerEmpty, PlatformDrawerError, PlatformDrawerField, PlatformDrawerFooter, PlatformDrawerForm, PlatformDrawerFormModule, PlatformDrawerInputAction, PlatformDrawerInputActionButton, PlatformDrawerSection, PlatformDrawerTable, PlatformDrawerToolbar, PlatformDrawerTree, PlatformDrawerTreeItem, PlatformDrawerTreeToggle, PlatformInputDirective, PlatformLoginPage, PlatformOverlayPortalHost, PlatformPrefixedInput, PlatformSearchComponent, PlatformSwitch, RoutePlaceholderPageComponent, RuntimeService, SHELL_CONFIG, SIDE_DRAWER_DATA, SearchBar, SectionNav, Segmented, ShellLayout, SideDrawerRef, SideDrawerService, SidebarHeaderLayout, StatusDot, Steps, Tabs, Tag, ThrowException, Timeline, TopNavHeader, TopNavLayout, Tree, TreeSelect, Upload, coreAuthGuard, coreGuestOnlyGuard, decreaseLoading, increaseLoading, injectShellConfig, isLoading, provideAuthenticatedStateGetter, provideCoreAuthGuardConfig, provideGlobalErrorHandler, provideHttpAuthTokenGetter, provideHttpConfig, provideHttpResponseInterceptorConfig, provideHttpUnauthorizedHandler, provideIMessageService, provideRuntimeContext, provideShellConfig, provideShellConfigFactory, requestInterceptor, resolveShellParts, responseInterceptor, withHttpSuccessMessage, withoutHttpSuccessMessage };
+export type { ActionMenuItem, AppMenuIcon, AppRuntimeContext, AppRuntimeHost, AuthenticatedStateGetter, AvatarGroupItem, AvatarIndicatorType, AvatarShape, AvatarStatus, BadgeValue, BottomNavItem, BreadcrumbItem, BreadcrumbOption, BreadcrumbSelectEvent, BreadcrumbSeparator, BsMessageAction, BsMessageActionTone, BsMessageItem, BsMessageOptions, BsMessageType, BsMessageVariant, BsSelectOption, CardActionEvent, CardIconAction, CardMenuItem, ConfirmDialogData, ConfirmDialogDetail, ConfirmDialogVariant, CoreAuthGuardConfig, DatePickerMode, DateRangeValue, DeleteConfirmDialogData, DialogContainerChrome, DialogContainerConfig, EmojiPickerOption, EmojiPickerTab, FileUploadButtonSelectedEvent, FilterSummaryChip, HeaderAction, HeaderActionEvent, HeaderInset, HeaderSize, HeaderSurface, HeaderTitleAlign, HttpAuthTokenGetter, HttpResponseInterceptorConfig, HttpResponseInterceptorConfigInput, HttpSuccessMessageConfig, HttpSuccessMessageConfigInput, HttpSuccessMessageInput, HttpSuccessMessageMethod, HttpSuccessMessageOptions, HttpUnauthorizedHandler, IMessageService, MAlphabetPlacement, MItemAvatarIconShape, MItemLayout, MItemStandardTone, MItemStatus, MItemVariant, MListDensity, MListDivider, MListVariant, MRailNavItem, MTabItem, MTabItemTone, MerchantCardChip, MerchantCardChipTone, NotificationCenterItem, OptionalPermissionInput, PermissionInput, PlatformDrawerFieldVariant, PlatformDrawerSectionLayout, PlatformInputSize, PlatformInputVariant, PlatformLoginFeature, PlatformLoginSocialProvider, PlatformLoginSubmitEvent, PlatformOverlayAttachOptions, PlatformOverlayComponentRef, PlatformSearchAppearance, RequiredPermissions, ResolvedShellPartConfig, STagColor, STagShape, STagSize, STagVariant, SearchBarSubmitEvent, SectionNavGroup, SectionNavItem, SectionNavSelectChange, SectionNavToggleChange, SegmentedOption, SegmentedSelectEvent, ShellBrandConfig, ShellConfig, ShellFooterVariant, ShellHeaderActionConfig, ShellHeaderConfig, ShellHeaderLanguageOption, ShellHeaderNotificationItem, ShellHeaderUtilityItem, ShellHeaderUtilityKind, ShellHeaderVariant, ShellLayoutMode, ShellNavItem, ShellSearchCategory, ShellSearchResult, ShellSidebarConfig, ShellSidebarVariant, SideDrawerConfig, SidebarHeaderPartConfig, SidebarHeaderShellConfig, StatusDotSize, StatusDotStatus, StepItem, StepStatus, StepsOrientation, StepsSize, StepsVariant, TabChangeEvent, TabItem, TabsVariant, TagTone, TagVariant, TimelineItem, TimelineStatus, TimelineVariant, TopNavPartConfig, TopNavShellConfig, TreeNode, TreeToggleChange, UploadActionEvent, UploadButtonVariant, UploadFilesSelectedEvent, UploadItem, UploadItemKind, UploadItemStatus, UploadSelectionSource, UploadVariant, WorkbenchPartConfig, WorkbenchShellConfig, WorkspaceRefreshable };