@masterteam/notification 0.0.27 → 0.0.29

package/types/masterteam-notification.d.ts

@@ -1,118 +1,257 @@
 import * as _angular_core from '@angular/core';
+import { DestroyRef, OnInit } from '@angular/core';
 import * as _masterteam_notification from '@masterteam/notification';
-import { FormGroup, FormControl } from '@angular/forms';
-import { LoadingStateShape, CrudStateBase, Response } from '@masterteam/components';
-import { ModalService } from '@masterteam/components/modal';
+import { FormControl, FormGroup } from '@angular/forms';
+import { LoadingStateShape } from '@masterteam/components';
 import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ModalService } from '@masterteam/components/modal';
 import { StateContext } from '@ngxs/store';
 
 declare enum NotificationActionKey {
     GetEvents = "getEvents",
-    GetReceivers = "getReceivers",
-    GetProperties = "getProperties",
+    GetContext = "getContext",
+    GetDefaults = "getDefaults",
+    GetPublications = "getPublications",
+    CreateTemplate = "createTemplate",
+    SaveTemplate = "saveTemplate",
     AddReceivers = "addReceivers",
     DeleteReceiver = "deleteReceiver",
-    AddTemplate = "addTemplate",
-    UpdateTemplate = "updateTemplate",
-    DeleteTemplate = "deleteTemplate"
-}
-type NotificationChannel = 'email' | 'sms' | 'app';
-interface ChannelConfig {
-    key: NotificationChannel;
-    labelKey: string;
-    /** Whether this channel supports bilingual content */
-    supportsBilingual: boolean;
-    /** Whether bilingual is optional (true = show toggle) */
-    bilingualOptional: boolean;
-    /** Whether this channel uses rich text editor (false = textarea) */
-    useRichEditor: boolean;
-    /** Payload key for non-bilingual template (string value) */
-    templateKey?: string;
-    /** Payload key for bilingual template (object with en/ar) */
-    translatableKey?: string;
-}
-declare const CHANNEL_CONFIGS: ChannelConfig[];
-/** Helper to get channel config by key */
-declare function getChannelConfig(key: NotificationChannel): ChannelConfig;
-/** Build form control name for a channel field */
-declare function getFormControlName(ch: ChannelConfig, type: 'single' | 'en' | 'ar'): string | null;
+    DeleteTemplate = "deleteTemplate",
+    PublishTemplate = "publishTemplate",
+    SetActivation = "setActivation",
+    RestorePublication = "restorePublication",
+    InitializeDefaults = "initializeDefaults",
+    RestoreDefault = "restoreDefault"
+}
+/** Writes that must never run twice at once (the contract forbids double submits). */
+declare const NOTIFICATION_MUTATION_KEYS: readonly NotificationActionKey[];
+type NotificationChannel = 'App' | 'Email' | 'Sms';
+type NotificationReceiverType = 'Actor' | 'Role' | 'Group';
+declare const NOTIFICATION_CHANNELS: readonly NotificationChannel[];
 interface TranslatableContent {
     en: string;
     ar: string;
 }
