@webround/editor 0.0.0-stage → 0.3.0

package/dist/messages.d.ts

@@ -0,0 +1,860 @@
+import type { WrElementKind } from '@webround/core/kinds';
+import type { WrNavConfig } from '@webround/core/types';
+import type { WrLangConfig } from '@webround/core/routing';
+import type { WrSeoPage, WrSeoSite } from '@webround/core/seo';
+import type { WrBreakpointId, WrStateId, WrStyleCatalog, WrStyleChange, WrStyleDescription } from '@webround/core/style';
+import type { Issue } from './check/types';
+import { LangCode } from '@webround/core/lang-codes';
+interface WrTargeted {
+    elementId: string;
+}
+interface WrCommonUpdate {
+    ariaLabel?: string;
+    hidden?: boolean;
+}
+export interface WrButtonUpdate extends WrTargeted, WrCommonUpdate {
+    content: string;
+}
+export interface WrLinkUpdate extends WrTargeted, WrCommonUpdate {
+    content?: string;
+}
+export interface WrVideoUpdate extends WrTargeted, WrCommonUpdate {
+}
+export interface WrIframeUpdate extends WrTargeted, WrCommonUpdate {
+}
+export interface WrInputUpdate extends WrTargeted, WrCommonUpdate {
+    label?: string;
+    placeholder?: string;
+}
+/** A form's messages are `msg-<code>` fields (see `wrFormMessagesOf`), each the text for the language shown. */
+export interface WrFormUpdate extends WrTargeted, WrCommonUpdate {
+    [message: `msg-${string}`]: string | undefined;
+}
+export interface WrNavUpdate extends WrTargeted, WrCommonUpdate, Pick<WrNavConfig, 'items'> {
+}
+export interface WrImageUpdate extends WrTargeted, WrCommonUpdate {
+    alt?: string;
+}
+export interface WrUploadResponse extends WrTargeted {
+    src?: string;
+    error?: string;
+    requestId?: string;
+}
+export interface WrUploadRequest extends WrTargeted {
+    requestId: string;
+    filename: string;
+    mimeType: string;
+    data: ArrayBuffer;
+}
+export type { WrElementKind };
+export interface WrElementInfo {
+    type: WrElementKind;
+    id: string | null;
+    /** L'id dell'elemento Wr* che lo contiene (null in cima): permette all'editor di mostrare il percorso e salire al genitore. */
+    parentId?: string | null;
+    /** Nome del JSON dell'ambito quando NON è la pagina (`_shared/header`, `_shared/footer`): l'elemento è condiviso tra pagine. */
+    scope?: string;
+}
+export interface WrRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface WrScanMessage {
+    elements: WrElementInfo[];
+}
+export interface WrSelectMessage {
+    element: WrElementInfo | null;
+    rect: WrRect | null;
+    parent?: WrParentSize | null;
+    fit?: WrBoxFit | null;
+    space?: WrBoxSpace | null;
+    gaps?: WrBoxGaps | null;
+    floor?: WrBoxFloor | null;
+    value: unknown;
+}
+export interface WrNavigateMessage {
+    pathname: string;
+}
+export interface WrHighlightMessage {
+    element: WrElementInfo;
+}
+export interface WrHoverMessage {
+    element: WrElementInfo;
+    rect: WrRect;
+}
+export interface WrPageCreateRequest {
+    pageName: string;
+    component: string;
+    lazy?: boolean;
+}
+export interface WrPageCreateResponse {
+    pageName: string;
+    error?: string;
+}
+export interface WrPageListEntry {
+    pageName: string;
+    component: string;
+    lazy?: boolean;
+    /** Header y footer del sito si vedono di default: `false` = questa pagina non li mostra. */
+    header?: boolean;
+    footer?: boolean;
+}
+export interface WrPageDeleteRequest {
+    pageName: string;
+}
+export interface WrPageDeleteResponse {
+    pageName: string;
+    error?: string;
+}
+export interface WrPageUpdateRequest {
+    pageName: string;
+    newPageName?: string;
+    newComponent?: string;
+    lazy?: boolean;
+    header?: boolean;
+    footer?: boolean;
+}
+export interface WrPageUpdateResponse {
+    pageName: string;
+    error?: string;
+}
+export interface WrSeoGetRequest {
+    pageName?: string;
+}
+export interface WrSeoGetResponse {
+    site: WrSeoSite;
+    /** Il sito conosce il suo indirizzo pubblico (senza, canonical, hreflang e sitemap non si possono scrivere). */
+    siteUrlKnown: boolean;
+    /** I dati della pagina chiesta, come sono salvati (titolo e descrizione per lingua). */
+    page?: {
+        pageName: string;
+        seo: WrSeoPage;
+    };
+    error?: string;
+}
+/** Una pagina: un testo vuoto toglie il valore. Testi e immagini (titolo, descrizione, immagine, testi social) si scrivono in una lingua (`default` se omessa). */
+export interface WrSeoSetRequest {
+    pageName: string;
+    lang?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    noindex?: boolean;
+    canonical?: string;
+    robots?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    ogType?: string;
+    twitterCard?: string;
+    twitterSite?: string;
+    twitterCreator?: string;
+    /** Dati strutturati (JSON-LD) come testo JSON, nella lingua `lang`: una lista di oggetti con "@type"; vuoto li toglie. */
+    jsonLd?: string;
+}
+export interface WrSeoSiteSetRequest {
+    siteUrl?: string;
+    siteName?: string;
+    titleTemplate?: string;
+    favicon?: string;
+    image?: string;
+    /** Il codice (o il tag intero) di verifica di Google Search Console. */
+    searchConsole?: string;
+    twitterSite?: string;
+    twitterCreator?: string;
+    /** Per `lang` (default se omessa): nome, modello del titolo, immagine e dati strutturati. */
+    lang?: string;
+    jsonLd?: string;
+}
+/** Un titolo e una descrizione proposti per una pagina, a partire da ciò che dice (niente è scritto). */
+export interface WrSeoSuggestRequest {
+    pageName: string;
+    lang?: string;
+}
+export interface WrSeoSuggestResponse {
+    pageName: string;
+    lang: string;
+    title?: string;
+    description?: string;
+    error?: string;
+}
+export interface WrSeoUpdateResponse {
+    error?: string;
+    code?: string;
+}
+export interface WrComment {
+    id: string;
+    /** Una pagina (`home`) o un componente condiviso (`_shared/header`): dov'è l'elemento. */
+    scope: string;
+    /** L'elemento di cui parla; assente se parla della pagina (o del componente condiviso) intera. */
+    elementId?: string;
+    text: string;
+    /** `user`: una persona, dall'editor. `ai`: un agente, dai tool. */
+    author: {
+        name: string;
+        kind: 'user' | 'ai';
+    };
+    /** Data ISO. */
+    createdAt: string;
+    status: 'open' | 'resolved';
+    resolvedAt?: string;
+    /** Cos'era l'elemento quando è stato commentato (tipo e inizio del testo). */
+    context?: {
+        kind: string;
+        excerpt?: string;
+    };
+}
+/** Un commento come lo elenca `comment-list`: `orphan` se l'elemento non è più nel codice. */
+export type WrListedComment = WrComment & {
+    orphan: boolean;
+};
+export interface WrCommentsResponse {
+    comments: WrListedComment[];
+    open: number;
+    error?: string;
+}
+export interface WrCommentAddRequest {
+    /** La pagina, o il componente condiviso (`_shared/header`), dell'elemento. */
+    page: string;
+    elementId?: string;
+    text: string;
+    /** Chi scrive (il nome della persona: l'editor lo conosce, l'anteprima no). */
+    authorName: string;
+}
+export interface WrCommentResolveRequest {
+    id: string;
+    resolved: boolean;
+}
+export interface WrCommentDeleteRequest {
+    id: string;
+}
+/** Gli elementi su cui l'anteprima deve dire dov'è il puntino di un commento aperto (ambito + id). */
+export interface WrCommentMarksRequest {
+    marks: {
+        scope: string;
+        id: string;
+    }[];
+}
+export interface WrCommentRectsResponse {
+    rects: {
+        scope: string;
+        id: string;
+        rect: WrRect;
+    }[];
+}
+export interface WrCheckResponse {
+    issues: Issue[];
+    /** Le chiavi dei problemi che la persona ha silenziato (valgono anche per ciò che l'anteprima misura da sé). */
+    muted: string[];
+    error?: string;
+}
+/** Silenzia un problema (o lo riporta): resta nel progetto, contato a parte. */
+export interface WrIssueMuteRequest {
+    key: string;
+    muted: boolean;
+}
+export interface WrIssueMuteResponse {
+    error?: string;
+}
+/** Toglie dal JSON i valori degli elementi che non sono più nel codice (di una pagina, o di tutte): le chiavi orfane. */
+export interface WrJsonPruneRequest {
+    page?: string;
+}
+export interface WrJsonPruneResponse {
+    removed: {
+        scope: string;
+        keys: string[];
+    }[];
+    error?: string;
+    code?: string;
+}
+/** Ciò che la pagina disegnata dice della sua accessibilità (contrasto, bersagli, testo piccolo, spaziatura, riflusso), misurato com'è ora (tema, breakpoint e modalità scura compresi): l'anteprima lo manda da sola quando cambia. */
+export interface WrMeasureReport {
+    pathname: string;
+    findings: {
+        rule: string;
+        elementId: string;
+        message: string;
+    }[];
+}
+export interface WrLangsUpdateRequest {
+    langs: WrLangConfig;
+}
+export interface WrLangsUpdateResponse {
+    error?: string;
+}
+export interface WrLangEntry {
+    code: LangCode;
+    isDefault: boolean;
+}
+export interface WrLangCreateRequest {
+    code: LangCode;
+}
+export interface WrLangCreateResponse {
+    code: LangCode;
+    error?: string;
+}
+export interface WrLangDeleteRequest {
+    code: LangCode;
+}
+export interface WrLangDeleteResponse {
+    code: LangCode;
+    error?: string;
+}
+export interface WrLangUpdateRequest {
+    code: LangCode;
+    setDefault?: boolean;
+}
+export interface WrLangUpdateResponse {
+    code: LangCode;
+    error?: string;
+}
+export interface WrNodeGetRequest {
+    elementId: string;
+}
+export interface WrNodeGetResponse {
+    elementId: string;
+    fields: string[];
+    values: Record<string, string | boolean | number>;
+}
+export interface WrNodeSetRequest {
+    elementId: string;
+    key: string;
+    value: string | boolean | number;
+    prevValue?: string | boolean | number;
+}
+export interface WrNodeSetResponse {
+    elementId: string;
+    key: string;
+    ok: boolean;
+    error?: string;
+}
+export interface WrStyleCatalogResponse {
+    catalog: WrStyleCatalog | null;
+    error?: string;
+}
+/** Lo stile di un elemento per ogni stato (hover, focus, premuto) per cui ha qualcosa. */
+export type WrStyleStates = Partial<Record<WrStateId, WrStyleDescription[]>>;
+export interface WrStyleGetRequest {
+    elementId: string;
+}
+export interface WrStyleGetResponse {
+    elementId: string;
+    /** false: le classi le decide il codice (un'espressione), non si toccano da qui; `reason` dice perché. */
+    editable: boolean;
+    reason?: string;
+    className: string | null;
+    styles: WrStyleDescription[];
+    /** Le classi che il pannello non gestisce (hover:, dark:, quelle del progetto). */
+    unmanaged: string[];
+    /** Gli stili condivisi che l'elemento usa (la loro classe sta nel suo className). */
+    sets?: {
+        name: string;
+        class: string;
+    }[];
+    /** Cosa dice per ogni stato (hover, focus, premuto) per cui dice qualcosa. */
+    states?: WrStyleStates;
+    error?: string;
+}
+/** `everywhere`: la modifica vale per tutti gli schermi ("All screens"): fatta dove si guarda, poi le proprietà toccate diventano una lista sola e gli override degli altri schermi spariscono. */
+export interface WrStyleSetRequest {
+    elementId: string;
+    changes: WrStyleChange[];
+    everywhere?: boolean;
+}
+/** The classes of one screen put on another, or (`to: 'all'`) one clean list for every screen: a single change, a single step of undo. Answered with `wr:style:set:response`. */
+export interface WrStyleCopyRequest {
+    elementId: string;
+    from: WrBreakpointId;
+    to: WrBreakpointId | 'all';
+}
+/**
+ * An element shown at a size that is not written yet (the drag of a handle, a number being dragged): `styles` are CSS properties of `WR_STYLE_PREVIEW_CSS`, nothing else is applied.
+ * the CSS is applied to the element for the moment and nothing is saved, nothing enters the history.
+ * `styles: null` ends it: the element goes back to what the code says, at once, or (`settle`) when its classes change or a moment has passed, so a size that was just written does
+ * not flash back to the old one before the page redraws.
+ */
+export interface WrStylePreviewRequest {
+    elementId: string;
+    styles: Record<string, string> | null;
+    settle?: boolean;
+}
+/**
+ * How the children of the selected box fill the room the box leaves them (its content box: without its padding): what an alignment has to move in. A box whose children fill
+ * all of it has nothing to move, and the person is told why (a padding that squeezes the content, a child as wide as the box).
+ */
+export interface WrBoxFit {
+    contentWidth: number;
+    contentHeight: number;
+    kidsWidth: number;
+    kidsHeight: number;
+    padX: [number, number];
+    padY: [number, number];
+}
+/** Where an element dragged over the page would land (see `drop.ts`): next to `overId` (before or after it) or inside it, and the line that shows it, in the page's coordinates. */
+export interface WrDropTarget {
+    overId: string;
+    zone: 'before' | 'inside' | 'after';
+    line: WrRect;
+}
+/** The smallest the element can be where it is, in pixels: what its width or height comes to when it is asked to be nothing (a `min-w-60`, its content, its padding hold it up). A size under it changes nothing. */
+export interface WrBoxFloor {
+    width: number;
+    height: number;
+}
+/** The room an element has inside (padding) and around (margin), each as top, right, bottom, left, in px, as the page shows it now: where the handles that drag them start from. */
+export interface WrBoxSpace {
+    padding: [number, number, number, number];
+    margin: [number, number, number, number];
+}
+/** One band of the gap between the children of a flex or grid box, where the page has it now (in the page's own coordinates, like a `WrRect`): `column` between children side by side, `row` between children one above the other. */
+export interface WrGapBand extends WrRect {
+    axis: 'column' | 'row';
+}
+/** The gap between the children of a flex or grid box, as the page shows it now: what each is in px, and the bands it takes (none: there is no gap to show). */
+export interface WrBoxGaps {
+    column: number;
+    row: number;
+    bands: WrGapBand[];
+}
+/** The room an element has around it: what its size can be a part of (a width is `3/4` of the parent's), and the size of 1rem. */
+export interface WrParentSize {
+    width: number;
+    height: number;
+    rem: number;
+}
+export interface WrStyleSetResponse {
+    elementId: string;
+    ok: boolean;
+    error?: string;
+    code?: string;
+    /** false: il valore era già quello, niente è stato scritto. */
+    changed?: boolean;
+    className?: string;
+    styles?: WrStyleDescription[];
+    unmanaged?: string[];
+    /** Gli stili condivisi che l'elemento usa ora. */
+    sets?: {
+        name: string;
+        class: string;
+    }[];
+    states?: WrStyleStates;
+}
+export interface WrStyleSetInfo {
+    name: string;
+    /** La classe che un elemento usa (`s-card`). */
+    class: string;
+    /** Le classi Tailwind che contiene, come un solo testo. */
+    classes: string;
+    /** Cosa significano, a parole. */
+    styles: string[];
+    usedBy: number;
+    places: {
+        file: string;
+        line: number;
+        id: string | null;
+    }[];
+}
+export interface WrStyleSetListResponse {
+    sets: WrStyleSetInfo[];
+    error?: string;
+}
+/** Crea uno stile; con `elementId` le classi dell'elemento ci vanno dentro e l'elemento lo usa. */
+export interface WrStyleSetCreateRequest {
+    name: string;
+    elementId?: string;
+}
+export interface WrStyleSetApplyRequest {
+    elementId: string;
+    name: string;
+}
+/** Toglie lo stile condiviso da un elemento, tenendone l'aspetto. */
+export interface WrStyleSetDetachRequest {
+    elementId: string;
+}
+export interface WrStyleSetNameRequest {
+    name: string;
+}
+/** Da un nome a un altro: la regola in theme.css e la classe in ogni elemento che la usa. */
+export interface WrStyleSetRenameRequest {
+    name: string;
+    to: string;
+}
+/** Lo stile di uno stile condiviso: le stesse richieste di un elemento, con il nome al posto dell'id. */
+export interface WrStyleSetStyleRequest {
+    name: string;
+}
+export interface WrStyleSetEditRequest {
+    name: string;
+    changes: WrStyleChange[];
+    everywhere?: boolean;
+}
+export interface WrStyleSetCopyRequest {
+    name: string;
+    from: WrBreakpointId;
+    to: WrBreakpointId | 'all';
+}
+export interface WrStyleSetStyleResponse {
+    name: string;
+    ok: boolean;
+    error?: string;
+    code?: string;
+    className?: string;
+    styles?: WrStyleDescription[];
+    unmanaged?: string[];
+    states?: WrStyleStates;
+    /** Quanti elementi cambiano insieme allo stile. */
+    usedBy?: number;
+}
+export type WrStyleSetAction = 'create' | 'apply' | 'detach' | 'detach-all' | 'rename' | 'delete';
+export interface WrStyleSetResult {
+    action: WrStyleSetAction;
+    name?: string;
+    ok: boolean;
+    error?: string;
+    code?: string;
+}
+export interface WrNodeDeleteRequest {
+    elementId: string;
+}
+export interface WrNodeDeleteResponse {
+    elementId: string;
+    removedIds: string[];
+    ok: boolean;
+    /** Falso se l'elemento non ha un posto da cui reinserirlo (dentro il codice che genera, es. una render prop): cancellato, ma niente annulla. */
+    undoable?: boolean;
+    error?: string;
+}
+export interface WrNodeMoveRequest {
+    elementId: string;
+    anchor: WrAnchor;
+    anchorMode: WrAnchorMode;
+}
+export interface WrNodeMoveResponse {
+    elementId: string;
+    ok: boolean;
+    /** Perché no: `invalid-move`, `not-a-container`, `generated-by-code`, `component-root`, `anchor-not-found`… */
+    code?: string;
+    error?: string;
+}
+/** Un tasto di spostamento premuto dentro la pagina (Alt + frecce) con un elemento selezionato: lo applica l'editor. */
+export type WrMoveDirection = 'up' | 'down' | 'out' | 'in';
+export type WrAnchorMode = 'before' | 'after' | 'first-child' | 'last-child';
+export type WrAnchor = {
+    id: string;
+} | {
+    root: true;
+};
+export interface WrNodeInsertRequest {
+    jsx: string;
+    anchor: WrAnchor;
+    anchorMode: WrAnchorMode;
+    jsonSeed?: Record<string, unknown>;
+    /** Predefinito true: un id già preso diventa `hero-2` invece di far fallire l'inserimento. */
+    uniqueIds?: boolean;
+}
+/** Duplicate an element: a copy of it, with everything it contains and its values, right after it. Answered like an insert (`wr:node:insert:response`): the copy is what the editor selects. */
+export interface WrNodeDuplicateRequest {
+    elementId: string;
+}
+export interface WrNodeInsertResponse {
+    ok: boolean;
+    /** Gli id di tutti i componenti inseriti, nell'ordine del documento, come sono finiti nel file. */
+    ids: string[];
+    /** Gli id degli elementi di primo livello che sono componenti Wr*. */
+    rootIds: string[];
+    /** Vero se ogni elemento di primo livello è un componente Wr*: solo allora un annulla per id può rimuoverlo. */
+    undoable: boolean;
+    /** `idRichiesto → idFinale` per gli id che il plugin ha cambiato. */
+    idMap: Record<string, string>;
+    /** Perché non è andata: `invalid-jsx`, `unknown-component`, `id-exists`, `generated-by-code`, `anchor-not-found`… */
+    code?: string;
+    error?: string;
+}
+export interface WrThemeFontFace {
+    src: string;
+    weight?: string;
+    style?: string;
+    stretch?: string;
+}
+export type WrThemeItem = 
+/** `dark`: the value in the `.dark` block, when the site has a dark theme and the property is in it. */
+{
+    kind: 'property';
+    key: string;
+    value: string;
+    dark?: string;
+} | {
+    kind: 'google-font';
+    key: string;
+    weights?: string;
+} | {
+    kind: 'custom-font';
+    key: string;
+    faces: WrThemeFontFace[];
+};
+export interface WrThemeGetRequest {
+}
+export interface WrThemeGetResponse {
+    items: WrThemeItem[];
+    /** The site has a dark theme: a `.dark` block in `theme.css`. */
+    dark?: boolean;
+    error?: string;
+}
+export interface WrThemeSetItemRequest {
+    item: WrThemeItem;
+}
+export interface WrThemeSetItemResponse {
+    kind: WrThemeItem['kind'];
+    key: string;
+    ok: boolean;
+    error?: string;
+}
+/** Turn the dark theme on (a `.dark` block that starts from the light values) or off (the block is taken away). */
+export interface WrThemeDarkRequest {
+    enabled: boolean;
+}
+export interface WrThemeDarkResponse {
+    enabled: boolean;
+    ok: boolean;
+    error?: string;
+}
+export interface WrThemeRemoveItemRequest {
+    kind: WrThemeItem['kind'];
+    key: string;
+}
+export interface WrThemeRemoveItemResponse {
+    kind: WrThemeItem['kind'];
+    key: string;
+    ok: boolean;
+    error?: string;
+}
+export type WrEditorInbound = ({
+    type: 'wr:button:update';
+} & WrButtonUpdate) | ({
+    type: 'wr:link:update';
+} & WrLinkUpdate) | ({
+    type: 'wr:nav:update';
+} & WrNavUpdate) | ({
+    type: 'wr:input:update';
+} & WrInputUpdate) | ({
+    type: 'wr:form:update';
+} & WrFormUpdate) | ({
+    type: 'wr:image:update';
+} & WrImageUpdate) | ({
+    type: 'wr:video:update';
+} & WrVideoUpdate) | ({
+    type: 'wr:iframe:update';
+} & WrIframeUpdate) | ({
+    type: 'wr:upload:response';
+} & WrUploadResponse) | ({
+    type: 'wr:highlight';
+} & WrHighlightMessage) | {
+    type: 'wr:highlight:clear';
+}
+/** Browsing the page as a visitor would: nothing is selected or hovered by clicking and pointing (what the page does with its clicks is its own). */
+ | {
+    type: 'wr:browse';
+    on: boolean;
+} | {
+    type: 'wr:undo';
+} | {
+    type: 'wr:redo';
+} | ({
+    type: 'wr:navigate:push';
+} & WrNavigateMessage) | ({
+    type: 'wr:page:create';
+} & WrPageCreateRequest) | ({
+    type: 'wr:page:list';
+}) | ({
+    type: 'wr:page:delete';
+} & WrPageDeleteRequest) | ({
+    type: 'wr:page:update';
+} & WrPageUpdateRequest) | ({
+    type: 'wr:seo:get';
+} & WrSeoGetRequest) | ({
+    type: 'wr:seo:set';
+} & WrSeoSetRequest) | ({
+    type: 'wr:seo:site:set';
+} & WrSeoSiteSetRequest) | ({
+    type: 'wr:seo:suggest';
+} & WrSeoSuggestRequest) | {
+    type: 'wr:check:run';
+} | ({
+    type: 'wr:json:prune';
+} & WrJsonPruneRequest) | ({
+    type: 'wr:issue:mute';
+} & WrIssueMuteRequest) | {
+    type: 'wr:comments:get';
+} | ({
+    type: 'wr:comment:add';
+} & WrCommentAddRequest) | ({
+    type: 'wr:comment:resolve';
+} & WrCommentResolveRequest) | ({
+    type: 'wr:comment:delete';
+} & WrCommentDeleteRequest) | ({
+    type: 'wr:comments:marks';
+} & WrCommentMarksRequest) | ({
+    type: 'wr:langs:list';
+}) | ({
+    type: 'wr:langs:update';
+} & WrLangsUpdateRequest) | ({
+    type: 'wr:node:get';
+} & WrNodeGetRequest) | ({
+    type: 'wr:node:set';
+} & WrNodeSetRequest) | ({
+    type: 'wr:node:delete';
+} & WrNodeDeleteRequest) | ({
+    type: 'wr:node:insert';
+} & WrNodeInsertRequest) | ({
+    type: 'wr:node:duplicate';
+} & WrNodeDuplicateRequest) | ({
+    type: 'wr:node:move';
+} & WrNodeMoveRequest) | {
+    type: 'wr:style:catalog';
+} | ({
+    type: 'wr:style:get';
+} & WrStyleGetRequest) | ({
+    type: 'wr:style:set';
+} & WrStyleSetRequest) | ({
+    type: 'wr:style:copy';
+} & WrStyleCopyRequest) | ({
+    type: 'wr:style:preview';
+} & WrStylePreviewRequest) | {
+    type: 'wr:styleset:list';
+} | ({
+    type: 'wr:styleset:create';
+} & WrStyleSetCreateRequest) | ({
+    type: 'wr:styleset:apply';
+} & WrStyleSetApplyRequest) | ({
+    type: 'wr:styleset:detach';
+} & WrStyleSetDetachRequest) | ({
+    type: 'wr:styleset:detach-all';
+} & WrStyleSetNameRequest) | ({
+    type: 'wr:styleset:rename';
+} & WrStyleSetRenameRequest) | ({
+    type: 'wr:styleset:delete';
+} & WrStyleSetNameRequest) | ({
+    type: 'wr:styleset:get';
+} & WrStyleSetStyleRequest) | ({
+    type: 'wr:styleset:set';
+} & WrStyleSetEditRequest) | ({
+    type: 'wr:styleset:copy';
+} & WrStyleSetCopyRequest)
+/** Where would `elementId` (none: a new block) land if it were let go at (x, y) of the page? `scroll`: the pointer is at the top (-1) or bottom (1) edge, so the page scrolls that way. Asked again while the drag goes on. */
+ | {
+    type: 'wr:drop:probe';
+    elementId?: string;
+    x: number;
+    y: number;
+    scroll?: -1 | 0 | 1;
+} | ({
+    type: 'wr:theme:get';
+} & WrThemeGetRequest) | ({
+    type: 'wr:theme:set-item';
+} & WrThemeSetItemRequest) | ({
+    type: 'wr:theme:remove-item';
+} & WrThemeRemoveItemRequest) | ({
+    type: 'wr:theme:dark';
+} & WrThemeDarkRequest);
+export type WrEditorOutbound = ({
+    type: 'wr:upload:request';
+} & WrUploadRequest) | ({
+    type: 'wr:upload:open';
+} & WrTargeted) | ({
+    type: 'wr:scan';
+} & WrScanMessage) | ({
+    type: 'wr:select';
+} & WrSelectMessage) | ({
+    type: 'wr:navigate';
+} & WrNavigateMessage) | ({
+    type: 'wr:page:created';
+} & WrPageCreateResponse) | ({
+    type: 'wr:page:list:response';
+    pages: WrPageListEntry[];
+}) | ({
+    type: 'wr:page:deleted';
+} & WrPageDeleteResponse) | ({
+    type: 'wr:page:updated';
+} & WrPageUpdateResponse) | ({
+    type: 'wr:hover';
+} & WrHoverMessage) | {
+    type: 'wr:hover:clear';
+}
+/** Where the selected and the hovered element are now (null: there is none): said again whenever either moves or changes shape (scroll, resize, a change of style, a layout that shifts). */
+ | {
+    type: 'wr:rects';
+    selected: WrRect | null;
+    hovered: WrRect | null;
+    parent?: WrParentSize | null;
+    fit?: WrBoxFit | null;
+    floor?: WrBoxFloor | null;
+    space?: WrBoxSpace | null;
+    gaps?: WrBoxGaps | null;
+} | {
+    type: 'wr:history:state';
+    canUndo: boolean;
+    canRedo: boolean;
+} | {
+    type: 'wr:drop:target';
+    target: WrDropTarget | null;
+} | ({
+    type: 'wr:seo:get:response';
+} & WrSeoGetResponse) | ({
+    type: 'wr:seo:updated';
+} & WrSeoUpdateResponse) | ({
+    type: 'wr:seo:suggest:response';
+} & WrSeoSuggestResponse) | ({
+    type: 'wr:check:response';
+} & WrCheckResponse) | ({
+    type: 'wr:json:pruned';
+} & WrJsonPruneResponse) | ({
+    type: 'wr:issue:muted';
+} & WrIssueMuteResponse) | ({
+    type: 'wr:comments:response';
+} & WrCommentsResponse) | ({
+    type: 'wr:comments:rects';
+} & WrCommentRectsResponse) | ({
+    type: 'wr:measure:report';
+} & WrMeasureReport) | ({
+    type: 'wr:langs:list:response';
+    langs: WrLangConfig | null;
+}) | ({
+    type: 'wr:langs:updated';
+} & WrLangsUpdateResponse) | ({
+    type: 'wr:node:get:response';
+} & WrNodeGetResponse) | ({
+    type: 'wr:node:set:response';
+} & WrNodeSetResponse) | ({
+    type: 'wr:node:delete:response';
+} & WrNodeDeleteResponse) | ({
+    type: 'wr:node:insert:response';
+} & WrNodeInsertResponse) | ({
+    type: 'wr:node:move:response';
+} & WrNodeMoveResponse) | ({
+    type: 'wr:style:catalog:response';
+} & WrStyleCatalogResponse) | ({
+    type: 'wr:style:get:response';
+} & WrStyleGetResponse) | ({
+    type: 'wr:style:set:response';
+} & WrStyleSetResponse) | ({
+    type: 'wr:styleset:list:response';
+} & WrStyleSetListResponse) | ({
+    type: 'wr:styleset:style:response';
+} & WrStyleSetStyleResponse) | ({
+    type: 'wr:styleset:result';
+} & WrStyleSetResult) | {
+    type: 'wr:move:key';
+    direction: WrMoveDirection;
+} | ({
+    type: 'wr:theme:get:response';
+} & WrThemeGetResponse) | ({
+    type: 'wr:theme:set-item:response';
+} & WrThemeSetItemResponse) | ({
+    type: 'wr:theme:remove-item:response';
+} & WrThemeRemoveItemResponse) | ({
+    type: 'wr:theme:dark:response';
+} & WrThemeDarkResponse);
+//# sourceMappingURL=messages.d.ts.map