@lyads/visual-editor 0.0.0-stage → 1.0.1

package/dist/vue/font-options.d.ts

@@ -0,0 +1,6 @@
+import type { EditorLocale } from './locale';
+import type { EditorSelectItem } from './components/ui/EditorSelect.vue';
+/** Labels the shared font allowlist for all editor typography controls. */
+export declare class EditorFontOptions {
+    items(locale: EditorLocale): readonly EditorSelectItem[];
+}

package/dist/vue/icon-data.d.ts

@@ -0,0 +1,233 @@
+export declare const EDITOR_ICON_DATA: {
+    'square-pen': {
+        body: string;
+    };
+    'grip-vertical': {
+        body: string;
+    };
+    'arrow-up': {
+        body: string;
+    };
+    'arrow-down': {
+        body: string;
+    };
+    copy: {
+        body: string;
+    };
+    'trash-2': {
+        body: string;
+    };
+    'corner-left-up': {
+        body: string;
+    };
+    image: {
+        body: string;
+    };
+    'code-xml': {
+        body: string;
+    };
+    plus: {
+        body: string;
+    };
+    'app-window': {
+        body: string;
+    };
+    bold: {
+        body: string;
+    };
+    italic: {
+        body: string;
+    };
+    underline: {
+        body: string;
+    };
+    strikethrough: {
+        body: string;
+    };
+    link: {
+        body: string;
+    };
+    check: {
+        body: string;
+    };
+    x: {
+        body: string;
+    };
+    type: {
+        body: string;
+    };
+    list: {
+        body: string;
+    };
+    'list-ordered': {
+        body: string;
+    };
+    'chevron-down': {
+        body: string;
+    };
+    'chevron-up': {
+        body: string;
+    };
+    'chevron-left': {
+        body: string;
+    };
+    'chevron-right': {
+        body: string;
+    };
+    'chevrons-up-down': {
+        body: string;
+    };
+    search: {
+        body: string;
+    };
+    'loader-circle': {
+        body: string;
+    };
+    minus: {
+        body: string;
+    };
+    ellipsis: {
+        body: string;
+    };
+    'remove-formatting': {
+        body: string;
+    };
+    'arrow-down-to-line': {
+        body: string;
+    };
+    'arrow-up-to-line': {
+        body: string;
+    };
+    box: {
+        body: string;
+    };
+    braces: {
+        body: string;
+    };
+    'circle-question-mark': {
+        body: string;
+    };
+    'clipboard-copy': {
+        body: string;
+    };
+    'clipboard-paste': {
+        body: string;
+    };
+    'columns-2': {
+        body: string;
+    };
+    download: {
+        body: string;
+    };
+    file: {
+        body: string;
+    };
+    'file-json': {
+        body: string;
+    };
+    heading: {
+        body: string;
+    };
+    keyboard: {
+        body: string;
+    };
+    'layout-grid': {
+        body: string;
+    };
+    'layout-template': {
+        body: string;
+    };
+    'list-tree': {
+        body: string;
+    };
+    monitor: {
+        body: string;
+    };
+    'mouse-pointer-click': {
+        body: string;
+    };
+    palette: {
+        body: string;
+    };
+    moon: {
+        body: string;
+    };
+    'bookmark-plus': {
+        body: string;
+    };
+    'list-checks': {
+        body: string;
+    };
+    'circle-alert': {
+        body: string;
+    };
+    'circle-check': {
+        body: string;
+    };
+    'panel-bottom': {
+        body: string;
+    };
+    'panel-left': {
+        body: string;
+    };
+    'panel-right': {
+        body: string;
+    };
+    pilcrow: {
+        body: string;
+    };
+    'rectangle-vertical': {
+        body: string;
+    };
+    'redo-2': {
+        body: string;
+    };
+    'rotate-ccw': {
+        body: string;
+    };
+    'rows-2': {
+        body: string;
+    };
+    save: {
+        body: string;
+    };
+    smartphone: {
+        body: string;
+    };
+    square: {
+        body: string;
+    };
+    'square-dashed': {
+        body: string;
+    };
+    'square-plus': {
+        body: string;
+    };
+    tablet: {
+        body: string;
+    };
+    'text-cursor-input': {
+        body: string;
+    };
+    'triangle-alert': {
+        body: string;
+    };
+    'undo-2': {
+        body: string;
+    };
+    'unfold-vertical': {
+        body: string;
+    };
+    unlink: {
+        body: string;
+    };
+    upload: {
+        body: string;
+    };
+    sun: {
+        body: string;
+    };
+    info: {
+        body: string;
+    };
+};

