@gridify/editors 0.0.0-stage → 1.0.0-rc.1

package/types/gridify-editors.d.ts

@@ -0,0 +1,1781 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, OnInit } from '@angular/core';
+import * as _gridify_studio from '@gridify/studio';
+import { GfyRibbonTab, GfyProblem, GfyRibbonActionEvent, GfyDockContainerNodeInput, GfyMenu, GfyStatusItem, GfyFormLayoutFile, GfyFormElement, GfyFormPlace, GfyFormLayout } from '@gridify/studio';
+
+interface History<T> {
+    readonly past: readonly T[];
+    readonly present: T;
+    readonly future: readonly T[];
+    /** What the last change was about; the next change with the same key close in time is joined to it. */
+    readonly mergeKey: string | null;
+    readonly changedAt: number;
+}
+
+/** A folder or a file in a folder of the project. */
+interface GfyEditorFileEntry {
+    /** The name in its folder (no `/`): `main.layout.json`, `layouts`. */
+    readonly name: string;
+    readonly kind: 'file' | 'folder';
+}
+/** A file of the project as it was read. */
+interface GfyEditorFile {
+    readonly text: string;
+    /**
+     * What tells this content of the file from another one (an ETag of the server, the time of the last change and the size of a file of the computer): the editor gives it back when it saves, so a file
+     * that was changed in the meantime is not overwritten without a word. `null`: the place does not know, and a save writes over whatever is there.
+     */
+    readonly version: string | null;
+}
+/** The condition of a write. Without one the file is written whatever is there. */
+interface GfyEditorWriteCondition {
+    /** The file must be this version (the one that was read or written last): another one, or no file, is a conflict. */
+    readonly ifVersion?: string;
+    /** There must be no file of this name (Save as… to a new name): one that is there is a conflict. */
+    readonly ifAbsent?: boolean;
+}
+/**
+ * Where the editors open and save the files of a project. A path is relative to the root of the place, with `/` between the names (`layouts/main.layout.json`); the root folder is `''`. A path that leaves
+ * the root (`..`), an empty name and `\` never come from the editors.
+ */
+interface GfyEditorFiles {
+    /**
+     * What tells this place from the others (without it: the label). A document that was opened from a place belongs to every place with the same id, so a new object for the same place keeps the link
+     * of the document (and a document that Auto save brings back after a reload has it again), and another place does not have it: give two places that may have the same label (two folders of the same
+     * name) ids of their own.
+     */
+    readonly id?: string;
+    /** The name of the place, for the dialogs and the status bar: the name of the folder, the address of the server. */
+    readonly label: string;
+    /** The folders and the files in a folder (`''`: the root). The editor sorts them and shows the files it opens. */
+    list(folder: string): Promise<readonly GfyEditorFileEntry[]>;
+    /** A file as text, with its version. */
+    read(path: string): Promise<GfyEditorFile>;
+    /** Writes a file (and makes it when there is none), and gives its new version. A condition that does not hold is refused with `GfyEditorFileConflict`; any other failure is an error of its own. */
+    write(path: string, text: string, condition?: GfyEditorWriteCondition): Promise<{
+        readonly version: string | null;
+    }>;
+}
+/** A write was refused because its condition did not hold: the file was changed (or removed) since it was read, or there is a file already where a new one was to be written. */
+declare class GfyEditorFileConflict extends Error {
+    /** The path of the file. */
+    readonly path: string;
+    readonly name = "GfyEditorFileConflict";
+    constructor(
+    /** The path of the file. */
+    path: string, message?: string);
+}
+interface GfyHttpFilesOptions {
+    /**
+     * The address of the API, as the server has it: `http://localhost:4300/files`, or a path of the server of the page (`/api/files`). The requests go to `<url>/list` and `<url>/file`; a query of the
+     * address (`?project=shop`) goes with every request.
+     */
+    readonly url: string;
+    /** The name of the place in the editors. Without it: the address. */
+    readonly label?: string;
+    /** What tells the place from the others (`GfyEditorFiles.id`). Without it: the address. */
+    readonly id?: string;
+    /** Headers of every request (a token): an object, or a function that gives them for each request. */
+    readonly headers?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
+    /** The `credentials` of `fetch`: `'include'` sends the cookies to a server of another origin (one that signs the user in with a cookie). Without it: the cookies of the same origin only. */
+    readonly credentials?: RequestCredentials;
+    /** The `fetch` that sends the requests (a test, an interceptor of your own). Without it: the `fetch` of the window. */
+    readonly fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * The files of a project that a server keeps:
+ *
+ * - `GET <url>/list?path=<folder>`: the entries of the folder as JSON, `[{"name": "main.layout.json", "kind": "file"}, {"name": "old", "kind": "folder"}]`;
+ * - `GET <url>/file?path=<path>`: the text of the file, and its version in the header `ETag`;
+ * - `PUT <url>/file?path=<path>`: the text as the body (`text/plain`), with `If-Match: <version>` (the version that was read) or `If-None-Match: *` (a new file); the answer has the new `ETag`, and `412` says
+ *   that the condition does not hold (a conflict).
+ *
+ * A server of another origin allows the origin of the page (CORS) with the methods `GET` and `PUT`, the headers `Content-Type`, `If-Match` and `If-None-Match`, and exposes `ETag` (without it the browser
+ * hides the version, and the editors write without the check: the console says so once).
+ */
+declare function gfyHttpFiles(options: GfyHttpFilesOptions): GfyEditorFiles;
+/** Can this browser open a folder of the computer (`showDirectoryPicker`: Chrome, Edge and the other browsers of Chromium, on HTTPS or localhost)? */
+declare const gfyLocalFolderSupported: () => boolean;
+/**
+ * Asks the user for a folder of the computer, to read and write (the browser asks too). `null`: the user closed the dialog, or chose a folder the browser does not give (a folder of the system). Call it
+ * from a click: the browser opens the dialog only for a gesture of the user. `id` lets the browser remember the folder that was chosen last for the next time.
+ */
+declare function gfyPickLocalFolder(id?: string): Promise<FileSystemDirectoryHandle | null>;
+interface GfyLocalFolderOptions {
+    /**
+     * What tells the folder from the others (`GfyEditorFiles.id`): the browser does not say where a folder is, so two folders of the same name are told apart only by an id that the application gives
+     * each folder the user chooses (and keeps with its handle). Without it: the name of the folder.
+     */
+    readonly id?: string;
+    /** The name of the place in the editors. Without it: the name of the folder. */
+    readonly label?: string;
+}
+/**
+ * The files of a folder of the computer, through a handle of the File System Access API (from `gfyPickLocalFolder`, or one that the application kept in IndexedDB). The version of a file is the time of its
+ * last change and its size. A handle that was kept has no permission after a reload of the page: the first list, read or write asks the browser for it again, and the browser asks the user (so the first
+ * of them comes from a click).
+ */
+declare function gfyLocalFolderFiles(folder: FileSystemDirectoryHandle, options?: GfyLocalFolderOptions): GfyEditorFiles;
+
+/** The file of the project the document belongs to. */
+interface ProjectLink {
+    /** The id of the place of the file (`GfyEditorFiles.id`, or its label): the link belongs to the place that has it. */
+    readonly place: string;
+    /** The label of the place, for the status bar. */
+    readonly label: string;
+    readonly path: string;
+    /** The version of the file as it was read or written last (`null`: the place does not know it). */
+    readonly version: string | null;
+}
+/**
+ * Where a document came from, when it belongs to no file of the project: a new one (`new`), a sample of the editor (`sample`, its label), a file of the computer that was opened or dropped on the editor
+ * (`file`, its name: the browser gives no more of it, and cannot write into it), the clipboard (`clipboard`). A document of the project is named by its link instead.
+ */
+type DocumentOrigin = {
+    readonly kind: 'new';
+} | {
+    readonly kind: 'sample';
+    readonly name: string;
+} | {
+    readonly kind: 'file';
+    readonly name: string;
+} | {
+    readonly kind: 'clipboard';
+};
+/** A file that was opened from the project. */
+interface ProjectFile {
+    readonly files: GfyEditorFiles;
+    readonly path: string;
+    readonly text: string;
+    readonly version: string | null;
+}
+interface EditorProjectOptions {
+    /** What the editor makes, for the titles and the questions: `layout`, `form layout`, `ribbon`. */
+    readonly noun: string;
+    /** The extension of its files (`.json`): the dialog shows these files, and a name of Save as… ends with it. */
+    readonly extension: string;
+    /** The prefix of the icons of the editor (its registry has `<prefix>:project-folder` and `<prefix>:project-file`, see `editor-icons.ts`). */
+    readonly icons: string;
+    /** Where Auto save keeps the link with the text of the document (`remember`, `recall`). */
+    readonly storageKey: string;
+    /** Writes a message into the status bar of the editor. */
+    readonly say: (text: string) => void;
+}
+/**
+ * What the project holds of the document of an editor: the link, where the document came from, whether a save or an opening is on its way, the count of the documents that replaced one another (a save
+ * that ends after its document was replaced does not link the new one), and the folder used last. The store leaves it in its keeper with the document, and the store that takes the document back takes it
+ * too (`EditorProject.adopt`).
+ */
+declare class ProjectState {
+    readonly link: _angular_core.WritableSignal<ProjectLink | null>;
+    readonly origin: _angular_core.WritableSignal<DocumentOrigin>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    generation: number;
+    lastFolder: string;
+}
+declare class EditorProject {
+    private readonly options;
+    private readonly dialogs;
+    private readonly box;
+    private readonly source;
+    private readonly current;
+    /** The place of the project the application gives the editor now, `null` without one (the File menu is as it always was). */
+    readonly files: Signal<GfyEditorFiles | null>;
+    /** The link of the document, whatever place it belongs to. */
+    readonly link: Signal<ProjectLink | null>;
+    /** The link of the document when it belongs to the place the editor has now (a link of another place, or of none, is no link). */
+    readonly linked: Signal<ProjectLink | null>;
+    /** A save or an opening is on its way: Save or Open pressed again meanwhile does nothing (the status bar says what is on its way). */
+    readonly busy: Signal<boolean>;
+    /** Where the document came from (what `replaced` was told last): it names a document that has no link. */
+    readonly origin: Signal<DocumentOrigin>;
+    constructor(options: EditorProjectOptions);
+    /** The title of the document for the menu bar of the editor (see `documentTitle`): read it in a `computed`, it follows the link, the origin and the place. */
+    title(modified: boolean): DocumentTitle;
+    /** Takes the place from the input of the editor (read while it is needed, so a new place counts at once). */
+    connect(files: () => GfyEditorFiles | null | undefined): void;
+    /** What the project holds of the document, for the keeper of the editor. */
+    get state(): ProjectState;
+    /** The document came back from the keeper: its project comes with it (a save that is still on its way ends in it). */
+    adopt(state: ProjectState): void;
+    /**
+     * The document was replaced by one that is not a file of the project (yet): it has no link, and it came from `origin`. A file of the project that is opened is replaced first (as a file of the computer,
+     * by its path) and linked to it then (`linkTo`).
+     */
+    replaced(origin: DocumentOrigin): void;
+    /** The document is the file that was opened (after it was loaded). */
+    linkTo(file: ProjectFile): void;
+    /** The dialog asks for a file of the project, and the file is read: `null` when none was chosen, or it could not be read (the user was told). */
+    open(): Promise<ProjectFile | null>;
+    /**
+     * Writes the text into the file of the link, when the file is still the version that was read (another one is asked about: overwrite it or not). A document without a link asks where it goes
+     * (`saveAs`). `true` when the document that is open now was saved, so the editor marks it saved.
+     */
+    save(text: string, name: string): Promise<boolean>;
+    /** Asks for a folder and a name (the ones of the link, or the folder used last and `name`), and writes the text there; a file that is there is asked about. The document is linked to the new file. */
+    saveAs(text: string, name: string): Promise<boolean>;
+    private write;
+    private mayOverwrite;
+    private fail;
+    /** The dialog of the files: the path that was chosen, `null` when it was closed without one (Cancel, Esc, the cross). */
+    private choose;
+    /** Keeps the link (or that there is none) and where the document came from beside the text that Auto save keeps: call it when the text is kept. */
+    remember(): void;
+    /** Forgets the link that was kept: call it when the text is forgotten. */
+    forget(): void;
+    /** The link and the origin that were kept with the text come back with it: call it when the text comes back (a link kept before the origin was kept comes back alone). */
+    recall(): void;
+}
+/** The title of a document in the menu bar of an editor: the text, and what its tooltip says. */
+interface DocumentTitle {
+    readonly text: string;
+    readonly tooltip: string;
+}
+
+interface EditorText {
+    /** The text with the values in place of its `{placeholders}`; a placeholder that has no value stays as it is. */
+    text(source: string, params?: Readonly<Record<string, string | number>>): string;
+    /** The text as a signal, for an input of the docking engine that takes one (the title of a window). */
+    signal(source: string): Signal<string>;
+}
+
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** The way from the root to a value: the names of the properties and the indexes of the arrays (`['tabs', 0, 'sections', 1]`). */
+type JsonPath = readonly (string | number)[];
+/** A place in the text: lines and columns count from 1, the offset from 0. */
+interface JsonPosition {
+    line: number;
+    column: number;
+    offset: number;
+}
+/** What is wrong, as a text with `{placeholders}` (English: the text function of the editor fills the placeholders) and the values for them. */
+interface JsonErrorInfo extends JsonPosition {
+    template: string;
+    params: Record<string, string | number>;
+}
+
+/** The cells of an item: 1-based, the spans are numbers. */
+interface Cell {
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+}
+interface PlacedItem extends Cell {
+    /** The item sets its column (or covers all columns). */
+    colFixed: boolean;
+    /** The item sets its row (or covers all rows). */
+    rowFixed: boolean;
+}
+
+/** The inputs of `<gfy-ribbon>` that change how the tabs are drawn. They are not part of the tabs, so they live beside them. */
+interface RibbonOptions {
+    defaultRows: number;
+    uniformRows: boolean;
+    /**
+     * The width of every column in px (see `colWidth` of `<gfy-ribbon>`), 24 for a new ribbon; `null` = not set: the ribbon makes every column as wide as its content. The editor always draws the columns
+     * at a fixed width, because an item covers as many cells as its `colSpan` says: a ribbon without `colWidth` is drawn with `DRAWN_COL_WIDTH` (see `drawnColWidth`).
+     */
+    colWidth: number | null;
+    /** The gap between the columns in px (0 is no gap); `null` = the gap of the density. */
+    colGap: number | null;
+    collapsible: boolean;
+    search: boolean;
+    /** The text of the empty search box; `null` = the text of the library, `''` = no text. */
+    searchPlaceholder: string | null;
+}
+
+/** What a file says besides the tabs: the options of the element, and the custom functions as the text of the Ribbon Options window (`s.field:2, s.flag:2`). */
+interface FileSettings$1 {
+    readonly options: RibbonOptions;
+    readonly functions: string;
+}
+
+/** What goes with the ribbon besides its tabs, and is a step of undo as well: the options of the element and the custom functions (`s.field:2, s.flag:2`). */
+type Settings$1 = FileSettings$1;
+/** What a step of undo brings back: the ribbon (always a list of tabs), its options and its custom functions. */
+interface Snapshot$1 extends Settings$1 {
+    readonly root: JsonValue;
+}
+interface EditorState$2 {
+    /** The ribbon with its options and functions, and the steps before and after it. */
+    readonly history: History<Snapshot$1>;
+    /** What the reading of the file that was loaded let pass although JSON does not (comments, single quotes, a declaration around the list, ...). It is gone with the next change. */
+    readonly notes: readonly JsonErrorInfo[];
+    /** The tab, section, item or choice that is selected. */
+    readonly selected: JsonPath | null;
+    /** The snapshot that the file on the disk holds: the one that was loaded, or the one that was downloaded last (`markSaved`). The document is modified while another one is present. */
+    readonly saved: Snapshot$1;
+}
+
+declare const CHOICE_KINDS: readonly ["item", "separator", "header", "source"];
+/** What the menus Add choice add to the choices of an item or a choice (the context menu, the button of the Outline): an entry, a separator, a heading, or a block of menu items. */
+interface ChoiceEntry {
+    /** The identity of the entry among the others. */
+    id: string;
+    label: string;
+    description: string;
+    kind: (typeof CHOICE_KINDS)[number];
+    /** `kind: 'source'`: the name of the block. */
+    source?: string;
+}
+type InputKind = 'boolean' | 'integer' | 'number' | 'text' | 'choice' | 'list' | 'function';
+interface InputSpec {
+    name: string;
+    kind: InputKind;
+    /** `choice`: the allowed values. */
+    options?: readonly string[];
+    /** What the control does while the input is missing. It is shown, and never written. */
+    fallback?: JsonValue;
+    /** `integer`: the smallest value. */
+    min?: number;
+    /** `function`: the TypeScript type of the function, for the code that is generated. */
+    signature?: string;
+    /** `text`: the input holds a CSS color, so the Inspector edits it with a color picker (see `FieldSpec.color`). */
+    color?: boolean;
+    /**
+     * The input does something only while another input of the control has (or has not) a value: the Inspector offers its row then, and while it is written. `equals`: the other input is this (what it is while it is
+     * missing is its `fallback`); `not`: it is anything else. An input that is code (a signal) counts as met.
+     */
+    dependsOn?: {
+        input: string;
+        equals?: JsonValue;
+        not?: JsonValue;
+    };
+    description: string;
+}
+type ControlGroup = 'buttons' | 'menus' | 'toggles' | 'fields' | 'display';
+/** Does the control take `choices`: not at all, may have them, or is nothing without them. */
+type ChoicesUse = 'none' | 'optional' | 'required';
+/** What `item.value` is for a control. */
+type ValueKind = 'none' | 'text' | 'number' | 'any';
+/**
+ * What a control does with the properties of the choices of its item (read from the controls of the library): a property it does not use is ignored by it, so the Inspector does not offer it. `structure`: a
+ * separator, a heading and a block of menu items are interpreted (a menu does; a table picker and a select skip them, a gallery, a combo box and a toggle group would draw them as ordinary entries). `icon`: the icon
+ * of the choice is drawn. `tile`: `preview` and `style`, the tile of a gallery. `checked`: the state of a button of a toggle group. `disabled`: the choice can be switched off. `submenu`: the choice may hold `choices`
+ * of its own.
+ */
+interface ChoiceUse {
+    structure: boolean;
+    icon: boolean;
+    tile: boolean;
+    checked: boolean;
+    disabled: boolean;
+    submenu: boolean;
+}
+interface ControlSpec {
+    type: string;
+    label: string;
+    group: ControlGroup;
+    description: string;
+    inputs: readonly InputSpec[];
+    choices: ChoicesUse;
+    /** Which properties of a choice the control uses (the rows of a choice in the Inspector follow it). */
+    choiceUse: ChoiceUse;
+    value: ValueKind;
+    /** Does the control use `item.checked`? */
+    checked: boolean;
+    /** Does the control draw the `icon` of the item (and so its `iconColor`)? The Inspector offers the two rows only for a control that does; a gallery and a toggle group draw the icons of their choices. */
+    icon: boolean;
+    /** Is it a command: it has a KeyTip, is found by the command search and can have a shortcut. */
+    command: boolean;
+    /** The properties of an item (`ITEM_FIELDS`) that the control does not use: the Inspector does not offer their rows (it keeps one that is written). */
+    ignores?: readonly string[];
+    /** What the action event carries as `value`, for the comment in the generated code. */
+    emits: string;
+    /** The number of rows the control spans when the item does not say, from the inputs of the item. */
+    defaultRowSpan(inputs: JsonObject): 'all' | 1;
+    /** A new item of this control: `id` is its handle, `tr` translates the texts that the user will see. */
+    create(id: string, tr: (text: string) => string): JsonObject;
+}
+
+/** The cells that an item is stretched to: what is not given stays as it is. */
+interface StretchSize {
+    col?: number;
+    row?: number;
+    colSpan?: number;
+    rowSpan?: number;
+}
+
+/** A row of the inspector. It has the shape of `GfyProperty` of the property grid. */
+interface InspectorRow$2 {
+    id: string;
+    /** The name of the property the row writes, as it stands in the JSON or in the component (`showForTags`, the `menuLayout` of `inputs`), not a translation of it: this is a tool for developers. A row that the editor adds is named like its id. */
+    label: string;
+    /** `readonly`: a value that is shown and cannot be typed (the place of an item, which is worked out from the grid). `color`: a color picker (it writes the code of the color, `#2563eb`; a row that holds code is a text row). */
+    kind: 'text' | 'number' | 'boolean' | 'select' | 'color' | 'readonly';
+    category: string;
+    description: string;
+    options?: readonly {
+        value: string;
+        label: string;
+    }[];
+    min?: number;
+    step?: number;
+    decimals?: number;
+    placeholder?: string;
+    defaultValue?: unknown;
+    /** The library takes a signal for the property, and the row is not a text field (a switch, a list, a number, a color): `bindRow` turns it into a code row (`=@name`). */
+    bindable?: boolean;
+    /** The row is shown and cannot be changed (the kind of a choice): the description says why, and `changeRow` refuses it too. */
+    disabled?: boolean;
+    /**
+     * The property holds code of the application (`{"$expr": "..."}`): the row is a text row that shows the code with a `=` in front (like a formula), and `was` is the kind the row has when the
+     * value is not code (a switch, a number, a list...). A text that starts with `=` is code, any other is the plain value of the row.
+     */
+    code?: {
+        was: 'text' | 'number' | 'boolean' | 'select';
+        defaultValue?: unknown;
+    };
+}
+interface Inspector$2 {
+    /** What is inspected: a tab, a section, an item or a choice. */
+    kind: 'tab' | 'section' | 'item' | 'choice';
+    path: JsonPath;
+    /** The rows, in the order of the categories. */
+    rows: InspectorRow$2[];
+    /** The values of the rows, by the id of the row. A property that is not set is missing. */
+    values: Record<string, unknown>;
+    /** The control of an item (`undefined` for the others, and for a control the editor does not know). */
+    control: ControlSpec | undefined;
+}
+
+/** The kinds of text the output window can show. */
+type OutputKind$2 = 'file' | 'json' | 'typescript' | 'handler' | 'template' | 'usage';
+/** A problem of the list: the problem of the list of the library, and the node it is about (a note on the reading of the file is about none). */
+interface EditorProblem$2 extends GfyProblem {
+    readonly nodePath: JsonPath | null;
+}
+/** A request of the store to the preview: measure the items and widen those that are too narrow for their content (see `RibbonEditorStore.fitItems`). */
+interface FitRequest {
+    /** A new request has a number that is higher than the last one. */
+    readonly seq: number;
+    /** The items to look at. */
+    readonly items: readonly JsonPath[];
+    /** The step of undo that the widening joins (the step that added the item), if any. */
+    readonly key: string | undefined;
+    /** Is the user told what was done? Only when an item was widened (a change of the content of an item), or never (an item that was added). */
+    readonly announce: false | 'widened';
+}
+/** An item whose content needs more columns than the item covers, as the preview measured it. */
+interface Overflow {
+    readonly path: JsonPath;
+    readonly needed: number;
+    readonly have: number;
+}
+/** What the commands that need a selected node can do now. */
+interface Capabilities$2 {
+    readonly remove: boolean;
+    readonly duplicate: boolean;
+    readonly moveUp: boolean;
+    readonly moveDown: boolean;
+    readonly addSection: boolean;
+    readonly addChoice: boolean;
+    /** A choice may hold choices of its own: the choice of the menu of a split button or a dropdown button, when it is an entry (the choices of the other controls are a flat list). */
+    readonly addSubChoice: boolean;
+    /** What the toolbox may add to the choices of the selected item, or next to the selected choice: a separator, a heading and a block only where the control interprets them. */
+    readonly choiceEntries: readonly ChoiceEntry[];
+}
+declare class RibbonEditorStore {
+    private readonly toast;
+    private readonly box;
+    private readonly icons;
+    /** The files of the project, while the application gives the editor a place for them (the input `files` of the editor): File > Open from the project…, Save and Save as…. */
+    readonly project: EditorProject;
+    /** The editor starts with an empty list of tabs (the samples are in File > Samples); with Auto save on, what was kept in the browser replaces it (see `restore`). */
+    readonly state: WritableSignal<EditorState$2>;
+    readonly root: _angular_core.Signal<JsonValue>;
+    readonly notes: _angular_core.Signal<readonly JsonErrorInfo[]>;
+    /** The selected node. A change of the ribbon makes a new path for the node that stays selected: it is the same selection (the windows that follow it are not told). */
+    readonly selected: _angular_core.Signal<JsonPath | null>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    /** The document has been changed since it was loaded or downloaded: the tabs, the options or the custom functions (the file holds all of them). */
+    readonly modified: _angular_core.Signal<boolean>;
+    /** Goes up when another document replaces the one that is edited: a window that keeps something by the place of a node (the open nodes of the Outline) starts again then. */
+    readonly documentSeq: WritableSignal<number>;
+    /** The options of `<gfy-ribbon>` that are not part of the tabs: they are for the preview and for the template that is generated. They are steps of undo, as the ribbon is (they live in the same history). */
+    readonly options: _angular_core.Signal<RibbonOptions>;
+    /** The preview shows the grid of cells (for finding the place of an item). */
+    readonly showGrid: WritableSignal<boolean>;
+    /** The preview draws a faint background over the cells of every item, to see where each one lies (without the grid). */
+    readonly showBackground: WritableSignal<boolean>;
+    /** The width of the ribbon in the Editor window in px, or `null` for all the room (a narrow ribbon shows how the sections shrink and collapse). */
+    readonly previewWidth: WritableSignal<number | null>;
+    /** Does the check of the ribbon look for the icons in the registry of this editor? Off by default: the ribbon of an application has icons that this editor does not have. */
+    readonly checkIcons: WritableSignal<boolean>;
+    /** The custom functions of the file, as the text of the Ribbon Options window (`s.field:2, s.flag:2`): a step of undo like the options. */
+    readonly customFunctions: _angular_core.Signal<string>;
+    /** The functions an expression may call: the predefined ones and the custom ones, and the argument of each that holds the text the preview shows (see `core/ribbon-expression.ts`). */
+    readonly functions: _angular_core.Signal<Map<string, number>>;
+    readonly predefinedFunctions: string;
+    /** The whole file as text: the custom functions, the options and the tabs. */
+    readonly file: _angular_core.Signal<string>;
+    /** What the preview is asked to do next: widen the items to the cells their content needs. A request is carried out once; the preview remembers the number of the last one it did. */
+    readonly fitRequest: WritableSignal<FitRequest | null>;
+    private fitSeq;
+    /** The items of the tab that is shown whose content is wider than their cells (the preview measures them after every change, and the list of problems tells). */
+    readonly overflows: WritableSignal<readonly Overflow[]>;
+    /** The control that is being dragged from the toolbox (the preview draws the cells it would cover); `null` when nothing is. */
+    readonly dragType: WritableSignal<string | null>;
+    readonly outputKind: WritableSignal<OutputKind$2>;
+    readonly status: WritableSignal<string>;
+    /** File > Auto save: the file is kept in the browser while it is edited and comes back at the next visit. Off by default, and a setting of the editor (not part of the document, not a step of undo). */
+    readonly autoSave: WritableSignal<boolean>;
+    constructor();
+    /** The state that an editor of this application left when it was closed (see `RibbonEditorKeeper`). */
+    private takeBack;
+    /** Turns Auto save on or off. Off: what was kept of the document goes at once. On: the document is kept from now on. */
+    setAutoSave(on: boolean): void;
+    private readAutoSave;
+    /** Takes away what an older version of the editor kept in the browser (see `LEGACY_KEYS`). */
+    private forgetLegacy;
+    /**
+     * The file that was kept (Auto save on) replaces the empty ribbon; one that was not saved after its last change comes back with its changes not saved, and with the file of the project it belongs to.
+     * A text that cannot be read is not loaded: the editor starts with the empty ribbon, and the next save of Auto save writes over the text. Gives whether a file came back.
+     */
+    private restore;
+    /** The editor has nothing but the empty ribbon it started with: no editor of the application came back, Auto save brought nothing, and nothing has been done since. */
+    private fresh;
+    /**
+     * Starts with a sample of File > Samples instead of the empty ribbon (the input `sample` of the editor: Gridify Designer gives one), and the status bar says where the help is. Only while the editor
+     * is fresh: a ribbon that came back, or one that was loaded or changed, stays.
+     */
+    startWith(id: string): void;
+    /** Auto save could not keep the text of the file (no room, or no storage): its changes are nowhere else, so leaving the page is asked about as without Auto save. */
+    private notKept;
+    /**
+     * Keeps the text of the file, whether it is the one that was saved last (`modified`: it is not), and the file of the project it belongs to. When the browser does not keep it, `tell` says so
+     * (once, not for every change).
+     */
+    private saveText;
+    private forgetText;
+    /** What the application would know by a key like `app:paste` and this editor does not: a placeholder is drawn instead, so that the preview stays readable. */
+    private previewIcon;
+    /** The tabs for `<gfy-ribbon>` of the Editor window. */
+    readonly tabs: _angular_core.Signal<GfyRibbonTab[]>;
+    /**
+     * The tabs for the ribbon of the Preview window: the same, made once more. A control that is used there writes its value into its item (a plain value of the data), and the Editor window, which shows the
+     * file, must not show it.
+     */
+    readonly liveTabs: _angular_core.Signal<GfyRibbonTab[]>;
+    /** The id of the tab of the preview that is shown: the tab of the selected node. */
+    readonly activeTabId: _angular_core.Signal<string | undefined>;
+    /** The tab of the selected node; the last one that was selected stays while nothing is (a section that is deselected does not take the tab away). */
+    private readonly shownTab;
+    /** The number of rows of the tabs, the same way the ribbon counts them. */
+    readonly rows: _angular_core.Signal<number[]>;
+    /** The width the Editor window draws a column at: `colWidth`, or 24 px when it is not set (an application makes the columns as wide as their content then, as the Preview does). */
+    readonly drawnColWidth: _angular_core.Signal<number>;
+    /** The ribbon with the cell of every item written (see `ops.pinRibbon`): a command that changes a layout starts from it, so no item of the ribbon is left to the grid once the ribbon has been edited. */
+    private layoutRoot;
+    /** The number of rows of the tab of a node (of the default, for a path that is not in a tab): the operations that keep the places of the items need it. */
+    private readonly rowsOf;
+    /** The control of the item that the node at `path` is (or that holds the choice it is). `undefined` for a control the editor does not know. */
+    private controlOf;
+    /**
+     * The Editor always draws the columns at a fixed width (`drawnColWidth`), and then the cells stay where they are: an empty column is a cell that is left empty, and the operations do not close it.
+     * So a command that moves an item away (or makes it narrower) would leave empty columns at the edge of its section. Those are cut off here, in the sections the command worked on (see `ops.trimColumns`): the first and the last column of a section always hold an item (a section whose `columns` is a text of grid tracks is left as it is).
+     */
+    private trimmed;
+    /** The inspector of the selected node. */
+    readonly inspector: _angular_core.Signal<Inspector$2 | null>;
+    /** The properties of the selected node that the rows of the inspector do not hold. */
+    readonly otherProperties: _angular_core.Signal<JsonObject>;
+    readonly capabilities: _angular_core.Signal<Capabilities$2>;
+    /** The problems, for the list: what the reading of the file let pass although JSON does not, and what the check of the ribbon finds. */
+    readonly problems: _angular_core.Signal<EditorProblem$2[]>;
+    /** The counts of the tabs, the sections and the items, for the status bar. */
+    readonly counts: _angular_core.Signal<{
+        tabs: number;
+        sections: number;
+        items: number;
+    }>;
+    /** The text of the output window. */
+    readonly output: _angular_core.Signal<string>;
+    say(text: string): void;
+    private warn;
+    /** Selects a node. */
+    select(path: JsonPath | null): void;
+    /** Selects the tab that the ribbon of the preview shows (`t0`, `t1`...), as its keys or the mouse change it. */
+    selectTabById(id: string): void;
+    /** A problem of the list was opened: the node it is about is selected. */
+    openProblem(problem: EditorProblem$2): void;
+    /**
+     * A command changed the ribbon. A result that holds what the ribbon holds already (a cell that an item has, a value that is written again) is no step of undo and no change of the document; only its
+     * selection is taken. Says whether the ribbon changed.
+     */
+    private run;
+    /**
+     * The tab that the Editor window shows: the tab of the selection, or the one that was shown last while nothing is selected. The ribbon draws its first tab while none was chosen yet, and when the one
+     * that was shown is gone, so that is the first one then (`undefined` for a ribbon without a tab).
+     */
+    private shownTabIndex;
+    /**
+     * Where a new item goes: the section of the selection (the last section of a selected tab, or of the tab that is shown). `section` is `null` when that tab has no section (one is made in it) or there is
+     * no tab at all (`tab` is -1 then: a tab with a section is made).
+     */
+    private placeForNewItem;
+    /** The index of the tab of the selected node. */
+    private selectedTab;
+    addTab(): void;
+    /** A new tab (with a section) after the last one, as the context menu of the empty place of the tab bar adds it. */
+    addTabAtEnd(): void;
+    addSection(): void;
+    /** Adds an item of a control to a section (the one of the selection, if no other is given). */
+    addItem(type: string, target?: {
+        sectionPath?: JsonPath;
+        index?: number;
+        cell?: {
+            col: number;
+            row: number;
+        };
+    }): void;
+    /**
+     * Adds a choice: to the end of the choices of the selected item; next to the selected choice (`after` unless said otherwise: that is where a new one is expected), or inside of it (`inside`: a choice
+     * that opens a list of choices, as the choices of a menu do).
+     */
+    addChoice(where?: 'inside' | 'before' | 'after', entry?: ChoiceEntry): void;
+    removeSelected(): void;
+    duplicateSelected(): void;
+    moveSelected(delta: number): void;
+    /** A tab was dragged in the Outline to the place `index` of the tabs (counted without it). */
+    moveTabTo(from: number, index: number): void;
+    /** A section was dragged in the Outline to the place `index` of the sections of the tab `tabIndex` (counted without it): in its tab, or into another one. */
+    moveSectionTo(path: JsonPath, tabIndex: number, index: number): void;
+    /** The user changed a row of the inspector. */
+    changeRow(id: string, value: unknown): void;
+    /** Would Reset change the row `id` of the selected node (take its property out)? Not for a row whose property is not taken out (the control, an id, the kind of a choice) or that has nothing to take. */
+    canReset(id: string): boolean;
+    /** The user bound a row that is not a text field to a signal of the application (`{"$bind": "name"}`; the row is a code row afterwards). */
+    bindRow(id: string): void;
+    /** The item that a change of the row `id` of the node at `path` may have made wider (its text, its icon, its control, an input, the text or the icon of a choice), or `null`. */
+    private itemWhoseContentChanged;
+    /**
+     * `defaultRows` of the ribbon: the least number of grid rows of a tab, any whole number from 1. A tab whose items stand lower than that keeps the rows they use, and `rows` of a tab is not less than it
+     * either: that is how the library counts them (`tabRows`), so nothing is refused here.
+     */
+    setDefaultRows(rows: number): void;
+    /** The text of the "other properties" of the selected node; gives the reason when it cannot be used. */
+    setOtherProperties(text: string): string | null;
+    /** The item at `itemPath` covers all columns of its section (`colSpan: "all"`, see `ops.coverAllColumns`), or goes back to one column. Refused while other items stand in its rows. */
+    spanAllColumns(itemPath: JsonPath, on: boolean): void;
+    /** Is the room free for an item: no other item stands on the cells (`ignore` is the index of the item that is moved or stretched, which does not count)? */
+    isCellFree(sectionPath: JsonPath, cell: {
+        col: number;
+        row: number;
+        colSpan: number;
+        rowSpan: number;
+    }, ignore: number | null): boolean;
+    /** The cells a control covers when it is added: what its item sets by itself. A control that covers all rows (a large button) starts at the first one, wherever it is dropped (`row`). */
+    spanOfControl(type: string | null, rows: number): {
+        colSpan: number;
+        rowSpan: number;
+        row?: number;
+    };
+    /** An item may not be put (or stretched) onto the cells of another one: the move is refused, and the user is told. */
+    private cellTaken;
+    /** The cells of all the items of a section, as the grid places them (in the order of the items; `null` for an entry that is not an item). */
+    placedSection(sectionPath: JsonPath): (PlacedItem | null)[];
+    /** What a drop on the boundary before the column `column` of a section would do to the columns (see `ops.plannedColumn`): the hint of the drag asks. */
+    plannedColumn(itemPath: JsonPath, sectionPath: JsonPath, column: number): {
+        column: number;
+        opens: boolean;
+    };
+    /** The row where the item can stand in a new column before the column `column` of a section, the nearest to `near`; `null` when the items that stretch over the column leave no room. */
+    rowInNewColumn(itemPath: JsonPath, sectionPath: JsonPath, column: number, rowSpan: number, near: number): number | null;
+    /** An item was dropped on the line of a new column of a section (before the column number `column`, or behind the last one): see `ops.moveItemToNewColumn`. One step of undo. */
+    moveItemToNewColumn(itemPath: JsonPath, sectionPath: JsonPath, column: number, row: number): void;
+    /** The cell where an item stands in the grid of its section (the one it sets, or the one the grid gives it). */
+    placedCell(itemPath: JsonPath): PlacedItem | null;
+    /** An item was dropped on a cell: in its own section it only changes its cell, in another one it moves there first. The other items stay where they are (see `ops.moveItemToCell`). One step of undo. */
+    moveItemToCell(itemPath: JsonPath, sectionPath: JsonPath, cell: {
+        col: number;
+        row: number;
+    }): void;
+    /**
+     * An item was stretched in the preview. It grows into the free columns, and where another item stands a column is opened (see `ops.stretchItem`); the cells above and below it must be free, and the rows of the
+     * tab must reach. One step of undo.
+     */
+    resizeItem(itemPath: JsonPath, size: StretchSize): void;
+    /** Can the item be stretched to `size` (see `ops.stretchItem`)? The preview asks while the edge is pulled. */
+    canResize(itemPath: JsonPath, size: StretchSize): boolean;
+    /**
+     * Asks the preview to measure the items and widen those that are too narrow for their content: the columns have a fixed width, and an item that says nothing about its columns has one. `key` joins
+     * the widening to the step of undo of the change before it.
+     */
+    requestFit(items: readonly JsonPath[], key: string | undefined, announce: false | 'widened'): void;
+    /**
+     * What the preview measured: for sections (by their path), the columns that the content of their items needs (see `cellsNeeded`), by the index of the item. The items that are narrower are widened
+     * (see `ops.fitItems`), in one step of undo. Gives the number of items that became wider.
+     */
+    fitItems(needs: readonly {
+        readonly section: JsonPath;
+        readonly items: ReadonlyMap<number, number>;
+    }[], options?: {
+        key?: string;
+        announce?: false | 'widened';
+    }): number;
+    /** The arrow keys of the preview: the selected item moves by a cell. */
+    nudgeItem(itemPath: JsonPath, dCol: number, dRow: number): void;
+    setOption<K extends keyof RibbonOptions>(key: K, value: RibbonOptions[K]): void;
+    /**
+     * An action of the ribbon in the Preview window: the status bar tells what the application would receive (the action of the item, and the value when there is one). A radio that is chosen
+     * turns the other radios of its group off, as the application does (the ribbon sets only the radio that was clicked, see `withRadioGroups`).
+     */
+    reportAction(event: GfyRibbonActionEvent): void;
+    /** The custom functions were changed (the Ribbon Options window): the text is read as a list such as `s.field:2, s.flag:2` (a predefined function is not a custom one). The same changes of it that follow each other soon are one step of undo. */
+    setCustomFunctions(text: string): void;
+    undo(): void;
+    redo(): void;
+    /** Is it all right to replace the document that is being edited? It is asked when the document has changes that were not saved (the tabs, the options or the functions). */
+    private mayReplace;
+    /** Another document replaces the one that is edited (New, a sample, a file, the clipboard). It is shown from its first tab: the tab that was shown was one of the document before it. */
+    private replaceDocument;
+    /** A new document: an empty ribbon with the default options and no custom functions, and nothing to undo, as the editor starts. Changes that were not saved are asked about first. */
+    newRibbon(): Promise<void>;
+    loadSample(id: string): Promise<void>;
+    /**
+     * A text from outside (a file, the clipboard, a drop) replaces the ribbon. The file of the editor brings its options and its custom functions with it; a bare list of tabs leaves the ones that are set.
+     * A text that cannot be read is not loaded: the user is told where it goes wrong, and the ribbon stays. Gives whether the text was loaded (the user may also keep the ribbon that was changed).
+     * `name` is what the messages call it, `origin` where it came from (by default a file of that name), for the title in the menu bar.
+     */
+    loadFromText(text: string, name: string, origin?: DocumentOrigin): Promise<boolean>;
+    /** Asks for a file and loads it. */
+    openFile(): void;
+    /** File > Open from the project…: a file of the project replaces the ribbon (as a file of the computer does), and the ribbon belongs to it then: Save writes it back there. */
+    openFromProject(): Promise<void>;
+    /** File > Save: the file goes back into the file of the project that it belongs to (a ribbon that belongs to none asks where, as Save as… does). The ribbon is saved then, as after a download. */
+    saveToProject(): Promise<void>;
+    /** File > Save as…: the file goes into a file of the project that the user chooses, and belongs to it from then on. */
+    saveToProjectAs(): Promise<void>;
+    pasteRibbon(): Promise<void>;
+    copyOutput(): Promise<void>;
+    /**
+     * Offers the file of the editor (the functions, the options and the tabs) for download. The document is the one on the disk now: it is not modified until the next change, unless it belongs to a file
+     * of the project (then the download is a copy, and the document is saved by Save).
+     */
+    downloadFile(): void;
+    private downloaded;
+    /** Offers what the output window shows as a file. */
+    downloadOutput(): void;
+    private saveFile;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonEditorStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RibbonEditorStore>;
+}
+
+/**
+ * An editor of the ribbon of an application. Its file holds the value that goes into `[tabs]` of `<gfy-ribbon>` (a list of `GfyRibbonTab`) with the options of the element and the custom functions of
+ * the expressions: it is opened from a file or the clipboard (a bare list of tabs is read as well), edited in the outline, the preview and the inspector, and taken out as the file, as JSON, as
+ * TypeScript, with a handler for `(action)` and with the code that loads it. The state is in `RibbonEditorStore`, which this
+ * component provides (so every instance has its own), and the windows only read it and call its commands. An application that gives it the files of a project (`files`) gets File > Open from the project…,
+ * Save and Save as… besides.
+ */
+declare class RibbonEditor implements OnInit {
+    /**
+     * The editor is shown by an application that has its own header with the name and the choice of the theme and the density (the application that switches between the editors): the editor
+     * then leaves its own name and its own choice out of the menu bar, and it fills the place it is given instead of the whole window. Every editor of the application takes this input.
+     */
+    readonly hosted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The files of a project (a folder of the computer, a server, a place of the application: see `GfyEditorFiles`): File > Open from the project… opens a ribbon of the project, Save writes it back
+     * (when the file is still the one that was opened), Save as… writes it under another name. Without them (the default) the editor opens a file of the computer and offers the ribbon for download, as
+     * it always did.
+     */
+    readonly files: _angular_core.InputSignal<GfyEditorFiles | null>;
+    /**
+     * The id of a sample of File > Samples that the editor starts with when it has nothing else to show (no ribbon that the application left in it, nothing that Auto save kept). Without it the
+     * editor starts with an empty ribbon; Gridify Designer gives `showcase`, the ribbon of a text editor. A ribbon that came back stays.
+     */
+    readonly sample: _angular_core.InputSignal<string | null>;
+    protected readonly store: RibbonEditorStore;
+    protected readonly texts: EditorText;
+    /** The Help menu and its window (it closes with the editor). */
+    private readonly help;
+    private readonly engine;
+    protected readonly layout: GfyDockContainerNodeInput;
+    protected readonly windowsKey = "gfy-ribbon-editor:windows";
+    constructor();
+    /** The sample to start with is an input, so it is known only now (the store started before it). */
+    ngOnInit(): void;
+    /**
+     * Every change of the windows is kept at once. The engine saves by itself only when the automatic saving of the page is on (`GfyEngineSettings.autoSaveLayout`, off by default), a setting of the
+     * whole page that the editor leaves to the application that shows it.
+     */
+    protected saveWindows(): void;
+    /**
+     * The windows of the View menu: each one checked while it is open (docked or floating), and a click closes an open one or opens a closed one again at its place (the View menu of the engine,
+     * `GfyViewTabs`, which follows the tabs as they open and close).
+     */
+    private windowItems;
+    private resetLayout;
+    /** The menus are computed, so the items follow the state. */
+    protected readonly menus: _angular_core.Signal<GfyMenu[]>;
+    /** The title of the document in the menu bar: its file of the project, or where it came from (a new one, a sample, a file of the computer, the clipboard), with a dot while it has changes. */
+    protected readonly title: _angular_core.Signal<DocumentTitle>;
+    protected readonly statusItems: _angular_core.Signal<GfyStatusItem[]>;
+    protected onFileDragOver(event: DragEvent): void;
+    protected onFileDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonEditor, "ribbon-editor", never, { "hosted": { "alias": "hosted"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; "sample": { "alias": "sample"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** `roles`: panels of documents and of tools (the default of the engine). `free`: any tab goes to any panel and the panels have the neutral role `panel` (`dockingMode` of the engine). */
+type DockingMode = 'roles' | 'free';
+/** The options of the engine that change what a layout means. */
+interface LayoutOptions {
+    dockingMode: DockingMode;
+}
+
+/** What a file says besides the layout. */
+interface FileSettings {
+    readonly options: LayoutOptions;
+    readonly components: readonly string[];
+}
+
+/** What goes with the layout besides the nodes, and is a step of undo as well: the docking mode and the keys of the components the application registers. */
+type Settings = FileSettings;
+/** What a step of undo brings back: the layout (always a container), its options and its components. */
+interface Snapshot extends Settings {
+    readonly root: JsonObject;
+}
+interface EditorState$1 {
+    /** The layout with its options and components, and the steps before and after it. */
+    readonly history: History<Snapshot>;
+    /** What the reading of the file that was loaded let pass although JSON does not (comments, single quotes, a declaration around the layout, ...). It is gone with the next change. */
+    readonly notes: readonly JsonErrorInfo[];
+    /** The container, panel or tab that is selected. */
+    readonly selected: JsonPath | null;
+    /** The step that was loaded or saved last (a download of the file): the document is modified while the present step is another one. */
+    readonly saved: Snapshot;
+}
+
+/** What the preview measured of a node, along the split of its parent (the width in a row, the height in a column). */
+interface Measure {
+    /** The length in pixels. */
+    readonly px: number;
+    /** The share of the container in percent. */
+    readonly percent: number;
+    /**
+     * The ratio that gives the node the same length beside its siblings that have a ratio: the ratios share what the lengths leave, so it is the length of the node in the ratio of their sum to
+     * their length on the screen. Missing when no open sibling has a ratio (the node would take all that is left whatever its number is).
+     */
+    readonly ratio?: number;
+}
+
+type NodeKind = 'container' | 'panel' | 'tab';
+/**
+ * The four kinds of tab a layout can hold, told by what the engine does with the tab:
+ *  - `html`: the tab has HTML content (`content`);
+ *  - `component`: a component of the application, found by its `componentKey` and given its `inputs`;
+ *  - `element`: a custom element, made from its `componentTag` with `document.createElement`, given its `componentProps` (`kind: 'component'`);
+ *  - `callback`: the content comes from a callback of the application (`serialize: 'callback'` and `callback`), which gives HTML or a component.
+ */
+type TabKind = 'html' | 'component' | 'element' | 'callback';
+
+type TabRole = 'document' | 'tool';
+/** The side of a node where a new panel goes. */
+type PanelSide = 'left' | 'right' | 'top' | 'bottom';
+
+/** A row of the inspector. It has the shape of `GfyProperty` of the property grid. */
+interface InspectorRow$1 {
+    id: string;
+    /** The name of the property the row writes, as it stands in the JSON (`allowDetachOnDrag`), not a translation of it: this is a tool for developers. A row that the editor adds is named like its id. */
+    label: string;
+    kind: 'text' | 'number' | 'boolean' | 'select';
+    category: string;
+    description: string;
+    options?: readonly {
+        value: string;
+        label: string;
+    }[];
+    min?: number;
+    max?: number;
+    step?: number;
+    decimals?: number;
+    placeholder?: string;
+    defaultValue?: unknown;
+    /** The property holds code of the application (`{"$expr": "..."}`): the row is a text row that shows the code with a `=` in front. */
+    code?: boolean;
+    /** The row cannot be changed (it is grey): the shell where a shell is not possible; the description says why. */
+    disabled?: boolean;
+    /** The row always has a value (the type of the engine requires the property, or it is the kind of a tab): it has no "not set", and the reset button of the Inspector does not take it out. */
+    required?: boolean;
+}
+/** The part of a tab that has an editor of its own under the rows: a text (HTML) or an object (JSON). */
+interface InspectorPart {
+    /** The property of the tab it is: `content`, `inputs`, `componentProps` or `callback`. */
+    key: string;
+    label: string;
+    description: string;
+    language: 'html' | 'json';
+    /** What the editor shows. */
+    text: string;
+}
+interface Inspector$1 {
+    kind: NodeKind;
+    path: JsonPath;
+    /** The rows, in the order of the categories. */
+    rows: InspectorRow$1[];
+    /** The values of the rows, by the id of the row. A property that is not set is missing. */
+    values: Record<string, unknown>;
+    /** The kind of a tab (`undefined` for the other nodes). */
+    tabKind: TabKind | undefined;
+    /** The part of a tab (`null` for the other nodes). */
+    part: InspectorPart | null;
+}
+
+/** Where the nodes of the preview came from: the path of the node with the number `n` is `paths[n]`. */
+interface PreviewLinks {
+    readonly paths: readonly JsonPath[];
+}
+/** What `mergeBack` reads of a tab of the engine. */
+interface EngineTabLike {
+    readonly id?: string;
+    readonly tag?: string;
+}
+/** What `mergeBack` reads of a node of the engine (`GfyDockContainerNode` and `GfyDockPanelNode` have these properties). */
+interface EngineNodeLike {
+    readonly id?: string;
+    readonly type: string;
+    readonly tag?: string;
+    readonly role?: string;
+    readonly size?: number;
+    readonly sizeUnit?: string;
+    /** Whether the user can resize the node: the engine moves it with the place of a node (a line it makes around a node takes it over, a node that takes the place of its container gets the container's). */
+    readonly resizable?: boolean;
+    /** The size while no sibling is collapsed: the size the node has in the layout (see `_baseSize` of the engine). */
+    readonly _baseSize?: number;
+    readonly collapsed?: boolean;
+    readonly activeTab?: number;
+    readonly children?: readonly EngineNodeLike[];
+    readonly tabs?: readonly EngineTabLike[];
+}
+
+/** The kinds of text the output window can show. */
+type OutputKind$1 = 'file' | 'json' | 'typescript' | 'template' | 'loader';
+/** A problem of the list: the problem of the list of the library, and the node it is about (a note on the reading of the file is about none). */
+interface EditorProblem$1 extends GfyProblem {
+    readonly nodePath: JsonPath | null;
+}
+/** What the commands that need a selected node can do now. */
+interface Capabilities$1 {
+    readonly remove: boolean;
+    readonly duplicate: boolean;
+    readonly moveUp: boolean;
+    readonly moveDown: boolean;
+}
+declare class LayoutEditorStore {
+    private readonly toast;
+    private readonly box;
+    private readonly icons;
+    /** The files of the project, while the application gives the editor a place for them (the input `files` of the editor): File > Open from the project…, Save and Save as…. */
+    readonly project: EditorProject;
+    /** The editor starts with an empty layout (the samples are in File > Samples); with Auto save on, what was kept in the browser replaces it (see `restore`). */
+    readonly state: _angular_core.WritableSignal<EditorState$1>;
+    readonly root: _angular_core.Signal<JsonObject>;
+    readonly notes: _angular_core.Signal<readonly JsonErrorInfo[]>;
+    readonly selected: _angular_core.Signal<JsonPath | null>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    /** The document (the layout, its options and its components) has been changed since it was loaded or downloaded. */
+    readonly modified: _angular_core.Signal<boolean>;
+    /** The docking mode the layout is made for, and the keys of the components the application registers: steps of undo, like the layout. */
+    readonly options: _angular_core.Signal<LayoutOptions>;
+    readonly components: _angular_core.Signal<readonly string[]>;
+    /** The whole file as text: the options, the components and the layout. */
+    readonly file: _angular_core.Signal<string>;
+    /** The shell is locked in the preview, as it is in the application (the default); off, tabs can be docked into the shell there too. A setting of the editor, not part of the document. */
+    readonly lockShell: _angular_core.WritableSignal<boolean>;
+    /**
+     * Counts the changes of the layout that the preview did not make itself: the preview is built again from the layout when it changes. What the user does in the preview is written into the layout
+     * (`mergeFromPreview`) and does not count, so the preview stays as it is while it is used.
+     */
+    readonly previewRevision: _angular_core.WritableSignal<number>;
+    /** The number of the times a change of a row was refused: the inspector shows its rows again then (a field would keep the value that was typed). */
+    readonly refusals: _angular_core.WritableSignal<number>;
+    readonly outputKind: _angular_core.WritableSignal<OutputKind$1>;
+    readonly status: _angular_core.WritableSignal<string>;
+    /** File > Auto save: the file is kept in the browser while it is edited and comes back at the next visit. Off by default, and a setting of the editor (not part of the document, not a step of undo). */
+    readonly autoSave: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** Turns Auto save on or off. Off: what was kept of the document goes at once. On: the document is kept from now on. */
+    setAutoSave(on: boolean): void;
+    private readAutoSave;
+    /**
+     * The file that was kept (Auto save on) replaces the empty layout; one that was not saved after its last change comes back with its changes not saved, and with the file of the project it belongs to.
+     * A text that cannot be read is left alone. Gives whether a file came back.
+     */
+    private restore;
+    /** The editor has nothing but the empty layout it started with: no editor of the application came back, Auto save brought nothing, and nothing has been done since. */
+    private fresh;
+    /**
+     * Starts with a sample of File > Samples instead of the empty layout (the input `sample` of the editor: Gridify Designer gives one), with the docking mode and the components it is made for, and the
+     * status bar says where the help is. Only while the editor is fresh: a layout that came back, or one that was loaded or changed, stays.
+     */
+    startWith(id: string): void;
+    /** Auto save could not keep the text of the file (no room, or no storage): its changes are nowhere else, so leaving the page is asked about as without Auto save. */
+    private notKept;
+    /**
+     * Keeps the text of the file, whether it is the one that was saved last (`modified`: it is not), and the file of the project it belongs to. When the browser does not keep it, `tell` says so
+     * (once, not for every change).
+     */
+    private saveText;
+    private forgetText;
+    /** The inspector of the selected node. */
+    readonly inspector: _angular_core.Signal<Inspector$1 | null>;
+    /** The properties of the selected node that the rows of the inspector do not hold. */
+    readonly otherProperties: _angular_core.Signal<JsonObject>;
+    /** A command is offered where it does something: the same commands are tried on the layout, and one that would be refused (or would change nothing) is grey. */
+    readonly capabilities: _angular_core.Signal<Capabilities$1>;
+    /** The problems, for the list: what the reading of the file let pass although JSON does not, and what the check of the layout finds. */
+    readonly problems: _angular_core.Signal<EditorProblem$1[]>;
+    /** The counts of the panels and the tabs, for the status bar. */
+    readonly counts: _angular_core.Signal<{
+        panels: number;
+        tabs: number;
+    }>;
+    /** The keys of the components that the application registers: those of the Options, then the others that the tabs use. */
+    readonly registered: _angular_core.Signal<string[]>;
+    /** The text of the output window. */
+    readonly output: _angular_core.Signal<string>;
+    say(text: string): void;
+    private warn;
+    /** Selects a node. */
+    select(path: JsonPath | null): void;
+    /** A problem of the list was opened: the node it is about is selected. */
+    openProblem(problem: EditorProblem$1): void;
+    /** A change that does not come from the preview: the layout is the new one, and the preview is built from it. */
+    private replaceState;
+    /** Takes the result of a command as a step of the document. Gives whether the layout changed (a command that could do nothing says nothing). */
+    private run;
+    /**
+     * What the user did in the preview (a splitter dragged, a tab moved, a panel collapsed, another tab shown) is written into the layout. `base` and `links` are what the preview was made from (see
+     * `mergeBack`); the result is the whole state of the preview, not a step on the layout as it is now. The preview is not built again. Gives whether the layout changed.
+     */
+    mergeFromPreview(base: JsonValue, links: PreviewLinks, engine: EngineNodeLike | null, mergeKey: string): boolean;
+    /** The measure the preview takes of a node (its size on the screen), for the change of the unit of its size; set by the window of the preview. */
+    private measurer;
+    setMeasurer(measurer: ((path: JsonPath) => Measure | undefined) | null): void;
+    /** A new empty tab, HTML or a component, for documents or for tools: in the selected panel, or the first one that takes the role, or in a new panel. */
+    addTab(kind: TabKind, role: TabRole): void;
+    /** A new panel with a new tab (a component), for documents or for tools, on a side of the selected node. A side where the panel would stand outside the shell is refused. */
+    addPanel(role: TabRole, side: PanelSide): void;
+    /** Can a panel go on that side of the selected node (the menus grey the sides that cannot)? */
+    canAddPanel(role: TabRole, side: PanelSide): boolean;
+    removeSelected(): void;
+    duplicateSelected(): void;
+    moveSelected(delta: number): void;
+    /**
+     * The user changed a row of the inspector. The shell may be refused (it has rules), a fixed role and a collapse that the engine would undo are refused too; the unit of a size keeps the room the
+     * node has now, as the preview measured it. A change after which the engine would tidy the layout (a container merged into the one around it) is tidied at once, and the user is told.
+     */
+    changeRow(id: string, value: unknown): void;
+    /** The text of the "other properties" of the selected node; gives the reason when it cannot be used. */
+    setOtherProperties(text: string): string | null;
+    /** The text of the part of the selected tab (its HTML, inputs, properties or callback); gives the reason when it cannot be used. */
+    setPart(text: string): string | null;
+    /**
+     * The docking mode the layout is made for (the Options window). The roles of the panels go with it, in the same step of undo (`convertRoles`): the neutral role `panel` in the free mode, the
+     * role of their tabs in the mode with roles (a panel that holds both is left as it is, and the Problems window says where). The free mode keeps no empty panel either: the engine takes them
+     * out when it shows the layout, and so does the editor.
+     */
+    setDockingMode(mode: DockingMode): void;
+    /** The keys of the components the application registers (the Options window), from the text typed: separated by commas, spaces or lines. */
+    setComponents(text: string): void;
+    undo(): void;
+    redo(): void;
+    /** Is it all right to replace the document that is being edited? A document that was changed since it was loaded or saved is asked about. */
+    private mayReplace;
+    /** A new document: an empty layout with the default docking mode and no components, and nothing to undo. A document that was changed is asked about first. */
+    newLayout(): Promise<void>;
+    loadSample(id: string): Promise<void>;
+    /**
+     * A text from outside (a file, the clipboard, a drop) replaces the layout. The file of the editor brings its options and its components with it; a bare layout leaves the ones that are set. A text
+     * that cannot be read is not loaded: the user is told where it goes wrong, and the layout stays. Gives whether the text was loaded (the user may also keep the layout that was changed). `name` is
+     * what the messages call it, `origin` where it came from (by default a file of that name), for the title in the menu bar.
+     */
+    loadFromText(text: string, name: string, origin?: DocumentOrigin): Promise<boolean>;
+    /** File > Open from the project…: a file of the project replaces the layout (as a file of the computer does), and the layout belongs to it then: Save writes it back there. */
+    openFromProject(): Promise<void>;
+    /** File > Save: the file goes back into the file of the project that it belongs to (a layout that belongs to none asks where, as Save as… does). The layout is saved then, as after a download. */
+    saveToProject(): Promise<void>;
+    /** File > Save as…: the file goes into a file of the project that the user chooses, and belongs to it from then on. */
+    saveToProjectAs(): Promise<void>;
+    /** Asks for a file and loads it. */
+    openFile(): void;
+    pasteLayout(): Promise<void>;
+    copyOutput(): Promise<void>;
+    /**
+     * Offers the file of the editor (the options, the components and the layout) for download. The document is saved then (it is not modified until the next change), unless it belongs to a file of the
+     * project: then the download is a copy, and the document is saved by Save.
+     */
+    downloadFile(): void;
+    private downloaded;
+    /** Offers what the output window shows as a file. */
+    downloadOutput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutEditorStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LayoutEditorStore>;
+}
+
+/**
+ * An editor of the layout of the docking engine. Its file holds the value that goes into `[defaultLayout]` of `<gfy-docking-engine>` (a container with panels and tabs) with the docking mode and the
+ * components it is made for: it is opened from a file or the clipboard (a bare layout is read as well) or started empty, edited in the outline, the preview and the inspector, and taken out as the file, as
+ * JSON, as TypeScript, as the template and as the code that loads it. The state is in `LayoutEditorStore`, which this component provides (so every instance has its own), and the windows only read it
+ * and call its commands. An application that gives it the files of a project (`files`) gets File > Open from the project…, Save and Save as… besides. The editor is English only.
+ */
+declare class LayoutEditor implements OnInit {
+    /**
+     * The editor is shown by an application that has its own header with the name and the choice of the theme and the density (the application that switches between the editors): the editor then leaves
+     * its own name and its own choice out of the menu bar, and it fills the place it is given instead of the whole window. Every editor of the application takes this input.
+     */
+    readonly hosted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The files of a project (a folder of the computer, a server, a place of the application: see `GfyEditorFiles`): File > Open from the project… opens a layout of the project, Save writes it back
+     * (when the file is still the one that was opened), Save as… writes it under another name. Without them (the default) the editor opens a file of the computer and offers the layout for download, as
+     * it always did.
+     */
+    readonly files: _angular_core.InputSignal<GfyEditorFiles | null>;
+    /**
+     * The id of a sample of File > Samples that the editor starts with when it has nothing else to show (no layout that the application left in it, nothing that Auto save kept). Without it the
+     * editor starts with an empty layout; Gridify Designer gives `ide`, the workbench. A layout that came back stays.
+     */
+    readonly sample: _angular_core.InputSignal<string | null>;
+    protected readonly store: LayoutEditorStore;
+    /** The Help menu and its window (it closes with the editor). */
+    private readonly help;
+    private readonly engine;
+    protected readonly layout: GfyDockContainerNodeInput;
+    /** The places of the windows are kept in the browser by the engine of the editor (the engine of the Preview keeps nothing), and come back at the next visit. */
+    protected readonly windowsKey = "gfy-layout-editor:windows";
+    constructor();
+    /** The sample to start with is an input, so it is known only now (the store started before it). */
+    ngOnInit(): void;
+    /**
+     * Every change of the windows is kept at once. The engine saves by itself only when the automatic saving of the page is on (`GfyEngineSettings.autoSaveLayout`), a setting of the whole page
+     * that the editor leaves to the application that shows it.
+     */
+    protected saveWindows(): void;
+    /**
+     * The windows of the View menu: each one checked while it is open (docked or floating), and a click closes an open one or opens a closed one again at its place (the View menu of the engine,
+     * `GfyViewTabs`, which follows the tabs as they open and close).
+     */
+    private windowItems;
+    /** The windows go back to where they are at the start (the engine forgets the places it kept). */
+    private resetWindows;
+    /** The menus are computed, so the items follow the state. */
+    protected readonly menus: _angular_core.Signal<GfyMenu[]>;
+    /** The title of the document in the menu bar: its file of the project, or where it came from (a new one, a sample, a file of the computer, the clipboard), with a dot while it has changes. */
+    protected readonly title: _angular_core.Signal<DocumentTitle>;
+    protected readonly statusItems: _angular_core.Signal<GfyStatusItem[]>;
+    protected onFileDragOver(event: DragEvent): void;
+    protected onFileDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutEditor, "layout-editor", never, { "hosted": { "alias": "hosted"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; "sample": { "alias": "sample"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type FormFile = GfyFormLayoutFile;
+type FormElement = GfyFormElement;
+type FormPlace = GfyFormPlace;
+/** A rectangle of cells: the first column and row (from 1) and how many it covers. */
+interface Cells {
+    readonly col: number;
+    readonly row: number;
+    readonly colSpan: number;
+    readonly rowSpan: number;
+}
+
+/** What the Inspector shows while no element is selected: the variant that is edited, its form, or the file. */
+type Scope = 'variant' | 'form' | 'file';
+interface Selection {
+    /** The form that is edited. */
+    readonly form: string;
+    /** The variant of it that is edited, by its `minWidth`. */
+    readonly minWidth: number;
+    /** The selected elements of the form, the one the Inspector shows first. */
+    readonly names: readonly string[];
+    readonly scope: Scope;
+}
+interface EditorState {
+    readonly history: History<FormFile>;
+    readonly selection: Selection;
+    /** What the reading of the file that was loaded let pass or mended; it is gone with the next change. */
+    readonly notes: readonly JsonErrorInfo[];
+    /** The file as it was loaded or saved last: the document is modified while the present one is another. */
+    readonly saved: FormFile;
+}
+
+/** A layer an element is shown in: the group of layers and the layer (a page of a property sheet is a layer of the group named by its sheet). */
+interface LayerRef {
+    readonly group: string;
+    readonly layer: string;
+    /** The layer is the one that is shown while nothing else is chosen: the first one of its group (the first page that has a place, for a sheet). */
+    readonly first: boolean;
+}
+/** An element of a form in one variant. */
+interface Placed {
+    readonly name: string;
+    readonly element: FormElement;
+    /** The group it is in, `null` at the top of the form. */
+    readonly parent: string | null;
+    readonly depth: number;
+    /** Its number in the order of the page, from 0. */
+    readonly order: number;
+    /** Its place in the variant: counted in the cells of its group, or of the grid. */
+    readonly place: FormPlace | null;
+    /** Its cells in the grid of the variant; `null` when it has no place, or a group around it has none. */
+    readonly cells: Cells | null;
+    /** The cells its place is counted in (and has to lie in): the cells of its group, or the whole grid; `null` when the group has no place. */
+    readonly bounds: Cells | null;
+    /** Its own layer and those of the groups around it, and the page it is in. */
+    readonly layers: readonly LayerRef[];
+}
+/** The edge cells of a container that its frame (or the tabs of a sheet) takes: how many rows and columns on each side its elements leave free. */
+interface Insets {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+
+/** The form and the variant that the editor works on. */
+interface Ctx {
+    readonly form: string;
+    readonly minWidth: number;
+}
+/** Where an element goes: a list (`parent`) and the cells of the grid of the variant that is edited. */
+interface Move {
+    readonly name: string;
+    readonly parent: string | null;
+    readonly cells: Cells;
+}
+/** How elements are lined up with the first selected one: an edge or the middle across or down, or its width, its height or both. */
+type AlignHow = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom' | 'width' | 'height' | 'size';
+/** The empty tracks at the edges of a variant. */
+interface EmptyEdges {
+    readonly top: number;
+    readonly bottom: number;
+    readonly left: number;
+    readonly right: number;
+}
+
+type ToolId = 'text-field' | 'text-area' | 'password' | 'date' | 'select' | 'combobox' | 'checkbox' | 'radio-group' | 'switch' | 'spinner' | 'button' | 'styled-button' | 'split-button' | 'dropdown-button' | 'time' | 'date-time' | 'mask' | 'multi-select' | 'tags' | 'slider' | 'toggle-group' | 'color' | 'file-upload' | 'picture' | 'gallery' | 'display' | 'own' | 'separator' | 'label-above' | 'label-beside' | 'label' | 'caption' | 'text' | 'group-box' | 'group' | 'property-sheet' | 'repeated-group' | 'subform';
+
+/** A row of the Inspector, in the shape of `GfyProperty` of the property grid. */
+interface InspectorRow {
+    readonly id: string;
+    /** The name of the property as the file has it: this is a tool for developers. */
+    readonly label: string;
+    readonly kind: 'text' | 'number' | 'boolean' | 'select' | 'readonly';
+    readonly category: string;
+    readonly description: string;
+    readonly options?: readonly {
+        value: unknown;
+        label: string;
+    }[];
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly unit?: string;
+    readonly placeholder?: string;
+    readonly defaultValue?: unknown;
+    readonly disabled?: boolean;
+}
+interface Inspector {
+    readonly kind: 'element' | 'elements' | 'variant' | 'form' | 'file';
+    /** What is inspected, for the head of the window: the kind and the name. */
+    readonly title: string;
+    readonly subtitle: string;
+    readonly rows: InspectorRow[];
+    readonly values: Record<string, unknown>;
+}
+/** The columns or the rows of the variant that are selected (a click on a number in the Editor; Shift and a click or a drag over the numbers: a range; Ctrl and a click: one more or one less). */
+interface TrackRef {
+    readonly axis: 'col' | 'row';
+    /** The numbers of the tracks, from 1, in the order of the grid; one at least. */
+    readonly indices: readonly number[];
+}
+
+/** What a problem is about: the form, the variant and the element (each when the problem names it). */
+interface ProblemTarget {
+    readonly form?: string;
+    readonly minWidth?: number;
+    readonly element?: string;
+}
+/** A problem of the list (the shape of `GfyProblem` of the problem list of the library), with what it leads to. */
+interface EditorProblem {
+    readonly id: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly code: string;
+    readonly message: string;
+    /** Where, as the column of the list shows it: the form, the variant and the element. */
+    readonly file: string;
+    /** The path in the file (the tooltip). */
+    readonly path: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly target: ProblemTarget | null;
+}
+
+/** The kinds of text the Output window can show. */
+type OutputKind = 'file' | 'template' | 'component';
+/** Where an element that the variant does not place is dropped from its node in the Outline: the Editor (the pointer in the coordinates of the window). */
+interface PlaceTarget {
+    /** The pointer is here: the frame shows where the element would go (green on free cells; none off the paper). */
+    over(name: string, clientX: number, clientY: number): void;
+    /** Dropped here: placed on free cells (on taken ones the Editor says why not; off the paper nothing happens). */
+    drop(name: string, clientX: number, clientY: number): void;
+    /** The drag ended elsewhere, or was given up: the frame goes. */
+    leave(): void;
+}
+/** The settings of the Editor and the Preview that are not part of the file (no step of undo): kept for the next store, not in the file. */
+interface ViewState {
+    /** The active layer of each group of layers, by the form. */
+    readonly layers: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    /** The page shown in each property sheet, by the form. */
+    readonly pages: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    /** The layer that new elements get, by the form (none when missing). */
+    readonly newLayer: Readonly<Record<string, string>>;
+    /** The width the Editor draws the variant at, in px; `null` fits it to the window (within the widths of the variant). */
+    readonly designWidth: number | null;
+    /** The lines of the cells are drawn. */
+    readonly showGrid: boolean;
+    /** The width of the form in the Preview, in px; `null` fits the window. */
+    readonly previewWidth: number | null;
+    /** The Preview takes the width the Editor draws the form at (its own slider, Fit and right edge are off then). */
+    readonly previewFollows?: boolean;
+}
+/** What the commands that need a selection can do now (the menus grey the others). */
+interface Capabilities {
+    readonly remove: boolean;
+    readonly duplicate: boolean;
+    readonly copy: boolean;
+    readonly paste: boolean;
+    readonly wrap: boolean;
+    readonly unwrap: boolean;
+    readonly unplace: boolean;
+    readonly addLabel: boolean;
+    /** Two elements or more are selected and the first of them has a place in the variant: the others can be lined up with it. */
+    readonly align: boolean;
+}
+declare class FormEditorStore {
+    private readonly toast;
+    private readonly box;
+    private readonly dialogs;
+    private readonly icons;
+    /** The files of the project, while the application gives the editor a place for them (the input `files` of the editor): File > Open from the project…, Save and Save as…. */
+    readonly project: EditorProject;
+    readonly state: _angular_core.WritableSignal<EditorState>;
+    readonly file: _angular_core.Signal<_gridify_studio.GfyFormLayoutFile>;
+    readonly selection: _angular_core.Signal<Selection>;
+    readonly selected: _angular_core.Signal<readonly string[]>;
+    readonly notes: _angular_core.Signal<readonly JsonErrorInfo[]>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    readonly modified: _angular_core.Signal<boolean>;
+    /** The text of the file. */
+    readonly fileText: _angular_core.Signal<string>;
+    /** The form that is edited and its variant. */
+    readonly form: _angular_core.Signal<_gridify_studio.GfyFormDefinition | undefined>;
+    readonly variant: _angular_core.Signal<_gridify_studio.GfyFormVariant | undefined>;
+    readonly variants: _angular_core.Signal<_gridify_studio.GfyFormVariant[]>;
+    /** The division of the file (as the library reads it: a whole number from 1 to 4, else the default). */
+    readonly division: _angular_core.Signal<number>;
+    readonly ctx: _angular_core.Signal<Ctx>;
+    readonly view: _angular_core.WritableSignal<ViewState>;
+    readonly outputKind: _angular_core.WritableSignal<OutputKind>;
+    readonly status: _angular_core.WritableSignal<string>;
+    /** Counts the times a window asked the Editor to take the focus (the Toolbox after a click adds a tool). */
+    readonly focusEditor: _angular_core.WritableSignal<number>;
+    readonly autoSave: _angular_core.WritableSignal<boolean>;
+    /** The tool that is dragged from the Toolbox (the Editor sizes its mark by it). */
+    readonly dragTool: _angular_core.WritableSignal<ToolId | null>;
+    /** The Editor, while it is shown: an element that the variant does not place, dragged from its node in the Outline, is dropped there. */
+    placeTarget: PlaceTarget | null;
+    /** The variant whose Inspector is shown (`form|minWidth`; empty while the Inspector shows the form or the file): the columns or the rows that are selected belong to it. */
+    private readonly trackScope;
+    /** The columns or the rows whose numbers were selected, with the variant they belong to. */
+    private readonly chosenTrack;
+    /**
+     * The columns or the rows whose numbers are selected in the Editor (a click, Shift or Ctrl and a click, a drag over the numbers): the Inspector of the variant shows their size. They belong to
+     * the variant that was edited then: another form or variant, or the Inspector of the form or the file, has none. An edit keeps them.
+     */
+    readonly track: _angular_core.Signal<TrackRef | null>;
+    /** The widths of the columns as the Editor draws the variant now, in px (the Editor tells them): what Keep their width writes. */
+    readonly drawnColumns: _angular_core.WritableSignal<readonly number[]>;
+    /** The width the Editor draws the form at, in px (the Editor tells it while it has a size; `null` before it was drawn): what the Preview takes when it follows the Editor. */
+    readonly editorWidth: _angular_core.WritableSignal<number | null>;
+    /** The mode in which a click on the elements gives them the order of the page, one after another (Set tab order). */
+    readonly tabOrderMode: _angular_core.WritableSignal<boolean>;
+    /** In the mode of the order of the page: where the next click puts an element in each list. */
+    private tabCounters;
+    /** The elements that were clicked since the mode of the order of the page was turned on: the Editor marks them (their numbers in the color of the selection). */
+    readonly tabOrdered: _angular_core.WritableSignal<ReadonlySet<string>>;
+    /** Counts the refusals of a change of a row: the Inspector shows its rows again then (a field would keep what was typed). */
+    readonly refusals: _angular_core.WritableSignal<number>;
+    /** The element whose text is edited in the Editor itself (a double click). */
+    readonly editingText: _angular_core.WritableSignal<string | null>;
+    /** The text that is edited in place is the caption of a control (a check box, a switch, a button: `preview.props.label`), not the name of the input. */
+    readonly editingCaption: _angular_core.WritableSignal<boolean>;
+    private readonly clipboard;
+    /** Every element of the form in the variant. */
+    readonly placed: _angular_core.Signal<Placed[]>;
+    readonly placedByName: _angular_core.Signal<Map<string, Placed>>;
+    /** The active layer of every group of the form, and the page of every property sheet (a page is a layer of the group named by its sheet). */
+    readonly active: _angular_core.Signal<Record<string, string>>;
+    /** The elements that the Editor draws: they have cells and their layers and pages are the active ones. */
+    readonly visible: _angular_core.Signal<Set<string>>;
+    /** The elements that have no place in the variant though their list has one: the strip under the grid offers them. */
+    readonly unplaced: _angular_core.Signal<Placed[]>;
+    /** The layer new elements get (in the form that is edited). */
+    readonly newLayer: _angular_core.Signal<string>;
+    /** The width the Editor draws the variant at when it is not fitted to the window (`null`: fit). */
+    readonly designWidth: _angular_core.Signal<number | null>;
+    /** The narrowest a form of the file gets (`minFormWidth`), in px; 0 for no limit. */
+    readonly minFormWidth: _angular_core.Signal<number>;
+    /** The widths the variant is used for: from its `minWidth` up to the next variant (or without an end). */
+    readonly variantRange: _angular_core.Signal<{
+        from: number;
+        to: number | null;
+    }>;
+    /** The file as the library loads it (the texts with code show their first text), for the Problems and the Preview. */
+    readonly loaded: _angular_core.Signal<_gridify_studio.GfyFormLoadResult>;
+    readonly layout: _angular_core.Signal<GfyFormLayout | null>;
+    /** The problems: what the reading of the file mended, what the library reports and what the editor checks. */
+    readonly problems: _angular_core.Signal<EditorProblem[]>;
+    /** The problems of each element of the form that is edited, the worst first (the Outline and the Editor mark them). */
+    readonly problemsByElement: _angular_core.Signal<Map<string, "error" | "warning">>;
+    readonly inspector: _angular_core.Signal<Inspector | null>;
+    readonly output: _angular_core.Signal<string>;
+    readonly capabilities: _angular_core.Signal<Capabilities>;
+    /** The forms a subform of the form that is edited can place. */
+    readonly subformTargets: _angular_core.Signal<string[]>;
+    constructor();
+    setAutoSave(on: boolean): void;
+    private readAutoSave;
+    /**
+     * The file that was kept (Auto save on), or the contact sample when none can be read; a file that was not saved after its last change comes back with its changes not saved, and with the file of the
+     * project it belongs to.
+     */
+    private restore;
+    /** The editor starts with the contact sample (an empty file when there is none). */
+    private startWithSample;
+    /** The sample the editor started with while nothing else has come or been done: no editor of the application came back, Auto save brought nothing, nothing was changed. */
+    private fresh;
+    /**
+     * Starts with another sample of File > Samples (the input `sample` of the editor: Gridify Designer gives one), and the status bar says where the help is. Only while the editor shows the sample it
+     * started with and nothing was done: a form layout that came back, or one that was loaded or changed, stays.
+     */
+    startWith(id: string): void;
+    /** Auto save could not keep the text of the file (no room, or no storage): its changes are nowhere else, so leaving the page is asked about as without Auto save. */
+    private notKept;
+    /**
+     * Keeps the text of the file, whether it is the one that was saved last (`modified`: it is not), and the file of the project it belongs to. When the browser does not keep it, `tell` says so
+     * (once, not for every change).
+     */
+    private saveText;
+    private forgetText;
+    say(text: string): void;
+    warn(text: string, id?: string): void;
+    /** Selects elements of the form that is edited (`[]` selects nothing: the Inspector shows the variant). An element in a layer or a page that is not shown is shown. */
+    select(names: readonly string[], scope?: Scope): void;
+    /** Adds an element to the selection or takes it out (Ctrl and a click). */
+    toggle(name: string): void;
+    /** Adds elements to the selection after what is selected (the rectangle of Shift or Ctrl and a drag), so the first selected element stays the one the others are lined up with. */
+    addToSelection(names: readonly string[]): void;
+    selectForm(name: string, scope?: Scope): void;
+    /** Edit the layers… of the menus: the Inspector shows the form, whose row `layers` holds its groups of layers, and the status bar says how they are written. */
+    editLayers(): void;
+    /** The subform whose form was opened from the Editor: the form it stands in and its name, for the way back. */
+    readonly openedFrom: _angular_core.WritableSignal<{
+        readonly form: string;
+        readonly name: string;
+    } | null>;
+    /** Opens the form a subform places (a double click on it in the Editor); the toolbar and Escape lead back. */
+    openSubform(name: string): void;
+    /** Back from the form of a subform to the form it stands in, with the subform selected. */
+    back(): void;
+    selectVariant(minWidth: number): void;
+    selectFile(): void;
+    /** Selects a column or a row of the variant (a click on its number): the Inspector shows its size. */
+    selectTrack(track: TrackRef | null): void;
+    /** All the elements the Editor draws in a list: the one given (the menu of empty cells: the list of those cells), else the list of the selected element, else the top of the form. */
+    selectAll(list?: string | null): void;
+    /** Shows the layers and the page an element is in, so the Editor draws it. */
+    reveal(name: string): void;
+    /** Chooses the active layer of a group of layers in the Editor and the Preview; the layer of new elements follows when it was a layer of that group. */
+    setLayer(group: string, layer: string): void;
+    /** The layer the elements that are added get (`''`: none). */
+    setNewLayer(layer: string): void;
+    /** Shows a page of a property sheet in the Editor and the Preview (`select`: and selects the page). */
+    showPage(sheet: string, page: string, selectIt?: boolean): void;
+    /** The width the Editor draws the variant at (`null`: Fit); the Editor keeps it within the widths of its slider. */
+    setDesignWidth(width: number | null): void;
+    setShowGrid(on: boolean): void;
+    /** The width of the form in the Preview (`null`: Fit); the Preview keeps it from `minFormWidth` of the file up (without it from 120 px). */
+    setPreviewWidth(width: number | null): void;
+    /** The Preview takes the width of the Editor (`on`), or its own again: then it keeps the width it has (the Editor's), as a Fit that is turned off keeps the width. */
+    setPreviewFollows(on: boolean): void;
+    /** A problem of the list was opened: the form, the variant and the element it is about are selected. */
+    openProblem(problem: EditorProblem): void;
+    /** What a step works on (the form, the variant, the selected elements): steps of one kind on the same things in a row are one step of undo. */
+    private stepKey;
+    /** Makes the step of an operation: a refusal is told, a note is said, the elements it names are selected. Gives whether the file changed. */
+    private run;
+    /** The list a new element goes into when no place is given: the selected group (the page shown in a selected sheet), or the list of the selected element, or the top of the form. */
+    private targetList;
+    /** The page a property sheet shows in the Editor. */
+    shownPageOf(sheet: string): string | null;
+    /** The cells inside the frame of a list: the cells of the group without its edge cells (the grid for the top). */
+    innerCells(parent: string | null): Cells | null;
+    /**
+     * How many columns the tabs at the side of a property sheet take: the library draws them as a bar as thick as a control (the text runs along a tab) with a little room, about 36 px of the
+     * width the Editor draws at.
+     */
+    tabColumns(placed: Placed | null): number;
+    /**
+     * Adds what a tool of the Toolbox makes: on the cells `at` of the grid into the list `parent` (an area drawn in the Editor: the tool takes it), or (without them) into the selected group or
+     * the list of the selected element, under what is in it (a group that is full grows for it; at the top of the form the grid grows down). New elements get the
+     * layer that is chosen for them.
+     */
+    addTool(id: ToolId, at?: {
+        parent: string | null;
+        cells: Cells;
+    } | null, subform?: string): void;
+    /** Adds a tool from a cell of a list (a drop, the menu of an empty cell): in its own size where it is free, else in the nearest free cells (see `toolRoom`). */
+    addToolAtCell(id: ToolId, parent: string | null, cell: {
+        col: number;
+        row: number;
+    }, subform?: string): void;
+    /** The cells of a list that are taken for the elements that are added (those of the layers they can be shown with). */
+    private takenIn;
+    /** The cells of the frame of a group at each edge (a title, the tabs of a sheet; none for a group without a frame and for a page). */
+    insetsOf(name: string): Insets;
+    /** The inside of a list (the cells of a group without its frame; the grid at the top): it may have no rows, when a group is not higher than its frame. */
+    private insideOf;
+    /**
+     * Where a tool goes in a list: from a cell, on the cells there in its own size (kept inside the list) or, where those are taken, the nearest free ones (the same columns further down, then
+     * the first free cells from that row on); without a cell (a click on the tool), under what is in the list, at its left edge. A group without room grows for it: `grow` rows go in at the
+     * bottom of its inside, where the tool goes. At the top of the form it goes under what is there (the grid grows down). `null` when the list has no place.
+     */
+    toolRoom(id: ToolId, parent: string | null, cell: {
+        col: number;
+        row: number;
+    } | null, subform?: string): {
+        cells: Cells;
+        grow: number;
+    } | null;
+    /** Puts what a tool makes on cells of a list; a group grows first by `grow` rows at the bottom of its inside (where the cells are then). */
+    private putTool;
+    /** What the status bar says about the elements that were added (they are selected): their names, and what F2 does with them. */
+    private addedText;
+    /** The cells an element without a place takes from a cell of its list (a drop from the strip under the grid). */
+    unplacedCells(name: string, cell: {
+        col: number;
+        row: number;
+    }): Cells | null;
+    private groupOfLayer;
+    /** A label for the selected input: above it when the row above is free, else before it in its row, else in the first free cells. */
+    addLabel(): void;
+    /** A new page of the property sheet (the selected one, or the one the selected page is in), shown at once. */
+    addPage(sheet: string): void;
+    /**
+     * Removes the selected elements from the form, with what is in them, in every variant (Delete, Remove from the form). A toast says from which variants and offers Undo; Shift+Delete
+     * (`unplaceSelected`) only takes them out of the variant that is edited.
+     */
+    removeSelected(): void;
+    /** The toast that offers to undo the last removal, and the file the removal left: its Undo undoes that step only, and it goes when the file changes otherwise. */
+    private removal;
+    private undoRemoval;
+    duplicateSelected(): void;
+    copySelected(): boolean;
+    cutSelected(): void;
+    /** Puts what was copied into the selected group (or the list of the selected element): where it was when that is the list it came from and the cells are free, else in the nearest free room. */
+    paste(at?: {
+        parent: string | null;
+        col: number;
+        row: number;
+    }): void;
+    /** Moves the selected elements with the arrows (with Shift they stretch the selected element). */
+    nudgeSelected(dCol: number, dRow: number): void;
+    /** Makes the selected elements larger or smaller to the right and down by cells (Shift with an arrow): each of them, in one step. */
+    growSelected(dCols: number, dRows: number): void;
+    /** Lines up the selected elements with the first of them (the buttons of the Editor, the Arrange menu, Ctrl and an arrow): one step of undo; what stayed where it was is said. */
+    alignSelected(how: AlignHow): void;
+    /** Moves the selected element earlier or later in the order of the page (Alt with Up or Down). */
+    reorderSelected(delta: number): void;
+    /** Elements dragged to other cells (the Editor). */
+    moveElements(moves: readonly Move[]): void;
+    /** An element stretched by its handles (the Editor). */
+    resize(name: string, cells: Cells): void;
+    /** An element moved in the Outline: into another list, or to another place in its own. */
+    moveInTree(name: string, parent: string | null, index: number): void;
+    rename(name: string, next: string): boolean;
+    /** The caption of a control in the Editor (a check box, a switch, a button): `preview.props.label`, which the Preview shows and the template of the Output writes; empty takes it out. */
+    setCaption(name: string, text: string): void;
+    /** What F2 edits in place: the selected element, or the field among a field and its label that were added together. */
+    textTarget(): string | null;
+    /**
+     * Opens the field that edits a text in the Editor itself (F2, a double click, the menus): the text of a static, the title of a group or a page, the caption of a control (`caption`), or the
+     * name. The Editor draws the field on the element, so an element it does not draw in the variant (one the variant does not place, or one in a group it does not place) is edited in the
+     * Inspector: the status bar says so. Gives whether the field opens.
+     */
+    editInPlace(name: string, caption?: boolean): boolean;
+    /** The text of a static or the title of a group typed in the Editor itself (`=code` is code). */
+    setText(name: string, text: string): void;
+    wrapSelected(look: 'none' | 'group-box'): void;
+    unwrapSelected(): void;
+    /** Takes the selected elements out of the variant that is edited (Shift+Delete, Not placed in this variant): they stay in the form and wait in the strip under the grid. */
+    unplaceSelected(): void;
+    /** Gives elements without a place in the variant free cells (the strip under the grid, Place all). */
+    placeUnplaced(names: readonly string[]): void;
+    /** An element without a place dropped on cells of the grid (the strip under the grid). */
+    placeAt(name: string, cells: Cells): void;
+    /** A setting of the place of the selected element (align, justify, flow, tabs). */
+    setPlaceSetting(name: string, key: 'align' | 'justify' | 'flow' | 'tabs', value: unknown): void;
+    setElementProperty(name: string, key: string, value: unknown): void;
+    /** The user changed a row of the Inspector. */
+    changeRow(id: string, value: unknown): void;
+    /** What the status bar says when a row that goes into the file when it is left did (its hint was there: Enter or Tab puts it into the file). */
+    private rowDone;
+    setTabOrderMode(on: boolean): void;
+    /** A new round of the order of the page: no element is clicked yet, and the first click in a list is its number 1. */
+    private newTabRound;
+    /**
+     * The round of the order of the page after a step of undo or redo, which may have taken clicks back: in order are the clicked elements that still stand at the start of their list, one after
+     * another, and the next click in the list comes after them.
+     */
+    private recountTabRound;
+    /** In the mode of the order of the page: the element that is clicked comes next in its list. */
+    clickInTabOrder(name: string): void;
+    /** A new variant from a width, a copy of the one that is edited; it is edited then. */
+    addVariant(minWidth: number): void;
+    /**
+     * Asks for a width of its own (Another width… of the menus of the variants) and adds a variant from it, a copy of the one that is edited. The field starts with the width the Editor is drawn at
+     * when it is chosen inside the widths of the variant, else with the middle of them (a variant without an end: 160 px more than its `minWidth`), when the form has no variant from there yet.
+     */
+    addVariantOfWidth(): Promise<void>;
+    /** The widths offered for a new variant: the usual breakpoints that the form does not have yet. */
+    readonly variantProposals: _angular_core.Signal<number[]>;
+    removeVariant(): Promise<void>;
+    /** Puts columns or rows in before the track `at`. When columns (or rows) are selected, the new ones are selected instead: the numbers of the others move. */
+    insertTrack(axis: 'col' | 'row', at: number, count?: number): void;
+    deleteTrack(axis: 'col' | 'row', at: number): void;
+    /** Takes the columns or the rows out (the menu of the numbers, for all the selected ones). */
+    deleteTracks(axis: 'col' | 'row', indices: readonly number[]): void;
+    /** Gives one size to columns or rows (`null`: the size of the others, 1fr or a row of the grid). */
+    setTrackSizes(axis: 'col' | 'row', indices: readonly number[], size: string | null): void;
+    /** The columns that the selected elements stand on in the variant that is edited (the numbers from 1, in order). */
+    columnsOfSelection(): number[];
+    /**
+     * Keep their width (the menu of an element): the columns of the selected elements get the width they have now in the Editor, in whole px, so the elements keep their width when the form is wider
+     * or narrower (a label stays beside its field). A column that has a size in px keeps it.
+     */
+    keepColumnWidths(columns?: readonly number[]): void;
+    /** Share the width (the menu of an element): the columns of the selected elements are 1fr again, a share of the width as the other columns. */
+    shareColumnWidths(): void;
+    /** Select them (the menu of an element): the columns of the selected elements are selected, and the Inspector has their size. */
+    selectColumnsOfSelection(): void;
+    /** Makes the grid of the variant longer or shorter by rows at the bottom (the handle under the grid). */
+    setRows(rows: number): void;
+    /** The empty rows and columns at the edges of the variant that is edited (the menus of the cells and of the variant trim them). */
+    readonly emptyEdges: _angular_core.Signal<EmptyEdges>;
+    /** Takes the empty rows or columns at the edges of the variant away: at the start (the top, the left), at the end (the bottom, the right), or at both. */
+    trimEdges(axis: 'col' | 'row', start: boolean, end: boolean): void;
+    addForm(): void;
+    removeForm(name: string): Promise<void>;
+    /** A copy of a form after it, under a free name: the copy is selected, and the status bar names it. */
+    duplicateForm(name: string): void;
+    moveForm(name: string, delta: number): void;
+    undo(): void;
+    redo(): void;
+    /** A step of undo or redo: the form and the variant it changed are shown, with the elements whose places it changed selected, so the user sees what came back. */
+    private step;
+    private mayReplace;
+    newFile(): Promise<void>;
+    loadSample(id: string): Promise<void>;
+    /**
+     * A text from outside (a file, the clipboard, a drop) replaces the document; a text that is not a form layout is not loaded, and the user is told where it goes wrong. Gives whether the text was loaded
+     * (the user may also keep the file that was changed). `name` is what the messages call it, `origin` where it came from (by default a file of that name), for the title in the menu bar.
+     */
+    loadFromText(text: string, name: string, origin?: DocumentOrigin): Promise<boolean>;
+    openFile(): void;
+    /** File > Open from the project…: a file of the project replaces the document (as a file of the computer does), and the document belongs to it then: Save writes it back there. */
+    openFromProject(): Promise<void>;
+    /** File > Save: the file goes back into the file of the project that it belongs to (a document that belongs to none asks where, as Save as… does). It is saved then, as after a download. */
+    saveToProject(): Promise<void>;
+    /** File > Save as…: the file goes into a file of the project that the user chooses, and belongs to it from then on. */
+    saveToProjectAs(): Promise<void>;
+    pasteFile(): Promise<void>;
+    copyOutput(): Promise<void>;
+    /** The name the file is downloaded under (and Save as… proposes): the first form's. */
+    private fileName;
+    /** Offers the file for download. It is saved then (not modified until the next change), unless it belongs to a file of the project: then the download is a copy, and the file is saved by Save. */
+    downloadFile(): void;
+    private downloaded;
+    downloadOutput(): void;
+    /** Where the selection is, for the status bar. */
+    readonly where: _angular_core.Signal<string>;
+    /**
+     * The elements that are shown and that some cells touch, in the order of the page: what the menu of an area drawn on the grid selects (Select these), and what the rectangle of Shift or Ctrl
+     * and a drag adds. A piece of an element is enough, and of a group too: a group that the cells touch is taken whole, and then what is in it goes with it (the group is named, not its
+     * elements, so they move together). Only cells that lie in a group, and are less than all of it, take what they touch in it and not the group: a rectangle drawn in a group.
+     */
+    elementsIn(cells: Cells): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormEditorStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormEditorStore>;
+}
+
+/**
+ * The editor of form layouts (`"format": "gfy-form-layout"`): the forms of a file, the elements of each form (texts, places for the controls of an application, groups, subforms) and the variants
+ * that give them their places in cells for the widths from a `minWidth` up. The grid of a variant is edited in the Editor window as `<gfy-form>` lays it out, the Preview shows the form working,
+ * and the file goes to the application (the Output window has the template and a component that loads it). The state is in `FormEditorStore`, which this component provides, and the windows only
+ * read it and call its commands. An application that gives it the files of a project (`files`) gets File > Open from the project…, Save and Save as… besides. The editor is English only.
+ */
+declare class FormEditor implements OnInit {
+    /** The editor is shown by an application with its own header (the one that switches between the editors): it leaves its name and the choice of the theme out, and fills the place it is given. */
+    readonly hosted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The files of a project (a folder of the computer, a server, a place of the application: see `GfyEditorFiles`): File > Open from the project… opens a form layout of the project, Save writes it back
+     * (when the file is still the one that was opened), Save as… writes it under another name. Without them (the default) the editor opens a file of the computer and offers the file for download, as it
+     * always did.
+     */
+    readonly files: _angular_core.InputSignal<GfyEditorFiles | null>;
+    /**
+     * The id of a sample of File > Samples that the editor starts with when it has nothing else to show (no form layout that the application left in it, nothing that Auto save kept). Without it the
+     * editor starts with the contact form; Gridify Designer gives `contact`. A form layout that came back stays.
+     */
+    readonly sample: _angular_core.InputSignal<string | null>;
+    protected readonly store: FormEditorStore;
+    /** The Help menu and its window (it closes with the editor). */
+    private readonly help;
+    private readonly engine;
+    protected readonly layout: GfyDockContainerNodeInput;
+    protected readonly windowsKey = "gfy-form-editor:windows";
+    constructor();
+    /** The sample to start with is an input, so it is known only now (the store started before it). */
+    ngOnInit(): void;
+    protected saveWindows(): void;
+    /**
+     * The windows of the View menu: each one checked while it is open (docked or floating), and a click closes an open one or opens a closed one again at its place (the View menu of the engine,
+     * `GfyViewTabs`, which follows the tabs as they open and close).
+     */
+    private windowItems;
+    private resetWindows;
+    protected readonly menus: _angular_core.Signal<GfyMenu[]>;
+    /** The title of the document in the menu bar: its file of the project, or where it came from (a new one, a sample, a file of the computer, the clipboard), with a dot while it has changes. */
+    protected readonly title: _angular_core.Signal<DocumentTitle>;
+    protected readonly statusItems: _angular_core.Signal<GfyStatusItem[]>;
+    protected onFileDragOver(event: DragEvent): void;
+    protected onFileDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormEditor, "form-editor", never, { "hosted": { "alias": "hosted"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; "sample": { "alias": "sample"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FormEditor, GfyEditorFileConflict, LayoutEditor, RibbonEditor, gfyHttpFiles, gfyLocalFolderFiles, gfyLocalFolderSupported, gfyPickLocalFolder };
+export type { GfyEditorFile, GfyEditorFileEntry, GfyEditorFiles, GfyEditorWriteCondition, GfyHttpFilesOptions, GfyLocalFolderOptions };