@forgeroute/ui 0.4.26 → 0.4.28

package/types/forgeroute-ui.d.ts

@@ -2491,7 +2491,7 @@ export declare class AudioPlayerComponent {
   /** Accessible name of the player. */
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
   /** How much to load before play: 'metadata' (default), 'auto' or 'none'. */
-  readonly preload: import("@angular/core").InputSignal<"none" | "auto" | "metadata">;
+  readonly preload: import("@angular/core").InputSignal<"metadata" | "none" | "auto">;
   /** Fires when the browser can't load or decode the source. */
   readonly playbackError: import("@angular/core").OutputEmitterRef<void>;
   protected readonly failed: import("@angular/core").WritableSignal<boolean>;
@@ -3766,7 +3766,7 @@ export declare class ButtonComponent {
    * `ghost-start`: a ghost button for list / section toggles - a full-width row with its content aligned to the start, transparent
    * background, hover tint and the normal focus ring. Pair it with `ariaExpanded` / `ariaPressed`; the label may contain a heading element.
    */
-  readonly variant: import("@angular/core").InputSignal<"primary" | "secondary" | "danger" | "warning" | "link" | "ghost" | "ghost-start" | "tab" | "icon" | "icon-danger">;
+  readonly variant: import("@angular/core").InputSignal<"link" | "primary" | "secondary" | "danger" | "warning" | "ghost" | "ghost-start" | "tab" | "icon" | "icon-danger">;
   /** Renders an anchor to this route instead of a button (use with `variant="link"` for an inline text link). `['/settings']` or `'/settings'`. While `disabled` or `loading` it renders a non-clickable `<span role="link" aria-disabled>` with no href (like `href`). */
   readonly routerLink: import("@angular/core").InputSignal<string | readonly unknown[] | null>;
   /** Query params of the `routerLink` (e.g. `{ section: 'deal-defaults' }`). */
@@ -3787,7 +3787,7 @@ export declare class ButtonComponent {
    */
   readonly href: import("@angular/core").InputSignal<string | null>;
   /** Where to open the `href` (`_blank` = a new tab). */
-  readonly target: import("@angular/core").InputSignal<"_self" | "_blank" | "_parent" | "_top" | null>;
+  readonly target: import("@angular/core").InputSignal<"_blank" | "_self" | "_parent" | "_top" | null>;
   /** `rel` of the `href` link. A `_blank` target always gets `noopener noreferrer` added. */
   readonly rel: import("@angular/core").InputSignal<string | null>;
   /** The href when it is allowed (http, https, mailto, tel, sms or a relative URL), else null. */
@@ -3812,7 +3812,7 @@ export declare class ButtonComponent {
   readonly color: import("@angular/core").InputSignal<string | undefined>;
   readonly active: import("@angular/core").InputSignal<boolean>;
   readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg" | "xs">;
-  readonly type: import("@angular/core").InputSignal<"reset" | "submit" | "button">;
+  readonly type: import("@angular/core").InputSignal<"button" | "reset" | "submit">;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   readonly loading: import("@angular/core").InputSignal<boolean>;
   readonly fullWidth: import("@angular/core").InputSignal<boolean>;
@@ -4427,7 +4427,7 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
   readonly passwordRequirements: import("@angular/core").InputSignal<boolean>;
   /** Rules for `passwordRequirements`; default = the library's five rules (8+ characters, upper, lower, digit, special). */
   readonly passwordRules: import("@angular/core").InputSignal<readonly PasswordRule[] | undefined>;
-  readonly type: import("@angular/core").InputSignal<"number" | "text" | "email" | "tel" | "password" | "url">;
+  readonly type: import("@angular/core").InputSignal<"number" | "text" | "password" | "email" | "tel" | "url">;
   readonly maxlength: import("@angular/core").InputSignal<number | undefined>;
   readonly required: import("@angular/core").InputSignal<boolean>;
   readonly autocomplete: import("@angular/core").InputSignal<string>;
@@ -4436,7 +4436,7 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
    * `search`, `text`, `none`). Empty (default) = the browser's default for the field, except `type="tel"`, which keeps `tel`.
    * It only picks the keyboard; it does not restrict what can be typed or pasted.
    */
-  readonly inputmode: import("@angular/core").InputSignal<"" | "none" | "text" | "search" | "email" | "tel" | "url" | "decimal" | "numeric">;
+  readonly inputmode: import("@angular/core").InputSignal<"" | "text" | "email" | "search" | "none" | "tel" | "url" | "decimal" | "numeric">;
   readonly readonly: import("@angular/core").InputSignal<boolean>;
   readonly hint: import("@angular/core").InputSignal<string>;
   readonly error: import("@angular/core").InputSignal<string>;
@@ -4500,7 +4500,7 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
   protected readonly _stepAttr: import("@angular/core").Signal<string | null>;
   protected readonly _revealable: import("@angular/core").Signal<boolean>;
   protected readonly _shown: import("@angular/core").WritableSignal<boolean>;
-  protected readonly _inputType: import("@angular/core").Signal<"number" | "text" | "email" | "tel" | "password" | "url">;
+  protected readonly _inputType: import("@angular/core").Signal<"number" | "text" | "password" | "email" | "tel" | "url">;
   protected readonly _eyePath: string;
   protected readonly _eyeOffPath: string;
   protected readonly _showRequirements: import("@angular/core").Signal<boolean>;
@@ -5848,7 +5848,7 @@ export declare class DropdownComponent {
   readonly loader: import("@angular/core").InputSignal<(() => Promise<DropdownItem[]>) | null>;
   readonly active: import("@angular/core").InputSignal<boolean>;
   readonly activeValue: import("@angular/core").InputSignal<string>;
-  readonly variant: import("@angular/core").InputSignal<"badge" | "button">;
+  readonly variant: import("@angular/core").InputSignal<"button" | "badge">;
   readonly menuWidth: import("@angular/core").InputSignal<string>;
   /**
    * Accessible name. Set it when the trigger has no meaningful visible text. Applied as `aria-label` on the
@@ -6046,7 +6046,7 @@ export declare class FormRowComponent {
  * child simply takes the full width. Keep a numeric span within the row's `cols` (use `all` for the whole row).
  */
 export declare class FormColSpanDirective {
-  readonly uiColSpan: import("@angular/core").InputSignal<"" | "2" | "3" | 2 | 3 | "all">;
+  readonly uiColSpan: import("@angular/core").InputSignal<"" | "all" | 2 | "2" | 3 | "3">;
   protected readonly _class: import("@angular/core").Signal<string>;
   static ɵfac: i0.ɵɵFactoryDeclaration<FormColSpanDirective, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<FormColSpanDirective, "[uiColSpan]", never, {
@@ -7076,7 +7076,7 @@ export declare class ChipGroupComponent {
   readonly spaceAbove: import("@angular/core").InputSignal<"none" | "sm" | "md">;
   /** Space below the chip group. */
   readonly spaceBelow: import("@angular/core").InputSignal<"none" | "sm" | "md">;
-  protected readonly _gap: import("@angular/core").Signal<"6px" | "12px" | "8px">;
+  protected readonly _gap: import("@angular/core").Signal<"8px" | "6px" | "12px">;
   protected readonly _spaceAbove: import("@angular/core").Signal<"0" | "6px" | "12px">;
   protected readonly _spaceBelow: import("@angular/core").Signal<"0" | "6px" | "12px">;
   static ɵfac: i0.ɵɵFactoryDeclaration<ChipGroupComponent, never>;
@@ -10970,4 +10970,868 @@ export declare class ImageGalleryDialogComponent {
     "index": "indexChange";
   }, never, never, true, never>;
 }
+/** The apps / modules that can offer integrations ('marketing' = the shared marketing module, which has its own Integrations page). */
+export type IntegrationApp = 'real-estate' | 'contractor' | 'cremo' | 'mfh' | 'marketing';
+/** One integration. `apps` says which apps offer it: `'all'` (Twilio, ...) or the list of apps it belongs to. Live ones can be connected; coming-soon ones are display-only. */
+export interface IntegrationDef {
+  key: string;
+  name: string;
+  description: string;
+  /** `'all'` = every app; otherwise only the listed apps offer it. */
+  apps: 'all' | readonly IntegrationApp[];
+  status: 'live' | 'coming-soon';
+  iconBg: string;
+  iconColor: string;
+  connectLabel: string;
+  connectDesc: string;
+  setupSteps?: {
+    title: string;
+    desc: string;
+  }[];
+  howItWorks?: {
+    title: string;
+    desc: string;
+  }[];
+  group?: string;
+  pricingNote?: string;
+  /** IDX providers only: where the provider's own documentation lives. */
+  supportUrl?: string;
+  /** IDX providers only: the lead fields the provider sends. */
+  fieldFormats?: string;
+  /** IDX providers only: how the provider delivers leads. */
+  webhookNote?: string;
+}
+/** Every integration any app offers: IDX providers first, then the rest in catalog order. Use `integrationsForApp()` to get one app's. */
+export declare const INTEGRATION_CATALOG: readonly IntegrationDef[];
+/** A text field the connect form shows while an integration is not connected. */
+export interface IntegrationFieldDef {
+  id: string;
+  label: string;
+  type: 'text' | 'password';
+  placeholder: string;
+  hint?: string;
+}
+/** A checkbox of an integration's import options (shown once connected). */
+export interface IntegrationOptionDef {
+  id: string;
+  label: string;
+  hint?: string;
+}
+export declare const INTEGRATION_FIELD_DEFS: Readonly<Record<string, readonly IntegrationFieldDef[]>>;
+export declare const INTEGRATION_OPTION_DEFS: Readonly<Record<string, readonly IntegrationOptionDef[]>>;
+/** Behavioural signals the IDX tracking webhook records (tier = how many lead-score points it is worth). */
+export declare const IDX_BEHAVIOR_SIGNALS: readonly {
+  label: string;
+  tier: 'high' | 'med' | 'low';
+}[];
+/** Ordered section labels used by `IntegrationDef.group`. */
+export declare const INTEGRATION_GROUP_ORDER: readonly string[];
+/** The integrations one app offers (those marked `'all'` plus those that list the app), in catalog order. */
+export declare function integrationsForApp(app: IntegrationApp): IntegrationDef[];
+/**
+ * The integrations that belong to ONE app / module only, i.e. whose `apps` list names it (integrations offered to 'all' apps are not included).
+ * The marketing module's own Integrations page uses `integrationsOnlyFor('marketing')`.
+ */
+export declare function integrationsOnlyFor(app: IntegrationApp): IntegrationDef[];
+/** Plain text plus the snippets to emphasise, for `<ui-text [text] [strong]>`. */
+export interface IntegrationPlainText {
+  text: string;
+  strong: string[];
+}
+/** Splits `<strong>x</strong>` markup out of catalog copy: `"a <strong>b</strong> c"` -> `{ text: 'a b c', strong: ['b'] }`. Any other tag is dropped. */
+export declare function integrationPlainText(html: string): IntegrationPlainText;
+/**
+ * How a connect button for an integration works.
+ *  - `oauth`: GET `authorizeEndpoint` answers `{ url }` and the browser goes there (QuickBooks, Slack, Gmail, Outlook, Google / Outlook calendar).
+ *  - `area-code`: asks for a US area code and POSTs `{ areaCode }` to `connectEndpoint` (Twilio buys a number that way); the status is reloaded after.
+ */
+export type SetupIntegrationConnect = {
+  type: 'oauth';
+  authorizeEndpoint: string;
+} | {
+  type: 'area-code';
+  connectEndpoint: string;
+  areaCodeLabel?: string;
+};
+/** One integration row in an `integrations` step. The three common ones (QuickBooks, Twilio, Slack) and email / calendar come ready made: see `SETUP_INTEGRATIONS`. */
+export interface SetupIntegration {
+  key: string;
+  title: string;
+  /** Shown while the integration is not connected. */
+  description: string;
+  /** Library `ui-list-item` icon name (default 'link'). */
+  icon?: string;
+  /** GET answering `{ connected: boolean, ... }` (relative to the API base URL of `FORGEROUTE_CONFIG`). */
+  statusEndpoint: string;
+  /** When one status endpoint answers several providers (`{ gmail: {...}, outlook: {...} }`), the property that belongs to this one. */
+  statusKey?: string;
+  /** The "Connected — …" detail built from the status payload (default: just "Connected"). */
+  connectedDetail?: (status: Record<string, unknown>) => string;
+  connect: SetupIntegrationConnect;
+}
+/** Texts of the built-in controls; every one has an English default and every one can be replaced by the app. */
+export interface SetupWizardTexts {
+  brand: string;
+  stepperLabel: string;
+  progress: (done: number, total: number) => string;
+  back: string;
+  skip: string;
+  saveAndContinue: string;
+  continue: string;
+  exit: string;
+  connect: string;
+  reconnect: string;
+  connected: string;
+  importMore: string;
+  whatGetsImported: string;
+  doneTitle: string;
+  doneDescription: string;
+  doneHint: string;
+  finish: string;
+  summaryDone: string;
+  summarySkipped: string;
+  summaryPending: string;
+  areaCode: string;
+  connectIntegrationFailed: (title: string) => string;
+}
+/** An import step: the library import window (CSV / pasted data / competitor sources) with the step's own words around it. */
+export interface SetupImportStep {
+  config: ImportExportConfig;
+  sources?: ImportSource[];
+  /** Short "what gets imported" tags shown above the button. */
+  tags?: string[];
+  /** Text on the open button, e.g. "Import Contacts". */
+  buttonLabel: string;
+  /** Hint above the button. */
+  hint?: string;
+  /** Result alert title, built from the number imported (default `${n} ${config.entityNamePlural.toLowerCase()} imported successfully.`). */
+  resultTitle?: (imported: number) => string;
+  /** Result alert body. */
+  resultText?: string;
+}
+/**
+ * One step of the wizard. `steps` is the list in walking order: the app builds it (and so decides the order, the wording and which steps exist for
+ * each kind of user). A `done` summary step is always added at the end by the wizard itself.
+ */
+export interface SetupStep {
+  /** Unique within the list. */
+  key: string;
+  label: string;
+  /** The paragraph under the heading. */
+  description?: string;
+  /** `custom` shows the app's own `<ng-template uiSetupStep="key">`; `import` and `integrations` are built in. */
+  kind: 'custom' | 'import' | 'integrations';
+  /** Shows "Skip for now" (default true). The first step of a wizard usually sets this to false. */
+  skippable?: boolean;
+  /** `custom`: runs on "Save & Continue". Resolve to continue; throw / error to stay on the step (the message is shown in an alert). */
+  save?: () => Observable<unknown> | Promise<unknown> | void;
+  /** `custom`: false disables "Save & Continue". */
+  canContinue?: () => boolean;
+  /** `custom`: text of the continue button (default "Save & Continue"). */
+  saveLabel?: string;
+  import?: SetupImportStep;
+  integrations?: SetupIntegration[];
+  /** `integrations`: runs when the step is left with Continue (e.g. to save sender settings). */
+  onContinue?: () => Observable<unknown> | Promise<unknown> | void;
+  /** Called when the step is shown (load data for a custom step). */
+  onEnter?: () => void;
+}
+/**
+ * The integrations every app can offer in a setup step. The endpoints follow the convention the apps' backends already use (`GET <x>/status`,
+ * `GET <x>/authorize` answering `{ url }`); an app whose routes differ spreads a preset and overrides what differs:
+ * `{ ...SETUP_INTEGRATIONS['quickbooks'], statusEndpoint: '/accounting/status' }`.
+ */
+export declare const SETUP_INTEGRATIONS: Readonly<Record<string, SetupIntegration>>;
+/** The presets for the given keys, in that order (unknown keys throw, so a typo is found at once). */
+export declare function setupIntegrations(...keys: (keyof typeof SETUP_INTEGRATIONS | string)[]): SetupIntegration[];
+/**
+ * Marks the content of a `custom` step of `ui-setup-wizard`:
+ *
+ *   <ui-setup-wizard [steps]="steps()">
+ *     <ng-template uiSetupStep="profile"> …the app's own form… </ng-template>
+ *   </ui-setup-wizard>
+ */
+export declare class SetupWizardStepDirective {
+  /** The `key` of the step this template belongs to. */
+  readonly key: import("@angular/core").InputSignal<string>;
+  readonly template: TemplateRef<unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SetupWizardStepDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SetupWizardStepDirective, "ng-template[uiSetupStep]", never, {
+    "key": {
+      "alias": "uiSetupStep";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** The key of the summary step the wizard appends to the app's steps. */
+export declare const SETUP_DONE_KEY = "done";
+/**
+ * `ui-setup-wizard` — the first-run setup wizard every app plugs into. A left stepper with progress, one step at a time on the right, Back / Skip /
+ * Save & Continue, and a final summary. The app gives it the list of steps (in the order that user type walks them) and the wording; the library
+ * does the rest:
+ *
+ *  - `kind: 'import'` steps open the library import window (CSV, pasted data, competitor sources) and show the result;
+ *  - `kind: 'integrations'` steps list integrations with Connect / Reconnect — QuickBooks, Twilio, Slack, email and calendar come ready made
+ *    (`SETUP_INTEGRATIONS` / `setupIntegrations(...)`); an app can add its own;
+ *  - `kind: 'custom'` steps show the app's own content (`<ng-template uiSetupStep="key">`) with the step's `save` / `canContinue` hooks.
+ *
+ *   <ui-setup-wizard [steps]="steps()" [texts]="{ brand: 'My App Setup' }" (finished)="goToDashboard()" (exited)="goToDashboard()">
+ *     <ng-template uiSetupStep="profile"> … </ng-template>
+ *   </ui-setup-wizard>
+ *
+ * Changing `steps` (for example when the user type becomes known) re-orders the stepper; progress of a step that is still in the list is kept.
+ */
+export declare class SetupWizardComponent {
+  private readonly http;
+  private readonly apiBase;
+  private readonly destroyRef;
+  /** The steps in walking order. A `done` summary step is appended automatically. */
+  readonly steps: import("@angular/core").InputSignal<SetupStep[]>;
+  /** Replaces any of the built-in texts. */
+  readonly texts: import("@angular/core").InputSignal<Partial<SetupWizardTexts>>;
+  /** The last step's button ("Go to Dashboard"). */
+  readonly finished: import("@angular/core").OutputEmitterRef<void>;
+  /** "Exit Setup". */
+  readonly exited: import("@angular/core").OutputEmitterRef<void>;
+  /** The step that was just shown (its key). */
+  readonly stepChange: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly stepTemplates: import("@angular/core").Signal<readonly SetupWizardStepDirective[]>;
+  protected readonly importers: import("@angular/core").Signal<readonly ImportExportComponent[]>;
+  protected readonly t: import("@angular/core").Signal<SetupWizardTexts>;
+  protected readonly currentKey: import("@angular/core").WritableSignal<string>;
+  private readonly completed;
+  private readonly skipped;
+  private readonly imports;
+  private readonly statuses;
+  protected readonly busy: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<string>;
+  protected readonly areaCodeOpen: import("@angular/core").WritableSignal<string>;
+  protected readonly areaCode: import("@angular/core").WritableSignal<string>;
+  /** A US area code: exactly three digits. */
+  protected readonly validAreaCode: import("@angular/core").Signal<boolean>;
+  /** The app's steps plus the summary step. */
+  protected readonly allSteps: import("@angular/core").Signal<SetupStep[]>;
+  protected readonly index: import("@angular/core").Signal<number>;
+  protected readonly current: import("@angular/core").Signal<SetupStep>;
+  protected readonly isDone: import("@angular/core").Signal<boolean>;
+  protected readonly completedCount: import("@angular/core").Signal<number>;
+  protected readonly stepperSteps: import("@angular/core").Signal<StepperStep[]>;
+  protected readonly summarySections: import("@angular/core").Signal<PanelInfoSection[]>;
+  constructor();
+  protected templateFor(key: string): import("@angular/core").TemplateRef<unknown> | null;
+  protected goTo(key: string): void;
+  private enter;
+  private advanceFrom;
+  protected back(): void;
+  protected skip(): void;
+  private markCompleted;
+  /** "Save & Continue" of a custom or integrations step: runs the step's hook, then moves on. */
+  protected saveAndContinue(): Promise<void>;
+  private run;
+  /** The message to show for a failure: the server's own `{ message }` (or a thrown error's message); never the HTTP client's technical text. */
+  private messageOf;
+  protected openImport(key: string): void;
+  protected onImported(key: string): void;
+  protected importResult(key: string): number | null;
+  protected clearImport(key: string): void;
+  protected importTitle(key: string): string;
+  protected continueFromImport(): void;
+  private loadStatuses;
+  private setStatuses;
+  protected isConnected(i: SetupIntegration): boolean;
+  protected detailFor(i: SetupIntegration): string;
+  protected connect(i: SetupIntegration): void;
+  protected areaCodeLabelFor(i: SetupIntegration): string;
+  /** Sends the browser to the provider's authorization page. */
+  protected redirect(url: string): void;
+  protected submitAreaCode(i: SetupIntegration): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SetupWizardComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SetupWizardComponent, "ui-setup-wizard", never, {
+    "steps": {
+      "alias": "steps";
+      "required": true;
+      "isSignal": true;
+    };
+    "texts": {
+      "alias": "texts";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "finished": "finished";
+    "exited": "exited";
+    "stepChange": "stepChange";
+  }, ["stepTemplates"], ["[setup-wizard-logo]"], true, never>;
+}
+/** One automated trigger a template can be assigned to (the host decides which exist). */
+export interface EmailTemplateAssignmentOption {
+  key: string;
+  name: string;
+  description: string;
+}
+/** The channels a template is assigned to for one trigger. */
+export interface EmailTemplateAssignmentChannels {
+  key: string;
+  email: boolean;
+  text: boolean;
+}
+/** A template as the editor shows it. `id` is null/absent for a template that is not stored yet (new, or a copy of another). */
+export interface EmailTemplateValue {
+  id?: string | null;
+  name: string;
+  subject: string;
+  category: string;
+  useAllYear: boolean;
+  /** `YYYY-MM-DD` or ''. */
+  activeFrom: string;
+  /** `YYYY-MM-DD` or ''. */
+  activeTo: string;
+  /** The stored message HTML (the editor reads and writes `<div data-block="true">…</div>` blocks). */
+  body: string;
+  videoId?: string | null;
+  videoTitle?: string | null;
+  /** The channels per trigger; a trigger that is missing is not assigned. */
+  assignments?: EmailTemplateAssignmentChannels[];
+}
+/** What `(save)` emits. Dates are the raw `YYYY-MM-DD` values (null while "all year" is on); the host maps them to its API. */
+export interface EmailTemplateSavePayload {
+  name: string;
+  subject: string;
+  body: string;
+  category: string;
+  useAllYear: boolean;
+  activeFrom: string | null;
+  activeTo: string | null;
+  videoId: string | null;
+  /** Only the triggers with at least one channel on. */
+  assignments: EmailTemplateAssignmentChannels[];
+}
+export interface EmailTemplateBlock {
+  key: string;
+  label: string;
+  /** The HTML a click / drop inserts as a new block. */
+  html: string;
+}
+export interface EmailTemplateBlockGroup {
+  name: string;
+  blocks: EmailTemplateBlock[];
+}
+export interface EmailTemplateVariable {
+  /** Inserted as `{{key}}`. */
+  key: string;
+  label: string;
+  example: string;
+}
+export interface EmailTemplateVariableGroup {
+  name: string;
+  variables: EmailTemplateVariable[];
+}
+/** A video from the host's library that can be added to the message. */
+export interface EmailTemplateVideo {
+  id: string;
+  title: string;
+  shareLink: string;
+  thumbnailUrl?: string | null;
+  durationSeconds?: number | null;
+  category?: string | null;
+}
+/** The video options the host starts with (e.g. the company's saved defaults); the user can change them in the Video tab. */
+export interface EmailTemplateVideoDefaults {
+  autoplay: boolean;
+  caption: string;
+  ctaType: string;
+  ctaUrl: string;
+  ctaLabel: string;
+  hideReactions: boolean;
+}
+export interface EmailTemplateVideoOptions extends EmailTemplateVideoDefaults {}
+/** Builds the link a video block points at; the default is the video's own share link. */
+export type EmailTemplateVideoLinkFn = (video: EmailTemplateVideo, options: EmailTemplateVideoOptions) => string;
+interface EmailBlock {
+  id: string;
+  html: string;
+  spacing?: string;
+}
+interface AssignmentView extends EmailTemplateAssignmentOption {
+  email: boolean;
+  text: boolean;
+}
+type EditorTab = 'edit' | 'preview' | 'mobile';
+type RightTab = 'blocks' | 'variables' | 'video';
+/**
+ * `ui-email-template-editor` - the full-page, block-based email template editor (details, assignments, block canvas with drag and drop,
+ * rich-text toolbar, preview / mobile preview, content blocks, merge variables, video library, test send and AI draft).
+ *
+ * The component owns the editing behaviour and holds no HTTP: the host loads the template (`[template]`), supplies what differs per app
+ * (`categories`, `assignmentOptions`, `variableGroups`, `blockGroups`, `videos`, `videoDefaults`, `maxBodyLength`, permissions) and reacts to
+ * `(save)`, `(testSend)`, `(aiGenerate)`, `(videosRequested)`, `(back)` and `(useAsMine)`. After a request the host calls back:
+ * `markSaved(id)` (a create succeeded), `closeTestSend()` and `addGeneratedHtml(html)`.
+ *
+ * Project an element with the `uiSubjectAction` attribute to put a host control (e.g. an AI copy button) at the end of the Subject label line.
+ *
+ * Message limit: `maxBodyLength` is measured on the serialised HTML. An untouched stored body that is already longer than the limit is
+ * accepted unchanged (legacy rows), exactly as the server does.
+ */
+export declare class EmailTemplateEditorComponent {
+  private readonly host;
+  private readonly injector;
+  private readonly toast;
+  /** The template to edit. `null` = a blank new template. An object without `id` is a new template that starts from those values (e.g. a copy). */
+  readonly template: import("@angular/core").InputSignal<EmailTemplateValue | null>;
+  readonly categories: import("@angular/core").InputSignal<SelectOption<string>[]>;
+  readonly categoryPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly assignmentOptions: import("@angular/core").InputSignal<EmailTemplateAssignmentOption[]>;
+  /** The assignment shown first (e.g. the trigger the user came from). */
+  readonly featuredAssignmentKey: import("@angular/core").InputSignal<string | null>;
+  readonly assignmentsDescription: import("@angular/core").InputSignal<string>;
+  readonly textEnabled: import("@angular/core").InputSignal<boolean>;
+  readonly variableGroups: import("@angular/core").InputSignal<EmailTemplateVariableGroup[]>;
+  readonly blockGroups: import("@angular/core").InputSignal<EmailTemplateBlockGroup[]>;
+  readonly aiExamples: import("@angular/core").InputSignal<string[]>;
+  readonly namePlaceholder: import("@angular/core").InputSignal<string>;
+  readonly subjectPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly backLabel: import("@angular/core").InputSignal<string>;
+  readonly createLabel: import("@angular/core").InputSignal<string>;
+  readonly editLabel: import("@angular/core").InputSignal<string>;
+  readonly systemNote: import("@angular/core").InputSignal<string>;
+  readonly readOnlyNote: import("@angular/core").InputSignal<string>;
+  /** Prefix of the ids of the field errors the editor renders (`<prefix>-body-error`). */
+  readonly idPrefix: import("@angular/core").InputSignal<string>;
+  /** The longest message (serialised HTML) that can be saved. */
+  readonly maxBodyLength: import("@angular/core").InputSignal<number>;
+  readonly maxTextLength: import("@angular/core").InputSignal<number>;
+  /** The member may change templates (false = read-only: everything is shown, nothing can be edited). */
+  readonly fullAccess: import("@angular/core").InputSignal<boolean>;
+  /** A built-in template: shown read-only; a member with full access can copy it ((useAsMine)). */
+  readonly systemTemplate: import("@angular/core").InputSignal<boolean>;
+  readonly aiEnabled: import("@angular/core").InputSignal<boolean>;
+  readonly testSendEnabled: import("@angular/core").InputSignal<boolean>;
+  readonly videosEnabled: import("@angular/core").InputSignal<boolean>;
+  readonly saving: import("@angular/core").InputSignal<boolean>;
+  readonly testSending: import("@angular/core").InputSignal<boolean>;
+  readonly aiGenerating: import("@angular/core").InputSignal<boolean>;
+  readonly videos: import("@angular/core").InputSignal<EmailTemplateVideo[]>;
+  readonly videosLoading: import("@angular/core").InputSignal<boolean>;
+  readonly videoDefaults: import("@angular/core").InputSignal<EmailTemplateVideoDefaults>;
+  readonly videoLink: import("@angular/core").InputSignal<EmailTemplateVideoLinkFn>;
+  readonly noVideosHint: import("@angular/core").InputSignal<string>;
+  readonly back: import("@angular/core").OutputEmitterRef<void>;
+  readonly save: import("@angular/core").OutputEmitterRef<EmailTemplateSavePayload>;
+  readonly testSend: import("@angular/core").OutputEmitterRef<string>;
+  readonly aiGenerate: import("@angular/core").OutputEmitterRef<string>;
+  /** The Video tab was opened (the host loads the library once). */
+  readonly videosRequested: import("@angular/core").OutputEmitterRef<void>;
+  readonly useAsMine: import("@angular/core").OutputEmitterRef<void>;
+  readonly editingId: import("@angular/core").WritableSignal<string | null>;
+  readonly isNew: import("@angular/core").Signal<boolean>;
+  readonly name: import("@angular/core").WritableSignal<string>;
+  readonly subject: import("@angular/core").WritableSignal<string>;
+  readonly category: import("@angular/core").WritableSignal<string>;
+  readonly useAllYear: import("@angular/core").WritableSignal<boolean>;
+  readonly activeFrom: import("@angular/core").WritableSignal<string>;
+  readonly activeTo: import("@angular/core").WritableSignal<string>;
+  readonly videoId: import("@angular/core").WritableSignal<string | null>;
+  readonly videoTitle: import("@angular/core").WritableSignal<string | null>;
+  /** The channels the template has per trigger; the rows shown are `assignmentOptions` with these applied. */
+  private readonly assignmentChannels;
+  private readonly assignmentState;
+  readonly blocks: import("@angular/core").WritableSignal<EmailBlock[]>;
+  readonly selectedBlockId: import("@angular/core").WritableSignal<string | null>;
+  private initializedBlockIds;
+  private savedRange;
+  private readonly blockEditors;
+  private readonly colorInputRef;
+  /** The stored body of the template being edited; null for a new one. */
+  private readonly loadedBody;
+  /** True once the user really edited the message (typing, blocks, formatting, links...). */
+  private readonly bodyEdited;
+  private savedSnapshot;
+  private dragFromPalette;
+  readonly dragFromCanvas: import("@angular/core").WritableSignal<number | null>;
+  readonly dragOverIndex: import("@angular/core").WritableSignal<number | null>;
+  readonly currentColor: import("@angular/core").WritableSignal<string>;
+  readonly blockSpacing: import("@angular/core").WritableSignal<string>;
+  readonly headingKey: import("@angular/core").WritableSignal<number>;
+  readonly sizeKey: import("@angular/core").WritableSignal<number>;
+  readonly headingOptions: SelectOption<string>[];
+  readonly fontSizeOptions: SelectOption<string>[];
+  readonly spacingOptions: SelectOption<string>[];
+  readonly ctaTypeOptions: SelectOption<string>[];
+  readonly playbackOptions: {
+    value: string;
+    label: string;
+  }[];
+  readonly showLinkDialog: import("@angular/core").WritableSignal<boolean>;
+  readonly linkUrl: import("@angular/core").WritableSignal<string>;
+  readonly linkText: import("@angular/core").WritableSignal<string>;
+  /** True when the link is made from selected text (the text field is then not needed). */
+  readonly linkTextFromSelection: import("@angular/core").WritableSignal<boolean>;
+  readonly showImageDialog: import("@angular/core").WritableSignal<boolean>;
+  readonly imageUrl: import("@angular/core").WritableSignal<string>;
+  readonly imageAlt: import("@angular/core").WritableSignal<string>;
+  readonly showTestSendDialog: import("@angular/core").WritableSignal<boolean>;
+  readonly testSendEmail: import("@angular/core").WritableSignal<string>;
+  readonly showAiPanel: import("@angular/core").WritableSignal<boolean>;
+  readonly aiPrompt: import("@angular/core").WritableSignal<string>;
+  readonly showAssignmentConfig: import("@angular/core").WritableSignal<boolean>;
+  readonly configTarget: import("@angular/core").WritableSignal<AssignmentView | null>;
+  readonly configEmail: import("@angular/core").WritableSignal<boolean>;
+  readonly configText: import("@angular/core").WritableSignal<boolean>;
+  readonly activeEditorTab: import("@angular/core").WritableSignal<EditorTab>;
+  readonly activeRightTab: import("@angular/core").WritableSignal<RightTab>;
+  readonly blockSearch: import("@angular/core").WritableSignal<string>;
+  readonly assignmentSearch: import("@angular/core").WritableSignal<string>;
+  /** Groups the user opened or closed; the first variable group starts open. */
+  private readonly toggledGroups;
+  readonly videoAutoplay: import("@angular/core").WritableSignal<boolean>;
+  readonly videoCaption: import("@angular/core").WritableSignal<string>;
+  readonly videoCtaType: import("@angular/core").WritableSignal<string>;
+  readonly videoCtaUrl: import("@angular/core").WritableSignal<string>;
+  readonly videoCtaLabel: import("@angular/core").WritableSignal<string>;
+  readonly videoHideReactions: import("@angular/core").WritableSignal<boolean>;
+  readonly canWrite: import("@angular/core").Signal<boolean>;
+  /** A system template can be copied into a new template of the company's own (full access). */
+  readonly canCopySystem: import("@angular/core").Signal<boolean>;
+  readonly filteredAssignments: import("@angular/core").Signal<AssignmentView[]>;
+  readonly filteredBlockGroups: import("@angular/core").Signal<EmailTemplateBlockGroup[]>;
+  private readonly serialized;
+  readonly previewHtml: import("@angular/core").Signal<string>;
+  /** Characters in the body as it is saved. */
+  readonly bodyLength: import("@angular/core").Signal<number>;
+  readonly bodyHasContent: import("@angular/core").Signal<boolean>;
+  /** The body as the server stores it and as the editor serialises it right after loading: while they match the message has not been touched. */
+  readonly bodyUnchanged: import("@angular/core").Signal<boolean>;
+  readonly nameError: import("@angular/core").Signal<string>;
+  readonly subjectError: import("@angular/core").Signal<string>;
+  readonly bodyError: import("@angular/core").Signal<string>;
+  /** "Active From / To" only apply when the template is not "all year"; when both are given To may not be before From. */
+  readonly datesError: import("@angular/core").Signal<"" | "Active To must be on or after Active From.">;
+  readonly canSave: import("@angular/core").Signal<boolean>;
+  readonly saveDisabled: import("@angular/core").Signal<boolean>;
+  private normalizedLink;
+  /** Why Insert is disabled: nothing for an empty field, a message for an address that is not a link. */
+  readonly linkUrlError: import("@angular/core").Signal<"" | "Enter a valid email address." | "Enter a valid web address, like https://example.com.">;
+  readonly canInsertLink: import("@angular/core").Signal<boolean>;
+  readonly imageUrlError: import("@angular/core").Signal<"" | "Enter a valid image address, like https://example.com/image.jpg.">;
+  readonly canInsertImage: import("@angular/core").Signal<boolean>;
+  readonly testEmailError: import("@angular/core").Signal<"" | "Enter a valid email address.">;
+  readonly canSendTest: import("@angular/core").Signal<boolean>;
+  /** The test email is the SAVED template: true when the editor holds changes that were not saved yet. */
+  readonly hasUnsavedChanges: import("@angular/core").Signal<boolean>;
+  readonly canGenerate: import("@angular/core").Signal<boolean>;
+  constructor();
+  /** A create succeeded: the template now has an id (Test Send becomes available) and what is on screen is the saved version. */
+  markSaved(id?: string | null): void;
+  /** The test email was sent: close the dialog. */
+  closeTestSend(): void;
+  /** The AI draft arrived: add it as a new block and close the AI panel. */
+  addGeneratedHtml(html: string): void;
+  private applyTemplate;
+  onSave(): void;
+  private snapshot;
+  private serialize;
+  private htmlToBlocks;
+  private stripBlockWrappers;
+  private genId;
+  private editorFor;
+  /** Copies each block's HTML from its DOM element (before saving / preview). */
+  syncActiveBlockHtml(): void;
+  private syncBlock;
+  setEditorTab(tab: EditorTab): void;
+  addBlock(blockKey?: string): void;
+  private addBlockHtml;
+  deleteBlock(index: number): void;
+  duplicateBlock(index: number): void;
+  moveBlock(index: number, direction: -1 | 1): void;
+  onBlockInput(event: Event, block: EmailBlock): void;
+  /**
+   * Typing and pasting stop at the body limit: input that would push the saved HTML past it is refused before it reaches the block
+   * (the disabled Save and the inline message cover everything else). Deleting is always allowed.
+   */
+  onBlockBeforeInput(event: InputEvent): void;
+  onBlockFocus(block: EmailBlock): void;
+  onPaletteDragStart(event: DragEvent, block: EmailTemplateBlock): void;
+  /**
+   * Starts reordering a block. Only the block's drag HANDLE is draggable (not the whole block): a draggable ancestor of a contenteditable makes
+   * Firefox and Safari hijack mouse text selection inside it. `wrapper` is the block, shown as the drag image instead of the small handle.
+   */
+  onBlockDragStart(event: DragEvent, index: number, wrapper?: HTMLElement): void;
+  onBlockDragEnd(): void;
+  /** The canvas as a whole accepts only a block drag; a text drag inside a block keeps the browser's own behaviour. */
+  onCanvasDragOver(event: DragEvent): void;
+  onDropZoneDragOver(event: DragEvent, index: number): void;
+  onDropZoneLeave(): void;
+  onDropZoneDrop(event: DragEvent, insertBefore: number): void;
+  /**
+   * Mousedown on the toolbar keeps the selection in the editor (a button click must not blur it). A `<select>` / `<input>` must be left alone:
+   * preventing the default of its mousedown stops the dropdown from opening. Those controls take focus, so they save the selection first
+   * (`(mousedown)="saveSelection()"`) and the command restores it.
+   */
+  preventFocusLoss(event: MouseEvent): void;
+  /** Remembers the selection before a control takes focus. Only a selection inside an editor block is kept; anything else clears an older one. */
+  saveSelection(): void;
+  /**
+   * Puts the remembered selection back, once. A saved range is used only when focus really left the editor (a dialog, a select, the colour
+   * picker): when the live selection is already inside a block (a toolbar button keeps it there) that live selection wins, and a range left over
+   * from an earlier interaction is dropped instead of formatting the wrong block.
+   */
+  private restoreSelection;
+  /** The HTML of the block being edited, or null when its editor is not on screen. */
+  private activeBlockHtml;
+  /**
+   * Runs one editing command and marks the body edited only when it can have changed it: it ran over a real (non-collapsed) selection, or the
+   * block's HTML is different afterwards. A click on Bold with only a caret in an untouched legacy body is not an edit. When the block cannot be
+   * read the command counts as an edit, so a real edit is never lost; typing always raises `(input)`, which marks it too.
+   */
+  private runEditCommand;
+  execCommand(cmd: string, value?: string): void;
+  onHeading(value: string): void;
+  onFontSize(value: string): void;
+  applyFontSize(size: string): void;
+  applyTextColor(color: string): void;
+  openColorPicker(): void;
+  applySpacing(value: string): void;
+  openLinkDialog(): void;
+  insertLink(): void;
+  openImageDialog(): void;
+  insertImageFromUrl(): void;
+  openTestSendDialog(): void;
+  onTestSend(): void;
+  openAiPanel(): void;
+  onAiGenerate(): void;
+  openVideoTab(): void;
+  insertVideo(video: EmailTemplateVideo): void;
+  formatDuration(seconds: number | null | undefined): string;
+  categoryLabel(cat: string | null | undefined): string;
+  openAssignmentConfig(item: AssignmentView): void;
+  saveAssignmentConfig(): void;
+  isOpen(id: string): boolean;
+  toggleGroup(id: string): void;
+  insertBlock(block: EmailTemplateBlock): void;
+  insertVariable(variable: EmailTemplateVariable): void;
+  private blockHtml;
+  static ɵfac: i0.ɵɵFactoryDeclaration<EmailTemplateEditorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<EmailTemplateEditorComponent, "ui-email-template-editor", never, {
+    "template": {
+      "alias": "template";
+      "required": false;
+      "isSignal": true;
+    };
+    "categories": {
+      "alias": "categories";
+      "required": false;
+      "isSignal": true;
+    };
+    "categoryPlaceholder": {
+      "alias": "categoryPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "assignmentOptions": {
+      "alias": "assignmentOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "featuredAssignmentKey": {
+      "alias": "featuredAssignmentKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "assignmentsDescription": {
+      "alias": "assignmentsDescription";
+      "required": false;
+      "isSignal": true;
+    };
+    "textEnabled": {
+      "alias": "textEnabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "variableGroups": {
+      "alias": "variableGroups";
+      "required": false;
+      "isSignal": true;
+    };
+    "blockGroups": {
+      "alias": "blockGroups";
+      "required": false;
+      "isSignal": true;
+    };
+    "aiExamples": {
+      "alias": "aiExamples";
+      "required": false;
+      "isSignal": true;
+    };
+    "namePlaceholder": {
+      "alias": "namePlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "subjectPlaceholder": {
+      "alias": "subjectPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "backLabel": {
+      "alias": "backLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "createLabel": {
+      "alias": "createLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "editLabel": {
+      "alias": "editLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "systemNote": {
+      "alias": "systemNote";
+      "required": false;
+      "isSignal": true;
+    };
+    "readOnlyNote": {
+      "alias": "readOnlyNote";
+      "required": false;
+      "isSignal": true;
+    };
+    "idPrefix": {
+      "alias": "idPrefix";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxBodyLength": {
+      "alias": "maxBodyLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxTextLength": {
+      "alias": "maxTextLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "fullAccess": {
+      "alias": "fullAccess";
+      "required": false;
+      "isSignal": true;
+    };
+    "systemTemplate": {
+      "alias": "systemTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "aiEnabled": {
+      "alias": "aiEnabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "testSendEnabled": {
+      "alias": "testSendEnabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "videosEnabled": {
+      "alias": "videosEnabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "saving": {
+      "alias": "saving";
+      "required": false;
+      "isSignal": true;
+    };
+    "testSending": {
+      "alias": "testSending";
+      "required": false;
+      "isSignal": true;
+    };
+    "aiGenerating": {
+      "alias": "aiGenerating";
+      "required": false;
+      "isSignal": true;
+    };
+    "videos": {
+      "alias": "videos";
+      "required": false;
+      "isSignal": true;
+    };
+    "videosLoading": {
+      "alias": "videosLoading";
+      "required": false;
+      "isSignal": true;
+    };
+    "videoDefaults": {
+      "alias": "videoDefaults";
+      "required": false;
+      "isSignal": true;
+    };
+    "videoLink": {
+      "alias": "videoLink";
+      "required": false;
+      "isSignal": true;
+    };
+    "noVideosHint": {
+      "alias": "noVideosHint";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "back": "back";
+    "save": "save";
+    "testSend": "testSend";
+    "aiGenerate": "aiGenerate";
+    "videosRequested": "videosRequested";
+    "useAsMine": "useAsMine";
+  }, never, ["[uiSubjectAction]"], true, never>;
+}
+/** The text a new template's first block starts with: it is a prompt, not content, so a template still holding only this has no message. */
+export declare const EMAIL_TEMPLATE_START_TEXT = "Start writing your email...";
+/** Longest message (serialised HTML) the editor accepts by default; hosts pass their own server limit through `maxBodyLength`. */
+export declare const EMAIL_TEMPLATE_MAX_BODY = 9000;
+/** Longest name / subject accepted by default. */
+export declare const EMAIL_TEMPLATE_MAX_TEXT = 255;
+/** Longest single email address (server rule). */
+export declare const MAX_EMAIL_ADDRESS_LENGTH = 254;
+/** True for a plausible single email address of at most 254 characters. */
+export declare const isValidEmailAddress: (address: string) => boolean;
+/** An http(s) address with a real host: no spaces or quotes (the address is written into an HTML attribute) and a dot or `localhost`. */
+export declare function isWebUrl(raw: string): boolean;
+/** Escapes text for HTML text and double-quoted attribute values. */
+export declare function escapeHtml(value: string): string;
+/** True when a block's HTML shows something to a reader: an image or other media, or text once tags, non-breaking spaces and whitespace are gone. */
+export declare function blockHasContent(html: string): boolean;
+/**
+ * The drag payload of a block (a palette item or a block being reordered). A custom type, never `text/plain`: a text drop onto a block's
+ * contenteditable would insert the payload into the message in every engine. Firefox only starts a drag when some data is set (a custom
+ * type counts); Safari lets a drop zone read `types` during dragover but not `getData`.
+ */
+export declare const EMAIL_BLOCK_DRAG_TYPE = "application/x-tpl-block";
+/** True when the drag carries a block payload (`types` is an array in current engines, a DOMStringList in very old ones). */
+export declare function isBlockDrag(event: {
+  dataTransfer?: {
+    types?: ArrayLike<string> | readonly string[];
+  } | null;
+}): boolean;
+/** True when a node sits inside one of the editor's blocks (the only place a saved selection may point). */
+export declare function insideEditorBlock(node: Node | null | undefined): boolean;
+/** `m:ss` for a duration in seconds; '' when there is none. */
+export declare function formatVideoDuration(seconds: number | null | undefined): string;
+/** `follow-up` → `Follow Up`. */
+export declare function formatCategoryLabel(cat: string | null | undefined): string;
+/** The email block a video becomes: a thumbnail with a play overlay, linked to `link`, with the title and a caption. Every user value is escaped. */
+export declare function buildVideoBlockHtml(video: EmailTemplateVideo, link: string, caption: string, origin: string): string;
+/** The content blocks every host gets unless it passes its own `blockGroups`. */
+export declare const DEFAULT_EMAIL_TEMPLATE_BLOCK_GROUPS: EmailTemplateBlockGroup[];
+/** Generic merge variables; a host passes its own `variableGroups` for the data its sender can fill in. */
+export declare const DEFAULT_EMAIL_TEMPLATE_VARIABLE_GROUPS: {
+  name: string;
+  variables: {
+    key: string;
+    label: string;
+    example: string;
+  }[];
+}[];
 export type { CalendarDay, CalendarRange, CalendarViewMode };