package/dist/vue/icons.d.ts

@@ -0,0 +1,5 @@
+/** Registers only the installed Lucide symbols used by the standalone UI. */
+export declare class EditorIconRegistry {
+    private static registered;
+    static register(): void;
+}

package/dist/vue/locale.d.ts

@@ -0,0 +1,7 @@
+export type EditorMessages = Readonly<Record<string, string>>;
+export declare class EditorLocale {
+    private readonly messages;
+    constructor(messages?: EditorMessages);
+    keys(): readonly string[];
+    text(key: string): string;
+}

package/dist/vue/outline.d.ts

@@ -0,0 +1,26 @@
+import type { DocumentNode, EditorDocumentData } from '../core/document';
+import { BlockCatalog } from '../core/catalog';
+import { CanvasLayout } from '../core/canvas-layout';
+import { UrlPolicy } from '../security/url-policy';
+export interface OutlineEntry {
+    readonly id: string;
+    readonly parentId: string | null;
+    readonly index: number;
+    readonly depth: number;
+    readonly tag: string;
+    readonly label: string;
+    readonly labelKey?: string;
+    readonly node: DocumentNode;
+}
+/** Projects editable text without bringing document styles/classes into the host DOM. */
+export declare class DocumentOutline {
+    private readonly urls;
+    private readonly capabilities;
+    private readonly layout;
+    private readonly rules;
+    constructor(urls?: UrlPolicy, capabilities?: BlockCatalog, layout?: CanvasLayout);
+    entries(document: EditorDocumentData): readonly OutlineEntry[];
+    text(node: DocumentNode): string;
+    editableTextNode(node: DocumentNode): DocumentNode | undefined;
+    richText(node: DocumentNode): string | undefined;
+}

package/dist/vue/projection-key.d.ts

@@ -0,0 +1,7 @@
+import type { EditorViewState } from './controller';
+type ProjectionState = Pick<EditorViewState, 'document' | 'selectedNodeId' | 'readOnly' | 'mode'>;
+/** Invalidates derived document views only after a committed document change. */
+export declare const documentProjectionKey: (state: Pick<ProjectionState, "document">) => string;
+/** Pending text updates do not change the selected canonical node or its capabilities. */
+export declare const selectionProjectionKey: (state: ProjectionState) => string;
+export {};

package/dist/vue/properties/selection-properties.d.ts

@@ -0,0 +1,40 @@
+import type { EditorWorkbench } from '../workbench';
+import type { EditorSelectItem } from '../components/ui/EditorSelect.vue';
+/**
+ * What the properties panel knows about the selected block: its values, what can be edited and
+ * how a change is applied. Every change goes through the controller; a run of changes to one
+ * field is one history step, and a refused value leaves the accepted one in place.
+ */
+export declare function useSelectionProperties(workbench: EditorWorkbench): {
+    errors: import("vue").Ref<Record<string, string>, Record<string, string>>;
+    disabled: import("vue").ComputedRef<boolean>;
+    selected: import("vue").ComputedRef<import("../outline").OutlineEntry | undefined>;
+    region: import("vue").ComputedRef<import("../../core/canvas-layout").CanvasRegion | undefined>;
+    capabilities: import("vue").ComputedRef<import("../session/structure").PropertyCapabilities | undefined>;
+    imageSize: import("vue").ComputedRef<import("../../application/document-presentation").ImageSizeContext | undefined>;
+    layout: import("vue").ComputedRef<import("../../core/section-layout").SectionLayoutContext | undefined>;
+    imageLink: import("vue").ComputedRef<import("../../application/image-link").ImageLinkContext | undefined>;
+    groups: import("vue").ComputedRef<{
+        id: import("./style-fields").StyleGroup;
+        label: string;
+        openByDefault: boolean;
+        selections: {
+            name: string;
+            label: string;
+            items: EditorSelectItem[];
+        }[];
+        measures: import("./style-fields").MeasureField[];
+        colors: import("./style-fields").ColorField[];
+    }[]>;
+    hasAttribute: (name: string) => boolean;
+    attribute: (name: string) => string;
+    inherited: (name: string) => boolean;
+    style: (name: string) => string;
+    apply: (field: string, action: () => boolean) => boolean;
+    applyLive: (field: string, action: () => boolean) => boolean;
+    updateStyle: (name: string, value: string) => void;
+    updateAttribute: (name: string, value: string) => void;
+    choices: (values: readonly (readonly [string, string])[]) => EditorSelectItem[];
+    withCurrent: (value: string, items: readonly EditorSelectItem[]) => EditorSelectItem[];
+};
+export type SelectionProperties = ReturnType<typeof useSelectionProperties>;