-interface ReceiverItem {
-    id: string | number;
-    identifier: string;
-    name: any;
-    type: string;
-    isSystem?: boolean;
+interface NotificationReceiver {
+    /** Saved recipient row id — the id used to remove it. */
+    id: number;
+    /** Catalog actor / role / group id. */
+    identifier: string | null;
+    type: NotificationReceiverType;
+    templateId: number;
+    isSystem: boolean;
+    name: {
+        display: string | null;
+        en: string | null;
+        ar: string | null;
+    };
 }
-interface ReceiverGroup {
-    groupName: string;
-    items: ReceiverItem[] | ReceiverSubGroup[];
+interface NotificationTemplateItem {
+    id: number;
+    eventId: number;
+    channel: NotificationChannel;
+    name: string | null;
+    subject: string | null;
+    emailTemplate: string | null;
+    smsTemplate: string | null;
+    appTemplate: TranslatableContent | null;
+    conditionFormula: string | null;
+    /** Aggregate concurrency token for every write on this template. */
+    revision: number;
+    draftRevision: number;
+    publishedRevision: number | null;
+    publishedHash: string | null;
+    isEnabled: boolean;
+    isSystem: boolean;
+    receivers: NotificationReceiver[];
+    auditState: string | null;
+    auditCode: string | null;
 }
-interface ReceiverSubGroup {
-    subGroupName: string;
-    items: ReceiverItem[];
+interface NotificationEvent {
+    id: number;
+    name: string;
+    eventName: string;
+    moduleId: number;
 }
-interface ReceiverOptionGroup {
-    groupName: string;
-    items: ReceiverItem[];
+interface NotificationEventWithTemplates extends NotificationEvent {
+    templates: NotificationTemplateItem[];
 }
 interface NotificationProperty {
     key: string;
     name: string;
-    groupName?: string;
+    nameEn: string;
+    nameAr: string;
 }
-interface PropertyGroup {
+interface NotificationPropertyGroup {
     groupName: string;
     properties: NotificationProperty[];
 }
-interface NotificationTemplateItem {
-    id: string | number;
-    eventId: string | number;
+/** A recipient catalog node: a subgroup when `items` is an array, otherwise a leaf. */
+interface NotificationRecipientNode {
+    subGroupName?: string | null;
+    items?: NotificationRecipientNode[] | null;
+    id?: string | null;
+    name?: string | null;
+    nameEn?: string | null;
+    nameAr?: string | null;
+    type?: NotificationReceiverType | null;
+}
+interface NotificationRecipientGroup {
+    groupName: string;
+    items: NotificationRecipientNode[];
+}
+interface NotificationAuthoringContext {
+    eventId: number;
+    channels: NotificationChannel[];
+    properties: NotificationPropertyGroup[];
+    conditionProperties: NotificationProperty[];
+    recipients: NotificationRecipientGroup[];
+    publicationHistoryLimit: number;
+}
+interface NotificationPublishedRecipient {
+    identifier: string;
     name: string;
+    type: NotificationReceiverType;
     isSystem: boolean;
-    channel: NotificationChannel;
-    receivers: ReceiverItem[];
-    emailTemplate: string;
-    emailContentTranslatable: TranslatableContent;
-    smsTemplate: string;
-    appTemplate: TranslatableContent;
-    conditionFormula?: string;
 }
-interface NotificationEvent {
-    id: string | number;
-    eventName: string;
+interface NotificationPublishedContent {
+    formatVersion: number;
+    channel: NotificationChannel;
+    sourceDraftRevision: number;
     name: string;
-}
-interface NotificationAction {
-    id: string | number;
+    subject: string | null;
+    emailContent: string | null;
+    smsContent: string | null;
+    /** Serialized `{ en, ar }` JSON — parse it, never render it as HTML. */
+    appContent: string | null;
+    conditionFormula: string | null;
+    receivers: NotificationPublishedRecipient[];
+}
+interface NotificationPublication {
+    revision: number;
+    sourceDraftRevision: number;
+    hash: string;
+    publishedAtUtc: string;
+    publishedBy: string;
+    content: NotificationPublishedContent;
+}
+type NotificationRecipeCoverage = 'Ready' | 'SafeGeneric' | 'NeedsReview';
+interface NotificationDefaultSlot {
+    eventId: number;
+    channel: NotificationChannel;
+    /** Null means the default was intentionally removed — never recreate it silently. */
+    templateId: number | null;
+    recipeKey: string;
+    recipeVersion: number;
+    recipeHash: string;
+    revision: number;
+}
+interface NotificationDefaultRecipe {
+    key: string;
+    version: number;
+    channel: NotificationChannel;
+    coverage: NotificationRecipeCoverage;
+    languageReviewRequired: boolean;
+    recipientReviewRequired: boolean;
+    autoPublishApp: boolean;
+    recipeHash: string;
+    /** Unsaved proposal in template shape (`id: 0`). */
+    draft: NotificationTemplateItem;
+}
+interface NotificationDefaults {
+    eventId: number;
+    slots: NotificationDefaultSlot[];
+    adoptions: Partial<Record<NotificationChannel, number>>;
+    recipes: NotificationDefaultRecipe[];
+}
+interface NotificationInitializeDefaultsResult {
+    defaults: NotificationDefaults;
+    createdTemplates: NotificationTemplateItem[];
+    auditProjectionFailures: number[];
+}
+interface NotificationDiagnostic {
+    code: string;
+    severity: string;
+    path: string;
+}
+interface NotificationPreviewRequest {
+    channel: NotificationChannel;
+    subject?: string | null;
+    emailTemplate?: string | null;
+    smsTemplate?: string | null;
+    appTemplate?: TranslatableContent | null;
+    samples?: Record<string, string>;
+}
+interface NotificationFragmentPreview {
+    html: string;
+    text: string;
+    bodyHash: string;
+    layoutHash: string;
+    diagnostics: NotificationDiagnostic[];
+}
+interface NotificationEmailPreview {
+    channel: 'Email';
+    subject: string | null;
+    html: string;
+    text: string;
+    sanitizedBody: string;
+    layoutRevision: number;
+    layoutSource: string;
+    layoutHash: string;
+    contentHash: string;
+    diagnostics: NotificationDiagnostic[];
+    approvedImageOrigins: string[];
+    fidelity: 'browser';
+}
+interface NotificationAppPreview {
+    channel: 'App';
+    english: NotificationFragmentPreview;
+    arabic: NotificationFragmentPreview;
+    sanitizedBody: TranslatableContent;
+    approvedImageOrigins: string[];
+    fidelity: 'browser';
+}
+interface NotificationSmsPreview {
+    channel: 'Sms';
+    text: string;
+    sanitizedBody: string;
+    diagnostics: NotificationDiagnostic[];
+    fidelity: 'text';
+}
+type NotificationPreview = NotificationEmailPreview | NotificationAppPreview | NotificationSmsPreview;
+interface NotificationReceiverRef {
+    type: NotificationReceiverType;
+    id: string;
+}
+interface CreateNotificationTemplatePayload {
+    channel: NotificationChannel;
     name: string;
-    type: string;
-}
-interface ActionGroup {
-    activity: string;
-    items: NotificationAction[];
-}
-interface ReceiverPayloadItem {
-    id: string | number;
-    type: string;
+    subject: string | null;
+    emailTemplate: string | null;
+    smsTemplate: string | null;
+    appTemplate: TranslatableContent | null;
+    conditionFormula: string | null;
+    receivers: NotificationReceiverRef[];
+}
+/** Replacement, not a patch: a null field clears its value. */
+interface SaveNotificationTemplatePayload {
+    expectedRevision: number;
+    name: string;
+    subject: string | null;
+    emailTemplate: string | null;
+    smsTemplate: string | null;
+    appTemplate: TranslatableContent | null;
+    conditionFormula: string | null;
 }
-interface AddReceiversPayload {
-    receivers: ReceiverPayloadItem[];
+interface NotificationReviewFlags {
+    recipientsReviewed: boolean;
+    languageReviewed: boolean;
 }
-interface AddTemplatePayload {
-    name: string;
+interface RestoreNotificationDefaultPayload {
     channel: NotificationChannel;
-}
-interface UpdateTemplatePayload {
-    title: string;
-    emailTemplate?: string;
-    emailContentTranslatable?: TranslatableContent;
-    smsTemplate?: string;
-    appTemplate?: TranslatableContent;
-    conditionFormula?: string;
+    expectedSlotRevision: number;
+    recipeHash: string;
 }
 interface NotificationStateModel extends LoadingStateShape<NotificationActionKey> {
     moduleType: string | null;
@@ -120,16 +259,14 @@ interface NotificationStateModel extends LoadingStateShape<NotificationActionKey
     parentModuleType: string | null;
     parentModuleId: string | number | null;
     parentPath: string;
-    isActionMode: boolean;
-    selectedActionId: string | number | null;
     events: NotificationEvent[];
     templates: NotificationTemplateItem[];
-    actions: NotificationAction[];
-    receivers: ReceiverItem[];
-    receiverGroups: ReceiverOptionGroup[];
-    propertyGroups: PropertyGroup[];
-    selectedEventName: string | null;
-    selectedTemplateId: string | number | null;
+    context: NotificationAuthoringContext | null;
+    defaults: NotificationDefaults | null;
+    publications: NotificationPublication[];
+    publicationsTemplateId: number | null;
+    selectedEventId: number | null;
+    selectedTemplateId: number | null;
 }
 
 declare class SetModuleInfo {
@@ -141,147 +278,272 @@ declare class SetModuleInfo {
     static readonly type = "[Notification] Set Module Info";
     constructor(moduleType: string, moduleId: string | number, parentModuleType?: string | undefined, parentModuleId?: string | number | undefined, parentPath?: string | undefined);
 }
+declare class ResetNotificationState {
+    static readonly type = "[Notification] Reset State";
+}
+/** Loads (or re-reads) the scope's events, keeping the current selection when it still exists. */
 declare class GetEvents {
     static readonly type = "[Notification] Get Events";
 }
-declare class GetReceivers {
-    static readonly type = "[Notification] Get Receivers";
-}
-declare class GetProperties {
-    isMultiLang?: boolean | undefined;
-    static readonly type = "[Notification] Get Properties";
-    constructor(isMultiLang?: boolean | undefined);
-}
-declare class SetActionMode {
-    actionId: string | number | null;
-    static readonly type = "[Notification] Set Action Mode";
-    constructor(actionId: string | number | null);
+declare class GetAuthoringContext {
+    eventId: number;
+    static readonly type = "[Notification] Get Authoring Context";
+    constructor(eventId: number);
 }
-declare class GetActionReceivers {
-    actionId: string | number;
-    static readonly type = "[Notification] Get Action Receivers";
-    constructor(actionId: string | number);
+declare class GetDefaultRecipes {
+    eventId: number;
+    static readonly type = "[Notification] Get Default Recipes";
+    constructor(eventId: number);
 }
-declare class GetActionProperties {
-    actionId: string | number;
-    isMultiLang?: boolean | undefined;
-    static readonly type = "[Notification] Get Action Properties";
-    constructor(actionId: string | number, isMultiLang?: boolean | undefined);
+declare class GetPublications {
+    templateId: number;
+    static readonly type = "[Notification] Get Publications";
+    constructor(templateId: number);
 }
 declare class SelectEvent {
-    eventName: string;
+    eventId: number;
     static readonly type = "[Notification] Select Event";
-    constructor(eventName: string);
+    constructor(eventId: number);
 }
 declare class SelectTemplate {
-    templateId: string | number;
+    templateId: number;
     static readonly type = "[Notification] Select Template";
-    constructor(templateId: string | number);
-}
-declare class AddReceivers {
-    templateId: string | number;
-    payload: AddReceiversPayload;
-    static readonly type = "[Notification] Add Receivers";
-    constructor(templateId: string | number, payload: AddReceiversPayload);
-}
-declare class DeleteReceiver {
-    receiverId: string | number;
-    static readonly type = "[Notification] Delete Receiver";
-    constructor(receiverId: string | number);
+    constructor(templateId: number);
 }
-declare class AddTemplate {
-    eventId: string | number;
-    payload: AddTemplatePayload;
-    static readonly type = "[Notification] Add Template";
-    constructor(eventId: string | number, payload: AddTemplatePayload);
+declare class CreateTemplate {
+    eventId: number;
+    payload: CreateNotificationTemplatePayload;
+    static readonly type = "[Notification] Create Template";
+    constructor(eventId: number, payload: CreateNotificationTemplatePayload);
 }
-declare class UpdateTemplate {
-    templateId: string | number;
-    payload: UpdateTemplatePayload;
-    static readonly type = "[Notification] Update Template";
-    constructor(templateId: string | number, payload: UpdateTemplatePayload);
+declare class SaveTemplate {
+    templateId: number;
+    payload: SaveNotificationTemplatePayload;
+    static readonly type = "[Notification] Save Template";
+    constructor(templateId: number, payload: SaveNotificationTemplatePayload);
 }
 declare class DeleteTemplate {
-    templateId: string | number;
+    templateId: number;
+    expectedRevision: number;
     static readonly type = "[Notification] Delete Template";
-    constructor(templateId: string | number);
+    constructor(templateId: number, expectedRevision: number);
 }
-declare class ResetNotificationState {
-    static readonly type = "[Notification] Reset State";
+declare class AddReceivers {
+    templateId: number;
+    expectedRevision: number;
+    receivers: NotificationReceiverRef[];
+    static readonly type = "[Notification] Add Receivers";
+    constructor(templateId: number, expectedRevision: number, receivers: NotificationReceiverRef[]);
+}
+declare class DeleteReceiver {
+    receiverId: number;
+    expectedRevision: number;
+    static readonly type = "[Notification] Delete Receiver";
+    constructor(receiverId: number, expectedRevision: number);
+}
+declare class PublishTemplate {
+    templateId: number;
+    expectedRevision: number;
+    reviews: NotificationReviewFlags;
+    static readonly type = "[Notification] Publish Template";
+    constructor(templateId: number, expectedRevision: number, reviews: NotificationReviewFlags);
+}
+declare class SetTemplateActivation {
+    templateId: number;
+    expectedRevision: number;
+    enabled: boolean;
+    reviews: NotificationReviewFlags | null;
+    static readonly type = "[Notification] Set Template Activation";
+    constructor(templateId: number, expectedRevision: number, enabled: boolean, reviews: NotificationReviewFlags | null);
+}
+declare class RestorePublication {
+    templateId: number;
+    expectedRevision: number;
+    publicationRevision: number;
+    reviews: NotificationReviewFlags;
+    static readonly type = "[Notification] Restore Publication";
+    constructor(templateId: number, expectedRevision: number, publicationRevision: number, reviews: NotificationReviewFlags);
+}
+declare class InitializeDefaults {
+    eventId: number;
+    static readonly type = "[Notification] Initialize Defaults";
+    constructor(eventId: number);
+}
+declare class RestoreDefault {
+    eventId: number;
+    payload: RestoreNotificationDefaultPayload;
+    static readonly type = "[Notification] Restore Default";
+    constructor(eventId: number, payload: RestoreNotificationDefaultPayload);
 }
 
-declare class NotificationState extends CrudStateBase<NotificationTemplateItem, NotificationStateModel, NotificationActionKey> {
+/**
+ * Notification authoring endpoints. Every call is marked `noMessage`: the
+ * backend answers failures with a bare stable code (`NOTIFICATION_*`) as the
+ * message, so the host's message interceptor would toast that raw code. The
+ * editor translates the code itself (see `notification.errors.ts`).
+ */
+declare class NotificationTemplateApi {
     private readonly http;
     private readonly baseUrl;
-    static getState(state: NotificationStateModel): NotificationStateModel;
+    private readonly headers;
+    getEvents(scopePath: string): Observable<NotificationEventWithTemplates[]>;
+    getContext(eventId: number): Observable<NotificationAuthoringContext>;
+    getDefaults(eventId: number): Observable<NotificationDefaults>;
+    initializeDefaults(eventId: number): Observable<NotificationInitializeDefaultsResult>;
+    restoreDefault(eventId: number, payload: RestoreNotificationDefaultPayload): Observable<NotificationTemplateItem>;
+    preview(eventId: number, request: NotificationPreviewRequest): Observable<NotificationPreview>;
+    createTemplate(eventId: number, payload: CreateNotificationTemplatePayload): Observable<NotificationTemplateItem>;
+    saveTemplate(templateId: number, payload: SaveNotificationTemplatePayload): Observable<NotificationTemplateItem>;
+    addReceivers(templateId: number, expectedRevision: number, receivers: NotificationReceiverRef[]): Observable<NotificationTemplateItem>;
+    deleteReceiver(receiverId: number, expectedRevision: number): Observable<NotificationTemplateItem>;
+    deleteTemplate(templateId: number, expectedRevision: number): Observable<unknown>;
+    getPublications(templateId: number): Observable<NotificationPublication[]>;
+    publish(templateId: number, expectedRevision: number, reviews: NotificationReviewFlags): Observable<NotificationTemplateItem>;
+    setActivation(templateId: number, expectedRevision: number, enabled: boolean, reviews: NotificationReviewFlags | null): Observable<NotificationTemplateItem>;
+    restorePublication(templateId: number, expectedRevision: number, publicationRevision: number, reviews: NotificationReviewFlags): Observable<NotificationTemplateItem>;
+    private get;
+    private post;
+    private delete;
+    private url;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationTemplateApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationTemplateApi>;
+}
+
+interface NotificationFailure {
+    /** Stable domain code (`NOTIFICATION_*` / `EMAIL_*`), or null for transport failures. */
+    code: string | null;
+    status: number | null;
+    diagnostics: NotificationDiagnostic[];
+}
+/**
+ * Reads the stable code out of a failed notification request.
+ *
+ * Domain failures arrive as `errors: { code, message, details }`. Command
+ * endpoints can wrap the domain code in `errors.details.code` under an outer
+ * validation code (e.g. `VAL_002`), so the nested code wins when present.
+ * Display text is never matched — only codes.
+ */
+declare function readNotificationFailure(error: unknown): NotificationFailure;
+declare function isRevisionConflict(failure: NotificationFailure): boolean;
+
+interface NotificationRecipientOption {
+    /** `${type}:${id}` — selections are keyed by type and id, never id alone. */
+    key: string;
+    id: string;
+    type: NotificationReceiverType;
+    name: string;
+}
+interface NotificationRecipientOptionGroup {
+    groupName: string;
+    items: NotificationRecipientOption[];
+}
+type NotificationTemplateStatus = 'on' | 'off' | 'draft';
+declare function recipientKey(type: NotificationReceiverType | null | undefined, id: string | null | undefined): string;
+/**
+ * Flattens the recipient catalog into select-ready groups. A node is a
+ * subgroup only when its `items` is an array — leaves carry `items: null` —
+ * and subgroup names are kept as a prefix so two "Manager" roles from
+ * different levels stay distinguishable.
+ */
+declare function flattenRecipientCatalog(groups: NotificationRecipientGroup[], lang: string): NotificationRecipientOptionGroup[];
+declare function templateStatus(template: NotificationTemplateItem): NotificationTemplateStatus;
+/** The retained publication that is live right now, if it is in the loaded history. */
+declare function currentPublication(template: NotificationTemplateItem, publications: NotificationPublication[]): NotificationPublication | null;
+/**
+ * Whether the saved draft differs from what is published. Comparing
+ * `draftRevision` to `publishedRevision` is wrong (they count different
+ * things); the contract compares the draft against the `sourceDraftRevision`
+ * of the current publication. Null when that cannot be known yet.
+ */
+declare function hasUnpublishedChanges(template: NotificationTemplateItem, publications: NotificationPublication[]): boolean | null;
+/** The default slot that owns this template, if any (owned defaults need a language review). */
+declare function isDefaultOwned(template: NotificationTemplateItem, defaults: NotificationDefaults | null): boolean;
+/** Channels with a recipe but no slot at all — the only ones "Add defaults" may create. */
+declare function missingDefaultChannels(defaults: NotificationDefaults | null): NotificationChannel[];
+declare function parseAppContent(value: string | null | undefined): TranslatableContent;
+/** Maps retained publication content onto the event preview request. */
+declare function publicationPreviewRequest(content: NotificationPublishedContent): NotificationPreviewRequest;
+declare function templatePreviewRequest(template: Pick<NotificationTemplateItem, 'channel' | 'subject' | 'emailTemplate' | 'smsTemplate' | 'appTemplate'>): NotificationPreviewRequest;
+/**
+ * Readable sample values for a preview: every field the content uses shows as
+ * its own name in brackets (`[Item name]`) instead of the server's "-", and the
+ * record link resolves. Only keys in the event's catalog are sent — the server
+ * rejects any other sample key — and never more than the server's limit.
+ */
+declare function previewSamples(request: NotificationPreviewRequest, properties: readonly NotificationPropertyGroup[], lang: string): Record<string, string>;
+declare function withPreviewSamples(request: NotificationPreviewRequest, properties: readonly NotificationPropertyGroup[], lang: string): NotificationPreviewRequest;
+/** The system principal that publishes generated App defaults. */
+declare const DEFAULTS_PUBLISHER = "system:notification-defaults";
+
+declare class NotificationState {
+    private readonly api;
     static getEvents(state: NotificationStateModel): NotificationEvent[];
     static getTemplates(state: NotificationStateModel): NotificationTemplateItem[];
-    static getReceivers(state: NotificationStateModel): ReceiverItem[];
-    static getReceiverGroups(state: NotificationStateModel): ReceiverOptionGroup[];
-    static getPropertyGroups(state: NotificationStateModel): PropertyGroup[];
-    static getSelectedEventName(state: NotificationStateModel): string | null;
-    static getSelectedTemplateId(state: NotificationStateModel): string | number | null;
+    static getSelectedEventId(state: NotificationStateModel): number | null;
+    static getSelectedTemplateId(state: NotificationStateModel): number | null;
+    static getContext(state: NotificationStateModel): NotificationAuthoringContext | null;
+    static getDefaults(state: NotificationStateModel): NotificationDefaults | null;
+    static getPublicationsSlice(state: NotificationStateModel): {
+        templateId: number | null;
+        items: NotificationPublication[];
+    };
     static getLoadingActive(state: NotificationStateModel): string[];
     static getErrors(state: NotificationStateModel): Record<string, string | null>;
-    static getSelectedEvent(events: NotificationEvent[], selectedEventName: string | null): NotificationEvent | null;
-    static getEventTemplates(templates: NotificationTemplateItem[], selectedEvent: NotificationEvent | null): NotificationTemplateItem[];
-    static getSelectedTemplate(templates: NotificationTemplateItem[], selectedTemplateId: string | number | null): NotificationTemplateItem | null;
-    static getAvailableReceivers(receivers: ReceiverItem[], selectedTemplate: NotificationTemplateItem | null): ReceiverItem[];
-    static getAvailableReceiverGroups(receiverGroups: ReceiverOptionGroup[], selectedTemplate: NotificationTemplateItem | null): ReceiverOptionGroup[];
-    /** API returns events with nested templates - we flatten for state */
-    private flattenEventsResponse;
-    private normalizeReceiverGroups;
-    private flattenReceiverItems;
-    private hasOwnField;
-    private mergeUpdatedTemplate;
+    static getSelectedEvent(events: NotificationEvent[], selectedEventId: number | null): NotificationEvent | null;
+    static getEventTemplates(templates: NotificationTemplateItem[], selectedEventId: number | null): NotificationTemplateItem[];
+    static getSelectedTemplate(templates: NotificationTemplateItem[], selectedTemplateId: number | null): NotificationTemplateItem | null;
+    static getPublications(slice: {
+        templateId: number | null;
+        items: NotificationPublication[];
+    }, selectedTemplateId: number | null): NotificationPublication[];
     setModuleInfo(ctx: StateContext<NotificationStateModel>, action: SetModuleInfo): void;
     resetState(ctx: StateContext<NotificationStateModel>): void;
-    getEvents(ctx: StateContext<NotificationStateModel>): rxjs.Observable<Response<(NotificationEvent & {
-        templates: NotificationTemplateItem[];
-    })[]>>;
-    getReceivers(ctx: StateContext<NotificationStateModel>): rxjs.Observable<Response<ReceiverGroup[]>>;
-    getProperties(ctx: StateContext<NotificationStateModel>, action: GetProperties): rxjs.Observable<Response<PropertyGroup[]>>;
-    setActionMode(ctx: StateContext<NotificationStateModel>, action: SetActionMode): void;
-    getActionReceivers(ctx: StateContext<NotificationStateModel>, action: GetActionReceivers): rxjs.Observable<Response<ReceiverGroup[]>>;
-    getActionProperties(ctx: StateContext<NotificationStateModel>, action: GetActionProperties): rxjs.Observable<Response<PropertyGroup[]>>;
-    selectEvent(ctx: StateContext<NotificationStateModel>, action: SelectEvent): void;
-    selectTemplate(ctx: StateContext<NotificationStateModel>, action: SelectTemplate): void;
-    addReceivers(ctx: StateContext<NotificationStateModel>, action: AddReceivers): rxjs.Observable<Response<ReceiverItem[]>>;
-    deleteReceiver(ctx: StateContext<NotificationStateModel>, action: DeleteReceiver): rxjs.Observable<Response<void>> | undefined;
-    addTemplate(ctx: StateContext<NotificationStateModel>, action: AddTemplate): rxjs.Observable<Response<NotificationTemplateItem>>;
-    updateTemplate(ctx: StateContext<NotificationStateModel>, action: UpdateTemplate): rxjs.Observable<Response<Partial<NotificationTemplateItem>>>;
-    deleteTemplate(ctx: StateContext<NotificationStateModel>, action: DeleteTemplate): rxjs.Observable<Response<void>>;
-    private getSelectedTemplate;
+    getEvents(ctx: StateContext<NotificationStateModel>): rxjs.Observable<NotificationEventWithTemplates[]> | undefined;
+    getAuthoringContext(ctx: StateContext<NotificationStateModel>, action: GetAuthoringContext): rxjs.Observable<NotificationAuthoringContext>;
+    getDefaultRecipes(ctx: StateContext<NotificationStateModel>, action: GetDefaultRecipes): rxjs.Observable<NotificationDefaults>;
+    getPublications(ctx: StateContext<NotificationStateModel>, action: GetPublications): rxjs.Observable<NotificationPublication[]> | undefined;
+    selectEvent(ctx: StateContext<NotificationStateModel>, action: SelectEvent): rxjs.Observable<void> | undefined;
+    selectTemplate(ctx: StateContext<NotificationStateModel>, action: SelectTemplate): rxjs.Observable<void> | undefined;
+    createTemplate(ctx: StateContext<NotificationStateModel>, action: CreateTemplate): rxjs.Observable<NotificationTemplateItem>;
+    saveTemplate(ctx: StateContext<NotificationStateModel>, action: SaveTemplate): rxjs.Observable<NotificationTemplateItem>;
+    addReceivers(ctx: StateContext<NotificationStateModel>, action: AddReceivers): rxjs.Observable<NotificationTemplateItem>;
+    deleteReceiver(ctx: StateContext<NotificationStateModel>, action: DeleteReceiver): rxjs.Observable<NotificationTemplateItem>;
+    deleteTemplate(ctx: StateContext<NotificationStateModel>, action: DeleteTemplate): rxjs.Observable<unknown>;
+    publishTemplate(ctx: StateContext<NotificationStateModel>, action: PublishTemplate): rxjs.Observable<NotificationTemplateItem>;
+    setTemplateActivation(ctx: StateContext<NotificationStateModel>, action: SetTemplateActivation): rxjs.Observable<NotificationTemplateItem>;
+    restorePublication(ctx: StateContext<NotificationStateModel>, action: RestorePublication): rxjs.Observable<NotificationTemplateItem>;
+    initializeDefaults(ctx: StateContext<NotificationStateModel>, action: InitializeDefaults): rxjs.Observable<_masterteam_notification.NotificationInitializeDefaultsResult>;
+    restoreDefault(ctx: StateContext<NotificationStateModel>, action: RestoreDefault): rxjs.Observable<NotificationTemplateItem>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationState, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationState>;
 }
 
 declare class NotificationFacade {
     private readonly store;
+    private readonly api;
     readonly events: _angular_core.Signal<_masterteam_notification.NotificationEvent[]>;
+    /** Templates of the selected event. */
     readonly templates: _angular_core.Signal<_masterteam_notification.NotificationTemplateItem[]>;
-    readonly receivers: _angular_core.Signal<_masterteam_notification.ReceiverItem[]>;
-    readonly receiverGroups: _angular_core.Signal<_masterteam_notification.ReceiverOptionGroup[]>;
-    readonly propertyGroups: _angular_core.Signal<_masterteam_notification.PropertyGroup[]>;
-    readonly selectedEventName: _angular_core.Signal<string | null>;
-    readonly selectedTemplateId: _angular_core.Signal<string | number | null>;
+    readonly selectedEventId: _angular_core.Signal<number | null>;
+    readonly selectedTemplateId: _angular_core.Signal<number | null>;
     readonly selectedEvent: _angular_core.Signal<_masterteam_notification.NotificationEvent | null>;
     readonly selectedTemplate: _angular_core.Signal<_masterteam_notification.NotificationTemplateItem | null>;
-    readonly availableReceivers: _angular_core.Signal<_masterteam_notification.ReceiverItem[]>;
-    readonly availableReceiverGroups: _angular_core.Signal<_masterteam_notification.ReceiverOptionGroup[]>;
+    readonly context: _angular_core.Signal<_masterteam_notification.NotificationAuthoringContext | null>;
+    readonly defaults: _angular_core.Signal<_masterteam_notification.NotificationDefaults | null>;
+    readonly publications: _angular_core.Signal<_masterteam_notification.NotificationPublication[]>;
     private readonly loadingActive;
     private readonly errors;
     readonly isLoadingEvents: _angular_core.Signal<boolean>;
-    readonly isLoadingReceivers: _angular_core.Signal<boolean>;
-    readonly isLoadingProperties: _angular_core.Signal<boolean>;
-    readonly isAddingReceivers: _angular_core.Signal<boolean>;
-    readonly isDeletingReceiver: _angular_core.Signal<boolean>;
-    readonly isAddingTemplate: _angular_core.Signal<boolean>;
-    readonly isUpdatingTemplate: _angular_core.Signal<boolean>;
-    readonly isDeletingTemplate: _angular_core.Signal<boolean>;
+    readonly isLoadingContext: _angular_core.Signal<boolean>;
+    readonly isLoadingDefaults: _angular_core.Signal<boolean>;
+    readonly isLoadingPublications: _angular_core.Signal<boolean>;
+    /** True while any write is in flight — every write control disables on it. */
+    readonly isMutating: _angular_core.Signal<boolean>;
     readonly eventsError: _angular_core.Signal<string | null>;
-    readonly receiversError: _angular_core.Signal<string | null>;
-    readonly propertiesError: _angular_core.Signal<string | null>;
+    readonly contextError: _angular_core.Signal<string | null>;
+    readonly defaultsError: _angular_core.Signal<string | null>;
+    /** Accepts the enum or its string value, so templates can name the key. */
+    isLoading(key: NotificationActionKey | `${NotificationActionKey}`): boolean;
     /**
      * Scopes this (shared, singleton) state to a module/event context.
      *
@@ -293,143 +555,367 @@ declare class NotificationFacade {
      * from the old one. See `workflow-builder.ts` / `escalation-builder.ts`
      * for the reference call sites.
      */
-    setModuleInfo(moduleType: string, moduleId: string | number, parentModuleType?: string, parentModuleId?: string | number, parentPath?: string): rxjs.Observable<void>;
-    resetState(): rxjs.Observable<void>;
-    loadEvents(): rxjs.Observable<void>;
-    loadReceivers(): rxjs.Observable<void>;
-    loadProperties(isMultiLang?: boolean): rxjs.Observable<void>;
-    loadPropertiesForCurrentContext(isMultiLang?: boolean): rxjs.Observable<void>;
-    setActionMode(actionId: string | number | null): rxjs.Observable<void>;
-    loadActionReceivers(actionId: string | number): rxjs.Observable<void>;
-    loadActionProperties(actionId: string | number, isMultiLang?: boolean): rxjs.Observable<void>;
-    selectEvent(eventName: string): rxjs.Observable<void>;
-    selectTemplate(templateId: string | number): rxjs.Observable<void>;
-    addReceivers(templateId: string | number, payload: AddReceiversPayload): rxjs.Observable<void>;
-    deleteReceiver(receiverId: string | number): rxjs.Observable<void>;
-    addTemplate(eventId: string | number, payload: AddTemplatePayload): rxjs.Observable<void>;
-    updateTemplate(templateId: string | number, payload: UpdateTemplatePayload): rxjs.Observable<void>;
-    deleteTemplate(templateId: string | number): rxjs.Observable<void>;
-    loadBaseData(): void;
-    /**
-     * Load all data for normal mode (non-workflow)
-     */
-    loadAllData(isMultiLang?: boolean): void;
+    setModuleInfo(moduleType: string, moduleId: string | number, parentModuleType?: string, parentModuleId?: string | number, parentPath?: string): Observable<void>;
+    resetState(): Observable<void>;
+    /** Loads the scope's events; the selected event's catalog and defaults follow. */
+    loadEvents(): Observable<void>;
+    /** Kept for existing hosts — both load the scope's events and what follows from them. */
+    loadBaseData(): Observable<void>;
+    loadAllData(): Observable<void>;
+    selectEvent(eventId: number): Observable<void>;
+    selectTemplate(templateId: number): Observable<void>;
+    reloadDefaults(eventId: number): Observable<void>;
+    createTemplate(eventId: number, payload: CreateNotificationTemplatePayload): Observable<void>;
+    saveTemplate(templateId: number, payload: SaveNotificationTemplatePayload): Observable<void>;
+    deleteTemplate(templateId: number, expectedRevision: number): Observable<void>;
+    addReceivers(templateId: number, expectedRevision: number, receivers: NotificationReceiverRef[]): Observable<void>;
+    deleteReceiver(receiverId: number, expectedRevision: number): Observable<void>;
+    publish(templateId: number, expectedRevision: number, reviews: NotificationReviewFlags): Observable<void>;
+    turnOn(templateId: number, expectedRevision: number, reviews: NotificationReviewFlags): Observable<void>;
+    turnOff(templateId: number, expectedRevision: number): Observable<void>;
+    restorePublication(templateId: number, expectedRevision: number, publicationRevision: number, reviews: NotificationReviewFlags): Observable<void>;
+    initializeDefaults(eventId: number): Observable<void>;
+    restoreDefault(eventId: number, payload: RestoreNotificationDefaultPayload): Observable<void>;
+    preview(eventId: number, request: NotificationPreviewRequest): Observable<NotificationPreview>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationFacade, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationFacade>;
 }
 
+type NotificationPreviewStatus = 'idle' | 'updating' | 'ready' | 'error';
+/**
+ * One preview pipeline per editor. A new request cancels the one in flight,
+ * a late answer for an older draft is dropped (`switchMap`), and Retry
+ * re-renders the exact request that failed — so retrying a history preview
+ * keeps the selected publication instead of falling back to the draft.
+ * Previews never save, publish, enable or send anything.
+ */
+declare class NotificationPreviewRunner {
+    readonly status: _angular_core.WritableSignal<NotificationPreviewStatus>;
+    /** Last successful render — kept on screen while the next one runs. */
+    readonly result: _angular_core.WritableSignal<NotificationPreview | null>;
+    readonly errorCode: _angular_core.WritableSignal<string | null>;
+    /** Identity of the request `result` was rendered from. */
+    readonly resultKey: _angular_core.WritableSignal<string | null>;
+    private readonly immediate$;
+    private readonly debounced$;
+    private readonly retry$;
+    private lastJob;
+    /** Bumped by every request, so a pending debounced one can tell it was overtaken. */
+    private seq;
+    constructor(facade: NotificationFacade, destroyRef: DestroyRef, debounceMs?: number);
+    /** Render now (opening a review, selecting a history entry). */
+    run(eventId: number, request: NotificationPreviewRequest): void;
+    /** Render after a typing pause. */
+    schedule(eventId: number, request: NotificationPreviewRequest): void;
+    retry(): void;
+    clear(): void;
+    isCurrent(eventId: number, request: NotificationPreviewRequest): boolean;
+}
+
+type ContentField = 'emailTemplate' | 'smsTemplate' | 'appEn' | 'appAr';
+/**
+ * Control Panel notification templates for one scope (Level, Module,
+ * LevelModule, Request/Step, EscalationRequest/Step, Delegation).
+ *
+ * Saving and previewing a draft never changes what is sent: only Publish
+ * (snapshot the saved draft) and Turn on/off do, and both go through an
+ * explicit review of the actual content and recipients first. Every write
+ * carries the last revision read; a conflict keeps the user's edits.
+ */
 declare class NotificationTemplate {
-    private readonly facade;
+    protected readonly facade: NotificationFacade;
+    private readonly messages;
     private readonly transloco;
-    private readonly confirmationService;
-    private readonly modalService;
-    readonly events: _angular_core.Signal<_masterteam_notification.NotificationEvent[]>;
-    readonly templates: _angular_core.Signal<NotificationTemplateItem[]>;
-    readonly receivers: _angular_core.Signal<ReceiverItem[]>;
-    readonly propertyGroups: _angular_core.Signal<_masterteam_notification.PropertyGroup[]>;
-    readonly selectedEventName: _angular_core.Signal<string | null>;
-    readonly selectedTemplateId: _angular_core.Signal<string | number | null>;
-    readonly selectedEvent: _angular_core.Signal<_masterteam_notification.NotificationEvent | null>;
-    readonly selectedTemplate: _angular_core.Signal<NotificationTemplateItem | null>;
-    readonly availableReceivers: _angular_core.Signal<ReceiverItem[]>;
-    readonly availableReceiverGroups: _angular_core.Signal<_masterteam_notification.ReceiverOptionGroup[]>;
-    readonly isLoadingEvents: _angular_core.Signal<boolean>;
-    readonly isLoadingReceivers: _angular_core.Signal<boolean>;
-    readonly isLoadingProperties: _angular_core.Signal<boolean>;
-    readonly isUpdatingTemplate: _angular_core.Signal<boolean>;
-    readonly isDeletingTemplate: _angular_core.Signal<boolean>;
-    readonly isAddingTemplate: _angular_core.Signal<boolean>;
-    readonly eventsError: _angular_core.Signal<string | null>;
-    readonly propertiesError: _angular_core.Signal<string | null>;
-    readonly deletingReceiverIds: _angular_core.WritableSignal<(string | number)[]>;
-    readonly addingReceiverIds: _angular_core.WritableSignal<(string | number)[]>;
-    readonly form: FormGroup<any>;
-    readonly propertyPickerControl: FormControl<string | null>;
-    readonly receiverPickerControl: FormControl<string | number | null>;
-    private readonly channelControl;
-    readonly channelSignal: _angular_core.Signal<NotificationChannel>;
-    private buildForm;
-    readonly channelConfigs: ChannelConfig[];
-    /** Check if channel should show bilingual fields - reads from form */
-    isBilingual(ch: ChannelConfig): boolean;
-    readonly channelOptions: _angular_core.Signal<{
-        name: string;
-        key: NotificationChannel;
-        labelKey: string;
-        supportsBilingual: boolean;
-        bilingualOptional: boolean;
-        useRichEditor: boolean;
-        templateKey?: string;
-        translatableKey?: string;
+    private readonly confirmation;
+    private readonly modal;
+    private readonly toast;
+    private readonly destroyRef;
+    private readonly lang;
+    protected readonly events: _angular_core.Signal<_masterteam_notification.NotificationEvent[]>;
+    protected readonly templates: _angular_core.Signal<NotificationTemplateItem[]>;
+    protected readonly selectedEvent: _angular_core.Signal<_masterteam_notification.NotificationEvent | null>;
+    protected readonly selectedEventId: _angular_core.Signal<number | null>;
+    protected readonly selectedTemplateId: _angular_core.Signal<number | null>;
+    protected readonly template: _angular_core.Signal<NotificationTemplateItem | null>;
+    protected readonly context: _angular_core.Signal<_masterteam_notification.NotificationAuthoringContext | null>;
+    protected readonly defaults: _angular_core.Signal<_masterteam_notification.NotificationDefaults | null>;
+    protected readonly publications: _angular_core.Signal<NotificationPublication[]>;
+    protected readonly isMutating: _angular_core.Signal<boolean>;
+    protected readonly eventControl: FormControl<number | null>;
+    protected readonly placeholderControl: FormControl<string | null>;
+    protected readonly recipientControl: FormControl<string | null>;
+    protected readonly form: FormGroup<{
+        name: FormControl<string>;
+        subject: FormControl<string>;
+        emailTemplate: FormControl<string>;
+        smsTemplate: FormControl<string>;
+        appEn: FormControl<string>;
+        appAr: FormControl<string>;
+        conditionFormula: FormControl<string>;
+    }>;
+    private readonly formValue;
+    /** Mirrors the tabs' own `active` model so a cancelled switch can snap back. */
+    protected readonly activeTab: _angular_core.WritableSignal<number | null>;
+    protected readonly activeField: _angular_core.WritableSignal<ContentField>;
+    protected readonly channelIcons: {
+        readonly App: "alert.bell-01";
+        readonly Email: "communication.mail-01";
+        readonly Sms: "communication.message-text-square-01";
+    };
+    private readonly host;
+    /** Editor and preview side by side; see the ResizeObserver in the constructor. */
+    protected readonly wide: _angular_core.WritableSignal<boolean>;
+    protected readonly conflict: _angular_core.WritableSignal<boolean>;
+    protected readonly writeDiagnostics: _angular_core.WritableSignal<NotificationDiagnostic[]>;
+    protected readonly preview: NotificationPreviewRunner;
+    /** A newly opened template renders at once instead of after the typing pause. */
+    private renderPreviewNow;
+    private readonly emailEditor;
+    private readonly appEnEditor;
+    private readonly appArEditor;
+    private readonly smsSource;
+    protected readonly channel: _angular_core.Signal<NotificationChannel | null>;
+    protected readonly status: _angular_core.Signal<_masterteam_notification.NotificationTemplateStatus | null>;
+    protected readonly unpublishedChanges: _angular_core.Signal<boolean | null>;
+    protected readonly defaultOwned: _angular_core.Signal<boolean>;
+    /** Unsaved edits, measured against the server baseline rather than control flags. */
+    protected readonly dirty: _angular_core.Signal<boolean>;
+    protected readonly nameValid: _angular_core.Signal<boolean>;
+    protected readonly canSave: _angular_core.Signal<boolean>;
+    protected readonly canPublish: _angular_core.Signal<boolean>;
+    protected readonly canTurnOn: _angular_core.Signal<boolean>;
+    protected readonly templateTabs: _angular_core.Signal<{
+        label: string;
+        value: number;
+        icon: "alert.bell-01" | "communication.mail-01" | "communication.message-text-square-01";
+    }[]>;
+    protected readonly placeholderGroups: _angular_core.Signal<{
+        groupName: string;
+        properties: {
+            key: string;
+            label: string;
+        }[];
     }[]>;
-    /** Templates of the selected event, rendered as tabs. */
-    readonly templateTabs: _angular_core.Signal<{
+    /** Image hosts the server accepts, as reported by the latest email preview. */
+    protected readonly emailImageOrigins: _angular_core.Signal<string[]>;
+    /** Image hosts the server accepts in App messages, from the latest App preview. */
+    protected readonly appImageOrigins: _angular_core.Signal<string[]>;
+    /** Catalog names by `type:id`, so saved receivers read as the catalog does. */
+    private readonly receiverLabels;
+    /** Field labels for the email editor's placeholder chips. */
+    protected readonly placeholderOptions: _angular_core.Signal<{
+        key: string;
         label: string;
-        value: string | number;
-        isSystem: boolean;
     }[]>;
-    readonly activeChannel: _angular_core.Signal<NotificationChannel>;
-    readonly shouldUseMultilingualProperties: _angular_core.Signal<boolean>;
-    readonly isFormInvalid: _angular_core.Signal<boolean>;
+    protected readonly recipientGroups: _angular_core.Signal<{
+        items: _masterteam_notification.NotificationRecipientOption[];
+        groupName: string;
+    }[]>;
+    protected readonly conditionPropertiesByPath: _angular_core.Signal<{
+        Current: {
+            key: string;
+            name: string;
+        }[];
+    }>;
+    protected readonly conditionKeys: _angular_core.Signal<string[]>;
+    protected readonly missingDefaults: _angular_core.Signal<NotificationChannel[]>;
+    protected readonly removedDefaults: _angular_core.Signal<{
+        slot: NotificationDefaultSlot;
+        recipe: NotificationDefaultRecipe;
+    }[]>;
+    /** What the live preview renders: the editor's current, unsaved values. */
+    private readonly previewRequest;
+    protected readonly previewStale: _angular_core.Signal<boolean>;
+    constructor();
+    protected onBeforeUnload(event: BeforeUnloadEvent): void;
+    protected onEventChange(eventId: number | null): void;
+    protected onTemplateTabChange(templateId: number): void;
+    protected retryLoad(): void;
+    protected setActiveField(field: ContentField): void;
+    protected onInsertPlaceholder(key: string | null): void;
+    protected onSave(): void;
+    protected onDiscard(): void;
+    protected onAddRecipient(key: string | null): void;
+    protected onRemoveRecipient(receiver: NotificationReceiver): void;
     /**
-     * Snapshot of the form's default shape, captured before any context ever
-     * patches it. Used by {@link resetTemplateFields} to clear the form when the
-     * selected template resolves to nothing, so a component switching context
-     * never keeps displaying a previous context's values (see
-     * `ResetNotificationState` for the store-level counterpart of this reset).
+     * The catalog's name first: ready-made templates come back with the raw
+     * identifier as their saved name (`creator`), while the catalog has the
+     * localized label.
      */
-    private readonly emptyFormValue;
-    constructor();
-    onEventChange(eventName: string): void;
-    onTemplateTabChange(templateId: string | number): void;
-    onAddProperty(propertyKey: string): void;
-    onAddReceiver(receiverId: string | number): void;
-    onDeleteReceiver(receiver: ReceiverItem): void;
-    isReceiverDeleting(receiverId: string | number): boolean;
-    onSaveTemplate(): void;
-    onDeleteTemplate(): void;
-    onAddTemplateClick(): void;
+    protected receiverName(receiver: {
+        type: NotificationReceiver['type'];
+        identifier: string | null;
+        name?: NotificationReceiver['name'] | string | null;
+    }): string;
+    protected onPublish(): void;
+    protected onTurnOn(): void;
+    protected onTurnOff(): void;
+    protected onOpenHistory(): void;
+    private restoreVersion;
+    protected onDelete(): void;
+    protected onAddTemplate(): void;
+    protected onTestEmail(): void;
+    protected onInitializeDefaults(): void;
+    protected onRestoreDefault(channel: NotificationChannel): void;
     /**
-     * Clears every template-owned control back to the captured empty shape.
-     *
-     * `event` is deliberately excluded, so `patchValue` leaves whatever the event
-     * effect (or the user's own pick) put in that control. An event with no
-     * templates yet — a brand-new one, or one whose last template was just
-     * deleted — resolves `selectedTemplate` to null, and this effect runs after
-     * the event effect in the same flush: resetting the whole group there would
-     * blank the event picker the user just used, while `selectedEvent()` stays
-     * truthy and keeps the tabs/add-template row visible. Leaving the control
-     * alone also keeps the two effects ordering-independent — on a full
-     * `ResetNotificationState` the event effect has already nulled it, and that
-     * null is carried through.
-     *
-     * `channel` is restored through {@link channelControl} with events enabled
-     * because `channelSignal` is a `toSignal` of its `valueChanges` and is the
-     * only consumer of them on this form — a silent reset would leave
-     * `activeChannel()` reporting the previous template's channel.
+     * After a revision conflict: re-read the latest version, then either keep
+     * the user's edits on top of it (the next Save applies them deliberately)
+     * or replace them with what is saved.
      */
-    private resetTemplateFields;
-    private appendToControl;
-    private patchForm;
-    private buildUpdatePayload;
-    private getTemplateControlValue;
-    private getTranslatableControlValue;
+    protected resolveConflict(keepMine: boolean): void;
+    protected describeDiagnostic(diagnostic: NotificationDiagnostic): string;
+    protected channelLabel(channel: NotificationChannel): string;
+    private afterWrite;
+    private onWriteError;
+    private review;
+    /** Readable sample values for every field the previewed content uses. */
+    private withSamples;
+    private confirmDiscard;
+    private patchFromTemplate;
+    /** Replacement semantics: only the template's own channel field is sent. */
+    private buildSavePayload;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationTemplate, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationTemplate, "mt-notification-template", never, {}, {}, never, never, true, never>;
 }
 
+interface AddTemplateDialogResult {
+    name: string;
+    channel: NotificationChannel;
+}
+/** A template's channel is chosen once, here — it cannot change afterwards. */
 declare class AddTemplateDialog {
     readonly modalService: ModalService;
     private readonly ref;
-    data: _angular_core.InputSignal<any>;
-    templateNameControl: FormControl<string | null>;
+    private readonly transloco;
+    /** Channels the event's authoring context allows. */
+    readonly channels: _angular_core.InputSignal<readonly NotificationChannel[]>;
+    readonly form: FormGroup<{
+        name: FormControl<string>;
+        channel: FormControl<NotificationChannel | null>;
+    }>;
+    protected readonly channelOptions: _angular_core.Signal<{
+        id: NotificationChannel;
+        name: string;
+        description: string;
+        icon: "alert.bell-01" | "communication.mail-01" | "communication.message-text-square-01";
+    }[]>;
     onSave(): void;
     onCancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AddTemplateDialog, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddTemplateDialog, "mt-add-template-dialog", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AddTemplateDialog, "mt-add-template-dialog", never, { "channels": { "alias": "channels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NotificationReviewMode = 'publish' | 'enable' | 'restore' | 'restoreDefault';
+interface NotificationReviewRecipient {
+    name: string;
+    type: NotificationReceiverType;
+}
+/**
+ * The explicit review before a write changes what is sent: the actual content
+ * (rendered by the server) and the actual receivers of the version being
+ * published / turned on / restored — never the working draft's.
+ *
+ * The review flags are not separate tick boxes (product decision, 2026-10-27):
+ * confirming this dialog, which only enables once the server preview has
+ * rendered, is the acknowledgement. They are sent only from that confirmation,
+ * never as defaults elsewhere.
+ */
+declare class TemplateReviewDialog implements OnInit {
+    protected readonly modalService: ModalService;
+    private readonly ref;
+    private readonly facade;
+    private readonly destroyRef;
+    readonly mode: _angular_core.InputSignal<NotificationReviewMode>;
+    readonly eventId: _angular_core.InputSignal<number>;
+    readonly request: _angular_core.InputSignal<NotificationPreviewRequest>;
+    readonly recipients: _angular_core.InputSignal<NotificationReviewRecipient[]>;
+    readonly condition: _angular_core.InputSignal<string | null>;
+    /** Templates a ready-made slot owns also need `languageReviewed`. */
+    readonly requireLanguageReview: _angular_core.InputSignal<boolean>;
+    /** Publishing an enabled template changes live sending at once. */
+    readonly isEnabled: _angular_core.InputSignal<boolean>;
+    protected readonly runner: NotificationPreviewRunner;
+    protected readonly previewReady: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    protected confirm(): void;
+    protected cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateReviewDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TemplateReviewDialog, "mt-notification-template-review-dialog", never, { "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "eventId": { "alias": "eventId"; "required": true; "isSignal": true; }; "request": { "alias": "request"; "required": true; "isSignal": true; }; "recipients": { "alias": "recipients"; "required": false; "isSignal": true; }; "condition": { "alias": "condition"; "required": false; "isSignal": true; }; "requireLanguageReview": { "alias": "requireLanguageReview"; "required": false; "isSignal": true; }; "isEnabled": { "alias": "isEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NotificationHistoryRestoreRequest {
+    publication: NotificationPublication;
+}
+/**
+ * Retained publications of one template, newest first. Selecting a version
+ * previews that version's own content and recipients — never the draft's.
+ * "Restore" hands the chosen version back to the editor, which runs the
+ * review before anything is written.
+ */
+declare class TemplateHistoryDrawer {
+    protected readonly modalService: ModalService;
+    private readonly ref;
+    protected readonly facade: NotificationFacade;
+    private readonly destroyRef;
+    private readonly transloco;
+    readonly eventId: _angular_core.InputSignal<number>;
+    /** Restoring is blocked while the editor holds unsaved edits. */
+    readonly draftDirty: _angular_core.InputSignal<boolean>;
+    readonly historyLimit: _angular_core.InputSignal<number | null>;
+    protected readonly runner: NotificationPreviewRunner;
+    protected readonly publications: _angular_core.Signal<NotificationPublication[]>;
+    protected readonly template: _angular_core.Signal<_masterteam_notification.NotificationTemplateItem | null>;
+    protected readonly selectedRevision: _angular_core.WritableSignal<number | null>;
+    protected readonly selected: _angular_core.Signal<NotificationPublication | null>;
+    protected readonly defaultsPublisher = "system:notification-defaults";
+    private readonly receiverLabels;
+    constructor();
+    protected select(publication: NotificationPublication): void;
+    /** The catalog's (localized) name; the snapshot keeps whatever was saved. */
+    protected recipientName(recipient: NotificationPublishedRecipient): string;
+    protected restore(): void;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateHistoryDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TemplateHistoryDrawer, "mt-notification-template-history-drawer", never, { "eventId": { "alias": "eventId"; "required": true; "isSignal": true; }; "draftDirty": { "alias": "draftDirty"; "required": false; "isSignal": true; }; "historyLimit": { "alias": "historyLimit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a notification preview the way it will be read: Email inside the
+ * shared design, App as its English and Arabic messages, SMS as plain text.
+ * HTML only ever goes into the sandboxed `mt-email-html-preview` frame.
+ * Images always show: the server strips every image outside
+ * `approvedImageOrigins`, and the frame's CSP allows only those origins.
+ */
+declare class NotificationContentPreview {
+    private readonly messages;
+    readonly preview: _angular_core.InputSignal<NotificationPreview | null>;
+    readonly status: _angular_core.InputSignal<NotificationPreviewStatus>;
+    readonly errorCode: _angular_core.InputSignal<string | null>;
+    /** The shown render is from an older version of the content. */
+    readonly stale: _angular_core.InputSignal<boolean>;
+    readonly height: _angular_core.InputSignal<string>;
+    /**
+     * Stretch the rendered frames to the height the host gives this preview
+     * (beside the editor), with `height` as the minimum.
+     */
+    readonly fill: _angular_core.InputSignal<boolean>;
+    /** Off beside the editor, where the Subject field is in view. */
+    readonly showSubject: _angular_core.InputSignal<boolean>;
+    readonly retry: _angular_core.OutputEmitterRef<void>;
+    protected readonly narrow: FormControl<boolean>;
+    protected readonly narrowValue: _angular_core.WritableSignal<boolean>;
+    protected readonly email: _angular_core.Signal<_masterteam_notification.NotificationEmailPreview | null>;
+    protected readonly app: _angular_core.Signal<_masterteam_notification.NotificationAppPreview | null>;
+    protected readonly sms: _angular_core.Signal<_masterteam_notification.NotificationSmsPreview | null>;
+    protected readonly diagnostics: _angular_core.Signal<NotificationDiagnostic[]>;
+    constructor();
+    protected describe(diagnostic: NotificationDiagnostic): string;
+    protected describeCode(code: string | null): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationContentPreview, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotificationContentPreview, "mt-notification-content-preview", never, { "preview": { "alias": "preview"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "errorCode": { "alias": "errorCode"; "required": false; "isSignal": true; }; "stale": { "alias": "stale"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "showSubject": { "alias": "showSubject"; "required": false; "isSignal": true; }; }, { "retry": "retry"; }, never, never, true, never>;
 }
 
 declare const APP_STATES: (typeof NotificationState)[];
 
-export { APP_STATES, AddReceivers, AddTemplate, AddTemplateDialog, CHANNEL_CONFIGS, DeleteReceiver, DeleteTemplate, GetActionProperties, GetActionReceivers, GetEvents, GetProperties, GetReceivers, NotificationActionKey, NotificationFacade, NotificationState, NotificationTemplate, ResetNotificationState, SelectEvent, SelectTemplate, SetActionMode, SetModuleInfo, UpdateTemplate, getChannelConfig, getFormControlName };
-export type { ActionGroup, AddReceiversPayload, AddTemplatePayload, ChannelConfig, NotificationAction, NotificationChannel, NotificationEvent, NotificationProperty, NotificationStateModel, NotificationTemplateItem, PropertyGroup, ReceiverGroup, ReceiverItem, ReceiverOptionGroup, ReceiverPayloadItem, ReceiverSubGroup, TranslatableContent, UpdateTemplatePayload };
+export { APP_STATES, AddReceivers, AddTemplateDialog, CreateTemplate, DEFAULTS_PUBLISHER, DeleteReceiver, DeleteTemplate, GetAuthoringContext, GetDefaultRecipes, GetEvents, GetPublications, InitializeDefaults, NOTIFICATION_CHANNELS, NOTIFICATION_MUTATION_KEYS, NotificationActionKey, NotificationContentPreview, NotificationFacade, NotificationState, NotificationTemplate, NotificationTemplateApi, PublishTemplate, ResetNotificationState, RestoreDefault, RestorePublication, SaveTemplate, SelectEvent, SelectTemplate, SetModuleInfo, SetTemplateActivation, TemplateHistoryDrawer, TemplateReviewDialog, currentPublication, flattenRecipientCatalog, hasUnpublishedChanges, isDefaultOwned, isRevisionConflict, missingDefaultChannels, parseAppContent, previewSamples, publicationPreviewRequest, readNotificationFailure, recipientKey, templatePreviewRequest, templateStatus, withPreviewSamples };
+export type { AddTemplateDialogResult, CreateNotificationTemplatePayload, NotificationAppPreview, NotificationAuthoringContext, NotificationChannel, NotificationDefaultRecipe, NotificationDefaultSlot, NotificationDefaults, NotificationDiagnostic, NotificationEmailPreview, NotificationEvent, NotificationEventWithTemplates, NotificationFailure, NotificationFragmentPreview, NotificationHistoryRestoreRequest, NotificationInitializeDefaultsResult, NotificationPreview, NotificationPreviewRequest, NotificationProperty, NotificationPropertyGroup, NotificationPublication, NotificationPublishedContent, NotificationPublishedRecipient, NotificationReceiver, NotificationReceiverRef, NotificationReceiverType, NotificationRecipeCoverage, NotificationRecipientGroup, NotificationRecipientNode, NotificationRecipientOption, NotificationRecipientOptionGroup, NotificationReviewFlags, NotificationReviewMode, NotificationReviewRecipient, NotificationSmsPreview, NotificationStateModel, NotificationTemplateItem, NotificationTemplateStatus, RestoreNotificationDefaultPayload, SaveNotificationTemplatePayload, TranslatableContent };