@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.10

package/types/src/sheet/style/SheetCellStyle.d.ts

@@ -6,18 +6,19 @@ import { IColor } from '../../color';
 import { IFill } from '../../fill';
 import { IFont } from '../../font';
 import { ITextFrame, IStyledFont } from '../../text';
-import { IBorder } from '../../border';
-import { IStyle, IStyleCollection } from '../../style';
+import { IBorders } from '../../border';
+import { ICellProtection } from '../../cell';
+import { ICellStyle, IStyleCollection } from '../../style';
 export interface CreateCellStyleOptions {
     styles: IStyleCollection;
     /**
      * Does not include empty or normal style
      */
-    properties: IStyle.Properties | IStyle.Properties[];
+    properties: ICellStyle.Properties | ICellStyle.Properties[];
     /**
      * Used if clone is called.
      */
-    direct: IProperties.ICellRanged<IStyle.Properties, IStyle.Modifiers>;
+    direct: IProperties.ICellRanged<ICellStyle.Properties, ICellStyle.Modifiers>;
     /**
      * A cell style is a specific coords (may be undefined for temporary/coordless cells)
      */
@@ -38,12 +39,12 @@ export interface CreateCellStyleOptions {
     updater: CellStyleUpdater;
 }
 export interface CellStyleUpdater {
-    (update: IStyle.Update, options?: IStyle.UpdateOptions, range?: IRange.Coords): IStyle;
+    (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions, range?: IRange.Coords): ICellStyle;
 }
 /**
  * This is for cell styles that don't have specific properties per row,column
  */
-export declare function resolveStyleUpdate(update: IStyle.Update, prev: (() => IStyle) | IStyle): IStyle.Modifiers;
+export declare function resolveStyleUpdate(update: ICellStyle.Update, prev: (() => ICellStyle) | ICellStyle): ICellStyle.Modifiers;
 declare class InheritableProperties<P, J> {
     protected _p: readonly Readonly<P>[];
     constructor(properties: Readonly<P> | readonly Readonly<P>[]);
@@ -89,54 +90,54 @@ declare class Inheritable<P, J> {
     getProperties(): P;
     toJSON(): J;
 }
-export declare class CellBorderStroke extends Inheritable<IBorder.StrokeProperties, IBorder.StrokeJSON> implements IBorder.IStroke {
-    protected _edge: IBorder.Edge;
-    constructor(edge: IBorder.Edge, options: CreateCellStyleOptions, properties: IBorder.StrokeProperties[]);
-    /** {@inheritDoc IBorder.IStroke.getStyle} */
-    getStyle(): IBorder.StrokeStyle;
-    /** {@inheritDoc IBorder.IStroke.setStyle} */
-    setStyle(style: IBorder.StrokeStyle | string | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
-    /** {@inheritDoc IBorder.IStroke.getColor} */
+export declare class CellBorderStroke extends Inheritable<IBorders.StrokeProperties, IBorders.StrokeJSON> implements IBorders.IStroke {
+    protected _edge: IBorders.Edge;
+    constructor(edge: IBorders.Edge, options: CreateCellStyleOptions, properties: IBorders.StrokeProperties[]);
+    /** {@inheritDoc IBorders.IStroke.getStyle} */
+    getStyle(): IBorders.StrokeStyle;
+    /** {@inheritDoc IBorders.IStroke.setStyle} */
+    setStyle(style: IBorders.StrokeStyle | string | null, options?: ICellStyle.UpdateOptions): IBorders.IStroke;
+    /** {@inheritDoc IBorders.IStroke.getColor} */
     getColor(): IColor;
-    /** {@inheritDoc IBorder.IStroke.setColor} */
-    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
-    /** {@inheritDoc IBorder.IStroke.isNone} */
+    /** {@inheritDoc IBorders.IStroke.setColor} */
+    setColor(color: IColor.Serializable | null, options?: ICellStyle.UpdateOptions): IBorders.IStroke;
+    /** {@inheritDoc IBorders.IStroke.isNone} */
     isNone(): boolean;
-    /** {@inheritDoc IBorder.IStroke.toCSS} */
+    /** {@inheritDoc IBorders.IStroke.toCSS} */
     toCSS(): Partial<CSSStyleDeclaration>;
     get [Symbol.toStringTag](): string;
     toString(): string;
-    /** {@inheritDoc IBorder.IStroke.isIStroke} */
+    /** {@inheritDoc IBorders.IStroke.isIStroke} */
     get isIStroke(): true;
 }
-export declare class CellBorder extends Inheritable<IBorder.Properties, IBorder.JSON> implements IBorder {
-    protected _left: IBorder.IStroke | undefined;
-    protected _right: IBorder.IStroke | undefined;
-    protected _top: IBorder.IStroke | undefined;
-    protected _bottom: IBorder.IStroke | undefined;
-    protected _diagUp: IBorder.IStroke | undefined;
-    protected _diagDown: IBorder.IStroke | undefined;
+export declare class CellBorder extends Inheritable<IBorders.Properties, IBorders.JSON> implements IBorders {
+    protected _left: IBorders.IStroke | undefined;
+    protected _right: IBorders.IStroke | undefined;
+    protected _top: IBorders.IStroke | undefined;
+    protected _bottom: IBorders.IStroke | undefined;
+    protected _diagUp: IBorders.IStroke | undefined;
+    protected _diagDown: IBorders.IStroke | undefined;
     protected _isEmpty: boolean | undefined;
-    /** {@inheritDoc IBorder.getLeft} */
-    getLeft(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setLeft} */
-    setLeft(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getRight} */
-    getRight(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setRight} */
-    setRight(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getTop} */
-    getTop(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setTop} */
-    setTop(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.IStroke.getBottom} */
-    getBottom(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setBottom} */
-    setBottom(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getHorizontal} */
-    getHorizontal(): IBorder.IStroke | null;
-    /** {@inheritDoc IBorder.getVertical} */
-    getVertical(): IBorder.IStroke | null;
+    /** {@inheritDoc IBorders.getLeft} */
+    getLeft(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setLeft} */
+    setLeft(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getRight} */
+    getRight(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setRight} */
+    setRight(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getTop} */
+    getTop(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setTop} */
+    setTop(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.IStroke.getBottom} */
+    getBottom(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setBottom} */
+    setBottom(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getHorizontal} */
+    getHorizontal(): IBorders.IStroke | null;
+    /** {@inheritDoc IBorders.getVertical} */
+    getVertical(): IBorders.IStroke | null;
     /**
      * The inner rule for an axis, read from the authored block rather than the cell.
      *
@@ -147,87 +148,101 @@ export declare class CellBorder extends Inheritable<IBorder.Properties, IBorder.
      * @internal
      */
     private _inner;
-    /** {@inheritDoc IBorder.IStroke.getDiagonalUp} */
-    getDiagonalUp(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setDiagonalUp} */
-    setDiagonalUp(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getDiagonalDown} */
-    getDiagonalDown(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setDiagonalDown} */
-    setDiagonalDown(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.setVertical} */
-    setVertical(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.setHorizontal} */
-    setHorizontal(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.setHorizontal} */
-    setOutline(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorders.IStroke.getDiagonalUp} */
+    getDiagonalUp(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setDiagonalUp} */
+    setDiagonalUp(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getDiagonalDown} */
+    getDiagonalDown(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setDiagonalDown} */
+    setDiagonalDown(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.setVertical} */
+    setVertical(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.setHorizontal} */
+    setHorizontal(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.setHorizontal} */
+    setOutline(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: ICellStyle.UpdateOptions): IBorders;
     /**
      * Resolves whether an edge's effective stroke style is `None` without allocating a
      * `CellBorderStroke`. Mirrors `CellBorderStroke.getStyle()` (last-defined `style` across layers,
      * honoring per-property inheritance).
      */
-    protected _edgeStyleIsNone(edge: IBorder.Edge): boolean;
-    /** {@inheritDoc IBorder.IStroke.isEmpty} */
+    protected _edgeStyleIsNone(edge: IBorders.Edge): boolean;
+    /** {@inheritDoc IBorders.IStroke.isEmpty} */
     isEmpty(): boolean;
     get [Symbol.toStringTag](): string;
     toString(): string;
-    /** {@inheritDoc IBorder.IStroke.isIBorder} */
-    get isIBorder(): true;
+    /** {@inheritDoc IBorders.isIBorders} */
+    get isIBorders(): true;
 }
 export declare class CellAlignment extends Inheritable<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment.JSON> implements ITextFrame.IAlignment {
     /** {@inheritDoc ITextBoxAlignment.getHorizontal} */
     getHorizontal(): ITextFrame.HorizontalAlignment;
     /** {@inheritDoc ITextBoxAlignment.setHorizontal} */
-    setHorizontal(horizontal: ITextFrame.HorizontalAlignment | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setHorizontal(horizontal: ITextFrame.HorizontalAlignment | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getVertical} */
     getVertical(): ITextFrame.VerticalAlignment;
     /** {@inheritDoc ITextBoxAlignment.setVertical} */
-    setVertical(vertical: ITextFrame.VerticalAlignment | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setVertical(vertical: ITextFrame.VerticalAlignment | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getIndent} */
     getIndent(): number;
     /** {@inheritDoc ITextBoxAlignment.setIndent} */
-    setIndent(indent: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setIndent(indent: number | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getRelativeIndent} */
     getRelativeIndent(): number;
     /** {@inheritDoc ITextBoxAlignment.setRelativeIndent} */
-    setRelativeIndent(relativeIndent: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setRelativeIndent(relativeIndent: number | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getOverflow} */
     getOverflow(): ITextFrame.Overflow;
     /** {@inheritDoc ITextBoxAlignment.setOverflow} */
-    setOverflow(overflow: ITextFrame.Overflow | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setOverflow(overflow: ITextFrame.Overflow | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getRotation} */
     getRotation(): number;
     /** {@inheritDoc ITextBoxAlignment.setRotation} */
-    setRotation(rotation: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setRotation(rotation: number | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getStacked} */
     getStacked(): boolean;
     /** {@inheritDoc ITextBoxAlignment.setStacked} */
-    setStacked(stacked: boolean | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setStacked(stacked: boolean | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getJustifyLastLine} */
     getJustifyLastLine(): boolean;
     /** {@inheritDoc ITextBoxAlignment.setJustifyLastLine} */
-    setJustifyLastLine(justifyLastLine: boolean | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setJustifyLastLine(justifyLastLine: boolean | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     /** {@inheritDoc ITextBoxAlignment.getReadingDirection} */
     getReadingDirection(): ITextFrame.ReadingDirection;
     /** {@inheritDoc ITextBoxAlignment.setReadingDirection} */
-    setReadingDirection(readingDirection: ITextFrame.ReadingDirection | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
+    setReadingDirection(readingDirection: ITextFrame.ReadingDirection | null, options?: ICellStyle.UpdateOptions): ITextFrame.IAlignment;
     get [Symbol.toStringTag](): string;
     toString(): string;
     /** {@inheritDoc ITextBoxAlignment.isITextBoxAlignment} */
     get isITextBoxAlignment(): true;
 }
+export declare class CellProtection extends Inheritable<ICellProtection.Properties, ICellProtection.JSON> implements ICellProtection {
+    /** {@inheritDoc ICellProtection.isAlwaysUnlocked} */
+    isAlwaysUnlocked(): boolean;
+    /** {@inheritDoc ICellProtection.setAlwaysUnlocked} */
+    setAlwaysUnlocked(alwaysUnlocked: boolean | null, options?: ICellStyle.UpdateOptions): ICellProtection;
+    /** {@inheritDoc ICellProtection.isShowFormulas} */
+    isShowFormulas(): boolean;
+    /** {@inheritDoc ICellProtection.setShowFormulas} */
+    setShowFormulas(showFormulas: boolean | null, options?: ICellStyle.UpdateOptions): ICellProtection;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ICellProtection.isICellProtection} */
+    get isICellProtection(): true;
+}
 export declare class CellFont extends Inheritable<IStyledFont.Properties, IStyledFont.JSON> implements IStyledFont {
-    /** {@inheritDoc IStyle.isEqualMeasure} */
+    /** {@inheritDoc ICellStyle.isEqualMeasure} */
     isEqualMeasure(other: IStyledFont): boolean;
-    /** {@inheritDoc IStyle.toCSS} */
+    /** {@inheritDoc ICellStyle.toCSS} */
     toCSS(mode?: IColor.CSSMode, zoom?: number, ignoreNormal?: boolean): CSSProperties;
-    /** {@inheritDoc IStyle.isSuperSub} */
+    /** {@inheritDoc ICellStyle.isSuperSub} */
     isSuperSub(): boolean;
-    /** {@inheritDoc IStyle.isSuperSub} */
+    /** {@inheritDoc ICellStyle.isSuperSub} */
     isSuperScript(): boolean;
-    /** {@inheritDoc IStyle.getSuperSubScale} */
+    /** {@inheritDoc ICellStyle.getSuperSubScale} */
     getSuperSubScale(): number;
-    /** {@inheritDoc IStyle.getSuperSubShift} */
+    /** {@inheritDoc ICellStyle.getSuperSubShift} */
     getSuperSubShift(): number;
     /**
      * The theme font this font is a reference to, or `undefined` if it names its own family.
@@ -237,218 +252,97 @@ export declare class CellFont extends Inheritable<IStyledFont.Properties, IStyle
      * where an English one caches `Calibri`), and the scheme is what the reference actually is.
      */
     private _schemeFamily;
-    /** {@inheritDoc IStyle.getFamily} */
+    /** {@inheritDoc ICellStyle.getFamily} */
     getFamily(): string;
-    /** {@inheritDoc IStyle.setFamily} */
-    setFamily(family: string | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getFallbacks} */
+    /** {@inheritDoc ICellStyle.setFamily} */
+    setFamily(family: string | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getFallbacks} */
     getFallbacks(): string[];
-    /** {@inheritDoc IStyle.setFamily} */
-    setFallbacks(fallbacks: string[] | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getSize} */
+    /** {@inheritDoc ICellStyle.setFamily} */
+    setFallbacks(fallbacks: string[] | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getSize} */
     getSize(): number;
-    /** {@inheritDoc IStyle.setSize} */
-    setSize(size: number | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getWeight} */
+    /** {@inheritDoc ICellStyle.setSize} */
+    setSize(size: number | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getWeight} */
     getWeight(): number;
-    /** {@inheritDoc IStyle.setWeight} */
-    setWeight(weight: number | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.setWeight} */
+    setWeight(weight: number | null, options?: ICellStyle.UpdateOptions): IStyledFont;
     /** {@inheritDoc IStyledFont.getBold} */
     getBold(): boolean;
     /** {@inheritDoc IStyledFont.setBold} */
-    setBold(bold: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getStyle} */
+    setBold(bold: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getStyle} */
     getStyle(): IFont.Style;
-    /** {@inheritDoc IStyle.setStyle} */
-    setStyle(style: IFont.Style | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.setStyle} */
+    setStyle(style: IFont.Style | null, options?: ICellStyle.UpdateOptions): IStyledFont;
     /** {@inheritDoc IStyledFont.getItalic} */
     getItalic(): boolean;
     /** {@inheritDoc IStyledFont.setItalic} */
-    setItalic(italic: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getColor} */
+    setItalic(italic: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getColor} */
     getColor(): IColor;
-    /** {@inheritDoc IStyle.setColor} */
-    setColor(color: IColor | string | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getLetterSpacing} */
+    /** {@inheritDoc ICellStyle.setColor} */
+    setColor(color: IColor | string | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getLetterSpacing} */
     getLetterSpacing(): number;
-    /** {@inheritDoc IStyle.setLetterSpacing} */
-    setLetterSpacing(letterSpacing: number | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getUnderline} */
+    /** {@inheritDoc ICellStyle.setLetterSpacing} */
+    setLetterSpacing(letterSpacing: number | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getUnderline} */
     getUnderline(): IFont.UnderlineStyle;
-    /** {@inheritDoc IStyle.setUnderline} */
-    setUnderline(underline: IFont.UnderlineStyle | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getStrike} */
+    /** {@inheritDoc ICellStyle.setUnderline} */
+    setUnderline(underline: IFont.UnderlineStyle | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getStrike} */
     getStrike(): boolean;
-    /** {@inheritDoc IStyle.setStrike} */
-    setStrike(strike: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getScheme} */
+    /** {@inheritDoc ICellStyle.setStrike} */
+    setStrike(strike: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getScheme} */
     getScheme(): IFont.Scheme;
-    /** {@inheritdoc IStyle.setScheme} */
-    setScheme(scheme: IFont.Scheme | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getVerticalAlignment} */
+    /** {@inheritdoc ICellStyle.setScheme} */
+    setScheme(scheme: IFont.Scheme | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getVerticalAlignment} */
     getVerticalAlignment(): IFont.VerticalAlignment;
-    /** {@inheritDoc IStyle.setVerticalAlignment} */
-    setVerticalAlignment(verticalAlign: IFont.VerticalAlignment | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getShadow} */
+    /** {@inheritDoc ICellStyle.setVerticalAlignment} */
+    setVerticalAlignment(verticalAlign: IFont.VerticalAlignment | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getShadow} */
     getShadow(): boolean;
-    /** {@inheritDoc IStyle.setShadow} */
-    setShadow(shadow: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getOutline} */
+    /** {@inheritDoc ICellStyle.setShadow} */
+    setShadow(shadow: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getOutline} */
     getOutline(): boolean;
-    /** {@inheritDoc IStyle.setOutline} */
-    setOutline(outline: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyle.getExtend} */
+    /** {@inheritDoc ICellStyle.setOutline} */
+    setOutline(outline: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.getExtend} */
     getExtend(): boolean;
-    /** {@inheritDoc IStyle.setExtend} */
-    setExtend(extend: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc ICellStyle.setExtend} */
+    setExtend(extend: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
     /** {@inheritDoc IStyledFont.getCharset} */
     getCharset(): IFont.Charset | null;
     /** {@inheritDoc IStyledFont.setCharset} */
-    setCharset(charset: IFont.Charset | null, options?: IStyle.UpdateOptions): IStyledFont;
+    setCharset(charset: IFont.Charset | null, options?: ICellStyle.UpdateOptions): IStyledFont;
     get [Symbol.toStringTag](): string;
     /** {@inheritDoc ICellRanges.toString} */
     toString(): string;
-    /** {@inheritDoc IStyle.isIStyledFont} */
+    /** {@inheritDoc ICellStyle.isIStyledFont} */
     get isIStyledFont(): true;
 }
-export declare class NoneFill extends Inheritable<IFill.NoneProperties, IFill.NoneJSON> implements IFill.INone {
-    /** {@inheritDoc IFill.INone.getType} */
-    getType(): typeof IFill.Type.None;
-    /** {@inheritDoc IFill.INone.getColor} */
-    getColor(): IColor | null;
-    /** {@inheritDoc IFill.INone.setColor} */
-    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill;
-    /** {@inheritDoc IFill.INone.toCSS} */
-    toCSS(_mode?: IColor.CSSMode): CSSProperties;
-    /** {@inheritDoc IFill.hasVisibleStyling} */
-    hasVisibleStyling(): boolean;
-    /** {@inheritDoc IFill.isEqual} */
-    isEqual(other: IFill | null): boolean;
-    /** {@inheritDoc IFill.INone.toJSON} */
-    toJSON(): IFill.NoneJSON;
-    get [Symbol.toStringTag](): string;
-    toString(): string;
-    /** {@inheritDoc IFill.isIFill} */
-    get isIFill(): true;
-}
-export declare class SolidFill extends Inheritable<IFill.SolidProperties, IFill.SolidJSON> implements IFill.ISolid {
-    /** {@inheritDoc IFill.ISolid.getType} */
-    getType(): typeof IFill.Type.Solid;
-    /** {@inheritDoc IFill.ISolid.getColor} */
-    getColor(): IColor;
-    /** {@inheritDoc IFill.ISolid.setColor} */
-    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.ISolid;
-    /** {@inheritDoc IFill.ISolid.toCSS} */
-    toCSS(mode?: IColor.CSSMode): CSSProperties;
-    /** {@inheritDoc IFill.hasVisibleStyling} */
-    hasVisibleStyling(): boolean;
-    /** {@inheritDoc IFill.isEqual} */
-    isEqual(other: IFill | null): boolean;
-    /** {@inheritDoc IFill.ISolid.toJSON} */
-    toJSON(): IFill.SolidJSON;
-    get [Symbol.toStringTag](): string;
-    toString(): string;
-    /** {@inheritDoc IFill.isIFill} */
-    get isIFill(): true;
-}
-export declare class GradientStop extends Inheritable<IFill.GradientStopProperties, any> implements IFill.IGradientStop {
-    protected _i: number;
-    protected _l: number;
-    constructor(index: number, length: number, options: CreateCellStyleOptions, properties: IFill.GradientStopProperties[]);
-    /** {@inheritDoc IFill.IGradientStop.getOffset} */
-    getOffset(): number;
-    /** {@inheritDoc IFill.IGradientStop.getColor} */
-    getColor(): IColor;
-}
-export declare class GradientFill extends Inheritable<IFill.GradientProperties, IFill.GradientJSON> implements IFill.IGradient {
-    /** {@inheritDoc IFill.IGradient.getType} */
-    getType(): typeof IFill.Type.Gradient;
-    /** {@inheritDoc IFill.IGradient.getColor} */
-    getColor(): IColor | null;
-    /** {@inheritDoc IFill.IGradient.setColor} */
-    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IGradient;
-    /** {@inheritDoc IFill.IGradient.getStops} */
-    getStops(): IFill.IGradientStop[];
-    /** {@inheritDoc IFill.IGradient.setStops} */
-    setStops(stops: IFill.IGradientStop[], options?: IStyle.UpdateOptions): IFill.IGradient;
-    /** {@inheritDoc IFill.IGradient.getGradientType} */
-    getGradientType(): IFill.GradientType;
-    /** {@inheritDoc IFill.IGradient.setGradientType} */
-    setGradientType(gradientType: IFill.GradientType, options?: IStyle.UpdateOptions): IFill.IGradient;
-    /** {@inheritDoc IFill.IGradient.getAngle} */
-    getAngle(): number;
-    /** {@inheritDoc IFill.IGradient.setAngle} */
-    setAngle(angle: number, options?: IStyle.UpdateOptions): IFill.IGradient;
-    /** {@inheritDoc IFill.IGradient.getFocus} */
-    getFocus(): Rectangle;
-    /** {@inheritDoc IFill.IGradient.setFocus} */
-    setFocus(focus: Rectangle, options?: IStyle.UpdateOptions): IFill.IGradient;
-    /** {@inheritDoc IFill.IGradient.toCSS} */
-    toCSS(mode?: IColor.CSSMode, size?: Size): CSSProperties;
-    /** {@inheritDoc IFill.hasVisibleStyling} */
-    hasVisibleStyling(): boolean;
-    /** {@inheritDoc IFill.isEqual} */
-    isEqual(other: IFill | null): boolean;
-    /** {@inheritDoc IFill.IGradient.toJSON} */
-    toJSON(): IFill.GradientJSON;
-    get [Symbol.toStringTag](): string;
-    toString(): string;
-    /** {@inheritDoc IFill.isIFill} */
-    get isIFill(): true;
-}
-export declare class PatternFill extends Inheritable<IFill.PatternProperties, IFill.PatternJSON> implements IFill.IPattern {
-    /** {@inheritDoc IFill.IPattern.getType} */
-    getType(): typeof IFill.Type.Pattern;
-    /** {@inheritDoc IFill.IPattern.getColor} */
-    getColor(): IColor;
-    /** {@inheritDoc IFill.IPattern.setColor} */
-    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
-    /** {@inheritDoc IFill.IPattern.getBackground} */
-    getBackground(): IColor;
-    /** {@inheritDoc IFill.ISolid.setBackground} */
-    setBackground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
-    /** {@inheritDoc IFill.IPattern.getForeground} */
-    getForeground(): IColor;
-    /** {@inheritDoc IFill.ISolid.setForeground} */
-    setForeground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
-    /** {@inheritDoc IFill.IPattern.getPatternType} */
-    getPatternType(): IFill.BuiltInSheetPattern;
-    /** {@inheritDoc IFill.IGradient.setPatternType} */
-    setPatternType(patternType: IFill.BuiltInSheetPattern, options?: IStyle.UpdateOptions): IFill.IPattern;
-    /** {@inheritDoc IFill.IPattern.toCSS} */
-    toCSS(mode?: IColor.CSSMode): CSSProperties;
-    /** {@inheritDoc IFill.IPattern.toCSSMask} */
-    toCSSMask(mode?: IColor.CSSMode): {
-        base: CSSProperties;
-        marks: CSSProperties;
-    } | null;
-    /** {@inheritDoc IFill.hasVisibleStyling} */
-    hasVisibleStyling(): boolean;
-    /** {@inheritDoc IFill.isEqual} */
-    isEqual(other: IFill | null): boolean;
-    /** {@inheritDoc IFill.IPattern.toJSON} */
-    toJSON(): IFill.PatternJSON;
-    get [Symbol.toStringTag](): string;
-    toString(): string;
-    /** {@inheritDoc IFill.isIFill} */
-    get isIFill(): true;
-}
-export declare class SheetCellStyle implements IStyle {
+export declare class SheetCellStyle implements ICellStyle {
     protected _o: CreateCellStyleOptions;
-    protected _p: InheritableProperties<IStyle.Properties, IStyle.JSON>;
+    protected _p: InheritableProperties<ICellStyle.Properties, ICellStyle.JSON>;
     protected _bestFit: Partial<Size> | undefined;
     protected _insets: Rectangle | undefined;
     protected _hasVisibleStyling: boolean | undefined;
     protected _font: IStyledFont | undefined;
     protected _alignment: ITextFrame.IAlignment | undefined;
-    protected _border: IBorder | undefined;
+    protected _border: IBorders | undefined;
     protected _fill: IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone | undefined;
+    protected _protection: ICellProtection | undefined;
     constructor(options: CreateCellStyleOptions);
-    /** {@inheritDoc IStyle.toJSON} */
-    toJSON(): IStyle.JSON;
-    /** {@inheritDoc IStyle.hasVisibleStyling} */
+    /** {@inheritDoc ICellStyle.toJSON} */
+    toJSON(): ICellStyle.JSON;
+    /** {@inheritDoc ICellStyle.hasVisibleStyling} */
     hasVisibleStyling(): boolean;
-    /** {@inheritDoc IStyle.isNormal} */
+    /** {@inheritDoc ICellStyle.isNormal} */
     isNormal(): boolean;
     /**
      * The AUTHORED (explicit) properties of this style: the direct layer values plus the `named`
@@ -456,75 +350,86 @@ export declare class SheetCellStyle implements IStyle {
      * re-derive at read time from the destination's own cascade. This is what a write/copy of this
      * style persists (see resolveStyleUpdate).
      */
-    getAuthoredProperties(): IStyle.Properties;
-    /** {@inheritDoc IStyle.createStyle} */
-    createStyle(update: IStyle.Update): IStyle;
-    /** {@inheritDoc IStyle.measureText} */
+    getAuthoredProperties(): ICellStyle.Properties;
+    /** {@inheritDoc ICellStyle.createStyle} */
+    createStyle(update: ICellStyle.Update): ICellStyle;
+    /** {@inheritDoc ICellStyle.measureText} */
     measureText(text: string, size?: number, family?: string, options?: IFont.MetricOptions): IFont.ExtendedMetrics;
-    /** {@inheritDoc IStyle.createTextFrame} */
+    /** {@inheritDoc ICellStyle.createTextFrame} */
     createTextFrame(text: string, allowWrap?: boolean): ITextFrame;
-    /** {@inheritDoc IStyle.update} */
-    update(update: IStyle.Update, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.clear} */
-    clear(): IStyle;
-    /** {@inheritDoc IStyle.getBestFit} */
+    /** {@inheritDoc ICellStyle.update} */
+    update(update: ICellStyle.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.clear} */
+    clear(): ICellStyle;
+    /** {@inheritDoc ICellStyle.getBestFit} */
     getBestFit(): Partial<Size> | null;
-    /** {@inheritDoc IStyle.getInsets} */
+    /** {@inheritDoc ICellStyle.getInsets} */
     getInsets(): Rectangle;
-    /** {@inheritDoc IStyle.getBorder} */
-    getBorder(): IBorder;
-    /** {@inheritDoc IStyle.setBorder} */
-    setBorder(border: IBorder.Update, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.getFont} */
+    /** {@inheritDoc ICellStyle.getBorders} */
+    getBorders(): IBorders;
+    /** {@inheritDoc ICellStyle.setBorders} */
+    setBorders(borders: IBorders.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getFont} */
     getFont(): IStyledFont;
-    /** {@inheritDoc IStyle.setFont} */
-    setFont(font: IStyledFont.Update, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.getFill} */
+    /** {@inheritDoc ICellStyle.setFont} */
+    setFont(font: IStyledFont.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getFill} */
     getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
-    /** {@inheritDoc IStyle.setFill} */
-    setFill(fill: IFill.Update, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.setFill} */
-    setFillSolid(options?: IStyle.UpdateOptions): IFill.ISolid;
-    /** {@inheritDoc IStyle.setFill} */
-    setFillGradient(options?: IStyle.UpdateOptions): IFill.IGradient;
-    /** {@inheritDoc IStyle.setFill} */
-    setFillPattern(options?: IStyle.UpdateOptions): IFill.IPattern;
-    /** {@inheritDoc IStyle.setFill} */
-    setFillNone(options?: IStyle.UpdateOptions): IFill.INone;
-    /** {@inheritDoc IStyle.getAlignment} */
+    /** {@inheritDoc ICellStyle.setFill} */
+    setFill(fill: IFill.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.setFill} */
+    setFillSolid(options?: ICellStyle.UpdateOptions): IFill.ISolid;
+    /** {@inheritDoc ICellStyle.setFill} */
+    setFillGradient(options?: ICellStyle.UpdateOptions): IFill.IGradient;
+    /** {@inheritDoc ICellStyle.setFill} */
+    setFillPattern(options?: ICellStyle.UpdateOptions): IFill.IPattern;
+    /** {@inheritDoc ICellStyle.setFill} */
+    setFillNone(options?: ICellStyle.UpdateOptions): IFill.INone;
+    /** {@inheritDoc ICellStyle.getAlignment} */
     getAlignment(): ITextFrame.IAlignment;
-    /** {@inheritDoc IStyle.setAlignment} */
-    setAlignment(alignment: ITextFrame.IAlignment.Update | string | null, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.getNumberFormat} */
+    /** {@inheritDoc ICellStyle.setAlignment} */
+    setAlignment(alignment: ITextFrame.IAlignment.Update | string | null, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getNumberFormat} */
     getNumberFormat(): string;
-    /** {@inheritDoc IStyle.setNumberFormat} */
-    setNumberFormat(numFmt: string | null, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.getQuotePrefix} */
+    /**
+     * The number format as stored: a built-in id or a format code. {@link getNumberFormat} resolves
+     * an id to its code.
+     *
+     * @internal
+     */
+    getNumberFormatRef(): string | number;
+    /** {@inheritDoc ICellStyle.setNumberFormat} */
+    setNumberFormat(numFmt: string | null, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getQuotePrefix} */
     getQuotePrefix(): boolean;
-    /** {@inheritDoc IStyle.setQuotePrefix} */
-    setQuotePrefix(quotePrefix: boolean | null, options?: IStyle.UpdateOptions): IStyle;
-    /** {@inheritDoc IStyle.getNamed} */
-    getNamed(): IStyle.INamed;
-    /** {@inheritDoc IStyle.setNamed} */
-    setNamed(named: string | IStyle.INamed | null, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc ICellStyle.setQuotePrefix} */
+    setQuotePrefix(quotePrefix: boolean | null, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getProtection} */
+    getProtection(): ICellProtection;
+    /** {@inheritDoc ICellStyle.setProtection} */
+    setProtection(protection: ICellProtection.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getNamed} */
+    getNamed(): ICellStyle.INamed;
+    /** {@inheritDoc ICellStyle.setNamed} */
+    setNamed(named: string | ICellStyle.INamed | null, options?: ICellStyle.UpdateOptions): ICellStyle;
     get [Symbol.toStringTag](): string;
     toString(): string;
-    /** {@inheritDoc IStyle.isIStyle} */
-    get isIStyle(): true;
+    /** {@inheritDoc ICellStyle.isICellStyle} */
+    get isICellStyle(): true;
 }
 /**
- * Create an `IStyle` using the properties.
+ * Create an `ICellStyle` using the properties.
  *
  * @remarks
  * Not part of the public interface.
  */
-export declare function createCellStyle(value: Scalar | undefined, styles: IStyleCollection, layer: IProperties.ICellRanged<IStyle.Properties>, range?: Readonly<IRange.Coords>, updater?: CellStyleUpdater, extent?: Readonly<IRange.Coords>): IStyle;
+export declare function createCellStyle(value: Scalar | undefined, styles: IStyleCollection, layer: IProperties.ICellRanged<ICellStyle.Properties>, range?: Readonly<IRange.Coords>, updater?: CellStyleUpdater, extent?: Readonly<IRange.Coords>): ICellStyle;
 export declare class EmptyStyle extends SheetCellStyle {
-    /** {@inheritDoc IStyle.hasVisibleStyling} */
+    /** {@inheritDoc ICellStyle.hasVisibleStyling} */
     hasVisibleStyling(): boolean;
 }
 export declare class NormalStyle extends SheetCellStyle {
-    /** {@inheritDoc IStyle.isNormal} */
+    /** {@inheritDoc ICellStyle.isNormal} */
     isNormal(): boolean;
     /**
      * {@inheritDoc SheetCellStyle.getAuthoredProperties}
@@ -533,8 +438,8 @@ export declare class NormalStyle extends SheetCellStyle {
      * marker). Without this, a customized Normal's def values would be copied as explicit direct
      * formatting (the `direct` layer here is the normal ranged def, not cell-authored values).
      */
-    getAuthoredProperties(): IStyle.Properties;
+    getAuthoredProperties(): ICellStyle.Properties;
 }
-export declare function ReadOnlyUpdater(update: IStyle.Update): IStyle;
+export declare function ReadOnlyUpdater(update: ICellStyle.Update): ICellStyle;
 export {};
 //# sourceMappingURL=SheetCellStyle.d.ts.map