package/dist/vue/properties/style-fields.d.ts

@@ -0,0 +1,30 @@
+/** One row of the Style tab: which control edits which CSS property, and under which heading. */
+export type StyleGroup = 'typography' | 'appearance' | 'layout' | 'borders';
+export interface ChoiceField {
+    readonly name: string;
+    readonly label: string;
+    /** Pairs of CSS value and catalog key. */
+    readonly options: readonly (readonly [string, string])[];
+}
+export interface MeasureField {
+    readonly name: string;
+    readonly label: string;
+    readonly minimum: number;
+    readonly units: readonly string[];
+}
+export interface ColorField {
+    readonly name: string;
+    readonly label: string;
+}
+export declare const STYLE_GROUPS: readonly {
+    readonly id: StyleGroup;
+    readonly label: string;
+    readonly open: boolean;
+}[];
+export declare const CHOICE_FIELDS: readonly ChoiceField[];
+export declare const MEASURE_FIELDS: readonly MeasureField[];
+export declare const COLOR_FIELDS: readonly ColorField[];
+/** The heading a CSS property belongs to in the Style tab. */
+export declare function styleGroup(name: string): StyleGroup;
+/** Layout of a grid only exists in pages; an e-mail keeps its table structure. */
+export declare const PAGE_ONLY_STYLES: readonly string[];

package/dist/vue/public.d.ts

@@ -0,0 +1,14 @@
+import './styles.css';
+export { default as VisualEditor } from './components/VisualEditor.vue';
+export { EditorController } from './controller';
+export { default as BlockVisualEditor } from './components/BlockVisualEditor.vue';
+export { BlockEditorController } from './block-controller';
+export type { BlockDestination } from './block-controller';
+export { EditorLocale } from './locale';
+export { EditorTheme } from './theme';
+export type { EditorMessages } from './locale';
+export type { EditorThemeOptions } from './theme';
+export type { EditorVariable } from './variables';
+export type { EditorImageChoice, EditorImagePicker, EditorImageRequest, } from './services/image-requests';
+export type { EditorSavedBlock, EditorSavedBlockInput, EditorSavedBlocks, } from './services/saved-blocks';
+export { SAVED_BLOCK_LIMITS } from './services/saved-blocks';

package/dist/vue/recovery.d.ts

