@rt-tools/ui-kit-v2 0.17.0 → 0.18.0

package/types/rt-tools-ui-kit-v2-action-bar.d.ts

@@ -0,0 +1,140 @@
+import * as i0 from '@angular/core';
+import { Signal, InputSignal, OutputEmitterRef } from '@angular/core';
+import { IRtIcon } from '@rt-tools/ui-kit-v2/core';
+import * as i1 from '@rt-tools/ui-kit-v2/radius';
+
+/**
+ * Контракты полосы массовых действий. Один корневой неймспейс с префиксом `I`.
+ *
+ * Отличие от договора первого кита одно и оно намеренное: произвольного объекта
+ * стилей на действии здесь нет. Вид кнопки называется именем из набора кита —
+ * значение цвета в разметку не приходит вовсе.
+ */
+declare namespace IRtActionBar {
+    /** Вид действия: тем же именем, каким его зовёт кнопка кита. */
+    type Look = 'plain' | 'danger';
+    /**
+     * Одно нажатие в полосе. Либо `run` — то, что действие делает, — либо `menu`:
+     * вложенный список. Действие с вложенным списком само не срабатывает: оно
+     * заголовок группы, и запуск его наравне с раскрытием запустил бы то, чего
+     * человек не выбирал.
+     */
+    interface Action {
+        readonly label: string;
+        readonly icon?: IRtIcon.Name;
+        readonly look?: IRtActionBar.Look;
+        readonly run?: () => void;
+        readonly menu?: readonly IRtActionBar.Action[];
+    }
+    /**
+     * Настройка полосы целиком. Счёт приходит парой: сколько выбрано и сколько
+     * всего. Полоса ничего из этого не считает — ей дают числа.
+     */
+    interface Config {
+        readonly selected: number;
+        readonly total: number;
+        readonly actions: readonly IRtActionBar.Action[];
+    }
+}
+/**
+ * Сколько полоса держится в разметке после закрытия — ровно длительность ухода
+ * из стилей.
+ *
+ * Число живёт здесь, а не только в правиле стиля: разметку снимает держатель, и,
+ * разойдясь с правилом, он обрывает уход на полпути. Держателю и стилям нужно
+ * одно и то же число, поэтому оно объявлено рядом с договором, а не в одном из них.
+ */
+declare const RT_ACTION_BAR_LEAVE_MS: number;
+
+/** Действие вместе с готовой записью модификаторов: шаблон методов не зовёт. */
+interface IActionView {
+    readonly action: IRtActionBar.Action;
+    readonly modifiers: Readonly<Record<string, boolean>>;
+    /**
+     * Имя кнопки для вспомогательных средств — у действия со значком. На грубом указателе подпись
+     * снята правилом стиля, а значок немой: без имени кнопка осталась бы безымянной.
+     */
+    readonly ariaLabel: string | null;
+}
+/**
+ * Полоса массовых действий: счёт слева, действия рядом, крестик справа.
+ *
+ * Своего состояния не держит вовсе — ни выбранного, ни открытости. Ей дают
+ * настройку входом, а наружу она сообщает две вещи: что нажали действие и что
+ * нажали крестик. Держатель `rt-action-bar-holder` решает, стоит ли она в
+ * разметке и где над страницей приколота.
+ *
+ * Действие с вложенным списком само не срабатывает: оно заголовок группы, и
+ * список раскрывается всплывающим слоем кита. Нажатие пункта списка закрывает
+ * полосу так же, как нажатие обычного действия: где человек нажал — в полосе
+ * или на шаг глубже — о трате выбранного не говорит ничего.
+ */
+declare class RtActionBarComponent {
+    #private;
+    protected readonly countText: Signal<string>;
+    protected readonly closeLabel: Signal<string>;
+    /**
+     * Действия с готовыми модификаторами. Признак значка стоит модификатором, а не
+     * условием в шаблоне: подпись у действия со значком снимает правило стиля по
+     * грубому указателю, и решать это условием значило бы увезти оформление в код.
+     */
+    protected readonly actions: Signal<readonly IActionView[]>;
+    readonly config: InputSignal<IRtActionBar.Config>;
+    readonly actionRun: OutputEmitterRef<IRtActionBar.Action>;
+    readonly closed: OutputEmitterRef<void>;
+    protected onAction(action: IRtActionBar.Action): void;
+    protected onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtActionBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtActionBarComponent, "rt-action-bar", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "actionRun": "actionRun"; "closed": "closed"; }, never, never, true, [{ directive: typeof i1.RtRadiusDirective; inputs: { "radius": "radius"; }; outputs: {}; }]>;
+}
+
+/**
+ * Держатель полосы массовых действий: решает, стоит ли она в разметке, и прикалывает
+ * её над страницей. Настройку читает у службы, которую потребитель объявил на своём
+ * уровне — там, где у него живёт список.
+ *
+ * Полоса открывается счётом выбранного, а не своим признаком: два источника одного
+ * признака расходятся молча, и признак, оставшийся поднятым над опустевшим выбором,
+ * держал бы полосу над страницей, где ничего не выбрано.
+ *
+ * После закрытия полоса остаётся в разметке ровно на длительность ухода — число одно
+ * и лежит в договоре рядом. Разойдясь с правилом стиля, держатель обрывал бы уход на
+ * полпути.
+ */
+declare class RtActionBarHolderComponent {
+    #private;
+    protected readonly config: Signal<IRtActionBar.Config>;
+    /** Выбрано ли что-нибудь: этим полоса и открывается. */
+    protected readonly opened: Signal<boolean>;
+    /** Стоит ли полоса в разметке: она остаётся в ней и на время ухода. */
+    protected readonly shown: Signal<boolean>;
+    protected readonly leaving: Signal<boolean>;
+    constructor();
+    /** Крестик сообщает наружу; выбранное отпускает служба, которой список и владеет. */
+    protected onClosed(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtActionBarHolderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtActionBarHolderComponent, "rt-action-bar-holder", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Настройка полосы массовых действий: держатель её читает, список — пишет.
+ *
+ * Служба без корня намеренно. Тот, кто отмечает строки, и тот, кто рисует полосу,
+ * стоят на разной глубине одного экрана, и передавать настройку вниз через всё,
+ * что между ними, значит рассказать о полосе каждому из них. Потребитель
+ * объявляет службу на своём уровне — там, где у него живёт список.
+ */
+declare class RtActionBarService {
+    #private;
+    readonly config: Signal<IRtActionBar.Config>;
+    /** Список действий. Счёт не трогается: он приходит своим вызовом. */
+    setActions(actions: readonly IRtActionBar.Action[]): void;
+    /** Счёт выбранного. Полоса открывается именно им. */
+    setCounts(selected: number, total: number): void;
+    /** Отпустить выбранное: счёт обнуляется, список действий остаётся. */
+    clearSelection(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtActionBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+export { IRtActionBar, RT_ACTION_BAR_LEAVE_MS, RtActionBarComponent, RtActionBarHolderComponent, RtActionBarService };

package/types/rt-tools-ui-kit-v2-aside-section.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from '@angular/core';
+import { InputSignal } from '@angular/core';
+
+/**
+ * Смысловая секция внутри асайда: единый вертикальный ритм между полями и
+ * необязательный заголовок одного стиля. Заменяет разнобой из `fieldset`,
+ * самопальных `div`-секций, `h3` и `<legend>`, которым раньше каждый диалог
+ * группировал контент по-своему.
+ *
+ * Заголовок (`[heading]`) рендерится только когда задан. Соседние секции
+ * автоматически разделяются верхней границей — отдельный разделитель в
+ * потребителе не нужен.
+ *
+ * Внутри секция размечена словарём формы панели: тело — колонкой контролов,
+ * заголовок — заголовком раздела. Ритм между ними приходит зазорами словаря,
+ * поэтому панель, собранная из готовых секций, и панель, размеченная словарём
+ * вручную, стоят одинаково.
+ */
+declare class RtAsideSectionComponent {
+    readonly heading: InputSignal<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtAsideSectionComponent, "rt-aside-section", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { RtAsideSectionComponent };

package/types/rt-tools-ui-kit-v2-aside.d.ts

@@ -0,0 +1,436 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from '@angular/core';
+import { Signal, ElementRef, InputSignal, InputSignalWithTransform, WritableSignal, Renderer2, Injector, InjectionToken, OutputEmitterRef } from '@angular/core';
+import { OverlayRef, ComponentType } from '@angular/cdk/overlay';
+import { Subject, Observable } from 'rxjs';
+import { TRtRadius, IRtIcon, TRtKitLabelMap } from '@rt-tools/ui-kit-v2/core';
+import { IRtTag } from '@rt-tools/ui-kit-v2/tag';
+
+/**
+ * Варианты ширины side-sheet:
+ * - `sm` — 400px (`--rt-aside-width-sm`)
+ * - `md` — 540px (`--rt-aside-width-md`, дефолт)
+ * - `lg` — 720px (`--rt-aside-width-lg`)
+ */
+type TRtAsideSize = 'sm' | 'md' | 'lg';
+/**
+ * Раскладка контентной зоны side-sheet:
+ * - `default` — контентная зона сама скроллится при overflow (штатный режим);
+ * - `tabs` — контент — это `rt-tabs`: внешняя зона перестаёт быть скроллером,
+ *   полоса вкладок прибита, скроллится только контент активной вкладки
+ *   (`rt-tabs__content`).
+ */
+type TRtAsideContentLayout = 'default' | 'tabs';
+/**
+ * Презентационный styled-frame для side-sheet.
+ *
+ * Видимость / backdrop / scroll-block / ESC / slide-in анимация — НЕ внутренняя
+ * ответственность компонента. Это обеспечивает CDK Overlay через
+ * `RtAsideService.open()`. rt-aside здесь — стилизованная "рамка" с size-вариантами
+ * и тремя слотами: `rt-aside-header`, содержимое и `rt-aside-footer`.
+ *
+ * Содержимое лежит в одной зоне `.rt-aside__content` — она и держит инсет панели,
+ * и прокручивается. Пока зоны не было, каждый корневой узел содержимого получал
+ * инсет и прокрутку сам по себе: разделы делили высоту панели между собой, а
+ * обводка фокуса поля срезалась краем такого мини-скроллера.
+ *
+ * Семантика — `role="complementary"` (mirror rt-dialog имеет `role="dialog"`,
+ * aside — другая роль, side-sheet не обязательно блокирующий).
+ *
+ * `ViewEncapsulation.None` — стили префиксованы `.rt-aside`, чтобы соседние
+ * rt-aside-header / rt-aside-footer работали с одним BEM-блоком без
+ * cross-encapsulation хака.
+ */
+declare class RtAsideComponent {
+    #private;
+    protected readonly frame: Signal<ElementRef<HTMLElement>>;
+    protected readonly hasRequestError: Signal<boolean>;
+    readonly size: InputSignal<TRtAsideSize>;
+    readonly contentLayout: InputSignal<TRtAsideContentLayout>;
+    readonly width: InputSignal<string | null>;
+    readonly ariaLabel: InputSignal<string | null>;
+    /**
+     * Ошибка неудавшегося запроса. Пока она есть, между шапкой и содержимым стоит блок ошибки с
+     * кнопкой копирования; `null` и `undefined` — ошибки нет, любое другое значение её показывает.
+     */
+    readonly requestError: InputSignal<unknown>;
+    /**
+     * Держать Tab внутри панели. При включении фокус уходит на `[cdkFocusInitial]` или первый
+     * элемент под Tab, а когда панель уходит или вход гаснет, возвращается туда, где стоял.
+     */
+    readonly trapFocus: InputSignalWithTransform<boolean, BooleanInput>;
+    /** Идёт запрос: панель накрыта слоем с крутилкой и помечена занятой. */
+    readonly pending: InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtAsideComponent, "rt-aside", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "contentLayout": { "alias": "contentLayout"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "requestError": { "alias": "requestError"; "required": false; "isSignal": true; }; "trapFocus": { "alias": "trapFocus"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; }, {}, never, ["rt-aside-header", "*", "rt-aside-footer"], true, never>;
+}
+
+/**
+ * Жест закрытия, на который панель не закрылась: `Escape` или нажатие по подложке. Панель
+ * отказывает в нём под `disableClose()` и когда жест выключен настройкой открытия.
+ */
+type TRtAsideCloseRequest = 'escape' | 'backdrop';
+/**
+ * Хэндл к программно открытой side-sheet (через `RtAsideService.open()`).
+ *
+ * Контент-компонент инжектит `RtAsideRef` и закрывает aside через `.close(result?)`.
+ * Родитель ждёт результата через `.afterClosed()`.
+ *
+ * Generic `<T>` — тип результата `close(result)`. Дефолт `unknown` — если результат
+ * не нужен, оставляй generic пустым.
+ *
+ * Lifecycle close():
+ *  1. Race-guard `#isClosing` гарантирует один эмит даже при двойном вызове.
+ *  2. Снимает `rt-aside-overlay--open` и ставит `rt-aside-overlay--leaving` на host —
+ *     CSS-transition (200ms) играет slide-out.
+ *  3. Эмиттит result в `afterClosed()` СРАЗУ (consumer не ждёт анимацию).
+ *  4. Через `setTimeout(200ms)` зовёт `overlayRef.dispose()` — overlay убран после анимации.
+ *
+ * Слой, снятый без `close()` — переходом по адресу (`disposeOnNavigation`) или уничтожением
+ * хозяина, — тоже завершает `afterClosed()`: подписчик получает `undefined`.
+ *
+ * @example
+ * \`\`\`ts
+ * // в контент-компоненте
+ * private readonly asideRef = inject(RtAsideRef<{ saved: boolean }>);
+ * onSave(): void { this.asideRef.close({ saved: true }); }
+ *
+ * // в родителе
+ * asideService.open(EditAsideComponent).afterClosed().subscribe(result => {...});
+ * \`\`\`
+ */
+declare class RtAsideRef<T = unknown> {
+    #private;
+    /**
+     * Runtime-флаг, блокирующий close() через ESC / backdrop click.
+     *
+     * Default `false`. Включай (`asideRef.disableClose.set(true)`) на время
+     * in-flight submit'а, чтобы юзер не потерял введённые в форму данные.
+     * Программный `close(result)` гейтом не задет — он всегда закрывает.
+     */
+    readonly disableClose: WritableSignal<boolean>;
+    /**
+     * `closeRequestsSource` наполняет служба: она слушает жесты и знает, отказала ли в них панель.
+     * Хэндл только завершает поток вместе с панелью.
+     */
+    constructor(overlayRef: OverlayRef, renderer: Renderer2, closeRequestsSource?: Subject<TRtAsideCloseRequest>);
+    /** Закрывает overlay со slide-out анимацией; эмиттит result в `afterClosed()` синхронно. */
+    close(result?: T): void;
+    /** Эмиттит один раз — результат `close(result)` или `undefined` при снятом слое — и завершается. */
+    afterClosed(): Observable<T | undefined>;
+    /**
+     * Жесты закрытия, в которых панель отказала: `Escape` и нажатие по подложке под
+     * `disableClose()` или выключенные настройкой. Завершается вместе с панелью.
+     */
+    closeRequests(): Observable<TRtAsideCloseRequest>;
+}
+
+/**
+ * Позиционирование side-sheet — у какого края viewport "приклеена" панель.
+ */
+type TRtAsidePosition = 'right' | 'left';
+/**
+ * Конфигурация открытия side-sheet через `RtAsideService.open()`.
+ */
+interface IRtAsideConfig<TData = unknown> {
+    /** Данные, доступные внутри aside'а через `inject(RT_ASIDE_DATA)`. */
+    data?: TData;
+    /** Дополнительный CSS-класс для backdrop (поверх стандартного `rt-aside-backdrop`). */
+    backdropClass?: string | string[];
+    /** Дополнительный CSS-класс для panel-обёртки overlay (поверх `rt-aside-overlay`). */
+    panelClass?: string | string[];
+    /** Закрывать aside по клику на backdrop. По дефолту `true`. */
+    closeOnBackdropClick?: boolean;
+    /** Закрывать aside по ESC. По дефолту `true`. */
+    closeOnEscape?: boolean;
+    /** К какому краю viewport "приклеить" панель. По дефолту `"right"`. */
+    position?: TRtAsidePosition;
+    /**
+     * Injector хозяина панели — обычно `inject(Injector)` открывающего компонента. Он становится
+     * родителем портала: содержимое видит провайдеры хозяина. Уничтожение хозяина закрывает
+     * панель через `close()`. Без него родитель — корневой injector, и панель живёт сама по себе.
+     */
+    injector?: Injector;
+}
+/**
+ * Программный API для открытия side-sheet поверх CDK Overlay.
+ *
+ * Архитектурно зеркалит `RtDialogService`, отличаясь только positionStrategy
+ * (edge-anchored: `right('0')` / `left('0')` + `top('0')`) и slide-in анимацией,
+ * которая триггерится через CSS-классы на overlay host (`Renderer2` инжектится
+ * через `RendererFactory2`, потому что в service нет ComponentRef).
+ *
+ * Lifecycle:
+ *  1. `overlay.create({ panelClass: [..., '--entering'] })` — host получает initial
+ *     CSS-стейт (translateX(±100%)).
+ *  2. `overlayRef.attach(portal)` — контент-компонент монтируется в host.
+ *  3. На следующий paint (`requestAnimationFrame`) сервис снимает `--entering` и
+ *     добавляет `--open` — CSS-transition сделает slide-in.
+ *  4. На `ref.close(result)` ref добавляет `--leaving`, эмиттит result синхронно,
+ *     deferred `dispose()` через 200ms (длительность анимации).
+ *
+ * Альтернатива rt-dialog — для длинных форм / мастеров / side-panels, где
+ * центрированная модалка ощущается тесной. Не предназначено для подтверждений
+ * или коротких диалогов (для этого — `RtDialogService`).
+ *
+ * @example
+ * \`\`\`ts
+ * private readonly asideService = inject(RtAsideService);
+ *
+ * openProfile(userId: number): void {
+ *   const ref = this.asideService.open<GuestProfileAsideComponent, { userId: number }, void>(
+ *     GuestProfileAsideComponent,
+ *     { data: { userId }, position: "right" }
+ *   );
+ *   ref.afterClosed().subscribe(() => this.reloadList());
+ * }
+ *
+ * // контент-компонент
+ * @Component({ ... })
+ * export class GuestProfileAsideComponent {
+ *   readonly data = inject(RT_ASIDE_DATA) as { userId: number };
+ *   readonly #ref = inject(RtAsideRef);
+ *   close(): void { this.#ref.close(); }
+ * }
+ * \`\`\`
+ */
+declare class RtAsideService {
+    #private;
+    constructor();
+    open<TComponent, TData = unknown, TResult = unknown>(component: ComponentType<TComponent>, config?: IRtAsideConfig<TData>): RtAsideRef<TResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Injection token для передачи данных в side-sheet, открытую через `RtAsideService.open()`.
+ *
+ * Пользовательский компонент-контент aside'а инжектит токен и получает данные,
+ * переданные в `IRtAsideConfig.data`. Тип значения задаётся generic'ом — `inject(RT_ASIDE_DATA)`
+ * вернёт `unknown`, прокастуй через `inject(RT_ASIDE_DATA) as MyDataType` ИЛИ
+ * объяви токен с конкретным generic'ом в feature-либе.
+ *
+ * Намеренно отдельный токен от `RT_DIALOG_DATA`, чтобы type-checker не путал контексты
+ * (rt-dialog vs rt-aside) — оба сервиса могут существовать в одном DI-дереве.
+ *
+ * @example
+ * \`\`\`ts
+ * @Component({...})
+ * export class GuestProfileAsideComponent {
+ *   readonly data = inject(RT_ASIDE_DATA) as { userId: number };
+ * }
+ *
+ * // parent
+ * asideService.open(GuestProfileAsideComponent, { data: { userId: 42 } });
+ * \`\`\`
+ */
+declare const RT_ASIDE_DATA: InjectionToken<unknown>;
+
+/**
+ * Контракты `rt-aside-header`. Один корневой неймспейс с
+ * префиксом `I`. `Badge` описывает один тег в ряду под заголовком — обёртка
+ * над `rt-tag`-инпутами с дефолтами, чтобы потребитель задавал только нужное.
+ */
+declare namespace IRtAsideHeader {
+    /** Конфиг одного бэйджа в ряду под заголовком (проксирует инпуты `rt-tag`). */
+    interface Badge {
+        /** Текст бэйджа. */
+        value: string;
+        /** Палитра. Дефолт потребления — `neutral`. */
+        severity?: IRtTag.Severity;
+        /** Вид заливки. Дефолт потребления — `solid`. */
+        appearance?: IRtTag.Appearance;
+        /** Шаг скругления метки. Пусто — `md`. */
+        radius?: TRtRadius | null;
+        /** Префикс-иконка. */
+        icon?: IRtIcon.Name | null;
+        /**
+         * Ссылка-назначение. Если задана — бэйдж рендерится якорем и открывает
+         * URL в новой вкладке (`target="_blank"`); иначе это обычный тег.
+         */
+        href?: string;
+    }
+}
+
+/**
+ * Заголовок side-sheet'а; работает в двух modes:
+ *
+ * 1. **Programmatic** (через `RtAsideService.open()`) — `RtAsideRef` провайдится
+ *    оверлей-инжектором; стрелка «назад» дёргает `asideRef.close()` напрямую,
+ *    consumer подписан на `afterClosed()`.
+ * 2. **Route-driven** (через `[rtContainerRightSidenavPanel]` driver в
+ *    rt-container'е) — `RtAsideRef` НЕ провайдится (overlay принадлежит
+ *    rt-container'у, не RtAsideService). Consumer слушает `(dismiss)` output и
+ *    сам зовёт `panel.close()`.
+ *
+ * Оба пути живут одновременно: `onDismiss()` сперва эмитит output, затем (если
+ * есть) дёргает optional `asideRef.close()`.
+ *
+ * Доменные действия (отклонить / удалить / снять с публикации и т.п.)
+ * проецируются в слот `[asideActions]` как ряд `rt-icon-button` справа от title.
+ *
+ * Слот `[asideHeaderContent]` — строка под заголовком на всю ширину шапки: поиск, вкладки,
+ * сводка. Пустой слот места не занимает.
+ *
+ * `ViewEncapsulation.None` — для единообразия с rt-dialog-header (стили
+ * префиксованы `.rt-aside-header`).
+ *
+ * @example
+ * ```html
+ * <rt-aside-header title="Профиль пользователя" />
+ * <rt-aside-header title="Создание записи" [closable]="false" />
+ * <rt-aside-header title="Детали" (dismiss)="onClose()">
+ *     <rt-icon-button asideActions icon="ico-error" variant="danger"
+ *                     ariaLabel="Отклонить" (clicked)="reject()" />
+ * </rt-aside-header>
+ * ```
+ */
+declare class RtAsideHeaderComponent {
+    #private;
+    /** Текст заголовка — рендерится в `<h2>`. Null/пустая строка вместе с
+     *  `[loading]=true` показывают skeleton вместо title. */
+    protected readonly t: Signal<TRtKitLabelMap>;
+    readonly title: InputSignal<string | null>;
+    /**
+     * Мелкий приглушённый надзаголовок НАД основным title (контекст действия:
+     * «Создание записи», «Запись № 6»). Null (дефолт) — обычный
+     * однострочный хедер. Overline не участвует в skeleton-режиме — это
+     * статичный текст, известный до загрузки данных.
+     */
+    readonly overline: InputSignal<string | null>;
+    /**
+     * Приглушённая подпись ПОД заголовком: что делается в панели. Null (дефолт) —
+     * строки нет. Как надзаголовок, в skeleton-режиме не участвует.
+     */
+    readonly subtitle: InputSignal<string | null>;
+    /**
+     * Ряд бэйджей (`rt-tag`) под заголовком — контекст сущности (статус, метка
+     * записи и т.п.). Пустой массив (дефолт) — ряд не рендерится. Async-данные:
+     * потребитель отдаёт `[]` пока сущность не зарезолвилась.
+     */
+    readonly badges: InputSignal<readonly IRtAsideHeader.Badge[]>;
+    /** Показывать кнопку закрытия в углу заголовка. Дефолт `true`. */
+    readonly closable: InputSignalWithTransform<boolean, BooleanInput>;
+    /** Показывать skeleton вместо title (loading-state aside'а пока данные
+     *  резолвятся через async fasade). Дефолт `false`. */
+    readonly loading: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Эмитится при клике по стрелке «назад» — намерение пользователя закрыть
+     * aside (intent, не «закрыто»). Route-driven consumer слушает этот output и
+     * дёргает `panel.close()` сам. Имя `dismiss` вместо `close` — ESLint
+     * `@angular-eslint/no-output-native` блокирует output с именем стандартного
+     * DOM-события (`close`).
+     */
+    readonly dismiss: OutputEmitterRef<void>;
+    protected onDismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtAsideHeaderComponent, "rt-aside-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "overline": { "alias": "overline"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "badges": { "alias": "badges"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, ["[asideActions]", "[asideHeaderContent]"], true, never>;
+}
+
+/**
+ * Footer-слот для композиции внутри `<rt-aside>`. Две зоны через именованные
+ * слоты: `[asideDismiss]` (слева — «Закрыть», `appearance="text"`, всегда) и
+ * `[asidePrimary]` (справа — единственный позитивный глагол: Сохранить /
+ * Отправить / Опубликовать, если есть). Раскладка `justify-content:
+ * space-between`. Доменные/деструктивные действия в футер не кладём — они
+ * проецируются иконками в `<rt-aside-header>` слот `[asideActions]`.
+ *
+ * Только две именованные зоны — безатрибутный контент НЕ проецируется (контент
+ * без `asideDismiss`/`asidePrimary` не отрендерится).
+ *
+ * `ViewEncapsulation.None` — для единообразия с rt-aside.
+ *
+ * @example
+ * \`\`\`html
+ * <rt-aside-footer>
+ *   <button rtButton asideDismiss appearance="text" (click)="onClose()">Закрыть</button>
+ *   <button rtButton asidePrimary theme="primary" (click)="save()">Сохранить</button>
+ * </rt-aside-footer>
+ * \`\`\`
+ */
+declare class RtAsideFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtAsideFooterComponent, "rt-aside-footer", never, {}, {}, never, ["[asideDismiss]", "[asidePrimary]"], true, never>;
+}
+
+/**
+ * Блок ошибки запроса боковой панели: надпись и кнопка, которая кладёт в буфер обмена время и
+ * ошибку. Перенос `rtui-aside-error-box` первого кита без Material.
+ *
+ * Обычно его рисует сама панель по входу `requestError`; отдельно он нужен приложению, которое
+ * показывает ошибку в другом месте.
+ */
+declare class RtAsideErrorBoxComponent {
+    #private;
+    protected readonly title: Signal<string>;
+    protected readonly copied: WritableSignal<boolean>;
+    protected readonly buttonLabel: Signal<string>;
+    protected readonly buttonIcon: Signal<string | null>;
+    /** Ошибка, пришедшая от неудавшегося запроса: уходит в копию как JSON. */
+    readonly error: InputSignal<unknown>;
+    constructor();
+    protected onCopy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideErrorBoxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtAsideErrorBoxComponent, "rt-aside-error-box", never, { "error": { "alias": "error"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Окно, которое видит пользователь, закрывая панель с несохранёнными правками. Три
+ * исхода: закрыть без сохранения, закрыть с сохранением, остаться. Открывает его
+ * общая основа асайда, поэтому наружу компонент не экспортируется.
+ *
+ * Отказ от правок подан красной кнопкой: это единственный исход, после которого
+ * введённое не вернуть.
+ */
+declare class RtAsideUnsavedDialogComponent {
+    #private;
+    protected readonly t: Signal<TRtKitLabelMap>;
+    protected onDiscard(): void;
+    protected onSave(): void;
+    protected onStay(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RtAsideUnsavedDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RtAsideUnsavedDialogComponent, "rt-aside-unsaved-dialog", never, {}, {}, never, never, true, never>;
+}
+
+/** Что делает панель, когда её просят закрыться. */
+declare enum ERtAsideCloseIntent {
+    /** Ничего: идёт запись, и закрытие посреди неё потеряло бы её результат. */
+    Ignore = "ignore",
+    /** Закрыться сразу: терять нечего. */
+    Close = "close",
+    /** Спросить, что сделать с несохранёнными правками. */
+    Ask = "ask"
+}
+/** Исход окна с несохранёнными правками. */
+declare enum ERtAsideUnsavedOutcome {
+    /** Закрыть без сохранения. */
+    Discard = "discard",
+    /** Закрыть с сохранением. */
+    Save = "save",
+    /** Остаться в панели. */
+    Stay = "stay"
+}
+/**
+ * Гард закрытия, который панель ставит на себя: признак нетронутости формы и
+ * запись, которую зовёт исход «закрыть с сохранением».
+ */
+interface IRtAsideUnsavedGuard {
+    pristine: Signal<boolean>;
+    save: () => void;
+}
+/** Состояние панели на момент намерения закрыть её. */
+interface IRtAsideCloseState {
+    submitting: boolean;
+    guarded: boolean;
+    pristine: boolean;
+}
+/**
+ * Решение по намерению закрыть панель. Одно на все четыре пути закрытия: кнопку
+ * в шапке, кнопку в футере, нажатие мимо панели и клавишу Esc — иначе Esc обошёл
+ * бы то, что ловит кнопка.
+ */
+declare function resolveCloseIntent(state: IRtAsideCloseState): ERtAsideCloseIntent;
+
+export { ERtAsideCloseIntent, ERtAsideUnsavedOutcome, IRtAsideHeader, RT_ASIDE_DATA, RtAsideComponent, RtAsideErrorBoxComponent, RtAsideFooterComponent, RtAsideHeaderComponent, RtAsideRef, RtAsideService, RtAsideUnsavedDialogComponent, resolveCloseIntent };
+export type { IRtAsideCloseState, IRtAsideConfig, IRtAsideUnsavedGuard, TRtAsideCloseRequest, TRtAsideContentLayout, TRtAsidePosition, TRtAsideSize };