@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

package/types/src/sheetView/ISheetView.d.ts

@@ -0,0 +1,439 @@
+import { IRange } from '@sheetxl/primitives';
+import { TopLeft } from '@sheetxl/utils';
+import { IListener } from '../listener';
+import { IColor } from '../color';
+import { IMovable, IMovableSelection } from '../movable';
+import { IRangeSelection } from '../selection';
+import { ISheet } from '../sheet';
+/**
+ * The `ISheetView` provides properties and methods for controlling how a sheet is displayed and interacted with,
+ * without affecting the underlying data itself.
+ *
+ * View settings include aspects like frozen panes, zoom level, selection, gridlines visibility, and whether formulas are displayed.
+ * but do not affect the underlying data itself.
+ *
+ * @remarks
+ * * Since views only affect the presentation of the data, changes to view settings are typically not included in the undo/redo stack.
+ * * Multiple views can be associated to the same collection of data, each providing a different way of viewing and interacting.
+ */
+export interface ISheetView extends IMovableSelection, IListener.ISource<IMovableSelection> {
+    /**
+     * The top left scroll position of the (main) pane.
+     *
+     * @remarks
+     * Expressed in zoom-independent (base, unzoomed) px. Screen/scroll position is derived as
+     * `base * zoomScale` at the rendering boundary, so this value is stable across zoom changes.
+     */
+    setTopLeft(topLeft: Partial<TopLeft> | null): this;
+    /**
+     * @see {@link setTopLeft}
+     */
+    getTopLeft(): TopLeft;
+    /**
+     * The first VISIBLE cell — the cell sitting at the grid's top-left corner right now. `A1` when
+     * unscrolled.
+     *
+     * @remarks
+     * The cell-coordinate reading of {@link getTopLeft} (which is base px), resolved against the row /
+     * column headers. Freeze-aware per axis: a frozen band is what actually occupies the corner, so on a
+     * frozen axis the FROZEN pane's own scroll ({@link ISheetView.FreezePanes.topLeft}) answers — normally
+     * leaving that axis at the sheet's start — while an unfrozen axis reads the main scroll. This is the
+     * same split the xlsx writer emits as `sheetView@topLeftCell` / `pane@topLeftCell`.
+     *
+     * Note this is the view's own scroll state, not a rendered measurement; a renderer mid-animation may
+     * briefly show something else.
+     */
+    getTopLeftCell(): IRange.CellCoords;
+    /**
+     * The freeze panes.
+     */
+    setFreezePanes(freezePanes: ISheetView.FreezePanes): this;
+    /**
+     * @see {@link setFreezePanes}
+     */
+    getFreezePanes(): ISheetView.FreezePanes;
+    /**
+     * Show/Hide row headers.
+     *
+     * @defaultValue `true`
+     */
+    setShowRowHeaders(showRowHeaders: boolean): this;
+    /**
+     * @see {@link setShowRowHeaders}
+     */
+    isShowRowHeaders(): boolean;
+    /**
+     * Show/Hide columns headers.
+     *
+     * @defaultValue `true`
+     */
+    setShowColumnHeaders(showColumnHeaders: boolean): this;
+    /**
+     * @see {@link setShowColumnHeaders}
+     */
+    isShowColumnHeaders(): boolean;
+    /**
+     * Show/Hide row gridlines.
+     *
+     * @defaultValue `true`
+     */
+    setShowRowGridlines(showRowGridlines: boolean): this;
+    /**
+     * @see {@link setShowRowGridlines}
+     */
+    isShowRowGridlines(): boolean;
+    /**
+     * Show/Hide column gridlines.
+     *
+     * @defaultValue `true`
+     */
+    setShowColumnGridlines(showColumnGridlines: boolean): this;
+    /**
+     * @see {@link setShowColumnGridlines}
+     */
+    isShowColumnGridlines(): boolean;
+    /**
+     * Style of displaying default row header text.
+     *
+     * @defaultValue {@link HeaderTextStyle.A1}
+     */
+    setRowHeaderStyle(rowHeaderStyle: ISheetView.HeaderTextStyle): this;
+    /**
+     * @see {@link setRowHeaderStyle}
+     */
+    getRowHeaderStyle(): ISheetView.HeaderTextStyle;
+    /**
+     * Style of displaying default column header text.
+     *
+     * @defaultValue {@link HeaderTextStyle.A1}
+     */
+    setColumnHeaderStyle(columnHeaderStyle: ISheetView.HeaderTextStyle): this;
+    /**
+     * @see {@link setColumnHeaderStyle}
+     */
+    getColumnHeaderStyle(): ISheetView.HeaderTextStyle;
+    /**
+     * Controls when the sheet's column headers display table column names.
+     *
+     * @defaultValue {@link ColumnHeaderTableNames.Sticky}
+     */
+    setColumnHeaderTableNames(tableNames: ISheetView.ColumnHeaderTableNames): this;
+    /**
+     * @see {@link setColumnHeaderTableNames}
+     */
+    getColumnHeaderTableNames(): ISheetView.ColumnHeaderTableNames;
+    /**
+     * Zoom. This is expressed as a percentage. Values can be between 10 (10%) or 400 (400%).
+     *
+     * @defaultValue `100`
+     */
+    setZoomScale(zoomScale: number): this;
+    /**
+     * @see {@link setZoomScale}
+     */
+    getZoomScale(): number;
+    /**
+     * Return the next zoom scale based on current zoom.
+     *
+     * @param zoomIn A flag to indicate if zooming in `true` or out `false`.
+     * @param amount The amount to zoom by. If not provided the default steps will be used.
+     */
+    getNextZoomScale(zoomIn: boolean, amount?: number): number;
+    /**
+     * Zoom in the view.
+     */
+    zoomIn(): this;
+    /**
+     * Zoom out the view.
+     */
+    zoomOut(): this;
+    /**
+     * Indicate if view is showing formulas or values
+     *
+     * @defaultValue `false`
+     */
+    setShowFormulas(showFormulas: boolean): this;
+    /**
+     * @see {@link setShowFormulas}
+     */
+    isShowFormulas(): boolean;
+    /**
+     * Indicate whether the sheet is displayed right-to-left (the leftmost column on
+     * the right). Persisted per sheet; round-trips through xlsx `sheetView@rightToLeft`.
+     *
+     * @defaultValue `false`
+     */
+    setRightToLeft(rightToLeft: boolean): this;
+    /**
+     * @see {@link setRightToLeft}
+     */
+    isRightToLeft(): boolean;
+    /**
+     * Indicate whether the sheet should show 0 (zero) or blanks in cells containing zero values.
+     *
+     * @defaultValue `true`
+     *
+     * @remarks
+     * When false, cells with zero value appear blank instead of showing the number zero.
+     */
+    setShowZeros(showZeros: boolean): this;
+    /**
+     * @see {@link setShowZeros}
+     */
+    isShowZeros(): boolean;
+    /**
+     * The color of the gridline on the sheet.
+     *
+     * @defaultValue `null` (adopts the app theme color)
+     *
+     * @remarks
+     * GridLine color is a sheet view attribute but in Excel is a workbook attribute.
+     * If null then use the app theme.
+     */
+    setGridLineColor(gridLineColor: any): this;
+    /**
+     * @see {@link setGridLineColor}
+     */
+    getGridLineColor(): any;
+    /**
+     * Returns a range selection.
+     */
+    getRangeSelection(): IRangeSelection;
+    /**
+     * Add a movable to the selection.
+     * If addToSelection is true then the items will be added to the selection.
+     *
+     * @param movables The movables to select.
+     * @param addToSelection
+     */
+    selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
+    /**
+     * Removes the movables from selection (if they were selected)
+     * @param movables
+     */
+    unselectMovables(movables: readonly IMovable[]): this;
+    /**
+     * Allow for a bulk update of the view properties.
+     */
+    update(properties: Partial<ISheetView.Properties>): this;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: ISheetView.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Persist to JSON.
+     *
+     * @remarks
+     * Returns null if it has no customized values.
+     */
+    toJSON(): ISheetView.JSON | null;
+    /**
+     * For runtime type checking.
+     */
+    readonly isISheetView: true;
+}
+/**
+ * {@inheritDoc ISheetView}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ISheetView}
+ */
+export declare namespace ISheetView {
+    /**
+     * The coordinates for a FreezePane.
+     *
+     * Can have either a coordinate or a topLeft or both.
+     */
+    interface FreezePanes {
+        /**
+         * At least one direction must be set.
+         */
+        coords?: Partial<IRange.CellCoords>;
+        /**
+         * The scroll offset captured at the start of the frozen region.
+         *
+         * @remarks
+         * If the current view has a scroll offset and freeze is called it will 'transfer' the scroll
+         * coordinates. Like {@link ISheetView.setTopLeft | topLeft}, this is expressed in zoom-independent
+         * (base, unzoomed) px and is therefore stable across zoom changes.
+         */
+        topLeft?: Partial<TopLeft>;
+    }
+    /**
+     * A listener for changes to the ISheetView object.
+     */
+    interface Events extends IMovableSelection.Events {
+        /**
+         * Called when the sheetView changes.
+         */
+        onTopLeftChange?(source: ISheetView, change: Readonly<Partial<TopLeft>>): void;
+        /**
+         * Called when the freeze pane settings have changed
+         */
+        onFreezePaneChange?(source: ISheetView): void;
+        /**
+         * Called when the selection changes.
+         */
+        onSelectionChange?(source: ISheetView): void;
+        /**
+         * Called when the zoom scale changes.
+         */
+        onZoomScaleChange?(source: ISheetView): void;
+        /**
+         * Called when the movable selection changes.
+         */
+        onMovableSelectionChange?(source: ISheetView): void;
+        /**
+         * Fired when header settings change.
+         */
+        onHeaderChange?(source: ISheetView): void;
+        /**
+         * Called when the movable selection changes.
+         */
+        onAnyChange?(source: ISheetView): void;
+    }
+    interface IListeners extends IListener.Callbacks<ISheetView, ISheetView.Events> {
+    }
+    /**
+     * A set of values that can be set on a ISheetView.
+     *
+     * @see
+     * {@link ISheetView}
+     */
+    interface Properties {
+        /** The selection coords. `null` when there is no stored selection (it lives on the RangeSelection). */
+        selection?: IRangeSelection.Coords | null;
+        /** {@inheritDoc ISheetView.setTopLeft} */
+        topLeft: TopLeft;
+        /** {@inheritDoc ISheetView.setFreezePanes} */
+        freezePanes: ISheetView.FreezePanes;
+        /** {@inheritDoc ISheetView.setShowRowHeaders} */
+        showRowHeaders: boolean;
+        /** {@inheritDoc ISheetView.setShowColumnHeaders} */
+        showColumnHeaders: boolean;
+        /** {@inheritDoc ISheetView.setShowRowGridlines} */
+        showRowGridlines: boolean;
+        /** {@inheritDoc ISheetView.setShowColumnGridlines} */
+        showColumnGridlines: boolean;
+        /** {@inheritDoc ISheetView.setRowHeaderStyle} */
+        rowHeaderStyle: ISheetView.HeaderTextStyle;
+        /** {@inheritDoc ISheetView.setColumnHeaderStyle} */
+        columnHeaderStyle: ISheetView.HeaderTextStyle;
+        /** {@inheritDoc ISheetView.setColumnHeaderTableNames} */
+        tableNames: ISheetView.ColumnHeaderTableNames;
+        /** {@inheritDoc ISheetView.setZoomScale} */
+        zoomScale: number;
+        /** {@inheritDoc ISheetView.setShowFormulas} */
+        showFormulas: boolean;
+        /** {@inheritDoc ISheetView.setShowZeros} */
+        showZeros: boolean;
+        /** {@inheritDoc ISheetView.setRightToLeft} */
+        rightToLeft: boolean;
+        /** {@inheritDoc ISheetView.setGridLineColor} */
+        gridLineColor: string | IColor | null;
+    }
+    interface ConstructorOptions {
+        /**
+         * Sheets need to be associated with a sheet.
+         */
+        sheet: ISheet;
+        /**
+         * The state to load.
+         */
+        json?: ISheetView.JSON;
+    }
+    /**
+     * A JSON representation useful for persistence.
+     */
+    interface JSON extends Omit<Partial<Properties>, 'selection' | 'topLeft' | 'freezePanes' | 'zoomScale'> {
+        selection?: IRangeSelection.Coords;
+        topLeft?: string | Partial<TopLeft>;
+        freezePanes?: string | FreezePanes;
+        zoomScale?: string | number;
+    }
+    /**
+     * Suggested style for rendering **header text** on either axis.
+     *
+     * The meaning is axis-aware:
+     * - On **column headers**:
+     *   - `A1` → Alphabetic (A, B, C, …, Z, AA, AB, …)
+     *   - `One` → Numeric, 1-based (1, 2, 3, …)
+     *   - `Zero` → Numeric, 0-based (0, 1, 2, …)
+     * - On **row headers**:
+     *   - `A1` → Numeric, 1-based (1, 2, 3, …) — Excel-style rows
+     *   - `One` → Numeric, 1-based (1, 2, 3, …)
+     *   - `Zero` → Numeric, 0-based (0, 1, 2, …)
+     *
+     * @remarks
+     * - This is a **hint** for the header renderer and may be ignored
+     *   (e.g., by a custom `HeaderRenderer`).
+     * - Use {@link ISheetView.setRowHeaderStyle} and
+     *   {@link ISheetView.setColumnHeaderStyle} to apply per-axis preferences.
+     *
+     * @example
+     * // Excel-like: columns as A/B/C…, rows as 1/2/3…
+     * sheetView.setColumnHeaderStyle(HeaderTextStyle.A1);
+     * sheetView.setRowHeaderStyle(HeaderTextStyle.A1);
+     *
+     * @example
+     * // Data-science style: zero-based rows
+     * sheetView.setRowHeaderStyle(HeaderTextStyle.Zero);
+     */
+    const HeaderTextStyle: {
+        /**
+         * Excel-style per axis (columns: A/B/C…, rows: 1/2/3…).
+         */
+        readonly A1: "a1";
+        /**
+         * Numeric, zero-based indexing (0, 1, 2, …).
+         */
+        readonly Zero: "zero";
+        /**
+         * Numeric, one-based indexing (1, 2, 3, …).
+         */
+        readonly One: "one";
+    };
+    type HeaderTextStyle = typeof HeaderTextStyle[keyof typeof HeaderTextStyle];
+    /**
+     * Controls when the sheet’s **column headers** display a table’s **column names**
+     * (instead of the sheet’s configured column-header style).
+     *
+     * @remarks
+     * - View-only: does not affect formulas or underlying data.
+     * - Applies when a table intersects the viewport; exact resolution when multiple
+     *   tables qualify is implementation-defined.
+     * - Complements {@link ISheetView.setFreezePanes | freeze panes} and does not
+     *   “freeze” content—this is a label-substitution rule for the column header UI.
+     *
+     * @example
+     * // Show table column names when the table header row scrolls off-screen
+     * sheetView.setColumnHeaderTableNames(ColumnHeaderTableNames.Sticky);
+     *
+     * @see {@link ISheetView.setColumnHeaderTableNames}
+     * @see {@link ISheetView.getColumnHeaderTableNames}
+     */
+    const ColumnHeaderTableNames: {
+        /**
+         * When a table is visible and its header row has scrolled off-screen,
+         * show that table's column names in the sheet's column headers
+         * (Excel-like sticky behavior).
+         */
+        readonly Sticky: "sticky";
+        /**
+         * When a table is selected but its header row is hidden,
+         * show that table's column names in the sheet's column headers.
+         */
+        readonly Hidden: "hidden";
+        /**
+         * Never show table column names in the sheet's column headers.
+         */
+        readonly None: "none";
+    };
+    /** Type union for {@link ColumnHeaderTableNames}. */
+    type ColumnHeaderTableNames = typeof ColumnHeaderTableNames[keyof typeof ColumnHeaderTableNames];
+}
+//# sourceMappingURL=ISheetView.d.ts.map