@@ -0,0 +1,30 @@
+import * as v from 'valibot';
+import type { EditorDocumentData, SourceInput } from '../core/document';
+import type { PendingRichTextDraft } from '../application/session';
+declare const recoverySchema: v.StrictObjectSchema<{
+    readonly format: v.LiteralSchema<"visual-editor-recovery-v1", undefined>;
+    readonly document: v.UnknownSchema;
+    readonly pendingSource: v.StrictObjectSchema<{
+        readonly html: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000000, undefined>]>;
+        readonly css: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 500000, undefined>]>;
+    }, undefined>;
+    readonly pendingRichText: v.ExactOptionalSchema<v.StrictObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+        readonly html: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000000, undefined>]>;
+        readonly originalHtml: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000000, undefined>]>;
+        readonly changed: v.BooleanSchema<undefined>;
+        readonly valid: v.BooleanSchema<undefined>;
+        readonly blocked: v.ExactOptionalSchema<v.LiteralSchema<"oversized", undefined>, undefined>;
+        readonly documentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>;
+        readonly baseRevision: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+        readonly editGeneration: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>;
+/** Pending source and canvas text are inert JSON. Reopening validates before projection. */
+export declare class DocumentRecovery {
+    encode(document: EditorDocumentData, pendingSource: SourceInput, pendingRichText?: PendingRichTextDraft): string;
+    decode(value: unknown): (Omit<v.InferOutput<typeof recoverySchema>, 'document'> & {
+        readonly document: EditorDocumentData;
+    }) | undefined;
+}
+export {};

package/dist/vue/responsive-panel.d.ts

@@ -0,0 +1 @@
+export declare const EDITOR_PANEL_MEDIA_QUERY = "(max-width: 900px)";

package/dist/vue/rich-text-commands.d.ts

@@ -0,0 +1,29 @@
+import type { RichTextCommandName, RichTextCommandState, RichTextCommands } from '../rich-text/commands';
+import type { UrlPolicy } from '../security/url-policy';
+/**
+ * Validates the value of a formatting command in the host, before any editor receives it: the
+ * same color, font, measure and link rules for the panel editor and for the preview frame.
+ */
+export declare class RichTextCommandValues {
+    private readonly urls;
+    private readonly colors;
+    private readonly fontSize;
+    private readonly lineHeight;
+    constructor(urls: () => UrlPolicy);
+    /** Returns undefined for a refused value; `null` asks to clear the style. */
+    resolve(command: RichTextCommandName, input: string | null | undefined): {
+        readonly value: string | null;
+    } | undefined;
+}
+/** Formatting commands for the editor inside the preview frame, sent as typed messages. */
+export declare class RemoteRichTextCommands implements RichTextCommands {
+    #private;
+    private readonly values;
+    private readonly post;
+    private readonly colors;
+    constructor(values: RichTextCommandValues, post: (command: RichTextCommandName, value: string | null) => void);
+    get state(): RichTextCommandState;
+    /** Telemetry from the frame, already validated by the message policy. */
+    update(state: RichTextCommandState | undefined): void;
+    run(command: RichTextCommandName, value?: string | null): boolean;
+}

package/dist/vue/services/block-command-definitions.d.ts

@@ -0,0 +1,14 @@
+export declare const BLOCK_COMMANDS: readonly ["editText", "selectParent", "insertBefore", "insertAfter", "insertInside", "duplicate", "moveUp", "moveDown", "editHtml", "replaceImage", "copy", "paste", "remove"];
+export type BlockCommandName = (typeof BLOCK_COMMANDS)[number];
+export interface BlockCommandItem {
+    readonly name: BlockCommandName;
+    readonly labelKey: string;
+    readonly icon: string;
+    /** Position of a separator: items of one group stay together. */
+    readonly group: number;
+    readonly enabled: boolean;
+    readonly danger?: boolean;
+    readonly keys?: readonly string[];
+}
+/** The commands of a block in menu order, with their label, icon, group and keys. */
+export declare const BLOCK_COMMAND_DEFINITIONS: readonly Omit<BlockCommandItem, 'enabled'>[];

package/dist/vue/services/block-commands.d.ts

