@sheetxl/sdk 0.8.0-beta.7 → 0.8.0-beta.9

package/types/scripting.d.ts

@@ -3037,6 +3037,17 @@ declare global {
         readonly isIBullet: true;
     }
 
+    /**
+     * A button: runs its macro when clicked. Content type `'button'`.
+     */
+    export interface IButton extends IFormControl, ICaptioned {
+    }
+
+    export namespace IButton {
+        interface JSON extends IFormControl.JSON, ICaptioned.JSON {
+        }
+    }
+
     /**
      * Calculation is the process of computing formulas and then displaying the results
      * as values in the cells that contain the formulas.
@@ -4465,6 +4476,51 @@ declare global {
         }
     }
 
+    /**
+     * A control that shows text: a button's label, the text beside a check box, a group box's title.
+     */
+    export interface ICaptioned {
+        /**
+         * Returns the text written on the control, or `null` if it has none.
+         */
+        getCaption(): string | null;
+        /**
+         * Sets the text written on the control.
+         *
+         * @param caption The text, or `null` for none.
+         */
+        setCaption(caption: string | null, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns the font the caption is drawn in, or `null` when the control has not said.
+         */
+        getFont(): ICaptioned.Font | null;
+    }
+
+    export namespace ICaptioned {
+        /**
+         * The font a caption is drawn in. Every field is optional; one the control has not said is the
+         * host's default.
+         */
+        interface Font {
+            /** The family name. */
+            name?: string;
+            /** The size in points. */
+            size?: number;
+            /** @defaultValue false */
+            bold?: boolean;
+            /** @defaultValue false */
+            italic?: boolean;
+            /** A hex color (`#RRGGBB`). */
+            color?: string;
+        }
+        interface JSON {
+            /** The text written on the control. */
+            caption?: string;
+            /** The font the caption is drawn in. */
+            font?: Font;
+        }
+    }
+
     /**
      * A single unit of data and meta data within an `ICellRange`, located at a specific row and column.
      */
@@ -4935,17 +4991,17 @@ declare global {
             /**
              * Present when the cell's text is rotated (angle not a multiple of 180°): per-line rotated
              * strip geometry — each laid-out line is an independent strip drawn at
-             * {@link TextRotation.Layout.angle}, wrapped against the content height and marching
+             * {@link TextRotation.RotatedLayout.angle}, wrapped against the content height and marching
              * horizontally. See {@link TextRotation.layoutLines} for the model.
              */
-            rotation?: TextRotation.Layout;
+            rotation?: TextRotation.RotatedLayout;
             /**
              * Present when the cell's text is stacked ("vertical text"): per-column slot geometry — every
              * glyph upright in its own slot of the line pitch, columns from line breaks (and from wrapping
              * against the content height), each column aligned on its own. See
              * {@link TextStacked.layoutColumns} for the model. {@link bounds} is then the column group.
              */
-            stacked?: TextStacked.Layout;
+            stacked?: TextStacked.StackedLayout;
         }
         /**
          * Expansive way to set cell updates options.
@@ -5406,6 +5462,12 @@ declare global {
          * {@link https://support.microsoft.com/en-us/office/change-the-column-width-and-row-height-72f5e3cc-994d-43e8-ae58-9774a0905f46}
          */
         getSizeRelative(): number;
+        /**
+         * The outline level, `0` to `7`. `0` is not grouped; `1` is the outermost group.
+         *
+         * @see `IOutline`
+         */
+        getOutlineLevel(): number;
         /**
          * For runtime introspection.
          */
@@ -5455,6 +5517,22 @@ declare global {
              * {@link ICellHeader.getSizeRelative()}
              */
             relativeSize?: boolean;
+            /**
+             * The outline level, `0` to `7`, or a function of the current one.
+             *
+             * @remarks
+             * To group or ungroup, prefer `ICellRange.group` and `ICellRange.ungroup`.
+             *
+             * @see
+             * {@link ICellHeader.getOutlineLevel()}
+             */
+            outlineLevel?: number | ((level: number) => number);
+            /**
+             * Whether the group this header is the summary of is collapsed.
+             *
+             * @internal
+             */
+            collapsed?: boolean;
         }
         /**
          * Stores information about header runs.
@@ -5473,11 +5551,11 @@ declare global {
              */
             h?: boolean;
             /**
-             * Header level
+             * Outline level, `1` to `7`. Absent when not grouped.
              */
             l?: number;
             /**
-             * Collapsed level
+             * Collapsed. Set on the summary header of a collapsed group.
              */
             cl?: boolean;
             /**
@@ -6788,6 +6866,64 @@ declare global {
          * @returns The current `ICellRange`.
          */
         autoFit(options?: ICellRange.AutoFitOptions): this;
+        /**
+         * Groups the rows or columns of the range: each one moves one outline level deeper.
+         *
+         * @param axis Whether to group the rows or the columns. When omitted, entire rows group the rows,
+         * entire columns group the columns, and any other range groups both.
+         * @returns The current `ICellRange`.
+         * @throws `Error` If a row or column in the range is already at the deepest level, `7`. Nothing is
+         * grouped.
+         *
+         * @see {@link ISheet.getOutline}
+         */
+        group(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+        /**
+         * Ungroups the rows or columns of the range: each grouped one moves one outline level out.
+         * Rows or columns that are not grouped are left alone.
+         *
+         * @param axis Whether to ungroup the rows or the columns. When omitted, chosen as for
+         * {@link group}.
+         * @returns The current `ICellRange`.
+         */
+        ungroup(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+        /**
+         * Expands the groups the range selects: those whose summary row or column is in the range or,
+         * when there are none, the innermost groups the range meets.
+         *
+         * @param axis Whether to expand row groups or column groups. Inferred when the range is entire
+         * rows or entire columns; required otherwise.
+         * @returns The current `ICellRange`.
+         * @throws `Error` If the axis is not given and cannot be inferred.
+         *
+         * @remarks
+         * Groups nested inside that are collapsed stay collapsed.
+         */
+        showGroupDetails(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+        /**
+         * Collapses the groups the range selects, chosen as for {@link showGroupDetails}: their details are
+         * hidden.
+         *
+         * @param axis Whether to collapse row groups or column groups. Inferred as for
+         * {@link showGroupDetails}.
+         * @returns The current `ICellRange`.
+         * @throws `Error` If the axis is not given and cannot be inferred.
+         */
+        hideGroupDetails(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+        /**
+         * Removes the outline levels from the rows and columns of the range. Hidden rows and columns
+         * stay hidden.
+         *
+         * @param axes Which levels to remove. Default `IRange.AxisSelection.Both`.
+         * @returns The current `ICellRange`.
+         *
+         * @remarks
+         * The counterpart of Excel's `Range.ClearOutline`: both axes over the range's rows and columns,
+         * so entire rows also clear every column's levels unless `axes` names the rows, and a single
+         * cell clears the whole sheet. To outline a sheet from its formulas see
+         * {@link IOutline.autoOutline}.
+         */
+        clearGroups(axes?: IRange.AxisSelection, options?: ITransaction.OperationOptions): this;
         /**
          * Clear the range.
          *
@@ -7169,11 +7305,17 @@ declare global {
          */
         isContentful(features?: ICellRange.Feature | readonly ICellRange.Feature[]): boolean;
         /**
-         * Returns `true` if the range represents the entire rows.
+         * Returns `true` if the range is entire rows, such as `2:4`: it spans every column of the sheet.
+         *
+         * @remarks
+         * The counterpart of Office Scripts' `isEntireRow`.
          */
         isEntireRows(): boolean;
         /**
-         * Returns `true` if the range represents the entire columns.
+         * Returns `true` if the range is entire columns, such as `B:D`: it spans every row of the sheet.
+         *
+         * @remarks
+         * The counterpart of Office Scripts' `isEntireColumn`.
          */
         isEntireColumns(): boolean;
         /**
@@ -8247,7 +8389,7 @@ declare global {
          * Represents an immutable reference to an `ICellRange`, capturing its content and metadata.
          * It may include complex objects such as tables, movables, images, listeners, or other items.
          *
-         * `ISnapshot` can be provided to `ICellRange.copyFrom``.
+         * `ISnapshot` can be provided to `ICellRange.copyFrom`.
          */
         interface ISnapshot<T = any, J = any> {
             /**
@@ -8992,35 +9134,35 @@ declare global {
          */
         isOverlapping(): boolean;
         /**
-         * Returns `true` if all of the the ranges have selected all of the rows.
+         * Returns `true` if every range is entire rows, such as `2:4`.
          *
          * @remarks
-         * This is different from `isEntireRowsAny` in that it will return `true` if 'ALL' of the
-         * ranges have isEntireRows `true`.
+         * {@link isEntireRowsAny} asks the same of any one range.
+         *
+         * @see {@link ICellRange.isEntireRows}
          */
         isEntireRows(): boolean;
         /**
-         * Returns `true` if any of the ranges have selected all of the rows.
+         * Returns `true` if any range is entire rows, such as `2:4`.
          *
          * @remarks
-         * This is different from `isEntireRows` in that it it will return true if 'ANY' of the
-         * ranges have isEntireRows `true`.
+         * {@link isEntireRows} asks the same of every range.
          */
         isEntireRowsAny(): boolean;
         /**
-         * Returns `true` if all of the the ranges have selected all of the columns.
+         * Returns `true` if every range is entire columns, such as `B:D`.
          *
          * @remarks
-         * This is different from `isEntireColumnsAny` in that it will return `true` if 'ALL' of the
-         * ranges have isEntireColumns `true`.
+         * {@link isEntireColumnsAny} asks the same of any one range.
+         *
+         * @see {@link ICellRange.isEntireColumns}
          */
         isEntireColumns(): boolean;
         /**
-         * Returns `true` if any of the ranges have selected all of the columns.
+         * Returns `true` if any range is entire columns, such as `B:D`.
          *
          * @remarks
-         * This is different from `isEntireColumns` in that it will return `true` if 'ANY' of the
-         * ranges have isEntireColumns `true`.
+         * {@link isEntireColumns} asks the same of every range.
          */
         isEntireColumnsAny(): boolean;
         /**
@@ -9526,6 +9668,43 @@ declare global {
         readonly isIChartCollection: true;
     }
 
+    /**
+     * A check box: on, off or mixed. Content type `'checkBox'`.
+     */
+    export interface ICheckBox extends IFormControl, ICaptioned, ILinked {
+        /**
+         * Returns `true` if the box is checked.
+         */
+        isChecked(): boolean;
+        /**
+         * Sets whether the box is checked. Clears {@link isMixed}.
+         */
+        setChecked(checked: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * Returns `true` if the box shows the mixed (neither) state.
+         */
+        isMixed(): boolean;
+        /**
+         * Sets whether the box shows the mixed state.
+         */
+        setMixed(mixed: boolean, options?: ITransaction.OperationOptions): this;
+    }
+
+    export namespace ICheckBox {
+        interface JSON extends IFormControl.JSON, ICaptioned.JSON, ILinked.JSON {
+            /**
+             * `true` if the box is checked.
+             * @defaultValue false
+             */
+            checked?: boolean;
+            /**
+             * `true` if the box shows the mixed state. Wins over `checked`.
+             * @defaultValue false
+             */
+            mixed?: boolean;
+        }
+    }
+
     /**
      * Interface used for all ICollections.
      *
@@ -11394,6 +11573,11 @@ declare global {
          * **UI Guidance:**
          * - Show "Ignore Blanks" checkbox for DataValidation (common use case)
          * - Hide for ConditionalFormat/TableFilter (default behavior is usually correct)
+         *
+         * **What is blank:**
+         * - Filters and ConditionalFormat: an empty cell, a `""` result, or a string of only spaces
+         *   (Excel's `LEN(TRIM(x))=0`). A tab, a non-breaking space, `0` and an error are values.
+         * - DataValidation: an empty cell only. A `""` result is a value and is judged.
          */
         isIncludeBlanks(): boolean;
         /**
@@ -11719,6 +11903,7 @@ declare global {
             readonly NextMonth: "nextMonth";
             readonly NextQuarter: "nextQuarter";
             readonly NextWeek: "nextWeek";
+            readonly NextYear: "nextYear";
             readonly Null: "null";
             readonly Q1: "Q1";
             readonly Q2: "Q2";
@@ -11727,6 +11912,7 @@ declare global {
             readonly ThisMonth: "thisMonth";
             readonly ThisQuarter: "thisQuarter";
             readonly ThisWeek: "thisWeek";
+            readonly ThisYear: "thisYear";
             readonly Today: "today";
             readonly Tomorrow: "tomorrow";
             readonly YearToDate: "yearToDate";
@@ -11799,9 +11985,30 @@ declare global {
         }
         interface InSetOption {
             /**
-             * If true this filter by blank.
+             * OOXML's `filters/@blank`, carried for the file. The condition's `includeBlanks` is what
+             * keeps a blank row: a reader sets both, the engine reads `includeBlanks`.
              */
             blank?: boolean;
+            /**
+             * Match string items against the text a cell SHOWS rather than the value it holds.
+             *
+             * @defaultValue `false`
+             *
+             * @remarks
+             * The identity is the value: `items: [1]` keeps every cell holding 1 however it is
+             * formatted, and `items: ['1']` keeps the cells holding the text `1`. Under `byDisplay` a
+             * string item is instead the displayed text, which is what a spreadsheet's filter list
+             * holds: `'1.50'` keeps a cell holding 1.5 under `0.00`, and `'$1'` one under `$0`. A typed
+             * item is matched by value in both modes.
+             *
+             * `byDisplay` is a filter's option, the one the column dropdown sets. A conditional format
+             * or a data validation has no displayed text to read, so the flag is inert there. Under a
+             * filter it also widens what is blank: a string of only spaces shows as nothing and is
+             * settled as a blank cell, and a whitespace-only item means `includeBlanks`. A port of
+             * Office Scripts' `applyValuesFilter` or Apps Script's `setVisibleValues` passes strings
+             * and sets it.
+             */
+            byDisplay?: boolean;
             /**
              * The values that match: an array, or a list validation's source as formula text.
              *
@@ -11817,7 +12024,7 @@ declare global {
              *   evaluated for each cell, so a relative reference gives each cell its own list, and the
              *   source follows inserts and deletes as any formula does.
              *
-             * An array matches as a filter's list of values does.
+             * An array's items match by value, or by displayed text under {@link byDisplay}.
              */
             items?: Scalar[] | string;
             /**
@@ -11894,17 +12101,17 @@ declare global {
              */
             toType<T extends InteropScalar>(value: Scalar, type: InteropScalarType): T;
             /**
-             * The text the current cell shows, when the evaluation matches by text; `null` otherwise.
+             * The text the current cell shows, under a filter; `null` elsewhere.
              *
              * @remarks
-             * A filter matches by shown text unless asked not to ({@link ICondition.RangeOptions.match}):
-             * a cell holding `1.5` and showing `1.50` is the item `1.50`. Conditional formats and data
-             * validations match by value, so this answers `null` for them. An operator that compares
-             * text reads `ctx.getText() ?? value`.
+             * Read by an operator asked to match displayed text ({@link InSetOption.byDisplay}): a cell
+             * holding `1.5` and showing `1.50` is the item `1.50`. A conditional format or a data
+             * validation has no displayed text, so this answers `null` there and the operator compares
+             * the value.
              *
              * Formatted on demand, so an operator that never asks pays nothing.
              */
-            getText(): string | null;
+            getDisplayText(): string | null;
             /**
              * Resolves a condition input to a fully-built ICondition instance.
              *
@@ -12331,26 +12538,6 @@ declare global {
              * with no explicit `hasHeader` evaluates the entire range, header row included.
              */
             hasHeader?: boolean;
-            /**
-             * What a filter's list items and `equalTo` text are compared with: the text a cell shows, or
-             * the value it holds.
-             *
-             * @defaultValue `'text'`
-             *
-             * @remarks
-             * `'text'` is a spreadsheet's AutoFilter: the item `1.50` keeps a cell holding `1.5` under the
-             * format `0.00`, and the item `1.5` does not. A number passed as an item or operand still
-             * matches the cells holding that number, however they are formatted.
-             *
-             * `'value'` compares typed values only, so the text `"1"` never matches the number `1`.
-             *
-             * Comparisons (`>`, `between`), Top N, averages, date periods and date groups read the value
-             * either way, and the text operators (contains, starts with, ends with) only ever match a
-             * cell that holds text.
-             *
-             * Read by filters. Conditional formats and data validations match by value.
-             */
-            match?: 'text' | 'value';
         }
         /**
          * JSON for serialization and round-tripping.
@@ -12944,87 +13131,6 @@ declare global {
         }
     }
 
-    /**
-     * Interface for working with form controls — a button, a checkbox, a scrollbar placed on a sheet.
-     *
-     * **PLACEHOLDER** - This is under development and not made public yet.
-     */
-    export interface IControl extends IModel, IMovable.IContent {
-        /**
-         * Returns the id of the shape that draws this control, or `null` if it has none.
-         *
-         * @remarks
-         * The shape lives in the sheet's legacy drawing, which is still opaque markup — this is the only
-         * link between the two, and it is what lets the shape be kept over the same cells as the control
-         * when rows and columns move.
-         */
-        getShapeId(): number | null;
-        /**
-         * Returns the markup of the part describing the control, or `null` if none was captured.
-         *
-         * @remarks
-         * Read-only, and the one escape hatch for what the control does not model yet: it is the
-         * `<formControlPr>` the control was read from — its kind, its linked cell, its macro. It will be
-         * removed when the control is modeled.
-         */
-        getXML(): string | null;
-        toJSON(toResourceId?: (resource: IResource) => number | null): IControl.JSON | null;
-        /**
-         * Deletes the control, and with it the movable that places it.
-         */
-        delete(options?: ITransaction.OperationOptions): void;
-        /** For runtime type checking. */
-        readonly isIControl: true;
-    }
-
-    /**
-     * {@inheritDoc IControl}
-     * @see
-     * ### **Interface**
-     *
-     * {@link IControl}
-     */
-    export namespace IControl {
-        interface JSON {
-            /**
-             * The id of the shape that draws this control.
-             *
-             * @see {@link IControl.getShapeId}
-             */
-            shapeId?: number;
-            /**
-             * The control's own properties, as they were read.
-             *
-             * @remarks
-             * Opaque. What they describe — a button's macro, a checkbox's linked cell — has no model yet,
-             * so they are held as they were read and written back unchanged. The position is *not* among
-             * them: it is the movable's own anchor, and is written from that.
-             */
-            props?: Record<string, string>;
-            /**
-             * Anything else the properties contained, as markup.
-             *
-             * @remarks
-             * Empty for every control this version has seen — a control's properties are attributes and an
-             * anchor, and the anchor is the movable's. Kept so a producer that writes more than that does
-             * not lose it.
-             */
-            xml?: string;
-            /**
-             * The part describing what kind of control this is and how it behaves.
-             *
-             * @remarks
-             * A control is drawn by a shape in the sheet's legacy drawing ({@link ISheet.LegacyDrawingJSON})
-             * and described by a part of its own; this is that part.
-             */
-            part?: IEmbeddedPart.JSON;
-        }
-        interface Events extends IModel.Events {
-        }
-        interface IListeners extends IListener.Callbacks<IControl, IControl.Events> {
-        }
-    }
-
     /**
      * A data validation: a rule that a cell's value must satisfy, over one or more ranges of a sheet,
      * with the prompt shown when the cell is selected and the alert for a value that fails.
@@ -13504,6 +13610,42 @@ declare global {
         }
     }
 
+    /**
+     * A drop-down. Content type `'dropDown'`.
+     */
+    export interface IDropDown extends IListControl {
+        /**
+         * Returns how the drop-down behaves: a list to pick from, a list that can also be typed into, or
+         * a plain list box. `null` if the control has not said.
+         */
+        getDropStyle(): IDropDown.DropStyle | null;
+        /**
+         * Returns how many items the drop-down shows at once, or `null` if the control has not said.
+         */
+        getDropLines(): number | null;
+    }
+
+    export namespace IDropDown {
+        /**
+         * How a drop-down behaves.
+         */
+        const DropStyle: {
+            /** A list to pick from. */
+            readonly Combo: "combo";
+            /** A list that can also be typed into. */
+            readonly ComboEdit: "comboEdit";
+            /** A list box that does not drop. */
+            readonly Simple: "simple";
+        };
+        type DropStyle = typeof DropStyle[keyof typeof DropStyle];
+        interface JSON extends IListControl.JSON {
+            /** How the drop-down behaves. */
+            dropStyle?: DropStyle;
+            /** How many items the drop-down shows at once. */
+            dropLines?: number;
+        }
+    }
+
     /**
      * *** **PLACEHOLDER** - Not yet implemented.
      *
@@ -14385,7 +14527,7 @@ declare global {
              * @remarks
              * * Not support in cells. This is currently only support in drawML (charts, shapes, powerpoint).
              */
-            readonly Image: "pattern";
+            readonly Image: "image";
             /**
              * An Image.
              * @remarks
@@ -14872,22 +15014,57 @@ declare global {
         }
         interface PatternJSON extends PatternProperties<string> {
         }
+        /**
+         * Insets of a rectangle from the edges of another, as percentages of its width and height
+         * (an inset of `-10` on the right extends past the edge by a tenth of the width).
+         */
+        interface RectInsets {
+            left?: number;
+            top?: number;
+            right?: number;
+            bottom?: number;
+        }
+        /** How a tiled image fill repeats (DrawingML `tile`). */
+        interface ImageTileProperties {
+            /** Offset of the first tile from the fill rectangle's origin, in pixels. */
+            offsetX?: number;
+            offsetY?: number;
+            /** Scale of each tile as a percentage (100 = natural size). */
+            scaleX?: number;
+            scaleY?: number;
+            /** Which tiles are mirrored: `none`, `x`, `y` or `xy`. */
+            flip?: string;
+            /** Where the tiles align in the shape: `tl`, `t`, `tr`, `l`, `ctr`, `r`, `bl`, `b`, `br`. */
+            alignment?: string;
+        }
+        /**
+         * An image fill: a workbook resource stretched over the shape or tiled across it.
+         *
+         * @remarks
+         * `resId` names the resource the way `IPicture.JSON.resId` names a placed picture's image and,
+         * like it, is meaningful only inside the persist scope the JSON was made in. A shape resolves it
+         * to the resource when it is created and names the resource again when it is serialized.
+         */
         interface ImageProperties extends IFill.Properties {
+            /** The resource id of the image. */
+            resId?: number;
+            /** The part of the image used (`srcRect`), as insets from its edges. Absent for the whole image. */
+            sourceRect?: RectInsets;
             /**
-             * A reference to the image resource.
-             *
-             * @remarks
-             * This is a placeholder
-             */
-            ref?: any;
-            /**
-             * Indicates whether the image fill should be tiled.
+             * The image is stretched to a rectangle inset from the shape's bounds (`stretch/fillRect`);
+             * `{}` for the whole shape. Absent when the image is tiled.
              */
-            tile?: boolean;
+            stretch?: RectInsets;
+            /** The image is tiled (`tile`). Absent when it is stretched. */
+            tile?: ImageTileProperties;
             /**
-             * The resolution of the image in dots per inch (DPI).
+             * The resolution the image is rendered at, in dots per inch (`dpi`); `0` for the image's own.
              */
             dpi?: number;
+            /** The compression the image was stored for (`blip/@cstate`): `email`, `screen`, `print`, `hqprint`, `none`. */
+            compressionState?: string;
+            /** `blip/extLst` as the file states it: an opaque DrawingML fragment, written back as it was. */
+            extLst?: string;
         }
         interface ImageJSON extends ImageProperties {
         }
@@ -14993,33 +15170,71 @@ declare global {
              * @defaultValue `10000`
              */
             limit?: number;
+            /**
+             * Group the column by the text its cells SHOW rather than by value, as a spreadsheet's filter
+             * list does: `1` under `$0` and under `0%` are two items, and a string of only spaces is a
+             * blank. The items are then the texts an `InSet { byDisplay: true }` condition holds.
+             *
+             * @defaultValue `false` — by value, the identity {@link ICondition.InSetOption.items} has.
+             */
+            byDisplay?: boolean;
         }
         /**
          * One distinct value of a filtered column.
          */
         interface Item {
             /**
-             * The text the cells show. This is the item an `InSet` condition holds: a filter matches by
-             * shown text ({@link ICondition.RangeOptions.match}).
+             * The item's label: by value, the value as `General` shows it (a date as its date format
+             * does); by display, the text the cells show, which is then the item an
+             * `InSet { byDisplay: true }` condition holds.
              */
             text: string;
-            /** The value of the first cell showing `text`; the item's place in the order. */
+            /** The value, or by display the value of the first cell showing `text`; the item's place in the order. */
             value: Scalar;
             /** The rows holding the value. */
             count: number;
             /** Whether at least one row holding the value passes the filters. */
             checked: boolean;
         }
+        /**
+         * One level of the date tree {@link Items.dates}: the nodes, each the run of items it spans,
+         * in the order the items are listed.
+         */
+        interface DateLevel {
+            /** The part this level groups by. */
+            group: ICondition.DateItemGroupingType;
+            /**
+             * The nodes. A run's `value` is the group item selecting exactly its items: the parts down
+             * to this level (`{ group: 'month', year: 1995, month: 10 }`).
+             */
+            runs: readonly RunCoordValue<ICondition.DateGroupItem>[];
+        }
         /**
          * What {@link IFilter.getItems} answers.
          */
         interface Items {
             /**
-             * The distinct texts, ascending by the workbook's comparison of their values. Values that
-             * show alike are one item. Blanks are not an item.
+             * The distinct values, or the distinct texts under `byDisplay`. The dates come first (the tree in {@link dates}), newest year first
+             * and ascending within a year, as Excel's date tree lists them; the rest follow, ascending
+             * by the workbook's comparison of their values. Values that show alike are one item. Blanks
+             * are not an item.
              */
             items: readonly Item[];
-            /** Whether a listed row is blank. */
+            /**
+             * The date tree over the leading items, one level per entry: year, month and day, then hour,
+             * minute and second when a date carries a time. Absent when the column shows no date.
+             *
+             * @remarks
+             * A date is a number shown under a date format; a time-only format is a number. Every level
+             * covers the same items, `0` to the last date, and a finer level's runs nest inside the
+             * coarser's. A node's checkbox is the state of its items; a checked node is written as its
+             * run's value, in {@link ICondition.InSetOption.dateGroups}.
+             */
+            dates?: readonly DateLevel[];
+            /**
+             * Whether a listed row is blank: empty, or showing nothing (a `""` result, a string of only
+             * spaces). The same rows `includeBlanks` keeps.
+             */
             hasBlanks: boolean;
             /** Whether at least one blank row passes the filters. */
             blanksChecked: boolean;
@@ -15027,6 +15242,12 @@ declare global {
             truncated: boolean;
             /** The rows read. */
             total: number;
+            /**
+             * The mode the list was read in, so a caller writes the items back under the same one:
+             * `{ operator: 'inSet', param: { items, byDisplay } }`. A list read by value fed back as
+             * texts under `byDisplay` would match nothing for a number.
+             */
+            byDisplay: boolean;
         }
         /**
          * Interface indicating the ability to filter data.
@@ -15396,6 +15617,135 @@ declare global {
         readonly isIFormatEngine: true;
     }
 
+    /**
+     * What every form control shares — a button, a check box, a scroll bar placed on a sheet.
+     *
+     * @remarks
+     * A form control is a movable whose content is one of Excel's legacy controls: the movable places
+     * it and the content models what it is. Each kind is its own content type
+     * ({@link IFormControl.Type}) and its own interface, composed from this and two facets: the kinds
+     * that show text ({@link ICaptioned}) and the kinds that hold a value a cell can mirror
+     * ({@link ILinked}). A control owns its state — a check box with no linked cell is still checked
+     * or not.
+     *
+     * **PLACEHOLDER** - This is under development and not made public yet.
+     */
+    export interface IFormControl extends IModel, IMovable.IContent {
+        /**
+         * Returns the id of the shape that draws this control, or `null` if it has none.
+         *
+         * @remarks
+         * The link to the shape in the sheet's legacy drawing, which is what keeps the two over the same
+         * cells when rows and columns move.
+         */
+        getShapeId(): number | null;
+        /**
+         * Returns the name of the macro the control runs when used, or `null` if it has none.
+         *
+         * @remarks
+         * Any kind may run one: a button when clicked, a check box when toggled, a scroll bar when moved.
+         */
+        getMacro(): string | null;
+        /**
+         * Sets the name of the macro the control runs when used.
+         *
+         * @param macro The name, or `null` for none.
+         */
+        setMacro(macro: string | null, options?: ITransaction.OperationOptions): this;
+        toJSON(toResourceId?: (resource: IResource) => number | null): IFormControl.JSON | null;
+        /**
+         * Deletes the control, and with it the movable that places it.
+         */
+        delete(options?: ITransaction.OperationOptions): void;
+        /** For runtime type checking. */
+        readonly isIFormControl: true;
+    }
+
+    /**
+     * {@inheritDoc IFormControl}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IFormControl}
+     */
+    export namespace IFormControl {
+        /**
+         * The kinds of form control, which are the content types a movable reports for them.
+         */
+        const Type: {
+            /** {@link IButton}: runs its macro when clicked. */
+            readonly Button: "button";
+            /** {@link ICheckBox}: on, off or mixed; writes a boolean to its linked cell. */
+            readonly CheckBox: "checkBox";
+            /** {@link IOptionButton}: one of a group; the group's linked cell holds the chosen index. */
+            readonly OptionButton: "optionButton";
+            /** {@link IListBox}: a list of items; writes the index of the chosen one. */
+            readonly ListBox: "listBox";
+            /** {@link IDropDown}: a list that drops down; writes the index of the chosen one. */
+            readonly DropDown: "dropDown";
+            /** {@link IScrollBar}: a thumb in a trough; writes a number. */
+            readonly ScrollBar: "scrollBar";
+            /** {@link ISpinner}: two arrows; writes a number. */
+            readonly Spinner: "spinner";
+            /** {@link IGroupBox}: a frame around other controls. */
+            readonly GroupBox: "groupBox";
+            /** {@link ILabel}: text, nothing more. */
+            readonly Label: "label";
+            /** A text field. Dialog sheets only. {@link IFormControl} only. */
+            readonly EditBox: "editBox";
+            /** A dialog frame. Dialog sheets only. {@link IFormControl} only. */
+            readonly Dialog: "dialog";
+            /** A kind this version does not know. {@link IFormControl} only. */
+            readonly Unknown: "formControl";
+        };
+        type Type = typeof Type[keyof typeof Type];
+        /**
+         * What every kind saves. Each facet and each kind adds its own fields.
+         */
+        interface JSON {
+            /**
+             * The id of the shape that draws this control.
+             *
+             * @see {@link IFormControl.getShapeId}
+             */
+            shapeId?: number;
+            /**
+             * The name of the macro the control runs when used.
+             */
+            macro?: string;
+            /**
+             * The control's placement properties as the file spelled them, less the ones modeled and the
+             * anchor, which is the movable's own.
+             *
+             * @remarks
+             * Whether it prints, whether it is locked, how it sizes with its cell. Carried so a file keeps
+             * what it said until each has a model.
+             */
+            props?: Record<string, string>;
+            /**
+             * The control's own properties as the file spelled them, less the ones modeled.
+             *
+             * @remarks
+             * The 3-D look, text locking, the width of a drop-down's arrow. Carried so a file keeps what
+             * it said until each has a model.
+             */
+            formProps?: Record<string, string>;
+            /**
+             * Anything a producer wrote inside the placement properties besides the anchor, as markup.
+             * Empty for every file seen so far.
+             */
+            xml?: string;
+            /**
+             * Extensions a producer wrote on the control's own properties, as markup.
+             */
+            extLst?: string;
+        }
+        interface Events extends IModel.Events {
+        }
+        interface IListeners extends IListener.Callbacks<IFormControl, IFormControl.Events> {
+        }
+    }
+
     /**
      * Everything a formula function is allowed to know about the world outside its arguments.
      *
@@ -17412,6 +17762,404 @@ declare global {
         }
     }
 
+    /**
+     * A shape's geometry evaluated at one size: its paths, text rectangle, adjust handles and
+     * connection sites, in pixels in the shape's own frame (its top-left is 0,0).
+     *
+     * @remarks
+     * Returned by {@link IShape.getGeometry}, which loads whatever the shape needs to evaluate.
+     * Once it has resolved, everything here is synchronous: a renderer re-evaluates at a new size
+     * ({@link resize}) or with new adjust values ({@link withAdjustments}) on every frame of a drag.
+     *
+     * A group's geometry is its members' paths, each placed in the group's frame; a group has no
+     * handles or connection sites of its own.
+     *
+     * @example
+     * ```ts
+     * const geometry = await shape.getGeometry(200, 100);
+     * const parts: string[] = [];
+     * geometry?.forEachPath((path) => {
+     *   if (path.layer === IGeometry.PathLayer.Stroke) parts.push(`<path d="${path.d}" fill="none" stroke="black"/>`);
+     * });
+     * ```
+     */
+    export interface IGeometry {
+        /** The width the geometry was evaluated at, in pixels. */
+        getWidth(): number;
+        /** The height the geometry was evaluated at, in pixels. */
+        getHeight(): number;
+        /** Where text is laid out: the definition's text rectangle, or the whole frame when it declares none. */
+        getTextRect(): IGeometry.Rect;
+        /**
+         * The box that holds every path, line ends included, in the shape's frame.
+         *
+         * @remarks
+         * It can reach outside the frame, as a callout's tail does, so its edges may be negative or past
+         * {@link getWidth} and {@link getHeight}. The line's own width is not included. A geometry
+         * that draws nothing answers its whole frame.
+         */
+        getPathBounds(): IGeometry.Rect;
+        /**
+         * Visits every path in paint order: a shape's fills, then its strokes, then its markers; a
+         * group's members in z-order, each in that order. A picture member is a rectangle whose fill
+         * is its image.
+         */
+        forEachPath(visit: (path: IGeometry.IPath) => void): void;
+        /** Visits the adjust handles, in the order {@link adjustmentsFromHandle} indexes them. */
+        forEachHandle(visit: (handle: IGeometry.IHandle) => void): void;
+        /** Visits the connection sites, in the order a connector's ends index them. */
+        forEachConnection(visit: (connection: IGeometry.IConnection) => void): void;
+        /** The same shape evaluated at another size. */
+        resize(width: number, height: number): IGeometry;
+        /**
+         * The same shape evaluated with other adjust values.
+         *
+         * @param adjustments Values by name, as {@link IShape.setAdjustments} takes them (what a
+         * handle drag produced); `null` for the preset's defaults.
+         */
+        withAdjustments(adjustments: Readonly<Record<string, number>> | null): IGeometry;
+        /**
+         * The adjust values that put a handle as near as it can go to a point: what dragging it there
+         * sets. Values the handle does not move are kept as they are.
+         *
+         * @param index The handle's {@link IGeometry.IHandle.index}.
+         * @param x In pixels, in the shape's frame.
+         * @param y In pixels, in the shape's frame.
+         * @returns Values to pass to {@link IShape.setAdjustments} or {@link withAdjustments}.
+         */
+        adjustmentsFromHandle(index: number, x: number, y: number): Record<string, number>;
+    }
+
+    /**
+     * {@inheritDoc IGeometry}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IGeometry}
+     */
+    export namespace IGeometry {
+        /**
+         * Every preset geometry, by the DrawingML name (`prstGeom/@prst`) a shape's
+         * {@link IShape.Properties.geometry} takes and {@link IShape.getShapeType} returns.
+         *
+         * @example
+         * ```ts
+         * await sheet.getMovables().add({ type: 'shape', json: { geometry: IGeometry.Preset.RoundRect }, bounds });
+         * ```
+         */
+        const Preset: Readonly<{
+            readonly AccentBorderCallout1: "accentBorderCallout1";
+            readonly AccentBorderCallout2: "accentBorderCallout2";
+            readonly AccentBorderCallout3: "accentBorderCallout3";
+            readonly AccentCallout1: "accentCallout1";
+            readonly AccentCallout2: "accentCallout2";
+            readonly AccentCallout3: "accentCallout3";
+            readonly ActionButtonBackPrevious: "actionButtonBackPrevious";
+            readonly ActionButtonBeginning: "actionButtonBeginning";
+            readonly ActionButtonBlank: "actionButtonBlank";
+            readonly ActionButtonDocument: "actionButtonDocument";
+            readonly ActionButtonEnd: "actionButtonEnd";
+            readonly ActionButtonForwardNext: "actionButtonForwardNext";
+            readonly ActionButtonHelp: "actionButtonHelp";
+            readonly ActionButtonHome: "actionButtonHome";
+            readonly ActionButtonInformation: "actionButtonInformation";
+            readonly ActionButtonMovie: "actionButtonMovie";
+            readonly ActionButtonReturn: "actionButtonReturn";
+            readonly ActionButtonSound: "actionButtonSound";
+            readonly Arc: "arc";
+            readonly BentArrow: "bentArrow";
+            readonly BentConnector2: "bentConnector2";
+            readonly BentConnector3: "bentConnector3";
+            readonly BentConnector4: "bentConnector4";
+            readonly BentConnector5: "bentConnector5";
+            readonly BentUpArrow: "bentUpArrow";
+            readonly Bevel: "bevel";
+            readonly BlockArc: "blockArc";
+            readonly BorderCallout1: "borderCallout1";
+            readonly BorderCallout2: "borderCallout2";
+            readonly BorderCallout3: "borderCallout3";
+            readonly BracePair: "bracePair";
+            readonly BracketPair: "bracketPair";
+            readonly Callout1: "callout1";
+            readonly Callout2: "callout2";
+            readonly Callout3: "callout3";
+            readonly Can: "can";
+            readonly ChartPlus: "chartPlus";
+            readonly ChartStar: "chartStar";
+            readonly ChartX: "chartX";
+            readonly Chevron: "chevron";
+            readonly Chord: "chord";
+            readonly CircularArrow: "circularArrow";
+            readonly Cloud: "cloud";
+            readonly CloudCallout: "cloudCallout";
+            readonly Corner: "corner";
+            readonly CornerTabs: "cornerTabs";
+            readonly Cube: "cube";
+            readonly CurvedConnector2: "curvedConnector2";
+            readonly CurvedConnector3: "curvedConnector3";
+            readonly CurvedConnector4: "curvedConnector4";
+            readonly CurvedConnector5: "curvedConnector5";
+            readonly CurvedDownArrow: "curvedDownArrow";
+            readonly CurvedLeftArrow: "curvedLeftArrow";
+            readonly CurvedRightArrow: "curvedRightArrow";
+            readonly CurvedUpArrow: "curvedUpArrow";
+            readonly Decagon: "decagon";
+            readonly DiagStripe: "diagStripe";
+            readonly Diamond: "diamond";
+            readonly Dodecagon: "dodecagon";
+            readonly Donut: "donut";
+            readonly DoubleWave: "doubleWave";
+            readonly DownArrow: "downArrow";
+            readonly DownArrowCallout: "downArrowCallout";
+            readonly Ellipse: "ellipse";
+            readonly EllipseRibbon: "ellipseRibbon";
+            readonly EllipseRibbon2: "ellipseRibbon2";
+            readonly FlowChartAlternateProcess: "flowChartAlternateProcess";
+            readonly FlowChartCollate: "flowChartCollate";
+            readonly FlowChartConnector: "flowChartConnector";
+            readonly FlowChartDecision: "flowChartDecision";
+            readonly FlowChartDelay: "flowChartDelay";
+            readonly FlowChartDisplay: "flowChartDisplay";
+            readonly FlowChartDocument: "flowChartDocument";
+            readonly FlowChartExtract: "flowChartExtract";
+            readonly FlowChartInputOutput: "flowChartInputOutput";
+            readonly FlowChartInternalStorage: "flowChartInternalStorage";
+            readonly FlowChartMagneticDisk: "flowChartMagneticDisk";
+            readonly FlowChartMagneticDrum: "flowChartMagneticDrum";
+            readonly FlowChartMagneticTape: "flowChartMagneticTape";
+            readonly FlowChartManualInput: "flowChartManualInput";
+            readonly FlowChartManualOperation: "flowChartManualOperation";
+            readonly FlowChartMerge: "flowChartMerge";
+            readonly FlowChartMultidocument: "flowChartMultidocument";
+            readonly FlowChartOfflineStorage: "flowChartOfflineStorage";
+            readonly FlowChartOffpageConnector: "flowChartOffpageConnector";
+            readonly FlowChartOnlineStorage: "flowChartOnlineStorage";
+            readonly FlowChartOr: "flowChartOr";
+            readonly FlowChartPredefinedProcess: "flowChartPredefinedProcess";
+            readonly FlowChartPreparation: "flowChartPreparation";
+            readonly FlowChartProcess: "flowChartProcess";
+            readonly FlowChartPunchedCard: "flowChartPunchedCard";
+            readonly FlowChartPunchedTape: "flowChartPunchedTape";
+            readonly FlowChartSort: "flowChartSort";
+            readonly FlowChartSummingJunction: "flowChartSummingJunction";
+            readonly FlowChartTerminator: "flowChartTerminator";
+            readonly FoldedCorner: "foldedCorner";
+            readonly Frame: "frame";
+            readonly Funnel: "funnel";
+            readonly Gear6: "gear6";
+            readonly Gear9: "gear9";
+            readonly HalfFrame: "halfFrame";
+            readonly Heart: "heart";
+            readonly Heptagon: "heptagon";
+            readonly Hexagon: "hexagon";
+            readonly HomePlate: "homePlate";
+            readonly HorizontalScroll: "horizontalScroll";
+            readonly IrregularSeal1: "irregularSeal1";
+            readonly IrregularSeal2: "irregularSeal2";
+            readonly LeftArrow: "leftArrow";
+            readonly LeftArrowCallout: "leftArrowCallout";
+            readonly LeftBrace: "leftBrace";
+            readonly LeftBracket: "leftBracket";
+            readonly LeftCircularArrow: "leftCircularArrow";
+            readonly LeftRightArrow: "leftRightArrow";
+            readonly LeftRightArrowCallout: "leftRightArrowCallout";
+            readonly LeftRightCircularArrow: "leftRightCircularArrow";
+            readonly LeftRightRibbon: "leftRightRibbon";
+            readonly LeftRightUpArrow: "leftRightUpArrow";
+            readonly LeftUpArrow: "leftUpArrow";
+            readonly LightningBolt: "lightningBolt";
+            readonly Line: "line";
+            readonly LineInv: "lineInv";
+            readonly MathDivide: "mathDivide";
+            readonly MathEqual: "mathEqual";
+            readonly MathMinus: "mathMinus";
+            readonly MathMultiply: "mathMultiply";
+            readonly MathNotEqual: "mathNotEqual";
+            readonly MathPlus: "mathPlus";
+            readonly Moon: "moon";
+            readonly NoSmoking: "noSmoking";
+            readonly NonIsoscelesTrapezoid: "nonIsoscelesTrapezoid";
+            readonly NotchedRightArrow: "notchedRightArrow";
+            readonly Octagon: "octagon";
+            readonly Parallelogram: "parallelogram";
+            readonly Pentagon: "pentagon";
+            readonly Pie: "pie";
+            readonly PieWedge: "pieWedge";
+            readonly Plaque: "plaque";
+            readonly PlaqueTabs: "plaqueTabs";
+            readonly Plus: "plus";
+            readonly QuadArrow: "quadArrow";
+            readonly QuadArrowCallout: "quadArrowCallout";
+            readonly Rect: "rect";
+            readonly Ribbon: "ribbon";
+            readonly Ribbon2: "ribbon2";
+            readonly RightArrow: "rightArrow";
+            readonly RightArrowCallout: "rightArrowCallout";
+            readonly RightBrace: "rightBrace";
+            readonly RightBracket: "rightBracket";
+            readonly Round1Rect: "round1Rect";
+            readonly Round2DiagRect: "round2DiagRect";
+            readonly Round2SameRect: "round2SameRect";
+            readonly RoundRect: "roundRect";
+            readonly RtTriangle: "rtTriangle";
+            readonly SmileyFace: "smileyFace";
+            readonly Snip1Rect: "snip1Rect";
+            readonly Snip2DiagRect: "snip2DiagRect";
+            readonly Snip2SameRect: "snip2SameRect";
+            readonly SnipRoundRect: "snipRoundRect";
+            readonly SquareTabs: "squareTabs";
+            readonly Star10: "star10";
+            readonly Star12: "star12";
+            readonly Star16: "star16";
+            readonly Star24: "star24";
+            readonly Star32: "star32";
+            readonly Star4: "star4";
+            readonly Star5: "star5";
+            readonly Star6: "star6";
+            readonly Star7: "star7";
+            readonly Star8: "star8";
+            readonly StraightConnector1: "straightConnector1";
+            readonly StripedRightArrow: "stripedRightArrow";
+            readonly Sun: "sun";
+            readonly SwooshArrow: "swooshArrow";
+            readonly Teardrop: "teardrop";
+            readonly Trapezoid: "trapezoid";
+            readonly Triangle: "triangle";
+            readonly UpArrow: "upArrow";
+            readonly UpArrowCallout: "upArrowCallout";
+            readonly UpDownArrow: "upDownArrow";
+            readonly UpDownArrowCallout: "upDownArrowCallout";
+            readonly UturnArrow: "uturnArrow";
+            readonly VerticalScroll: "verticalScroll";
+            readonly Wave: "wave";
+            readonly WedgeEllipseCallout: "wedgeEllipseCallout";
+            readonly WedgeRectCallout: "wedgeRectCallout";
+            readonly WedgeRoundRectCallout: "wedgeRoundRectCallout";
+        }>;
+        type Preset = typeof Preset[keyof typeof Preset];
+        /**
+         * A geometry definition, as DrawingML states one: adjust values, guides, handles, connection
+         * sites, text rectangle and paths. A shape drawn from its own geometry (a file's `custGeom`)
+         * gives one as its {@link IShape.Properties.geometry}; every {@link Preset} is one too.
+         *
+         * @remarks
+         * The definition is DrawingML's own formula language, kept verbatim (`'x1 +- hc dx1 0'`) so it
+         * reads like the markup it came from, and the way a file states a custom shape round-trips
+         * unchanged. SheetXL evaluates it rather than models it: lengths come out in the unit the shape
+         * is evaluated in (pixels), and angles in degrees. Inside the language, angles are 60,000ths of
+         * a degree and ratios are 100,000ths, which is what an adjust value is.
+         */
+        interface Def {
+            /** Adjust values, document order: `'name val N'`. */
+            av?: readonly string[];
+            /** Calculated guides, document order: `'name op a b c'`. A name may be rebound. */
+            gd?: readonly string[];
+            /**
+             * Adjust handles, document order.
+             *
+             * `'xy gdRefX gdRefY posX posY [minX maxX minY maxY]'` or
+             * `'polar gdRefR gdRefAng posX posY [minR maxR minAng maxAng]'`. An absent reference or bound
+             * is `_`; the bounds group is omitted when all four are absent.
+             */
+            ah?: readonly string[];
+            /** Connection sites, `'ang x y'` each. */
+            cxn?: readonly string[];
+            /** Text rectangle `'l t r b'`; absent is the whole frame. */
+            rect?: string;
+            paths: readonly DefPath[];
+        }
+        /** One path of a {@link Def}. */
+        interface DefPath {
+            /** `none` when the path is not filled, else its {@link PathFill | shading}; absent is `norm`. */
+            f?: 'none' | Exclude<PathFill, 'norm'>;
+            /** `0` when the path is not stroked. */
+            s?: 0;
+            /** Path coordinate space width; absent means the shape width. */
+            w?: number;
+            /** Path coordinate space height; absent means the shape height. */
+            h?: number;
+            /**
+             * Mini-path: `M x y | L x y | Q x1 y1 x2 y2 | C x1 y1 x2 y2 x3 y3 | A wR hR stAng swAng | Z`,
+             * space separated; coordinate tokens are guide names or integer literals.
+             */
+            d: string;
+        }
+        /** Edges of a rectangle in the shape's frame, in pixels. */
+        interface Rect {
+            l: number;
+            t: number;
+            r: number;
+            b: number;
+        }
+        /** Which paint a visited path takes. */
+        const PathLayer: {
+            /** The shape's fill, shaded as {@link IPath.fill} says. */
+            readonly Fill: "fill";
+            /** The shape's line. */
+            readonly Stroke: "stroke";
+            /** A marker at either end of the line (an arrowhead): a filled path painted with the line's paint. */
+            readonly Marker: "marker";
+        };
+        type PathLayer = typeof PathLayer[keyof typeof PathLayer];
+        /**
+         * How a fill is shaded: `norm` is the fill as it is; the others are the shaded faces of a cube,
+         * a can or a fold, each the fill through {@link FillTransfer}.
+         */
+        type PathFill = 'norm' | 'darken' | 'darkenLess' | 'lighten' | 'lightenLess';
+        /**
+         * Each shading's transfer, per color channel in sRGB: `c' = slope · c + intercept`, with `c` in
+         * `0..1`. As an SVG filter, `feFuncR`/`G`/`B` of `type="linear"`.
+         */
+        const FillTransfer: Readonly<Record<PathFill, readonly [slope: number, intercept: number]>>;
+        /** One path, as {@link IGeometry.forEachPath} visits it. */
+        interface IPath {
+            /** The visit's position in paint order: unique within one {@link IGeometry.forEachPath}. */
+            readonly index: number;
+            /** SVG path data, in pixels, in the frame of the shape, or of {@link member} when there is one. */
+            readonly d: string;
+            readonly layer: PathLayer;
+            /** The shading of a {@link PathLayer.Fill} path; `norm` on every other layer. */
+            readonly fill: PathFill;
+            /** The group member the path belongs to; absent for a shape that is not a group. */
+            readonly member?: IMember;
+        }
+        /** A group member a path belongs to: what it is, and where the group places it. */
+        interface IMember {
+            /** The member's JSON, for its fill and line (a picture member's fill is its image). */
+            readonly json: IShape.JSON;
+            /** The SVG `transform` that places the member's frame in the group's, rotation and flips included. */
+            readonly transform: string;
+            /** The member's frame, in pixels: what its paths were evaluated at, and what a picture fills. */
+            readonly width: number;
+            readonly height: number;
+        }
+        /** How an adjust handle moves: along x and/or y, or by radius and/or angle about the shape's center. */
+        const HandleType: {
+            readonly XY: "xy";
+            readonly Polar: "polar";
+        };
+        type HandleType = typeof HandleType[keyof typeof HandleType];
+        /**
+         * An adjust handle, as {@link IGeometry.forEachHandle} visits it: where it is, in pixels in the
+         * shape's frame. What it moves and how far is the definition's business;
+         * {@link IGeometry.adjustmentsFromHandle} answers a drag.
+         */
+        interface IHandle {
+            readonly type: HandleType;
+            readonly index: number;
+            readonly x: number;
+            readonly y: number;
+        }
+        /** A point a connector may attach to, as {@link IGeometry.forEachConnection} visits it. */
+        interface IConnection {
+            readonly index: number;
+            readonly x: number;
+            readonly y: number;
+            /** The direction a connector leaves the site, in degrees clockwise from +x. */
+            readonly ang: number;
+        }
+    }
+
     /**
      * Primary interface for retrieving and setting values in a 2D space.
      *
@@ -17689,6 +18437,17 @@ declare global {
         type KeyIterator = IterableIterator<CellCoords, CellCoords, CellCoords>;
     }
 
+    /**
+     * A group box: a frame around other controls. Content type `'groupBox'`.
+     */
+    export interface IGroupBox extends IFormControl, ICaptioned {
+    }
+
+    export namespace IGroupBox {
+        interface JSON extends IFormControl.JSON, ICaptioned.JSON {
+        }
+    }
+
     /**
      * Encapsulates functionalities crucial for maintaining a comprehensive version history
      * and audit trail within the spreadsheet application. It provides mechanisms to capture, store,
@@ -17891,6 +18650,14 @@ declare global {
             screenTip?: string;
             /** {@inheritDoc IHyperlink.getTarget} */
             target?: string;
+            /**
+             * An action the link performs instead of, or beside, following its address, as a file states
+             * it (`hlinkClick/@action`). Office's own (`ppaction://…`) mean nothing in a workbook; kept so
+             * the file reads back as written.
+             */
+            action?: string;
+            /** Whether following the link adds it to the browsing history (`hlinkClick/@history`). */
+            history?: boolean;
         }
         /**
          * A JSON representation useful for persistence.
@@ -17898,6 +18665,17 @@ declare global {
         type JSON = Partial<Omit<IHyperlink.Properties, 'textToDisplay'>> | string;
     }
 
+    /**
+     * A label: text, nothing more. Content type `'label'`.
+     */
+    export interface ILabel extends IFormControl, ICaptioned {
+    }
+
+    export namespace ILabel {
+        interface JSON extends IFormControl.JSON, ICaptioned.JSON {
+        }
+    }
+
     /**
      * The handle a {@link Lazy} parameter receives: an argument's subtree, anchored at the calling
      * cell, that has either not been evaluated yet or has been evaluated already.
@@ -17920,6 +18698,78 @@ declare global {
         getValue(): T;
     }
 
+    /**
+     * A control whose state a cell mirrors: the control writes to the cell when used, and reads it
+     * back when the cell changes.
+     */
+    export interface ILinked {
+        /**
+         * Returns the address of the cell the control writes its state to, or `null` if it has none.
+         *
+         * @remarks
+         * As the file spelled it, which may name a sheet (`Sheet1!$A$1`).
+         */
+        getLinkedCell(): string | null;
+        /**
+         * Sets the cell the control writes its state to.
+         *
+         * @param address The address, or `null` for none.
+         */
+        setLinkedCell(address: string | null, options?: ITransaction.OperationOptions): this;
+    }
+
+    export namespace ILinked {
+        interface JSON {
+            /** The address of the cell the control writes its state to. */
+            linkedCell?: string;
+        }
+    }
+
+    /**
+     * A list box. Content type `'listBox'`.
+     */
+    export interface IListBox extends IListControl {
+    }
+
+    export namespace IListBox {
+        interface JSON extends IListControl.JSON {
+        }
+    }
+
+    /**
+     * What a list box and a drop-down share: items, one of which may be chosen.
+     */
+    export interface IListControl extends IFormControl, ILinked {
+        /**
+         * Returns the items.
+         *
+         * @remarks
+         * Empty when the items come from {@link getListFillRange} rather than being held by the control.
+         */
+        getItems(): readonly string[];
+        /** Sets the items. */
+        setItems(items: readonly string[], options?: ITransaction.OperationOptions): this;
+        /** Returns the address of the range the items come from, or `null` if the control holds them. */
+        getListFillRange(): string | null;
+        /** Sets the range the items come from. */
+        setListFillRange(address: string | null, options?: ITransaction.OperationOptions): this;
+        /** Returns the index of the chosen item, or `null` if none is. */
+        getSelectedIndex(): number | null;
+        /** Sets the chosen item. */
+        setSelectedIndex(index: number | null, options?: ITransaction.OperationOptions): this;
+    }
+
+    export namespace IListControl {
+        interface JSON extends IFormControl.JSON, ILinked.JSON {
+            /** The items held by the control itself. */
+            items?: string[];
+            /** The address of the range the items come from. */
+            listFillRange?: string;
+            /** The index of the chosen item. Absent when none is. */
+            selectedIndex?: number;
+        }
+    }
+
     /**
      * Namespace used for listeners to events.
      */
@@ -18367,10 +19217,11 @@ declare global {
          * | `'chart'` | {@link IChart} |
          * | `'shape'` | {@link IShape} — text boxes, callouts, connectors and groups |
          * | `'slicer'` | {@link ISlicer} |
-         * | `'control'` | {@link IControl} — a form control |
+         * | `'checkBox'`, `'button'`, `'scrollBar'`, … | {@link IFormControl} — a form control, one type per kind ({@link IFormControl.Type}) |
          *
-         * Anything else is content that is positioned and saved but not modeled; it answers
-         * {@link IMovable.IContent} and nothing more.
+         * A host adds kinds of its own through {@link MovableContentRegistry}. Anything else is content
+         * that is positioned and saved but not modeled; it answers {@link IMovable.IContent} and nothing
+         * more.
          *
          * The content owns what identifies it: its name, its description and its id. The movable owns
          * where it is drawn. To remove both, delete the content.
@@ -18405,11 +19256,12 @@ declare global {
          */
         isSelected: () => boolean;
         /**
-         * Set the absolution position of a movable in pixels.
+         * Set the position and size of the movable's unrotated frame, in pixels.
          * @param bounds The new bounds.
          *
          * @remarks
-         * If only some of the points are provided then only those will be moved.
+         * If only some of the points are provided then only those will be moved. The frame is what
+         * {@link getBounds} returns; the cells the movable is anchored to follow from it and the rotation.
          */
         setBounds(bounds: Partial<Bounds>, options?: ITransaction.OperationOptions): IMovable;
         /**
@@ -18422,7 +19274,13 @@ declare global {
          */
         scrollIntoView: (options?: globalThis.ScrollIntoViewOptions | boolean) => Promise<boolean>;
         /**
-         * Returns the absolute bounds of the movable object in pixels or `null` if not yet laid out.
+         * Returns the movable's unrotated frame in pixels, or `null` if not yet laid out.
+         *
+         * @remarks
+         * The frame is the box the movable is drawn in before it is turned by {@link getRotation}, about
+         * its center. A rotated movable is anchored to the cells of the box it occupies as rotated,
+         * which Excel takes to be the frame with its width and height swapped when the rotation is within
+         * 45° of 90° or 270°, and the frame itself otherwise.
          */
         getBounds(): Bounds | null;
         /**
@@ -18435,12 +19293,16 @@ declare global {
          */
         isHidden(): boolean;
         /**
-         * Set the rotation in degrees.
+         * Set the rotation in degrees, clockwise about the frame's center.
+         *
+         * @remarks
+         * The frame keeps its position and size; the cells the movable is anchored to are those of the
+         * box it then occupies (see {@link getBounds}).
          */
         setRotation(rotation: number): IMovable;
         /**
          * @see
-         * {@link setHidden}
+         * {@link setRotation}
          */
         getRotation(): number;
         /**
@@ -18506,6 +19368,23 @@ declare global {
      * {@link IMovable}
      */
     export namespace IMovable {
+        /**
+         * A content's formulas as the calculation engine holds them: references that follow the cells
+         * they name through inserts, deletes, moves and sheet renames.
+         *
+         * @remarks
+         * Handed out by the sheet when content is created
+         * ({@link MovableContentRegistry.CreateOptions.holdFormulas}); a chart holds its series this way.
+         */
+        interface HeldFormulas {
+            /**
+             * The formula at `index` as it reads now, or `null` while it reads as it was handed over:
+             * the engine does not hold it, or nothing has moved what it names.
+             */
+            getText(index: number): string | null;
+            /** Takes the formulas out of the engine, as part of the current operation. */
+            release(): void;
+        }
         /**
          * What a movable draws: a chart, a picture, a shape, a slicer, a control.
          *
@@ -18789,6 +19668,18 @@ declare global {
              * @defaultValue false
              */
             fullyContained?: boolean;
+            /**
+             * Match {@link address} against what each movable paints rather than the cells it is anchored
+             * to: its rotation, a drawing that reaches outside its frame (a callout's tail) and its line.
+             * Use it to find the movables visible in a range.
+             *
+             * @remarks
+             * A shape's drawing is known once its geometry has been evaluated, which the search starts;
+             * until then it is matched by its frame, and the collection notifies a change when the answer
+             * is ready. Ignored with {@link fullyContained}.
+             * @defaultValue false
+             */
+            drawn?: boolean;
         }
         /**
          * Options for adding a movable to the collection.
@@ -18815,9 +19706,15 @@ declare global {
              */
             fromResourceId?: (resourceId: number) => IResource;
             /**
-             * The boundary for the movable object in pixels.
+             * The movable's unrotated frame in pixels (see {@link IMovable.getBounds}).
              */
             bounds?: Partial<Bounds>;
+            /**
+             * The rotation in degrees, clockwise about the frame's center.
+             *
+             * @defaultValue 0
+             */
+            rotation?: number;
             /**
              * Placement hint used only when {@link bounds} is omitted. `'viewport'` centers the (default-sized)
              * movable in the visible viewport via {@link ISheet.IListeners.onRequestViewport}, falling back to the
@@ -19733,6 +20630,214 @@ declare global {
         constructor(message?: string, options?: ErrorOptions);
     }
 
+    /**
+     * An option button: one of a group, of which one is chosen. Content type `'optionButton'`.
+     */
+    export interface IOptionButton extends IFormControl, ICaptioned, ILinked {
+        /**
+         * Returns `true` if this is the chosen button of its group.
+         */
+        isChecked(): boolean;
+        /**
+         * Sets whether this is the chosen button of its group.
+         */
+        setChecked(checked: boolean, options?: ITransaction.OperationOptions): this;
+    }
+
+    export namespace IOptionButton {
+        interface JSON extends IFormControl.JSON, ICaptioned.JSON, ILinked.JSON {
+            /**
+             * `true` if this is the chosen button of its group.
+             * @defaultValue false
+             */
+            checked?: boolean;
+        }
+    }
+
+    /**
+     * The row and column groups on a sheet, and how they are laid out.
+     *
+     * @remarks
+     * There is no group object to create or delete. Every row and column carries an outline level,
+     * `0` to `7` ({@link ICellHeader.getOutlineLevel}), and a group at level *n* is a run of
+     * consecutive rows (or columns) whose level is *n* or more. Its summary row is the one just past
+     * the run, on the side {@link getSummaryDirection} names. Collapsing a group hides its detail rows.
+     *
+     * Groups are made and removed with {@link ICellRange.group} and {@link ICellRange.ungroup}, or
+     * from the sheet's formulas with {@link autoOutline}, and collapsed and expanded with
+     * {@link ICellRange.hideGroupDetails} and {@link ICellRange.showGroupDetails}. Whether the symbols are drawn
+     * is the view's: {@link ISheetView.setShowOutlineSymbols}.
+     *
+     * The counterpart of Excel's `Worksheet.Outline`.
+     */
+    export interface IOutline extends IListener.ISource<IOutline, IOutline.Events> {
+        /**
+         * Where a group's summary sits: `down` or `up` for rows, `right` or `left` for columns.
+         *
+         * @defaultValue `down` for rows, `right` for columns.
+         */
+        getSummaryDirection(axis: IRange.Axis): IRange.Direction;
+        /**
+         * Sets where a group's summary sits.
+         *
+         * @throws `Error` If the direction does not belong to the axis (`left` for rows).
+         */
+        setSummaryDirection(axis: IRange.Axis, direction: IRange.Direction, options?: ITransaction.OperationOptions): this;
+        /**
+         * Whether the automatic outline styles are applied to summary rows and columns.
+         *
+         * @defaultValue false
+         */
+        isAutomaticStyles(): boolean;
+        /**
+         * Sets whether the automatic outline styles are applied.
+         */
+        setAutomaticStyles(automatic: boolean, options?: ITransaction.OperationOptions): this;
+        /**
+         * The deepest outline level in use on the axis; `0` when nothing is grouped.
+         */
+        getLevelCount(axis: IRange.Axis): number;
+        /**
+         * The groups on an axis, outermost level first and in order within a level.
+         *
+         * @param axis The axis.
+         * @param options Limits the groups returned.
+         */
+        getGroups(axis: IRange.Axis, options?: IOutline.GetGroupsOptions): readonly IOutline.Group[];
+        /**
+         * Expands the groups up to a level and collapses everything deeper, as the level buttons do.
+         *
+         * @param axis The axis.
+         * @param levels How many levels stay visible, from `1` (only the outermost summaries); more levels
+         * than exist shows every row or column.
+         *
+         * @remarks
+         * The counterpart of Excel's `Outline.ShowLevels` and Office Scripts' `showOutlineLevels`, one
+         * axis at a time.
+         */
+        setVisibleLevels(axis: IRange.Axis, levels: number, options?: ITransaction.OperationOptions): this;
+        /**
+         * Removes every outline level from the sheet. Hidden rows and columns stay hidden.
+         *
+         * @param axes Which levels to remove. Default `IRange.AxisSelection.Both`.
+         * @returns The current `IOutline`.
+         * @throws `Error` If the sheet is protected.
+         *
+         * @remarks
+         * The whole-sheet form of {@link ICellRange.clearGroups}, which is what Excel's Clear Outline
+         * does with one cell selected.
+         */
+        clear(axes?: IRange.AxisSelection, options?: ITransaction.OperationOptions): this;
+        /**
+         * Outlines the sheet from its formulas: a cell whose formula totals the cells on one side of it
+         * in its own column makes its row a summary row and those rows a group, and the same for
+         * columns.
+         *
+         * @returns The current `IOutline`.
+         * @throws `Error` If no summary rows or columns are found, or the sheet is protected.
+         *
+         * @remarks
+         * The counterpart of Excel's `Range.AutoOutline`, which outlines the whole sheet whatever the
+         * range. Any outline the sheet already has is removed first, and the summary direction of each
+         * axis is set to where its first summary sits: below and right, or above and left.
+         */
+        autoOutline(options?: ITransaction.OperationOptions): this;
+        /**
+         * The settings that differ from their defaults, or `null` when none do.
+         *
+         * @remarks
+         * The levels themselves are saved with the rows and columns, not here.
+         */
+        toJSON(): IOutline.JSON | null;
+        /**
+         * For runtime type checking.
+         */
+        readonly isIOutline: true;
+    }
+
+    /**
+     * {@inheritDoc IOutline}
+     * @see
+     * ### **Interface**
+     *
+     * {@link IOutline}
+     */
+    export namespace IOutline {
+        /**
+         * A group of rows or columns.
+         */
+        interface Group {
+            /**
+             * The level, from `1`; level 1 is the outermost.
+             */
+            level: number;
+            /**
+             * The first detail row or column.
+             */
+            start: number;
+            /**
+             * The last detail row or column, inclusive.
+             */
+            end: number;
+            /**
+             * The summary row or column, or `null` when the group runs to the edge of the sheet on the
+             * summary side.
+             */
+            summary: number | null;
+            /**
+             * Whether the details are collapsed: every one of them is hidden, whoever hid them.
+             *
+             * @remarks
+             * Read from the hidden details, as Excel reads it. A group whose summary is itself hidden,
+             * inside a collapsed outer group, reads collapsed only when it was collapsed before the outer
+             * one; expanding the outer group leaves such a group collapsed and opens the rest.
+             */
+            collapsed: boolean;
+        }
+        /**
+         * Options for {@link IOutline.getGroups}.
+         */
+        interface GetGroupsOptions {
+            /**
+             * Only this level. Omitted returns every level.
+             */
+            level?: number;
+            /**
+             * Only groups that meet the span from here (a viewport). Includes the summary.
+             */
+            from?: number;
+            /**
+             * Only groups that meet the span to here, inclusive.
+             */
+            to?: number;
+        }
+        /**
+         * The outline settings that differ from their defaults.
+         */
+        interface JSON {
+            /**
+             * Present, as `up`, when a group's summary row sits above its details.
+             */
+            summaryRow?: 'up';
+            /**
+             * Present, as `left`, when a group's summary column sits left of its details.
+             */
+            summaryColumn?: 'left';
+            /**
+             * Present, as `true`, when the automatic outline styles are applied.
+             */
+            automaticStyles?: true;
+        }
+        interface Events {
+            /**
+             * Called when the outline changes: its settings, a level, or which details are shown.
+             */
+            onOutlineChange?(source: IOutline): void;
+        }
+        interface IListeners extends IListener.Callbacks<IOutline, IOutline.Events> {
+        }
+    }
+
     /**
      * A person known to the workbook: the author of a comment, or someone mentioned in one.
      *
@@ -22110,6 +23215,41 @@ declare global {
         type JSONReference<J = any> = JSONReferenceEntry<J> | JSONReferenceTuple<J>;
     }
 
+    /**
+     * What a scroll bar and a spinner share: a number between two bounds.
+     */
+    export interface IRangedControl extends IFormControl, ILinked {
+        /** Returns the current value, or `null` if the control has not said. */
+        getValue(): number | null;
+        /** Sets the current value. */
+        setValue(value: number | null, options?: ITransaction.OperationOptions): this;
+        /** Returns the smallest value, or `null` if the control has not said. */
+        getMin(): number | null;
+        /** Sets the smallest value. */
+        setMin(min: number | null, options?: ITransaction.OperationOptions): this;
+        /** Returns the largest value, or `null` if the control has not said. */
+        getMax(): number | null;
+        /** Sets the largest value. */
+        setMax(max: number | null, options?: ITransaction.OperationOptions): this;
+        /** Returns how far one arrow click moves the value, or `null` if the control has not said. */
+        getIncrement(): number | null;
+        /** Sets how far one arrow click moves the value. */
+        setIncrement(increment: number | null, options?: ITransaction.OperationOptions): this;
+    }
+
+    export namespace IRangedControl {
+        interface JSON extends IFormControl.JSON, ILinked.JSON {
+            /** The current value. */
+            value?: number;
+            /** The smallest value. */
+            min?: number;
+            /** The largest value. */
+            max?: number;
+            /** How far one arrow click moves the value. */
+            increment?: number;
+        }
+    }
+
     /**
      * Interface representing a range selection within a sheet.
      */
@@ -23640,6 +24780,30 @@ declare global {
         }
     }
 
+    /**
+     * A scroll bar: a thumb in a trough. Content type `'scrollBar'`.
+     */
+    export interface IScrollBar extends IRangedControl {
+        /** Returns how far a click in the trough moves the value, or `null` if the control has not said. */
+        getPageIncrement(): number | null;
+        /** Sets how far a click in the trough moves the value. */
+        setPageIncrement(increment: number | null, options?: ITransaction.OperationOptions): this;
+        /** Returns `true` if the bar lies on its side. */
+        isHorizontal(): boolean;
+    }
+
+    export namespace IScrollBar {
+        interface JSON extends IRangedControl.JSON {
+            /** How far a click in the trough moves the value. */
+            pageIncrement?: number;
+            /**
+             * `true` if the bar lies on its side.
+             * @defaultValue false
+             */
+            horizontal?: boolean;
+        }
+    }
+
     /**
      * A drawn shape: a text box, a callout, a rectangle, a connector, or a group of them.
      *
@@ -23648,8 +24812,8 @@ declare global {
      * whose content type is `'shape'`. The movable carries the position; the shape carries what is
      * drawn there and what is written on it.
      *
-     * Reading only: a shape's preset and its text. An imported shape is otherwise kept as the source
-     * wrote it and saved back unchanged.
+     * Reading, and adjust values: a shape is JSON ({@link IShape.JSON}) that a file reads into and
+     * writes from; the editing API beyond `setAdjustments` is still to come.
      */
     export interface IShape extends IModel, IMovable.IContent {
         toJSON(toResourceId?: (resource: IResource) => number | null): IShape.JSON | null;
@@ -23657,6 +24821,12 @@ declare global {
          * Returns the name of the shape.
          */
         getName(): string | null;
+        /**
+         * The image a resource id in this shape's JSON names: an image fill's `resId`, a picture
+         * member's among them, as {@link toJSON} with no scope names them. `null` when the shape holds
+         * no such resource.
+         */
+        getResource(resourceId: number): IResource | null;
         /**
          * Deletes the shape, and with it the movable that places it.
          */
@@ -23665,8 +24835,9 @@ declare global {
          * Returns the kind of shape this is: its preset geometry.
          *
          * @remarks
-         * A DrawingML preset id — `rect`, `borderCallout2`, `curvedConnector3` — or `'custom'` for a
-         * shape drawn from its own path, or `'group'` for a group of shapes.
+         * A DrawingML preset id ({@link IGeometry.Preset}) — `rect`, `borderCallout2`, `curvedConnector3` —
+         * or `'custom'` for a shape drawn from its own path, or `'group'` for a group of shapes. A file
+         * may name a preset this SDK does not know; it is returned as the file states it.
          *
          * The preset says what a shape is for where its name does not: a callout annotates something,
          * a connector links two shapes, and a rectangle with no text is usually a box drawn around the
@@ -23692,6 +24863,48 @@ declare global {
          * ```
          */
         getTextFrame(): ITextFrame.IText | null;
+        /**
+         * Returns the adjust values set on this shape, by name.
+         *
+         * @remarks
+         * A preset's handles move its adjust values — how rounded a `roundRect` is, where a callout
+         * points. Only values that differ from the preset's defaults are stored.
+         *
+         * The values are the geometry definition's own numbers (a ratio in 100,000ths, an angle in
+         * 60,000ths of a degree), opaque to a caller: a handle drag produces them through
+         * {@link IGeometry.adjustmentsFromHandle}, and a file reads and writes them as they are.
+         */
+        getAdjustments(): Readonly<Record<string, number>>;
+        /**
+         * Sets the adjust values, replacing any already set.
+         *
+         * @param adjustments Values by name, as {@link IGeometry.adjustmentsFromHandle} returns them;
+         * `null` restores the preset's defaults. Names the preset does not declare are kept but have no
+         * effect.
+         */
+        setAdjustments(adjustments: Record<string, number> | null, options?: ITransaction.OperationOptions): this;
+        /**
+         * Evaluates the shape's geometry at a size.
+         *
+         * @remarks
+         * What evaluates a shape loads on first use, and only what that shape needs, so this is
+         * asynchronous; a workbook with no shapes loads none of it. Everything on the geometry it
+         * returns is synchronous, including evaluating it again at another size or with other adjust
+         * values. Paths, handles and sites are in sheet pixels, in the shape's own frame (its top-left
+         * is 0,0), which is how the movable layer draws them.
+         *
+         * An open path takes the line ends the shape's line declares (its own over its theme style's):
+         * its stroke is trimmed under them, and they are visited as {@link IGeometry.PathLayer.Marker}
+         * paths. A group's geometry is its members', each placed in the group's frame.
+         *
+         * @param width Width in pixels. @defaultValue the movable's bounds.
+         * @param height Height in pixels. @defaultValue the movable's bounds.
+         * @returns `null` for a shape whose preset is unknown, or a shape with no size. A custom
+         * geometry evaluates like a preset, from its own definition.
+         */
+        getGeometry(width?: number, height?: number): Promise<IGeometry | null>;
+        /** For runtime type checking. */
+        readonly isIShape: true;
     }
 
     /**
@@ -23702,6 +24915,25 @@ declare global {
      * {@link IShape}
      */
     export namespace IShape {
+        /**
+         * What kind of drawing a shape's JSON describes.
+         *
+         * @remarks
+         * Every kind is an `IShape` whose {@link IMovable.IContent.getType | content type} is `'shape'`;
+         * this is the one place the distinction survives a round trip. A JSON that states none is a
+         * {@link IShape.Type.Shape | shape}.
+         */
+        const Type: {
+            /** A shape drawn from a preset or custom geometry, with or without text. */
+            readonly Shape: "shape";
+            /** A connector: a line that may be glued to other shapes' connection sites. */
+            readonly Connector: "connector";
+            /** A group of shapes, placed together; its members are its {@link JSON.children}. */
+            readonly Group: "group";
+            /** A picture inside a group; see {@link PictureMemberJSON}. */
+            readonly Picture: "picture";
+        };
+        type Type = typeof Type[keyof typeof Type];
         /**
          * A set of values that can be set on a IShape.
          *
@@ -23710,15 +24942,20 @@ declare global {
          */
         interface Properties {
             /**
-             * The unique name of the table
+             * The name of the shape.
              */
             name?: string;
             /**
-             * The preset Geometry for the shape. This could also be custom.
+             * The geometry: a DrawingML preset name (`'rect'`, `'roundRect'`, `'wedgeEllipseCallout'`…)
+             * or a custom definition in the same form as a preset.
              *
              * @defaultValue 'rect'
              */
-            geometry?: PresetGeometry | GeometryProperties;
+            geometry?: string | IGeometry.Def;
+            /**
+             * Adjust values that differ from the preset's defaults, by name (`adj`, `adj1`…).
+             */
+            adjustments?: Record<string, number>;
             /**
              * The fill.
              */
@@ -23730,224 +24967,124 @@ declare global {
             /**
              * A hyperlink for the entire shape.
              */
-            hyperlink?: string | IHyperlink.JSON;
+            hyperlink?: IHyperlink.JSON;
         }
         /**
          * A JSON representation useful for persistence.
          */
-        interface JSON extends Omit<Properties, 'fill' | 'stroke' | 'geometry'> {
-            fill?: IFill.SolidJSON | IFill.GradientJSON | IFill.PatternJSON | IFill.NoneJSON;
-            stroke?: IStroke.JSON;
-            geometry?: string | GeometryJSON;
-            /** Which drawing element this was read from ("sp" | "cxnSp" | "grpSp") — `getType()` always
-             * reports "shape" regardless, so this is the only place the distinction survives a round trip. */
-            type?: string;
-            /** Opaque source XML fragment, captured verbatim from the source file and replayed as-is on
-             * save, for whatever this shape doesn't (yet) model structurally. */
-            xml?: string;
-            /** The `mc:Fallback` rendition of `xml`, captured verbatim, when the source offered the shape as an
-             * `mc:AlternateContent`. An equation's fallback is where its linear text form is. */
-            fallbackXml?: string;
-            /** Original `cNvPr` id from the captured source fragment, if any; used to avoid id collisions
-             * with freshly-generated ids on write. */
-            sourceId?: number;
-        }
-        interface GeometryProperties {
-            geometry?: PresetGeometry;
-            ah: (PolarAdjustmentHandle | XYAdjustmentHandle)[];
-            av?: IShape.AdjustmentGuide[];
-            connections?: IShape.ConnectionSite[];
-            guides?: IShape.AdjustmentGuide[];
-            paths?: IShape.Path[] | string[] | string;
+        interface JSON extends Omit<Properties, 'fill' | 'stroke' | 'geometry' | 'hyperlink'> {
             /**
-             * Specifies the rectangular bounding box for text within the shape.
-             * @defaultValue `null` - The bounds of the shape,
-             */
-            textBounds?: Rectangle;
-        }
-        interface Path {
-            paths: string[];
-            /**
-             * Specifies that the use of 3D extrusions are possible on this path. This allows the generating application to know whether
-             * 3D extrusion can be applied in any form.
-             *
-             * @defaultValue `false`
+             * What kind of drawing this is. Absent for a {@link Type.Shape | shape}; a connector, a group
+             * and a group's picture member state theirs.
              */
-            extrusionOk?: boolean;
+            type?: Type;
+            fill?: IFill.SolidJSON | IFill.GradientJSON | IFill.PatternJSON | IFill.ImageJSON | IFill.NoneJSON;
+            stroke?: IStroke.JSON;
             /**
-             * Specifies how the corresponding path should be filled.
-             *
-             * @defaultValue `PathFill.Normal`
-             */
-            pathFill?: PathFill;
+             * The shape's effects (`spPr/effectLst`). An empty list is an explicit none: the element
+             * present and empty, which turns off the effects the shape's theme style would give it.
+             */
+            effects?: IEffect.JSON[];
+            /** The 3-D scene (`spPr/scene3d`) as the file states it: an opaque DrawingML fragment. */
+            scene3d?: string;
+            /** The 3-D shape properties (`spPr/sp3d`) as the file states it: an opaque DrawingML fragment. */
+            shape3d?: string;
+            /** Extension lists kept as the file states them, by the element each extends. */
+            extLst?: ExtLstJSON;
+            geometry?: string | IGeometry.Def;
+            /** The hyperlink on the whole shape (`cNvPr/hlinkClick`). */
+            hyperlink?: IHyperlink.JSON;
+            /** The hyperlink followed on hover (`cNvPr/hlinkHover`). */
+            hoverHyperlink?: IHyperlink.JSON;
+            /** The title (`cNvPr/@title`), beside the description. */
+            title?: string;
+            /** The macro bound to the shape (`sp/@macro`), as the file states it. */
+            macro?: string;
+            /** The cell a text box's text is linked to (`sp/@textlink`), as the file states it. */
+            textLink?: string;
+            /** The text cannot be edited while the sheet is protected (`sp/@fLocksText`). */
+            locksText?: boolean;
+            /** `sp/@fPublished`. */
+            published?: boolean;
+            /** The shape was inserted as a text box (`cNvSpPr/@txBox`). */
+            textBox?: boolean;
+            /**
+             * Edit locks (`spLocks`/`cxnSpLocks`) by the file's own names: `noGrp`, `noSelect`, `noRot`,
+             * `noChangeAspect`, `noMove`, `noResize`, `noEditPoints`, `noAdjustHandles`,
+             * `noChangeArrowheads`, `noChangeShapeType`, `noTextEdit`.
+             */
+            locks?: Record<string, boolean>;
+            /** A connector's glued ends. */
+            connectorEnds?: {
+                start?: ConnectorEndJSON;
+                end?: ConnectorEndJSON;
+            };
+            /** The text written on the shape, by paragraph. Absent for a shape with no text body. */
+            text?: ITextFrame.JSON;
             /**
-             * Specifies the height, or maximum y coordinate that should be used for within the path coordinate system. This value determines
-             * the vertical placement of all points within the corresponding path as they will all be calculated using this height attribute
-             * as the max y coordinate.
-             *
-             * @defaultValue `null`
+             * A group's members in z-order. A member is read like any shape but is not captured on its
+             * own: the group's markup holds it. A member's `bounds` are in the group's child space. A
+             * picture among them is a {@link PictureMemberJSON}.
              */
-            h?: number;
+            children?: (JSON | PictureMemberJSON)[];
+            /** Where the shape sits as the file states it (`xfrm`), in pixels. For a group member, in the group's child space. */
+            bounds?: Bounds;
+            /** A group's child space (`chOff`/`chExt`), in pixels: what its members' `bounds` are stated in. */
+            childBounds?: Bounds;
+            /** Rotation in degrees as the file states it on the shape's own `xfrm`. */
+            rotation?: number;
+            /** Mirrored left to right (`xfrm/@flipH`), as the file states it. */
+            flipH?: boolean;
+            /** Mirrored top to bottom (`xfrm/@flipV`), as the file states it. */
+            flipV?: boolean;
             /**
-             * Specifies if the corresponding path should have a path stroke shown. This is a boolean value that will effect on the outline of the path.
-             *
-             * @defaultValue `true`
+             * The theme style the shape draws with wherever it states no fill, stroke or text color of its
+             * own: the file's `style` element, which refers into the theme's format scheme by position.
+             * A reference not stated is Excel's for a new shape (a connector's differ: the first line, no
+             * fill); `null`, the shape has no style and draws only what it states itself.
              */
-            stroke?: boolean;
+            style?: ITheme.StyleRefsJSON | null;
             /**
-             * Specifies the width, or maximum x coordinate that should be used for within the path coordinate system. This value determines
-             * the horizontal placement of all points within the corresponding path as they will all be calculated using this width attribute
-             * as the max x coordinate.
-             *
-             * @defaultValue `null`
+             * The id the file gave the shape (`cNvPr/@id`), which is what a connector's
+             * {@link connectorEnds} name their targets by. A file writes the shape with this id again
+             * (made unique when two shapes share one, as a copy does); a shape without one takes the next.
              */
-            w?: number;
+            sourceId?: number;
         }
         /**
-         * Specifies the manner in which a path should be filled. The lightening and darkening of a path allow for certain parts of the shape
-         * to be colored lighter of darker depending on user preference.
-         */
-        const PathFill: {
-            readonly Darken: "darken";
-            readonly DarkenLess: "darkenLess";
-            readonly Lighten: "lighten";
-            readonly LightenLess: "lightenLess";
-            readonly None: "none";
-            readonly Normal: "normal";
-        };
-        type PathFill = typeof PathFill[keyof typeof PathFill];
-        /**
-         * Specifies the presence of a shape guide that will be used to govern the geometry of the specified shape.
+         * The `extLst` fragments of a shape's elements: opaque DrawingML kept as the file states it and
+         * written back as it was, the one markup that stays once the shape is otherwise JSON. A line's
+         * is on its stroke, a text body's on its body.
          */
-        interface AdjustmentGuide {
-            /**
-             * Specifies the name that will be used to reference to this guide. This name may be used just as a variable
-             * would within an equation. That is this name may be substituted for literal values within other guides or
-             * the specification of the shape path.
-             */
-            name: string;
-            /**
-             * Specifies the formula that will be used to calculate the value for a guide. Each formula has a certain
-             * number of arguments and a specific set of operations to perform on these arguments in order to generate a
-             * value for a guide. There are a total of 17 different formulas available. These are shown below with the usage
-             * for each defined
-             */
-            fmla: string;
+        interface ExtLstJSON {
+            /** `cNvPr/extLst`: the creation id and whatever else extends the non-visual properties. */
+            nonVisual?: string;
+            /** `spPr/extLst`. */
+            properties?: string;
         }
         /**
-         * These adjust handles will specify points within the geometric shape that can be used to perform certain
-         * transform operations on the shape.
+         * A picture inside a group (`pic`): a member like any other, placed by its `bounds` in the
+         * group's child space. Its geometry is a rectangle and its image is its fill.
+         *
+         * @remarks
+         * The fill's `resId` names the image the way {@link IPicture.JSON.resId} names a placed
+         * picture's, and like it is meaningful only inside the persist scope the JSON was made in: a
+         * shape resolves it to the resource when it is created and names the resource again when it
+         * is serialized.
          */
-        interface AdjustmentHandle {
-            /**
-             * The point of the adjustment
-             */
-            pos: Point;
-        }
-        interface PolarAdjustmentHandle extends AdjustmentHandle {
-            type: 'polar';
-            /**
-             * Specifies the name of the guide that will be updated with the adjustment angle from this adjust handle.
-             */
-            gdRefAng: string;
-            /**
-             * Specifies the name of the guide that will be updated with the adjustment radius from this adjust handle.
-             */
-            gdRefR: string;
-            /**
-             * Specifies the maximum angle position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move angularly.
-             */
-            maxAng: number;
-            /**
-             * Specifies the maximum radial position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move radially.
-             */
-            maxR: number;
-            /**
-             * Specifies the minimum angle position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move angularly.
-             */
-            minAng: number;
-            /**
-             * Specifies the minimum radial position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move radially.
-             */
-            minR: number;
-        }
-        interface XYAdjustmentHandle extends AdjustmentHandle {
-            type: 'xy';
-            /**
-             * Specifies the name of the guide that will be updated with the adjustment x position from this adjust handle.
-             */
-            gdRefX: string;
-            /**
-             * Specifies the name of the guide that will be updated with the adjustment y position from this adjust handle.
-             */
-            gdRefY: string;
-            /**
-             * Specifies the maximum horizontal position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move in the x direction.
-             */
-            maxX: number;
-            /**
-             * Specifies the maximum vertical position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move in the y direction.
-             */
-            maxY: number;
-            /**
-             * Specifies the minimum horizontal position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move in the x direction.
-             */
-            minX: number;
-            /**
-             * Specifies the minimum vertical position that is allowed for this adjustment handle. If this attribute is omitted,
-             * then it will be assumed that this adjust handle cannot move in the y direction.
-             */
-            minY: number;
+        interface PictureMemberJSON extends JSON {
+            type: typeof Type.Picture;
+            /** The image, as an image fill. */
+            fill?: IFill.ImageJSON;
         }
         /**
-         * A connection site allows a `ConnectionShape` to be attached to this shape. This connection will be maintained
-         * when the shape is repositioned. It should be noted that this connection is placed within the shape
-         * bounding box using the transform coordinate system which is also called the shape coordinate system,
-         * as it encompasses the entire shape.
+         * One glued end of a connector: the shape it is attached to, by the id the file gives that
+         * shape (its `sourceId` here), and which of that shape's connection sites.
          */
-        interface ConnectionSite {
-            /**
-             * Specifies the incoming connector angle. This angle is the angle around the connection site that an
-             * incoming connector will try to be routed to. This allows connectors to know where the shape is in
-             * relation to the connection site and route connectors so as to avoid any overlap with the shape.
-             */
-            angle: string;
-            /**
-             * Specifies a position coordinate within the shape bounding box. It should be noted that this coordinate
-             * is placed within the shape bounding box using the transform coordinate system which is also called the
-             * shape coordinate system, as it encompasses the entire shape.
-             */
-            pos: Point;
-        }
-        interface GeometryJSON extends GeometryProperties {
-        }
-        interface Events extends IModel.Events {
-        }
-        interface IListeners extends IListener.Callbacks<IShape, IShape.Events> {
-        }
-        interface IConnection {
-        }
-        interface Connection extends IShape.JSON {
-            cxnSp?: any;
+        interface ConnectorEndJSON {
+            id: number;
+            index: number;
         }
-        /**
-         * @see {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_ShapeType_topic_ID0EBTFOB.html#topic_ID0EBTFOB}
-         */
-        const PresetGeometry: {
-            readonly Line: "line";
-            readonly LineInv: "lineInv";
-            readonly triangle: "triangle";
-            readonly rtTriangle: "rtTriangle";
-            readonly Rect: "rect";
-        };
-        type PresetGeometry = typeof PresetGeometry[keyof typeof PresetGeometry];
     }
 
     /**
@@ -24183,12 +25320,9 @@ declare global {
          */
         getCodeName(): string | null;
         /**
-         * How row and column groups are laid out on this sheet.
-         *
-         * @remarks
-         * Always fully populated: a sheet that declares nothing reports the defaults.
+         * The row and column groups on this sheet, and how they are laid out.
          */
-        getOutlineSettings(): Readonly<ISheet.OutlineSettings>;
+        getOutline(): IOutline;
         /**
          * Whether conditional formats on this sheet are recalculated as the sheet changes.
          *
@@ -24893,12 +26027,13 @@ declare global {
              */
             container?: ISheet.ContainerOptions;
             /**
-             * A unique identifier used for identifying this sheet during operations (i.e. copy/paste).
-             * This must be unique for all in-memory instances of a sheet.
+             * The sheet's id ({@link ISheet.getId}): what formulas and operations (copy/paste) identify it
+             * by. Must be unique among all in-memory sheets.
              *
-             * @returns A unique identifier for in memory operations. If not provided a default one will be used.
+             * @returns The id. If not provided a new one is made.
              * @remarks
-             * This is not saved as part of the {@link ISheet.JSON} persisted model.
+             * Not saved as part of the {@link ISheet.JSON} persisted model. A container that names its
+             * sheets before it builds them (a workbook loading its sheets) supplies it.
              */
             uid?: () => string;
             /**
@@ -24994,38 +26129,6 @@ declare global {
                 type: string;
             };
         }
-        /**
-         * How row and column groups are laid out.
-         *
-         * @see {@link ISheet.getOutlineSettings}
-         */
-        interface OutlineSettings {
-            /**
-             * Whether a group's summary row sits below its detail rows. When `false` it sits above them.
-             *
-             * @defaultValue true
-             */
-            summaryBelow: boolean;
-            /**
-             * Whether a group's summary column sits to the right of its detail columns. When `false` it
-             * sits to the left.
-             *
-             * @defaultValue true
-             */
-            summaryRight: boolean;
-            /**
-             * Whether the expand and collapse buttons for groups are shown.
-             *
-             * @defaultValue true
-             */
-            showOutlineSymbols: boolean;
-            /**
-             * Whether the automatic outline styles are applied to summary rows and columns.
-             *
-             * @defaultValue false
-             */
-            applyStyles: boolean;
-        }
         /**
          * A drawing whose shapes are described in the origin format's own legacy vector markup rather
          * than through {@link IMovable | movables}.
@@ -25073,7 +26176,6 @@ declare global {
              */
             cols?: IRange.JSONReference<ICellHeader.JSON>[];
             defaultColSize?: number;
-            outlineLevelCol?: number;
             /**
              * Row headers, each addressed as an entire-row run (`'5:5'`, `'5:12'`).
              *
@@ -25082,7 +26184,6 @@ declare global {
              */
             rows?: IRange.JSONReference<ICellHeader.JSON>[];
             defaultRowSize?: number;
-            outlineLevelRow?: number;
             styles?: IStyleCollection.JSON;
             resources?: IResource.JSON[];
             strings?: string[];
@@ -25135,9 +26236,9 @@ declare global {
             /**
              * The outline settings that differ from their defaults.
              *
-             * @see {@link ISheet.getOutlineSettings}
+             * @see {@link ISheet.getOutline}
              */
-            outline?: Partial<OutlineSettings>;
+            outline?: IOutline.JSON;
             /**
              * Present, as `false`, only when conditional format calculation is turned off.
              *
@@ -25465,6 +26566,10 @@ declare global {
              * Called when headers visibility (hidden) has changed.
              */
             onHiddenChange?(source: ISheetHeader): void;
+            /**
+             * Called when header outline levels, or which groups are collapsed, have changed.
+             */
+            onOutlineChange?(source: ISheetHeader): void;
         }
         interface IListeners extends IListener.Callbacks<ISheetHeader, ISheetHeader.Events> {
         }
@@ -25882,6 +26987,21 @@ declare global {
          * @see {@link setShowZeros}
          */
         isShowZeros(): boolean;
+        /**
+         * Indicate whether the outline symbols (the brackets, the collapse and expand buttons and the
+         * level buttons of the row and column groups) are shown.
+         *
+         * @defaultValue `true`
+         *
+         * @remarks
+         * A view setting, as in Excel (`Window.DisplayOutline`, Ctrl+8): the groups stay on the sheet,
+         * only their symbols are hidden. Round-trips through xlsx `sheetView@showOutlineSymbols`.
+         */
+        setShowOutlineSymbols(showOutlineSymbols: boolean): this;
+        /**
+         * @see {@link setShowOutlineSymbols}
+         */
+        isShowOutlineSymbols(): boolean;
         /**
          * The color of the gridline on the sheet.
          *
@@ -26037,6 +27157,8 @@ declare global {
             showInvalid: boolean;
             /** {@inheritDoc ISheetView.setShowZeros} */
             showZeros: boolean;
+            /** {@inheritDoc ISheetView.setShowOutlineSymbols} */
+            showOutlineSymbols: boolean;
             /** {@inheritDoc ISheetView.setRightToLeft} */
             rightToLeft: boolean;
             /** {@inheritDoc ISheetView.setGridLineColor} */
@@ -26506,6 +27628,17 @@ declare global {
         };
     }
 
+    /**
+     * A spinner: two arrows. Content type `'spinner'`.
+     */
+    export interface ISpinner extends IRangedControl {
+    }
+
+    export namespace ISpinner {
+        interface JSON extends IRangedControl.JSON {
+        }
+    }
+
     /**
      * Contains a collection of interned strings.
      *
@@ -26627,32 +27760,25 @@ declare global {
              */
             miterLimit: number;
             /**
-             * Defines the arrowhead or shape that will be drawn at the first vertex of the given shape.
-             *
-             * @defaultValue `null`.
-             *
-             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-start}
+             * The line end drawn at the start of an open path (DrawingML `headEnd`).
              *
+             * @defaultValue `'none'`
              */
-            markerStart: IStroke.IMarker;
+            headType: IStroke.LineEndType;
+            /** The head's width, relative to the line width. @defaultValue `'med'` */
+            headWidth: IStroke.LineEndSize;
+            /** The head's length, relative to the line width. @defaultValue `'med'` */
+            headLength: IStroke.LineEndSize;
             /**
-             * Defines the arrowhead or shape that will be drawn at all interior vertices of the given shape.
-             *
-             * @defaultValue `null`.
-             *
-             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-mid}
-             *
-             */
-            markerMid: IStroke.IMarker;
-            /**
-             * Defines the arrowhead or shape that will be drawn at final vertex for the given shape.
-             *
-             * @defaultValue `null`.
-             *
-             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-end}
+             * The line end drawn at the end of an open path (DrawingML `tailEnd`).
              *
+             * @defaultValue `'none'`
              */
-            markerEnd: IStroke.IMarker;
+            tailType: IStroke.LineEndType;
+            /** The tail's width, relative to the line width. @defaultValue `'med'` */
+            tailWidth: IStroke.LineEndSize;
+            /** The tail's length, relative to the line width. @defaultValue `'med'` */
+            tailLength: IStroke.LineEndSize;
             /**
              * Custom or preset for the stroke.
              */
@@ -26677,20 +27803,24 @@ declare global {
              */
             align: IStroke.Align;
         }
-        /**
-         * A Marker is a custom placeholder for shapes along a stroke.
-         *
-         * @remarks
-         * The Marker contains the positioning and shape of the marker.
-         *
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Element/marker}
-         */
-        interface IMarker {
-            width: number;
-            height: number;
-            axis: number;
-            shape: IStroke.PresetMarkerShape;
-        }
+        /** The shape drawn at an open path's end (DrawingML `ST_LineEndType`). */
+        const LineEndType: {
+            readonly None: "none";
+            readonly Triangle: "triangle";
+            readonly Stealth: "stealth";
+            readonly Diamond: "diamond";
+            readonly Oval: "oval";
+            /** An open arrowhead: two strokes of the line's width. */
+            readonly Arrow: "arrow";
+        };
+        type LineEndType = typeof LineEndType[keyof typeof LineEndType];
+        /** A line end's width or length, relative to the line width (DrawingML `ST_LineEndWidth` / `ST_LineEndLength`). */
+        const LineEndSize: {
+            readonly Small: "sm";
+            readonly Medium: "med";
+            readonly Large: "lg";
+        };
+        type LineEndSize = typeof LineEndSize[keyof typeof LineEndSize];
         /**
          * Support stroke with multiple strokes.
          * ** PLACEHOLDER **
@@ -26794,13 +27924,6 @@ declare global {
             readonly Round: "round";
         };
         type LineJoin = typeof LineJoin[keyof typeof LineJoin];
-        const PresetMarkerShape: {
-            readonly Single: "none";
-            readonly Double: "double";
-            readonly ThickThin: "thickThin";
-            readonly ThinThick: "thinThick";
-        };
-        type PresetMarkerShape = typeof PresetMarkerShape[keyof typeof PresetMarkerShape];
         const StrokeStyle: {
             readonly None: "none";
             readonly Dashed: "dashed";
@@ -26820,6 +27943,8 @@ declare global {
          */
         interface JSON extends Properties {
             fill: IFill.JSON;
+            /** The line's `extLst` as a file states it (DrawingML `ln/extLst`): an opaque fragment, written back as it was. */
+            extLst?: string;
         }
     }
 
@@ -29463,6 +30588,184 @@ declare global {
             readonly Double: "double";
         };
         type StrikeStyle = typeof StrikeStyle[keyof typeof StrikeStyle];
+        /**
+         * How a paragraph's text is aligned between its margins.
+         */
+        const ParagraphAlignment: {
+            readonly Left: "left";
+            readonly Center: "center";
+            readonly Right: "right";
+            /** Spread to both margins, the last line excepted. */
+            readonly Justify: "justify";
+            /** Justified with a low kashida, for Arabic text. */
+            readonly JustifyLow: "justifyLow";
+            /** Every line, the last included, is spread to both margins. */
+            readonly Distributed: "distributed";
+            /** Distributed the way Thai text is. */
+            readonly ThaiDistributed: "thaiDistributed";
+        };
+        type ParagraphAlignment = typeof ParagraphAlignment[keyof typeof ParagraphAlignment];
+        /**
+         * Where runs of different sizes sit on a line.
+         */
+        const FontAlignment: {
+            readonly Auto: "auto";
+            readonly Top: "top";
+            readonly Center: "center";
+            readonly Baseline: "baseline";
+            readonly Bottom: "bottom";
+        };
+        type FontAlignment = typeof FontAlignment[keyof typeof FontAlignment];
+        /**
+         * How a run of drawing text is underlined.
+         *
+         * @remarks
+         * Drawing text has more underlines than a cell's font ({@link IFont.UnderlineStyle}); the two
+         * agree on `none`, `single` and `double`.
+         */
+        const UnderlineStyle: {
+            readonly None: "none";
+            /** Each word underlined, the spaces between them not. */
+            readonly Words: "words";
+            readonly Single: "single";
+            readonly Double: "double";
+            readonly Heavy: "heavy";
+            readonly Dotted: "dotted";
+            readonly DottedHeavy: "dottedHeavy";
+            readonly Dash: "dash";
+            readonly DashHeavy: "dashHeavy";
+            readonly DashLong: "dashLong";
+            readonly DashLongHeavy: "dashLongHeavy";
+            readonly DotDash: "dotDash";
+            readonly DotDashHeavy: "dotDashHeavy";
+            readonly DotDotDash: "dotDotDash";
+            readonly DotDotDashHeavy: "dotDotDashHeavy";
+            readonly Wavy: "wavy";
+            readonly WavyHeavy: "wavyHeavy";
+            readonly WavyDouble: "wavyDouble";
+        };
+        type UnderlineStyle = typeof UnderlineStyle[keyof typeof UnderlineStyle];
+        /**
+         * A font named by a run: a family, or one of the theme's two fonts.
+         */
+        interface FontJSON {
+            family?: string;
+            /** The theme's heading (`major`) or body (`minor`) font, in place of a family. */
+            scheme?: IFont.Scheme;
+            /** PANOSE classification as the file states it (ten hex bytes). */
+            panose?: string;
+            /** A family to fall back to, derived from `panose` when read. */
+            fallbacks?: string[];
+            pitch?: string;
+            charset?: IFont.Charset;
+        }
+        /**
+         * How a run is formatted. Sizes are in points, `baseline` is a percentage of the size (`30`
+         * raises the run as a superscript), colors are fills or serialized colors.
+         *
+         * @remarks
+         * Where a cell's font has the same property ({@link IStyledFont.Properties}) the name and
+         * values are the same: `weight`, `style`, `letterSpacing`, `family`.
+         */
+        interface RunPropertiesJSON {
+            /** Font size in points. */
+            size?: number;
+            /** `700` for bold, `400` for regular. */
+            weight?: number;
+            style?: IFont.Style;
+            underline?: UnderlineStyle;
+            strike?: StrikeStyle;
+            /** The text color: a fill (solid, gradient, pattern) or a serialized color. */
+            color?: IFill.JSON | string;
+            /** The Latin font. */
+            font?: FontJSON;
+            eastAsianFont?: FontJSON;
+            complexScriptFont?: FontJSON;
+            symbolFont?: FontJSON;
+            /** Language tag (`en-US`). */
+            language?: string;
+            alternateLanguage?: string;
+            /** Kerning threshold in points. */
+            kerning?: number;
+            /** Character spacing in points. */
+            letterSpacing?: number;
+            /** Baseline shift as a percentage of the font size; positive raises. */
+            baseline?: number;
+            capitals?: SmallCaps;
+            normalizeHeight?: boolean;
+            /** Highlight color, serialized. */
+            highlight?: string;
+            hyperlink?: IHyperlink.JSON;
+            /** The text outline. */
+            outline?: IStroke.JSON;
+            effects?: IEffect.JSON[];
+        }
+        /** A run of text. */
+        interface RunJSON extends RunPropertiesJSON {
+            /** The run's text; `'\n'` alone is a line break inside the paragraph. */
+            text: string;
+            /** Set when the run is a field (`fld`): its id and kind (`TxLink`, `slidenum`…). */
+            field?: {
+                id: string;
+                type?: string;
+            };
+        }
+        /** A spacing: in points, or as a percentage of a line (`100` is single spacing). */
+        type SpacingJSON = {
+            points: number;
+        } | {
+            percent: number;
+        };
+        /** A paragraph's bullet. Without a `type` the entry only restyles the inherited bullet. */
+        interface BulletJSON {
+            type?: 'none' | 'char' | 'auto' | 'image';
+            /** The character of a `char` bullet. */
+            char?: string;
+            /** The numbering scheme of an `auto` bullet (`arabicPeriod`, `romanLcParenR`…). */
+            autoType?: string;
+            startAt?: number;
+            font?: FontJSON;
+            fontFollowsText?: boolean;
+            /** Serialized color. */
+            color?: string;
+            colorFollowsText?: boolean;
+            size?: SpacingJSON;
+            sizeFollowsText?: boolean;
+        }
+        interface TabJSON {
+            /** Position in pixels. */
+            position: number;
+            align?: ITextFrame.TabStopAlignment;
+        }
+        /** How a paragraph is laid out. Lengths are in pixels. */
+        interface ParagraphPropertiesJSON {
+            align?: ParagraphAlignment;
+            /** Outline level, `0` to `8`. */
+            level?: number;
+            marginLeft?: number;
+            marginRight?: number;
+            /** First-line indent; negative for a hanging indent. */
+            indent?: number;
+            defaultTabSize?: number;
+            rightToLeft?: boolean;
+            eastAsianLineBreak?: boolean;
+            latinLineBreak?: boolean;
+            hangingPunctuation?: boolean;
+            fontAlign?: FontAlignment;
+            lineSpacing?: SpacingJSON;
+            spaceBefore?: SpacingJSON;
+            spaceAfter?: SpacingJSON;
+            bullet?: BulletJSON;
+            tabs?: TabJSON[];
+            /** The run formatting the paragraph's runs inherit. */
+            defaultRun?: RunPropertiesJSON;
+        }
+        /** A paragraph: runs in order, and how it is laid out. */
+        interface ParagraphJSON extends ParagraphPropertiesJSON {
+            runs: RunJSON[];
+            /** The formatting of the paragraph mark (what a new run at its end takes). */
+            endRun?: RunPropertiesJSON;
+        }
     }
 
     /**
@@ -29934,8 +31237,92 @@ declare global {
              * Centers text at the tab stop.
              */
             readonly Center: "center";
+            /**
+             * Aligns numbers at the tab stop on their decimal point.
+             */
+            readonly Decimal: "decimal";
         };
         type TabStopAlignment = typeof TabStopAlignment[keyof typeof TabStopAlignment];
+        /**
+         * The direction drawing text runs in its body.
+         */
+        const WritingMode: {
+            readonly Horizontal: "horizontal";
+            /** Each line turned 90° clockwise, read top to bottom; lines advance leftwards. */
+            readonly Vertical: "vertical";
+            /** Each line turned 270° clockwise, read bottom to top; lines advance rightwards. */
+            readonly Vertical270: "vertical270";
+            /** WordArt vertical: upright letters stacked top to bottom. */
+            readonly WordArtVertical: "wordArtVertical";
+            /** East Asian vertical: upright ideographs, Latin text turned. */
+            readonly EastAsianVertical: "eastAsianVertical";
+            /** Mongolian vertical: top to bottom, lines advancing rightwards. */
+            readonly MongolianVertical: "mongolianVertical";
+            /** WordArt vertical read right to left. */
+            readonly WordArtVerticalRtl: "wordArtVerticalRtl";
+        };
+        type WritingMode = typeof WritingMode[keyof typeof WritingMode];
+        /** Text insets from the text rectangle, in pixels. */
+        interface InsetsJSON {
+            left?: number;
+            top?: number;
+            right?: number;
+            bottom?: number;
+        }
+        /** How a text body sits in the frame that holds it. */
+        interface BodyJSON {
+            /** Vertical anchor of the text in the frame. */
+            anchor?: VerticalAlignment;
+            /** Center the text box horizontally within the frame. */
+            anchorCenter?: boolean;
+            wrap?: 'none' | 'square';
+            insets?: InsetsJSON;
+            /** `shape` grows the frame to fit the text; `normal` shrinks the text to fit the frame. */
+            autoFit?: Autofit;
+            /** With `normal` autofit: the font scale applied, as a percentage. */
+            fontScale?: number;
+            /** With `normal` autofit: the line spacing reduction applied, as a percentage. */
+            lineSpacingReduction?: number;
+            vertical?: WritingMode;
+            /** What happens to text past the bottom: `visible`, `ellipsis` or `clip`. */
+            verticalOverflow?: Overflow;
+            /** What happens to text past the sides: `visible` or `clip`. */
+            horizontalOverflow?: Overflow;
+            upright?: boolean;
+            rightToLeftColumns?: boolean;
+            columns?: number;
+            /** Space between columns, in pixels. */
+            columnSpacing?: number;
+            fromWordArt?: boolean;
+            forceAntiAlias?: boolean;
+            compatibleLineSpacing?: boolean;
+            spaceFirstLastParagraph?: boolean;
+            /** A preset text warp (`prstTxWarp`) and its adjust values, in the preset grammar's units. */
+            warp?: {
+                preset: string;
+                adjustments?: Record<string, number>;
+            };
+            /** `bodyPr/extLst` as the file states it: an opaque DrawingML fragment, written back as it was. */
+            extLst?: string;
+        }
+        /** The paragraph formatting a text body's levels inherit (`lstStyle`). */
+        interface ListStyleJSON {
+            default?: IText.ParagraphPropertiesJSON;
+            /** Levels 1 to 9, by index; a level the file does not state is absent. */
+            levels?: (IText.ParagraphPropertiesJSON | undefined)[];
+        }
+        /**
+         * The text written in a frame — a shape's text body — as JSON: its paragraphs, how the body
+         * sits in the frame, and the list style the paragraphs inherit from.
+         */
+        interface JSON {
+            paragraphs: IText.ParagraphJSON[];
+            /** Text rotation in degrees, when the body states one. */
+            rotation?: number;
+            /** How the body sits in the frame; absent for the defaults. */
+            body?: BodyJSON;
+            listStyle?: ListStyleJSON;
+        }
         interface CloneableTextFrame extends ITextFrame {
             clone(visitor?: TextVisitor): ITextFrame;
             equals(other: ITextFrame): boolean;
@@ -30253,6 +31640,29 @@ declare global {
         }
         interface FontSchemeJSON extends Partial<FontSchemeProperties> {
         }
+        /**
+         * One reference into a theme style list (`fillRef`, `lnRef`, `effectRef`): the one-based position
+         * in the list, `0` for none, and the color the list entry's placeholder (`phClr`) takes.
+         */
+        interface StyleRefJSON {
+            index: number;
+            color?: string;
+        }
+        /** The font a theme style refers to: the theme's `major` or `minor` font, or `none`, and the text color. */
+        interface FontRefJSON {
+            index: IFont.Scheme;
+            color?: string;
+        }
+        /**
+         * References into the theme's format scheme — what a shape or chart draws with wherever it
+         * states nothing of its own: DrawingML's `style` element.
+         */
+        interface StyleRefsJSON {
+            fill?: StyleRefJSON;
+            stroke?: StyleRefJSON;
+            effect?: StyleRefJSON;
+            font?: FontRefJSON;
+        }
         interface JSON {
             name: string;
             fonts?: ITheme.FontSchemeJSON;
@@ -34017,18 +35427,6 @@ declare global {
      */
     export type LanguageTag = string;
 
-    /**
-     * The placed geometry for all columns — see {@link layoutColumns}.
-     */
-    export interface Layout {
-        /** The slot pitch: the font's line height. Also the column width. */
-        pitch: number;
-        /** One entry per column, in reading order (left → right). */
-        columns: readonly Column[];
-        /** The axis-aligned union of all columns. */
-        bounds: Bounds;
-    }
-
     /**
      * Declares a parameter the engine may hand over UNEVALUATED — the argument's subtree is not run
      * before the call, and it runs only if this call's answer needs it.
@@ -34257,7 +35655,7 @@ declare global {
     export interface Line {
         /**
          * Where the strip's un-rotated top-left sits (content-box coordinate space). The strip is the
-         * line's box (`size`) rotated by the layout {@link Layout.angle angle} **about this point**.
+         * line's box (`size`) rotated by the layout {@link RotatedLayout.angle angle} **about this point**.
          */
         origin: Point;
         /** The un-rotated strip box: the line's text width × line height. */
@@ -34731,6 +36129,66 @@ declare global {
         vol?: 1;
     }
 
+    /**
+     * The kinds of content a movable can place, by type, and how each is created.
+     *
+     * @remarks
+     * A sheet creates a movable's content from its JSON by looking the content's `type` up here. The
+     * built-in kinds (picture, chart, shape, slicer, the form controls) are registered when the SDK
+     * loads; a host registers its own the same way, and from then on a workbook that carries that
+     * type creates the host's content, saves it through its `toJSON`, and offers it to the UI under
+     * the same type (`registerMovableRenderer` in `@sheetxl/react`).
+     *
+     * A type nobody has registered still loads and saves: it becomes an unmodeled content that
+     * carries its JSON as it was.
+     */
+    export namespace MovableContentRegistry {
+        /**
+         * What a movable's content is given when created.
+         */
+        interface CreateOptions extends AbstractMovableContent.ConstructorOptions<any> {
+            /** The content's type, as registered. */
+            type: string;
+            /** The content's JSON, as saved. */
+            json?: any;
+            /** Returns an IResource from the resourceId or null if not found. */
+            fromResourceId?: (resourceId: number) => IResource;
+            /** Useful for load/save/copying. */
+            beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
+            /** Allow for the default lock aspect ratio to be overwritten. */
+            defaultLockAspectRatio?: boolean;
+            /** Resolves an address against the workbook the content lives in. */
+            getRange: (address: string) => ICellRange | null;
+            /** Hands formulas to the calculation engine so they follow structural edits. */
+            holdFormulas: (getExpressions: () => readonly string[]) => IMovable.HeldFormulas;
+        }
+        /**
+         * What a movable needs of its content: {@link IMovable.IContent}, and that it can be saved.
+         */
+        interface Content extends IMovable.IContent {
+            toJSON(toResourceId?: (resource: IResource) => number | null): any;
+        }
+        /**
+         * Creates the content of one kind.
+         */
+        type Factory = (options: CreateOptions) => Content;
+        /**
+         * Registers how a kind of content is created, replacing any earlier registration.
+         *
+         * @param type The content type (`IMovable.IContent.getType()`).
+         * @returns A function that removes the registration.
+         */
+        function register(type: string, factory: Factory): () => void;
+        /**
+         * The factory for a kind of content, or `undefined` if none is registered.
+         */
+        function get(type: string): Factory | undefined;
+        /**
+         * The registered types.
+         */
+        function getTypes(): string[];
+    }
+
     /**
      * Declares that the members reaching a REPEATING scalar parameter are COERCED rather than
      * filtered — one that cannot be coerced is `#VALUE!` for the whole call.
@@ -35938,6 +37396,28 @@ declare global {
         folders: string[];
     }
 
+    /**
+     * The placed geometry for all lines — see {@link layoutLines}.
+     */
+    export interface RotatedLayout {
+        /** The rotation, CSS degrees clockwise, normalized to [0, 360). Never 0 or 180 (callers skip). */
+        angle: number;
+        /**
+         * The available text length along a rotated line before it exhausts the content height. Wrapped
+         * text breaks at this length; fit tests (`####`, repeat fills) measure against it.
+         */
+        lineLength: number;
+        /**
+         * The signed horizontal advance between consecutive line origins (`-lineHeight / sin θ`).
+         * Positive marches right (up-slanted text), negative marches left (down-slanted).
+         */
+        advance: number;
+        /** One entry per laid-out text line, in reading order. */
+        lines: readonly Line[];
+        /** The axis-aligned union of all strips — the painted footprint (may exceed the content box). */
+        bounds: Bounds;
+    }
+
     /**
      * A RunCoords represents a discrete set of values in a single dimension.
      *
@@ -36285,6 +37765,18 @@ declare global {
         thisRow: string;
     }
 
+    /**
+     * The placed geometry for all columns — see {@link layoutColumns}.
+     */
+    export interface StackedLayout {
+        /** The slot pitch: the font's line height. Also the column width. */
+        pitch: number;
+        /** One entry per column, in reading order (left → right). */
+        columns: readonly Column[];
+        /** The axis-aligned union of all columns. */
+        bounds: Bounds;
+    }
+
     /**
      * Returns meta data about the number format.
      */