package/types/src/sheetView/SheetView.d.ts

@@ -0,0 +1,113 @@
+import { IRange } from '@sheetxl/primitives';
+import { TopLeft } from '@sheetxl/utils';
+import { IListener } from '../listener';
+import { IColor } from '../color';
+import { IMovable, IMovableSelection } from '../movable';
+import { IRangeSelection } from '../selection';
+import { ISheet } from '../sheet';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { ISheetView } from './ISheetView';
+/**
+ * Default Sheet View
+ */
+export declare class SheetView implements ISheetView, IMovableSelection {
+    protected _state: ISheetView.Properties;
+    protected _sheet: ISheet;
+    protected _rangeSelection: IRangeSelection;
+    protected _rangeSelectionRemoveListener: IListener.Remove;
+    protected _emitter: ListenerEmitter<ISheetView, ISheetView.IListeners>;
+    protected _movableSelection: readonly IMovable[];
+    constructor(options: ISheetView.ConstructorOptions);
+    /** {@inheritDoc ISheetView.addListeners} */
+    addListeners(listeners: ISheetView.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc ISheetView.setTopLeft} */
+    setTopLeft(topLeft: Partial<TopLeft>): this;
+    /** {@inheritDoc ISheetView.getTopLeft} */
+    getTopLeft(): TopLeft;
+    /** {@inheritDoc ISheetView.getTopLeftCell} */
+    getTopLeftCell(): IRange.CellCoords;
+    /** {@inheritDoc ISheetView.getFreezePanes} */
+    getFreezePanes(): ISheetView.FreezePanes;
+    /** {@inheritDoc ISheetView.setFreezePanes} */
+    setFreezePanes(freezePanes: Partial<ISheetView.FreezePanes> | null): this;
+    protected _mergeFreezePanes(freezePanes: Partial<ISheetView.FreezePanes> | null): Partial<ISheetView.FreezePanes>;
+    /** {@inheritDoc ISheetView.isShowRowHeaders} */
+    isShowRowHeaders(): boolean;
+    /** {@inheritDoc ISheetView.setShowRowHeaders} */
+    setShowRowHeaders(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowColumnHeaders} */
+    isShowColumnHeaders(): boolean;
+    /** {@inheritDoc ISheetView.setShowColumnHeaders} */
+    setShowColumnHeaders(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowRowGridlines} */
+    isShowRowGridlines(): boolean;
+    /** {@inheritDoc ISheetView.setShowRowGridlines} */
+    setShowRowGridlines(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowColumnGridlines} */
+    isShowColumnGridlines(): boolean;
+    /** {@inheritDoc ISheetView.setShowColumnGridlines} */
+    setShowColumnGridlines(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.getRowHeaderStyle} */
+    getRowHeaderStyle(): ISheetView.HeaderTextStyle;
+    /** {@inheritDoc ISheetView.setRowHeaderStyle} */
+    setRowHeaderStyle(newValue: ISheetView.HeaderTextStyle): this;
+    /** {@inheritDoc ISheetView.setColumnHeaderStyle} */
+    setColumnHeaderStyle(newValue: ISheetView.HeaderTextStyle): this;
+    /** {@inheritDoc ISheetView.getColumnHeaderStyle} */
+    getColumnHeaderStyle(): ISheetView.HeaderTextStyle;
+    /** {@inheritDoc ISheetView.setColumnHeaderTableNames} */
+    setColumnHeaderTableNames(tableNames: ISheetView.ColumnHeaderTableNames): this;
+    /** {@inheritDoc ISheetView.getColumnHeaderTableNames} */
+    getColumnHeaderTableNames(): ISheetView.ColumnHeaderTableNames;
+    /** {@inheritDoc ISheetView.getZoomScale} */
+    getZoomScale(): number;
+    /** {@inheritDoc ISheetView.setZoomScale} */
+    setZoomScale(zoomScale: number): this;
+    /** {@inheritDoc ISheetView.zoomIn} */
+    zoomIn(): this;
+    /** {@inheritDoc ISheetView.zoomOut} */
+    zoomOut(): this;
+    protected _updateZoom(nextZoom: number): this;
+    /** {@inheritDoc ISheetView.getNextZoomScale} */
+    getNextZoomScale(zoomIn: boolean, amount?: number): number;
+    /** {@inheritDoc ISheetView.isShowFormulas} */
+    isShowFormulas(): boolean;
+    /** {@inheritDoc ISheetView.setShowFormulas} */
+    setShowFormulas(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isRightToLeft} */
+    isRightToLeft(): boolean;
+    /** {@inheritDoc ISheetView.setRightToLeft} */
+    setRightToLeft(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowZeros} */
+    isShowZeros(): boolean;
+    /** {@inheritDoc ISheetView.setShowZeros} */
+    setShowZeros(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.getGridLineColor} */
+    getGridLineColor(): any;
+    /** {@inheritDoc ISheetView.setGridLineColor} */
+    setGridLineColor(newValue: IColor | null): this;
+    /** {@inheritDoc ISheetView.getRangeSelection} */
+    getRangeSelection(): IRangeSelection;
+    /** {@inheritDoc ISheetView.getMovableSelection} */
+    getMovableSelection(): readonly IMovable[];
+    /** {@inheritDoc ISheetView.setMovableSelection} */
+    setMovableSelection(newValue: readonly IMovable[] | null): this;
+    /** {@inheritDoc IMovableSelection.selectMovables} */
+    selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
+    /** {@inheritDoc IMovableSelection.unselectMovables} */
+    unselectMovables(movables: IMovable[]): this;
+    protected _update<T extends ISheetView.Properties[K], K extends keyof ISheetView.Properties>(newValue: T, property: K, event: keyof ISheetView.IListeners): T;
+    protected _notifyAll(): void;
+    /** {@inheritDoc ISheetView.toJSON} */
+    toJSON(): ISheetView.JSON | null;
+    protected _fromJSON(json: ISheetView.JSON): void;
+    /** {@inheritDoc ISheetView.clear} */
+    clear(notify?: boolean): this;
+    /** {@inheritDoc ISheetView.update} */
+    update(properties: Partial<ISheetView.Properties>): this;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ISheetView.isISheetView} */
+    get isISheetView(): true;
+}
+//# sourceMappingURL=SheetView.d.ts.map