@@ -0,0 +1,114 @@
+import type { ShallowRef } from 'vue';
+import type { CanvasPlacement } from '../../core/canvas-layout';
+import type { SourceInput } from '../../core/document';
+import type { EditorController } from '../controller';
+import type { BlockCommandItem, BlockCommandName } from './block-command-definitions';
+export interface FrameRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface InsertionRequest {
+    readonly targetId: string;
+    readonly placement: CanvasPlacement;
+    /** Where the request was made, in page coordinates, to open the picker next to it. */
+    readonly anchor?: FrameRect;
+    /** Asked with the keyboard: the keyboard returns to the piece when the picker closes. */
+    readonly keyboard?: boolean;
+    /** Gives the keyboard back to where the request was made. */
+    readonly returnFocus?: () => void;
+}
+/** The menu of one block, open at a point of the page. */
+export interface BlockMenuRequest {
+    readonly targetId: string;
+    readonly anchor: FrameRect;
+    /** Asked with the keyboard: its first item takes the keyboard. */
+    readonly keyboard?: boolean;
+    /** Gives the keyboard back to where the menu was asked for, when it is dismissed. */
+    readonly returnFocus?: () => void;
+}
+export interface SourceEdit {
+    readonly id: string;
+    readonly html: string;
+}
+/** What the commands need from the shell; none of it is document logic. */
+export interface BlockCommandPorts {
+    controller(): EditorController;
+    /** Concludes a text being edited in the piece; false when it could not be concluded. */
+    flush(): Promise<boolean>;
+    editText(id: string): void;
+    replaceImage(id: string): void;
+    elementSource(id: string): string | undefined;
+    replaceElementSource(id: string, html: string): SourceInput | undefined;
+    notify(outcome: 'applied' | 'copied' | 'invalid'): void;
+}
+interface Removal {
+    readonly owner: EditorController;
+    readonly id: string;
+    readonly documentId: string;
+    readonly revision: number;
+    /** Gives the keyboard back to the piece once the block is gone, on the block next to it. */
+    readonly returnFocus?: () => void;
+}
+/** Where a command was asked from, when the keyboard has to come back there afterwards. */
+export interface CommandOrigin {
+    readonly keyboard?: boolean;
+    readonly returnFocus?: () => void;
+}
+/**
+ * The single door for acting on a block. The action bar of the piece, the context menus, the
+ * tree, the keyboard and the panel all ask here, so a command means the same thing everywhere.
+ * Requests which need an answer from the person (confirm, pick a block, edit the HTML) are
+ * exposed as state for the shell to show; the document only changes through the controller.
+ */
+export declare class BlockCommandService {
+    #private;
+    private readonly ports;
+    private readonly clock;
+    readonly removal: ShallowRef<Removal | undefined>;
+    readonly insertion: ShallowRef<InsertionRequest | undefined>;
+    readonly sourceEdit: ShallowRef<SourceEdit | undefined>;
+    /** The menu of one block, asked for with the secondary button in the piece. */
+    readonly menu: ShallowRef<BlockMenuRequest | undefined>;
+    /** A copied block; markup already produced by this document, validated again when pasted. */
+    readonly clipboard: ShallowRef<string | undefined>;
+    /** Why the last HTML written for an element was refused, as catalog keys. */
+    readonly sourceProblems: ShallowRef<readonly string[]>;
+    constructor(ports: BlockCommandPorts, clock?: () => number);
+    /** A menu or the picker was dismissed: what the piece asks next, for a second, is not shown. */
+    dismissed(): void;
+    private state;
+    /** The commands offered for one block, in menu order, with what is possible right now. */
+    items(id: string | undefined): readonly BlockCommandItem[];
+    /** Runs a command on a block, by default the selected one. */
+    run(name: BlockCommandName, target?: string, anchor?: FrameRect, origin?: CommandOrigin): Promise<boolean>;
+    private apply;
+    /** Moves a block next to or into another one: the drop of the piece and of the tree. */
+    move(sourceId: string, targetId: string, placement: CanvasPlacement): Promise<boolean>;
+    /** A resize made with the handles of the image in the piece. */
+    resizeImage(id: string, width: number, height: number): Promise<boolean>;
+    /** `fromPiece`: asked by the frame, which is not shown right after a dismissal. */
+    openMenu(targetId: string, anchor: FrameRect | undefined, options?: Pick<BlockMenuRequest, 'keyboard' | 'returnFocus'> & {
+        fromPiece?: boolean;
+    }): void;
+    closeMenu(): void;
+    requestInsertion(request: InsertionRequest, fromPiece?: boolean): void;
+    cancelInsertion(): void;
+    /**
+     * Adds a block of the palette. With a destination it goes exactly there; without one it goes
+     * after the selected block, inside it when it is a container, or to the end of the content.
+     */
+    insert(type: string, destination?: Pick<InsertionRequest, 'targetId' | 'placement'> | 'end'): Promise<boolean>;
+    /** Applies the HTML a person wrote for one element: only that element changes, in one step. */
+    applySource(html: string): Promise<boolean>;
+    cancelSource(): void;
+    cancelRemoval(): void;
+    /** Removes the block the person confirmed, unless the document changed meanwhile. */
+    confirmRemoval(): Promise<boolean>;
+    /** The block before the one being removed, or the one after it, or the one which held it. */
+    private neighbour;
+    /** Another revision, document or owner: pending questions no longer describe what is on screen. */
+    invalidate(): void;
+}
+export {};

