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

package/types/src/movable/IMovable.d.ts

@@ -39,10 +39,11 @@ export interface IMovable extends IAnchored, ITransaction.ITransactional, IHisto
      * | `'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.
@@ -77,11 +78,12 @@ export interface IMovable extends IAnchored, ITransaction.ITransactional, IHisto
      */
     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;
     /**
@@ -94,7 +96,13 @@ export interface IMovable extends IAnchored, ITransaction.ITransactional, IHisto
      */
     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;
     /**
@@ -107,12 +115,16 @@ export interface IMovable extends IAnchored, ITransaction.ITransactional, IHisto
      */
     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;
     /**
@@ -177,6 +189,23 @@ export interface IMovable extends IAnchored, ITransaction.ITransactional, IHisto
  * {@link IMovable}
  */
 export declare 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.
      *

package/types/src/movable/IMovableCollection.d.ts

@@ -86,6 +86,18 @@ export declare namespace IMovableCollection {
          * @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.
@@ -112,9 +124,15 @@ export declare namespace IMovableCollection {
          */
         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

package/types/src/movable/Movable.d.ts

@@ -66,10 +66,30 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     getZIndex(): number;
     /** {@inheritDoc IMovable.setBounds} */
     setBounds(bounds: Partial<Bounds>, options?: ITransaction.OperationOptions): this;
+    /**
+     * Places the movable so that the box it occupies on the sheet as rotated is `anchorBounds`.
+     */
+    private _setAnchorBounds;
     private _updateMovableLocation;
     private _calcAbsoluteBounds;
     /** {@inheritDoc IMovable.getBounds} */
     getBounds(): Bounds | null;
+    /**
+     * The box the movable's anchor states and the box it paints, in pixels: its content's drawing,
+     * which can reach past the frame, turned with the frame. `null` before it is laid out.
+     *
+     * @param onReady Called when the content has a newer answer than the one returned.
+     * @internal
+     */
+    _getDrawnBounds(onReady: () => void): {
+        anchor: Bounds;
+        drawn: Bounds;
+    } | null;
+    /**
+     * The box the movable occupies on the sheet as rotated, which its anchor states; the frame is
+     * this box with its sides swapped within 45° of a quarter turn.
+     */
+    private _getAnchorBounds;
     /** {@inheritDoc IMovable.setAnchorType} */
     setAnchorType(type: IAnchored.Type): this;
     protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;

package/types/src/movable/MovableContentRegistry.d.ts

@@ -0,0 +1,64 @@
+import { IResource, IResourceCollection } from '../resource';
+import { ICellRange } from '../cellRange';
+import { IMovable } from './IMovable';
+import { AbstractMovableContent } from './AbstractMovableContent';
+/**
+ * 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 declare 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[];
+}
+//# sourceMappingURL=MovableContentRegistry.d.ts.map

package/types/src/movable/_BuiltInContents.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=_BuiltInContents.d.ts.map

package/types/src/movable/_DrawnBounds.d.ts

@@ -0,0 +1,33 @@
+import { Bounds } from '@sheetxl/utils';
+/** Edges of a box in a movable's frame, in pixels; they may lie outside the frame. */
+export interface FrameRect {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+/**
+ * Content that can paint outside its frame (a shape: a callout's tail, its line).
+ *
+ * @remarks
+ * Answers synchronously from what it last evaluated, or `null` before it has; `onReady` is called
+ * when a newer answer is ready.
+ */
+export interface DrawnContent {
+    _getDrawnRect(width: number, height: number, onReady: () => void): FrameRect | null;
+}
+export declare const isDrawnContent: (content: unknown) => content is DrawnContent;
+/**
+ * The box a movable paints on the sheet: `rect` (its frame when absent), placed in the unrotated
+ * `frame`, turned by `rotation` degrees clockwise about the frame's center.
+ */
+export declare const drawnBounds: (frame: Bounds, rect: FrameRect | null, rotation: number) => Bounds;
+/**
+ * How far `drawn` reaches past `anchor` on its farthest side, in pixels; `0` when it stays inside.
+ */
+export declare const overhang: (anchor: Bounds, drawn: Bounds) => number;
+/** Whether two boxes overlap or touch. */
+export declare const isBoundsIntersect: (a: Bounds, b: Bounds) => boolean;
+export declare const getDrawnVersion: () => number;
+export declare const bumpDrawnVersion: () => void;
+//# sourceMappingURL=_DrawnBounds.d.ts.map

package/types/src/movable/_RotatedFrame.d.ts

@@ -0,0 +1,20 @@
+import { Bounds } from '@sheetxl/utils';
+/**
+ * Whether a rotation is within 45° of a quarter turn (90° or 270°), in either direction.
+ *
+ * @remarks
+ * Excel's anchor of a rotated drawing is the box of the drawing as rotated, and Excel does not
+ * compute a true rotated bounding box: within 45° of a quarter turn the anchor is the unrotated
+ * frame with its width and height swapped, otherwise it is the frame itself. The same rule
+ * places a member rotated by a quarter turn in a group that is scaled unevenly.
+ */
+export declare const isQuarterTurn: (rotation: number) => boolean;
+/**
+ * Between a drawing's unrotated frame and its anchor, the box it occupies as rotated: within 45°
+ * of a quarter turn the sides are swapped about the same center, otherwise the box is unchanged.
+ *
+ * @remarks
+ * Its own inverse, so it maps a frame to its anchor and an anchor to its frame.
+ */
+export declare const swapForRotation: (bounds: Bounds, rotation: number) => Bounds;
+//# sourceMappingURL=_RotatedFrame.d.ts.map

package/types/src/movable/index.d.ts

@@ -1,8 +1,10 @@
-/**
- * @hidden
- */
-export * from './IControl';
 export * from './IMovable';
 export * from './IMovableCollection';
 export * from './IMovableSelection';
+export * from './MovableContentRegistry';
+export * from './AbstractMovableContent';
+/**
+ * @hidden
+ */
+export * from './IFormControl';
 //# sourceMappingURL=index.d.ts.map

package/types/src/numFmt/BuiltInFormats.d.ts

@@ -49,6 +49,11 @@ export declare function getBuiltInFormatCode(id: number): string | undefined;
  * always returns the canonical code.
  */
 export declare function resolveNumberFormat(ref: NumberFormatRef): string;
+/**
+ * The preset names a format may be given by (`Short Date`, `Fixed`), and the code or built-in
+ * id each stands for. A name is not a code: its letters are not tokens.
+ */
+export declare const XMLFormatMap: Readonly<Record<string, string | number>>;
 /**
  * Find the built-in id Excel saves a format code as, or `undefined` if Excel
  * saves it as a custom format.

package/types/src/numFmt/_NumFmtUtils.d.ts

@@ -43,7 +43,6 @@ export declare function toLocaleDateCore(format: NumberFormatRef, value: number,
     fmt: string;
     date: Date;
 } | null;
-export declare const XMLFormatMap: Readonly<Record<string, string | number>>;
 /**
  * Returns a legacy color as an rgb value
  */

package/types/src/numFmt/vendor/numfmt/_sheetxl.d.ts

@@ -13,3 +13,9 @@ export declare function roundDisplay(value: number, places: number): number;
 
 /** §3a — `String(value)` with the exponential form expanded to plain decimal notation. */
 export declare function toDecimalString(value: number): string;
+
+/**
+ * Which calendar (`date`) and clock (`time`) parts a format code evaluates, read off the
+ * parser. Neither for a code whose only date tokens are elapsed ones, and for an illegal code.
+ */
+export declare function dateTimeParts(pattern: string): { readonly date: boolean, readonly time: boolean };

package/types/src/outline/IOutline.d.ts

@@ -0,0 +1,186 @@
+import { IRange } from '@sheetxl/primitives';
+import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
+/**
+ * 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 declare 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> {
+    }
+}
+//# sourceMappingURL=IOutline.d.ts.map

package/types/src/outline/Outline.d.ts

@@ -0,0 +1,157 @@
+import { IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ISheet } from '../sheet/ISheet';
+import { IOutline } from './IOutline';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { SheetHeader } from '../sheetHeader/SheetHeader';
+import type * as _HeaderUtils from '../sheetHeader/_HeaderUtils';
+type HeaderRun = ITypes.RunCoordValue<_HeaderUtils.CellHeaderState>;
+/**
+ * The groups on one axis, derived from that axis's header runs.
+ */
+interface AxisGroups {
+    runs: readonly HeaderRun[];
+    direction: IRange.Direction;
+    entireMax: number;
+    /** Per level, `byLevel[level - 1]`, ordered and non-overlapping within a level. */
+    byLevel: IOutline.Group[][];
+}
+interface State {
+    summaryRow: IRange.Direction;
+    summaryColumn: IRange.Direction;
+    automaticStyles: boolean;
+}
+/** A summary line and the detail lines it totals, found by {@link Outline.autoOutline}. */
+interface SummarySpan {
+    summary: number;
+    start: number;
+    end: number;
+}
+/**
+ * The outline of a sheet.
+ *
+ * @remarks
+ * Holds only the settings. The levels and collapsed flags live on the header runs, and the groups
+ * are derived from those runs (runs × levels, never a row walk), cached against the run array,
+ * which the headers replace rather than mutate.
+ *
+ * Whether a group is collapsed is derived too, as Excel derives it: its details are all hidden,
+ * and either its summary is showing or the summary carries the collapsed flag. The flag is what
+ * tells an inner group that was collapsed from one that was merely hidden with its outer group,
+ * so it is recorded on every collapsed inner summary before an outer group hides it.
+ */
+export declare class Outline implements IOutline {
+    protected _options: Outline.ConstructorOptions;
+    protected _transactions: ITransaction.IStore;
+    protected _id: string;
+    protected _emitter: ListenerEmitter<IOutline, IOutline.IListeners>;
+    protected _removeListeners: IListener.Remove[];
+    protected _closed: boolean;
+    protected _rowGroups: AxisGroups | null;
+    protected _columnGroups: AxisGroups | null;
+    constructor(options: Outline.ConstructorOptions);
+    protected _getState(): Readonly<State>;
+    protected _updateState(update: Partial<State>, options?: ITransaction.OperationOptions): void;
+    protected _header(axis: IRange.Axis): SheetHeader;
+    protected _sheet(): ISheet;
+    /**
+     * The structure of an outline and its settings need an unprotected sheet, whatever the
+     * protection allows; only showing and hiding details goes by Format Rows / Format Columns.
+     */
+    protected _assertUnlocked(): void;
+    /** {@inheritDoc IOutline.getSummaryDirection} */
+    getSummaryDirection(axis: IRange.Axis): IRange.Direction;
+    /** {@inheritDoc IOutline.setSummaryDirection} */
+    setSummaryDirection(axis: IRange.Axis, direction: IRange.Direction, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IOutline.isAutomaticStyles} */
+    isAutomaticStyles(): boolean;
+    /** {@inheritDoc IOutline.setAutomaticStyles} */
+    setAutomaticStyles(automatic: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IOutline.getLevelCount} */
+    getLevelCount(axis: IRange.Axis): number;
+    /** {@inheritDoc IOutline.getGroups} */
+    getGroups(axis: IRange.Axis, options?: IOutline.GetGroupsOptions): readonly IOutline.Group[];
+    /** {@inheritDoc IOutline.setVisibleLevels} */
+    setVisibleLevels(axis: IRange.Axis, levels: number, options?: ITransaction.OperationOptions): this;
+    protected _setVisibleLevels(axis: IRange.Axis, levels: number): void;
+    /**
+     * Adds `delta` to the outline level of every header in `coords`.
+     *
+     * @internal
+     */
+    _changeLevels(axis: IRange.Axis, coords: RunCoords, delta: 1 | -1, options?: ITransaction.OperationOptions): void;
+    /**
+     * Throws if any header in `coords` is already at the deepest outline level.
+     *
+     * @internal
+     */
+    _assertNotDeepest(axis: IRange.Axis, coords: RunCoords): void;
+    /** {@inheritDoc IOutline.clear} */
+    clear(axes?: IRange.AxisSelection, options?: ITransaction.OperationOptions): this;
+    protected _clearAxis(axis: IRange.Axis): void;
+    /**
+     * Removes the outline levels and collapsed flags from the headers in `coords`.
+     *
+     * @internal
+     */
+    _clear(axis: IRange.Axis, coords: RunCoords, options?: ITransaction.OperationOptions): void;
+    /**
+     * Collapses or expands the groups a span selects: those whose summary falls in it, or, when there
+     * are none, the deepest groups whose details meet it.
+     *
+     * @internal
+     */
+    _setGroupDetails(axis: IRange.Axis, coords: RunCoords, show: boolean, options?: ITransaction.OperationOptions): void;
+    protected _selectGroups(axis: IRange.Axis, coords: RunCoords): IOutline.Group[];
+    /**
+     * The groups nested in `group`, deeper levels only, excluding those that share its summary (one
+     * flag cannot tell the two apart).
+     */
+    protected _innerGroups(axis: IRange.Axis, group: IOutline.Group): IOutline.Group[];
+    protected _hideGroupDetails(axis: IRange.Axis, group: IOutline.Group): void;
+    protected _showGroupDetails(axis: IRange.Axis, group: IOutline.Group): void;
+    /** {@inheritDoc IOutline.autoOutline} */
+    autoOutline(options?: ITransaction.OperationOptions): this;
+    /**
+     * The summary lines of one axis within `scope`, and the direction their details lie in.
+     */
+    protected _findSummaries(scope: IRange.Coords, axis: IRange.Axis): {
+        direction: IRange.Direction;
+        spans: SummarySpan[];
+    };
+    protected _groups(axis: IRange.Axis): AxisGroups;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: IOutline.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IOutline.toJSON} */
+    toJSON(): IOutline.JSON | null;
+    /**
+     * Stops listening and drops the state. Terminal and not undoable.
+     *
+     * @internal
+     */
+    close(): void;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IOutline.isIOutline} */
+    get isIOutline(): true;
+}
+/**
+ * {@inheritDoc Outline}
+ * @see
+ * ### **Interface**
+ *
+ * {@link Outline}
+ */
+export declare namespace Outline {
+    interface ConstructorOptions {
+        rowHeaders: SheetHeader;
+        columnHeaders: SheetHeader;
+        transactions?: ITransaction.IStore;
+        json?: IOutline.JSON | null;
+    }
+}
+export {};
+//# sourceMappingURL=Outline.d.ts.map

package/types/src/outline/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IOutline';
+//# sourceMappingURL=index.d.ts.map