package/types/src/sheetView/_SheetViewUtils.d.ts

@@ -0,0 +1,19 @@
+import { IRangeSelection } from '../selection';
+import { ISheetView } from './ISheetView';
+/**
+ * Frozen FreezePanes for easy comparisons.
+ */
+export declare const EmptyFreezePanes: ISheetView.FreezePanes;
+/**
+ * Frozen IRangeSelection.Coords for easy comparisons.
+ */
+export declare const EmptySelection: IRangeSelection.Coords;
+export declare const DefaultSheetProperties: ISheetView.Properties;
+/**
+ * A simple stepper.
+ *
+ * @remarks
+ * Used for zoom.
+ */
+export declare function findNextStep(size: number, increase?: boolean, defaultStep?: number, min?: number, max?: number): number;
+//# sourceMappingURL=_SheetViewUtils.d.ts.map

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

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

package/types/src/slicer/ISlicer.d.ts

@@ -0,0 +1,38 @@
+import { IResource } from '../resource';
+import { IModel } from '../model';
+/**
+ * ISplicer
+ *
+ * @remarks
+ * Not fully implemented.
+ *
+ * @hidden
+ * @internal
+ */
+export interface ISlicer extends IModel {
+    toJSON(toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
+    getDescription(): string;
+}
+export declare namespace ISlicer {
+    /**
+     * JSON representation of a slicer.
+     */
+    interface JSON {
+        tableId: string;
+        columnId: string;
+        caption?: string;
+        columnCount?: number;
+        startItem?: number;
+        showCaption?: boolean;
+        level?: number;
+        locked?: boolean;
+        displayHeader?: boolean;
+        sortDescending?: boolean;
+        useCustomLists?: boolean;
+        hideNoDataItems?: boolean;
+        indicateNoDataItems?: boolean;
+        showNoDataItemsLast?: boolean;
+        style?: string;
+    }
+}
+//# sourceMappingURL=ISlicer.d.ts.map

package/types/src/slicer/Slicer.d.ts

@@ -0,0 +1,41 @@
+import { IResource } from '../resource';
+import { IModel, AbstractModel } from '../model';
+import { ISlicer } from './ISlicer';
+/**
+ * Implementation for {@link ISlicer}.
+ */
+export declare class Slicer extends AbstractModel<State, ISlicer.JSON> implements ISlicer {
+    constructor(options: Slicer.ConstructorOptions);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc Movable.Content.getDescription} */
+    getDescription(): string;
+    /** {@inheritDoc Movable.Content.toJSON} */
+    toJSON(_toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
+    /** {@inheritDoc Movable.Content.getTypeDescription} */
+    getTypeDescription(): string;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+}
+/**
+ * Interfaces for creating `Slicer` items.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link Slicer}
+ */
+export declare namespace Slicer {
+    /**
+     * Options for creating a chart.
+     */
+    interface ConstructorOptions extends IModel.ConstructorOptions<ISlicer.JSON> {
+        name: string;
+    }
+}
+interface State extends AbstractModel.State {
+    data?: any;
+    name?: string;
+}
+export {};
+//# sourceMappingURL=Slicer.d.ts.map

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

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