package/dist/vue/services/block-menu.d.ts

@@ -0,0 +1,12 @@
+import type { BlockCommandItem } from './block-command-definitions';
+export interface BlockMenuEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly icon: string;
+    readonly group: number;
+    readonly disabled: boolean;
+    readonly danger?: boolean;
+    readonly kbds?: readonly string[];
+}
+/** The commands of a block as menu entries: one shape for the piece and for the tree. */
+export declare function blockMenuItems(items: readonly BlockCommandItem[], text: (key: string) => string): BlockMenuEntry[];

package/dist/vue/services/block-palette.d.ts

@@ -0,0 +1,21 @@
+import type { BlockCategory } from './block-presentation';
+export interface PaletteBlock {
+    readonly type: string;
+    readonly label: string;
+    readonly icon: string;
+}
+export interface PaletteGroup {
+    readonly category: BlockCategory;
+    readonly label: string;
+    readonly blocks: readonly PaletteBlock[];
+}
+/** Folds accents and case, so "titulo" finds "Título". */
+export declare function searchKey(value: string): string;
+/** The blocks a person can add, grouped by purpose and filtered by what they typed. */
+export declare class BlockPalette {
+    private readonly text;
+    private readonly presentation;
+    constructor(text: (key: string) => string);
+    blocks(types: readonly string[]): readonly PaletteBlock[];
+    groups(types: readonly string[], query?: string): readonly PaletteGroup[];
+}

package/dist/vue/services/block-presentation.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasRegion } from '../../core/canvas-layout';
+export type BlockCategory = 'structure' | 'text' | 'media' | 'actions' | 'other';
+export declare const BLOCK_CATEGORIES: readonly BlockCategory[];
+/**
+ * How a block is presented to a person: its category in the palette, its icon and the friendly
+ * name of what is selected. One table for the palette, the tree, the path and the piece.
+ */
+export declare class BlockPresentation {
+    private readonly labels;
+    category(type: string): BlockCategory;
+    icon(type: string): string;
+    /** Catalog key of the friendly name of a selectable region. */
+    regionLabelKey(region: CanvasRegion): string;
+    regionIcon(region: CanvasRegion): string;
+    static icons(): readonly string[];
+}

package/dist/vue/services/diagnostic-groups.d.ts

@@ -0,0 +1,25 @@
+export interface DiagnosticLike {
+    readonly code: string;
+    readonly messageKey: string;
+    readonly severity?: string;
+    readonly count?: number;
+}
+export interface DiagnosticGroup {
+    readonly key: string;
+    readonly code: string;
+    readonly messageKey: string;
+    readonly message: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly count: number;
+}
+/**
+ * Shows each notice once. Diagnostics which say the same thing are one line with a count, whether
+ * the count came with them or they simply repeat.
+ */
+export declare class DiagnosticGroups {
+    private readonly text;
+    constructor(text: (key: string) => string);
+    group(diagnostics: readonly DiagnosticLike[]): readonly DiagnosticGroup[];
+    /** A stable name for a set of notices, to remember that the person dismissed it. */
+    signature(groups: readonly DiagnosticGroup[]): string;
+}