@lifecorner/angular-ui-kit 3.4.0 → 3.5.0

package/types/lifecorner-angular-ui-kit-radio.d.ts

@@ -0,0 +1,297 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, OnDestroy, OnInit, Signal } from "@angular/core";
+import { ControlValueAccessor } from "@angular/forms";
+export type RadioSize = 'xs' | 'sm' | 'md' | 'lg';
+/**
+ * Tracks every live `lc-radio` so that checking one radio can uncheck the
+ * others of its group. The browser does this natively (same `name`, same form
+ * owner) without firing an event on the radios that lose the check, so their
+ * component state would otherwise go stale.
+ */
+export declare class RadioGroupRegistry {
+  private readonly radios;
+  add(radio: RadioComponent): void;
+  remove(radio: RadioComponent): void;
+  /** Marks `source` as the checked radio of its group; siblings are unchecked. */
+  select(source: RadioComponent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupRegistry, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class RadioComponent implements ControlValueAccessor, OnInit, OnDestroy {
+  readonly id: import("@angular/core").InputSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly error: import("@angular/core").InputSignal<boolean>;
+  readonly errorMessage: import("@angular/core").InputSignal<string>;
+  readonly helpText: import("@angular/core").InputSignal<string>;
+  readonly size: import("@angular/core").InputSignal<RadioSize>;
+  readonly required: import("@angular/core").InputSignal<boolean>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly ariaLabelledBy: import("@angular/core").InputSignal<string>;
+  readonly ariaDescribedBy: import("@angular/core").InputSignal<string>;
+  /**
+   * Checked state (two-way bindable). Emits `checkedChange` whenever it
+   * changes: on user selection, when a sibling of the same group is selected,
+   * and when a bound form control writes a value.
+   */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  readonly valueChange: import("@angular/core").OutputEmitterRef<string>;
+  /** Disabled state pushed by a form control (`setDisabledState`). */
+  private readonly formDisabled;
+  /** The `lc-radio-group` around this radio, if any. */
+  private readonly group;
+  /** Effective disabled state: `disabled` input OR form control OR group disabled. */
+  readonly isDisabled: import("@angular/core").Signal<boolean>;
+  /** The rendered `name`: the group's inside an `lc-radio-group`, else `name`. */
+  readonly effectiveName: import("@angular/core").Signal<string>;
+  /** `required` here or on the group. */
+  readonly isRequired: import("@angular/core").Signal<boolean>;
+  /** Error state here or on the group. */
+  readonly isInvalid: import("@angular/core").Signal<boolean>;
+  readonly labelClasses: import("@angular/core").Signal<string>;
+  /** id of the rendered help text (only while it is shown). */
+  readonly helpTextId: import("@angular/core").Signal<string | null>;
+  /** id of the rendered error message (only while it is shown). */
+  readonly errorMessageId: import("@angular/core").Signal<string | null>;
+  /** aria-describedby: consumer-supplied ids plus the rendered help/error text. */
+  readonly describedBy: import("@angular/core").Signal<string | null>;
+  private readonly cdr;
+  private readonly ngControl;
+  private readonly registry;
+  private readonly inputEl;
+  /**
+   * Last value written by a bound form control; `null` until a form has
+   * written once, so `[checked]` bindings on unbound radios are left alone.
+   */
+  private readonly formValue;
+  private valueChangeSub?;
+  private onChange;
+  private onTouched;
+  constructor();
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  /** Native form owner of the radio input; scopes the radio group like the browser does. */
+  formOwner(): HTMLFormElement | null;
+  writeValue(value: string | null): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  handleChange(event: Event): void;
+  handleBlur(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "lc-radio", never, {
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessage": {
+      "alias": "errorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "helpText": {
+      "alias": "helpText";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabelledBy": {
+      "alias": "ariaLabelledBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaDescribedBy": {
+      "alias": "ariaDescribedBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+    "valueChange": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * What an `lc-radio` inside an `lc-radio-group` reads from its group: the
+ * shared name, the selected value and the group's states. Provided by
+ * `RadioGroupComponent`; a radio without a group works on its own as before.
+ */
+export interface RadioGroupContext {
+  /** The `name` every radio of the group renders. */
+  readonly groupName: Signal<string>;
+  /** The selected value; `''` = none. */
+  readonly selectedValue: Signal<string>;
+  readonly groupDisabled: Signal<boolean>;
+  readonly groupRequired: Signal<boolean>;
+  readonly groupInvalid: Signal<boolean>;
+  /** Called by a radio the person selects. */
+  select(value: string): void;
+  /** Called when a radio loses focus (marks a bound form control touched). */
+  touch(): void;
+}
+export declare const RADIO_GROUP: InjectionToken<RadioGroupContext>;
+export type RadioGroupOrientation = 'vertical' | 'horizontal';
+/**
+ * A group of `lc-radio`s: a native `<fieldset>` named by its `<legend>`, with
+ * group help text and one group error, both linked by `aria-describedby`. The
+ * group gives every radio inside the same `name`, `required`, `disabled` and
+ * invalid state, and holds the selected value (`[(value)]` or a form control on
+ * the group).
+ *
+ * @example
+ * ```html
+ * <lc-radio-group legend="Sprache" [legendHidden]="true" [(value)]="locale">
+ *   <lc-radio value="device" label="Wie dieses Gerät" size="lg" />
+ *   <lc-radio value="en" label="English" size="lg" lang="en" />
+ *   <lc-radio value="de" label="Deutsch" size="lg" lang="de" />
+ * </lc-radio-group>
+ * ```
+ */
+export declare class RadioGroupComponent implements RadioGroupContext, ControlValueAccessor {
+  /** The group's question, rendered as the `<legend>` (its accessible name). */
+  readonly legend: import("@angular/core").InputSignal<string>;
+  /** Hide the legend visually; screen readers still read it. */
+  readonly legendHidden: import("@angular/core").InputSignal<boolean>;
+  /** The `name` of every radio in the group. Unset = a generated one. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Help for the whole group, below the legend. */
+  readonly helpText: import("@angular/core").InputSignal<string>;
+  /** One error for the whole group, below the help text; marks every radio invalid. */
+  readonly error: import("@angular/core").InputSignal<string>;
+  /** Every radio is `required`. */
+  readonly required: import("@angular/core").InputSignal<boolean>;
+  /** Show `*` after the legend of a required group. */
+  readonly requiredIndicator: import("@angular/core").InputSignal<boolean>;
+  /** Accessible name of the `*` marker. */
+  readonly requiredAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Disables every radio. */
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** `vertical` (default) or `horizontal` (wraps). */
+  readonly orientation: import("@angular/core").InputSignal<RadioGroupOrientation>;
+  /** The selected value (two-way bindable); `''` = none. */
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly groupId: string;
+  readonly helpId: string;
+  readonly errorId: string;
+  private readonly formDisabled;
+  private onChange;
+  private onTouched;
+  readonly groupName: import("@angular/core").Signal<string>;
+  readonly selectedValue: import("@angular/core").Signal<string>;
+  readonly groupDisabled: import("@angular/core").Signal<boolean>;
+  readonly groupRequired: import("@angular/core").Signal<boolean>;
+  readonly groupInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly describedBy: import("@angular/core").Signal<string | null>;
+  select(value: string): void;
+  touch(): void;
+  writeValue(value: string | null | undefined): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "lc-radio-group", never, {
+    "legend": {
+      "alias": "legend";
+      "required": false;
+      "isSignal": true;
+    };
+    "legendHidden": {
+      "alias": "legendHidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "helpText": {
+      "alias": "helpText";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "requiredIndicator": {
+      "alias": "requiredIndicator";
+      "required": false;
+      "isSignal": true;
+    };
+    "requiredAriaLabel": {
+      "alias": "requiredAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}

package/types/lifecorner-angular-ui-kit-rating.d.ts

@@ -0,0 +1,115 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+export type RatingSize = 'sm' | 'md' | 'lg';
+export declare class RatingComponent implements ControlValueAccessor {
+  private static nextId;
+  /** Maximum number of stars */
+  max: import("@angular/core").InputSignal<number>;
+  /** Size variant */
+  size: import("@angular/core").InputSignal<RatingSize>;
+  /** Whether the rating is read-only */
+  readonly: import("@angular/core").InputSignal<boolean>;
+  /** Whether the rating is disabled */
+  disabled: import("@angular/core").InputSignal<boolean>;
+  /** Whether to allow half-star ratings */
+  allowHalf: import("@angular/core").InputSignal<boolean>;
+  /** Label text */
+  label: import("@angular/core").InputSignal<string | undefined>;
+  /** Whether to show the numeric value */
+  showValue: import("@angular/core").InputSignal<boolean>;
+  /** Accessible name of the star group when no visible `label` is set. */
+  ariaLabel: import("@angular/core").InputSignal<string>;
+  /** Emits the selected rating */
+  ratingChange: import("@angular/core").OutputEmitterRef<number>;
+  /** Per-instance id naming the radiogroup by the visible label. */
+  protected readonly labelId: string;
+  protected value: import("@angular/core").WritableSignal<number>;
+  protected hoveredValue: import("@angular/core").WritableSignal<number>;
+  /** Disabled through the form control (`setDisabledState`), as opposed to the input. */
+  private readonly formDisabled;
+  /** Disabled by either route — the one flag the template consults. */
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  /** Whether clicks and keys change the value. Read-only stays focusable, it just does not react. */
+  protected readonly interactive: import("@angular/core").Signal<boolean>;
+  private readonly starButtons;
+  protected stars: import("@angular/core").Signal<number[]>;
+  /** Smallest change the value can make. */
+  private readonly stepSize;
+  /**
+   * The star that carries the group's single tab stop (roving tabindex): the
+   * one holding the current value, or the first when nothing is selected.
+   */
+  protected readonly focusableStar: import("@angular/core").Signal<number>;
+  protected ratingClasses: import("@angular/core").Signal<string>;
+  protected getStarState(star: number): 'full' | 'half' | 'empty';
+  protected isStarFilled(star: number): boolean;
+  protected isStarHalf(star: number): boolean;
+  /** `aria-checked` for the radio that represents the current value (2.5 lives on star 3). */
+  protected isStarChecked(star: number): boolean;
+  /** Radio label — names the half value on the star that holds it. */
+  protected starLabel(star: number): string;
+  /**
+   * The value a pointer at `clientX` over `star` stands for: the left half of
+   * a star (right half in RTL) is the half step when halves are allowed.
+   * Keyboard-triggered clicks carry no coordinates and mean the whole star.
+   */
+  private valueAt;
+  protected onStarClick(star: number, event: MouseEvent): void;
+  protected onStarHover(star: number, event: MouseEvent): void;
+  protected onMouseLeave(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  /** Marks the control touched once focus leaves the group (not when it moves between stars). */
+  protected onFocusOut(event: FocusEvent): void;
+  private select;
+  private onChange;
+  private onTouched;
+  writeValue(val: number): void;
+  registerOnChange(fn: (val: number) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RatingComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RatingComponent, "lc-rating", never, {
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "allowHalf": {
+      "alias": "allowHalf";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "showValue": {
+      "alias": "showValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "ratingChange": "ratingChange";
+  }, never, never, true, never>;
+}

package/types/lifecorner-angular-ui-kit-rich-text-editor.d.ts

@@ -0,0 +1,226 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+export type RichTextEditorMode = 'rich' | 'markdown' | 'split';
+export type ToolbarAction = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'h1' | 'h2' | 'h3' | 'ul' | 'ol' | 'blockquote' | 'code' | 'codeblock' | 'link' | 'image' | 'hr';
+export interface ToolbarConfig {
+  actions: ToolbarAction[];
+}
+/**
+ * Rich Text Editor with Markdown support.
+ *
+ * Supports three modes:
+ * - `rich`: WYSIWYG editing with toolbar
+ * - `markdown`: Raw markdown editing with syntax highlighting
+ * - `split`: Side-by-side markdown and preview
+ *
+ * Implements ControlValueAccessor for reactive form integration.
+ * The value is always stored as Markdown.
+ *
+ * The built-in markdown → HTML conversion escapes the source before it applies
+ * any markup and only lets http(s)/mailto/tel and relative URLs through as
+ * links, so markdown that arrives from a server or another user cannot inject
+ * markup or script. The result is additionally run through Angular's HTML
+ * sanitizer before it reaches the DOM.
+ *
+ * @example
+ * ```html
+ * <lc-rich-text-editor
+ *   [(ngModel)]="content"
+ *   mode="split"
+ *   placeholder="Write something..." />
+ * ```
+ */
+export declare class RichTextEditorComponent implements ControlValueAccessor {
+  /** Editor mode */
+  mode: import("@angular/core").InputSignal<RichTextEditorMode>;
+  /** Placeholder text */
+  placeholder: import("@angular/core").InputSignal<string>;
+  /** Minimum height in px */
+  minHeight: import("@angular/core").InputSignal<number>;
+  /** Maximum height in px (0 = unlimited) */
+  maxHeight: import("@angular/core").InputSignal<number>;
+  /** Whether the editor is disabled */
+  disabled: import("@angular/core").InputSignal<boolean>;
+  /** Whether the editor is readonly */
+  readonly: import("@angular/core").InputSignal<boolean>;
+  /** Toolbar configuration */
+  toolbar: import("@angular/core").InputSignal<ToolbarConfig>;
+  /** Whether to show word count */
+  showWordCount: import("@angular/core").InputSignal<boolean>;
+  /** Tooltips and accessible names of the toolbar actions, by action (`{ bold: 'Fett' }`); missing ones keep the English default. */
+  actionTitles: import("@angular/core").InputSignal<Partial<Record<ToolbarAction, string>>>;
+  /** Label of the rich-text mode button. */
+  richModeLabel: import("@angular/core").InputSignal<string>;
+  /** Tooltip of the rich-text mode button. */
+  richModeTitle: import("@angular/core").InputSignal<string>;
+  /** Label of the Markdown mode button. */
+  markdownModeLabel: import("@angular/core").InputSignal<string>;
+  /** Tooltip of the Markdown mode button. */
+  markdownModeTitle: import("@angular/core").InputSignal<string>;
+  /** Label of the split-view mode button. */
+  splitModeLabel: import("@angular/core").InputSignal<string>;
+  /** Tooltip of the split-view mode button. */
+  splitModeTitle: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the Markdown text area. */
+  markdownEditorAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Unit after the word count (`showWordCount`). */
+  wordsLabel: import("@angular/core").InputSignal<string>;
+  /** Unit after the character count (`showWordCount`). */
+  charactersLabel: import("@angular/core").InputSignal<string>;
+  /** Emitted on every content change */
+  readonly contentChange: import("@angular/core").OutputEmitterRef<string>;
+  private readonly editorArea;
+  private readonly richArea;
+  private readonly sanitizer;
+  /** Internal markdown value */
+  protected markdown: import("@angular/core").WritableSignal<string>;
+  /** Current active mode: follows the `mode` input until the user toggles it. */
+  protected activeMode: import("@angular/core").WritableSignal<RichTextEditorMode>;
+  /** Disabled through the form control (`setDisabledState`), as opposed to the input. */
+  private readonly formDisabled;
+  /** Disabled by either route — the one flag the template consults. */
+  protected readonly isDisabled: import("@angular/core").Signal<boolean>;
+  /** Whether the content can currently be edited at all. */
+  protected readonly editable: import("@angular/core").Signal<boolean>;
+  /** Word count */
+  protected wordCount: import("@angular/core").Signal<number>;
+  /** Character count */
+  protected charCount: import("@angular/core").Signal<number>;
+  /**
+   * Rendered HTML from markdown — escaped by the converter and, on top of that,
+   * passed through Angular's HTML sanitizer, so it is safe to assign to
+   * `innerHTML` directly.
+   */
+  protected renderedHtml: import("@angular/core").Signal<string>;
+  private onChange;
+  private onTouched;
+  constructor();
+  writeValue(value: string | null | undefined): void;
+  registerOnChange(fn: (value: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  protected switchMode(mode: RichTextEditorMode): void;
+  protected onToolbarAction(action: ToolbarAction): void;
+  private execRichCommand;
+  private insertMarkdownSyntax;
+  protected onMarkdownInput(event: Event): void;
+  protected onRichInput(): void;
+  protected onBlur(): void;
+  private syncFromRich;
+  /** Puts the current markdown into the rich area, as sanitised HTML. */
+  private renderRich;
+  /**
+   * Angular's HTML sanitizer, as the last line of defence behind the escaping
+   * `markdownToHtml` does itself: whatever it might miss, this strips.
+   */
+  private sanitizeHtml;
+  private emitChange;
+  private getSelection;
+  protected getActionLabel(action: ToolbarAction): string;
+  protected getActionTitle(action: ToolbarAction): string;
+  /**
+   * Converts the editor's markdown subset to HTML. The source is HTML-escaped
+   * *first*, so nothing in it can open a tag or an attribute; the conversions
+   * below then only ever add markup of their own. Raw HTML in the markdown is
+   * therefore shown as text — with one exception, `<u>`, which the toolbar's
+   * underline action emits (markdown has no underline) and which is let back
+   * through in escaped form only.
+   */
+  protected markdownToHtml(md: string): string;
+  private htmlToMarkdown;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RichTextEditorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RichTextEditorComponent, "lc-rich-text-editor", never, {
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "minHeight": {
+      "alias": "minHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxHeight": {
+      "alias": "maxHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "toolbar": {
+      "alias": "toolbar";
+      "required": false;
+      "isSignal": true;
+    };
+    "showWordCount": {
+      "alias": "showWordCount";
+      "required": false;
+      "isSignal": true;
+    };
+    "actionTitles": {
+      "alias": "actionTitles";
+      "required": false;
+      "isSignal": true;
+    };
+    "richModeLabel": {
+      "alias": "richModeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "richModeTitle": {
+      "alias": "richModeTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "markdownModeLabel": {
+      "alias": "markdownModeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "markdownModeTitle": {
+      "alias": "markdownModeTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "splitModeLabel": {
+      "alias": "splitModeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "splitModeTitle": {
+      "alias": "splitModeTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "markdownEditorAriaLabel": {
+      "alias": "markdownEditorAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "wordsLabel": {
+      "alias": "wordsLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "charactersLabel": {
+      "alias": "charactersLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "contentChange": "contentChange";
+  }, never, never, true, never>;
+}