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

package/types/src/comment/IComment.d.ts

@@ -4,6 +4,8 @@ import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
 import { IPerson } from '../person';
 import { ISheet } from '../sheet';
+import { IMovable } from '../movable';
+import { IRichText } from '../text';
 /**
  * A comment on a cell: the root of a thread, with its replies, or a note.
  *
@@ -15,12 +17,47 @@ import { ISheet } from '../sheet';
  *
  * Anchored to its cell, so it follows a row or column insert or delete and is deleted when its
  * cell is.
+ *
+ * A note is also the content of a {@link getMovable | movable}: the box it is shown in.
  */
-export interface IComment extends IAnchored {
+export interface IComment extends IAnchored, IMovable.IContent {
     /**
      * The comment's identifier, unique within the workbook.
      */
     getId(): string;
+    /**
+     * `'note'` for a note, `'comment'` for a threaded comment.
+     */
+    getType(): string;
+    /**
+     * The box a note is shown in, or `null` for a threaded comment, which has none.
+     *
+     * @remarks
+     * The box is an ordinary movable: it is selected, moved and resized like a picture's, and is
+     * among the sheet's `getMovables()`. Its content is this comment.
+     *
+     * * **Placement.** A box that has not been moved sits where Excel puts a new note, beside its
+     *   cell, and stores nothing. Moving or resizing it stores where it is, relative to its cell,
+     *   so a note copied to another cell keeps its box beside it.
+     * * **Shown or on hover.** `isHidden()` is `true` for a box that appears only while its cell is
+     *   pointed at, which is how a note starts and which a view decides. `setHidden(false)` keeps
+     *   it on the sheet.
+     *
+     * A reply converts a note to a threaded comment, and its box goes with it.
+     *
+     * @example
+     * ```ts
+     * const note = sheet.getComments().add('B2', 'Check this', { asNote: true });
+     * const box = note.getMovable();
+     * box.setHidden(false); // always shown
+     * box.setBounds({ width: 240 });
+     * ```
+     */
+    getMovable(): IMovable | null;
+    /**
+     * Deletes the comment: its replies with it, or a note's box.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * The sheet the comment is on.
      */
@@ -43,12 +80,15 @@ export interface IComment extends IAnchored {
      * Replaces the content.
      *
      * @param content Plain text, or formatting runs for a note.
+     *
+     * @remarks
+     * Drops the comment's mentions: each names a span of the text it was made in.
      */
     setContent(content: IComment.Content, options?: ITransaction.OperationOptions): this;
     /**
      * The content with its formatting runs, or `null` when it is plain text.
      */
-    getRichContent(): IComment.RichContent | null;
+    getRichContent(): IRichText.JSON | null;
     /**
      * The person who wrote the comment, or `null` if the workbook does not know them.
      */
@@ -150,7 +190,7 @@ export declare namespace IComment {
          */
         getContent(): string;
         /**
-         * Replaces the content.
+         * Replaces the content, dropping the reply's mentions.
          */
         setContent(content: IComment.Content, options?: ITransaction.OperationOptions): this;
         /**
@@ -183,42 +223,12 @@ export declare namespace IComment {
         readonly isICommentReply: true;
     }
     /**
-     * One formatted span of a note's content.
+     * What a comment says: plain text, or formatting runs for a note.
      *
      * @remarks
-     * A note keeps Excel's rich text; a threaded comment is plain text and never carries these.
-     * Every property but `text` is optional and inherits the note's default when absent.
-     */
-    interface Run {
-        /**
-         * The text of the span.
-         */
-        text: string;
-        /**
-         * The font name.
-         */
-        font?: string;
-        /**
-         * The font size in points.
-         */
-        size?: number;
-        bold?: boolean;
-        italic?: boolean;
-        /**
-         * The color as a hex string.
-         */
-        color?: string;
-    }
-    /**
-     * Content with formatting: a list of {@link Run | runs}.
+     * A note keeps Excel's rich text; a threaded comment is plain text and never carries runs.
      */
-    interface RichContent {
-        runs: Run[];
-    }
-    /**
-     * What a comment says: plain text, or formatting runs for a note.
-     */
-    type Content = string | RichContent;
+    type Content = string | IRichText.JSON;
     /**
      * The values that can be set on a comment.
      */
@@ -317,23 +327,22 @@ export declare namespace IComment {
     interface ReplyJSON extends EntryJSON {
     }
     /**
-     * The note's box: the shape Excel draws the note in, held as it was read.
-     *
-     * @remarks
-     * Only ever present on a comment read from a file. A comment authored here has none, and is
-     * written with Excel's default box (hidden until hovered, hung to the right of its cell); a
-     * comment that has one is written with that box, its cell rewritten from the comment's so it
-     * stays with the note, its size, fill and offsets replayed as they were.
-     *
-     * Opaque markup, as a half-house — the VML `<v:shape>`, not a {@link IShape.JSON}, whose own
-     * `xml` is DrawingML. What it holds is a movable's worth: the cells and offsets of its corners
-     * (an {@link IMovable.AnchorOffset}), whether it is hidden, and a shape's fill and size. That
-     * is where it graduates to — an anchor, a `hidden` flag and an {@link IShape.JSON} — once the
-     * VML can be read into them; the offsets are the authoring machine's pixels, which is what
-     * keeps them opaque today.
+     * A note's box, where it differs from the default.
      */
     interface BoxJSON {
-        xml: string;
+        /**
+         * Where the box is: the cells and pixel offsets of its top-left and bottom-right corners,
+         * the cells counted from the note's own (`r: -1` is the row above it).
+         *
+         * @remarks
+         * Absent for a box that has not been moved or resized, which is placed beside its cell.
+         */
+        anchor?: IMovable.AnchorOffset;
+        /**
+         * How the box is drawn when that is not Excel's default, held as it was read: the VML
+         * `<v:shape>` without its id, its position or its cell.
+         */
+        xml?: string;
     }
     /**
      * A comment, for persisting.
@@ -351,6 +360,16 @@ export declare namespace IComment {
          * The replies, oldest first.
          */
         replies?: ReplyJSON[];
+        /**
+         * Whether a note's box stays on the sheet rather than appearing on hover.
+         *
+         * @defaultValue false
+         */
+        shown?: boolean;
+        /**
+         * The alternative text of a note's box.
+         */
+        description?: string;
         /**
          * {@inheritDoc IComment.BoxJSON}
          */

package/types/src/comment/NoteMovable.d.ts

@@ -0,0 +1,26 @@
+import { Bounds, ReferenceableClipboard } from '@sheetxl/utils';
+import { IHistory } from '../history';
+import { IMovable } from '../movable';
+import { Movable } from '../movable/Movable';
+/**
+ * The box a note is shown in: a movable whose content is the note.
+ *
+ * @remarks
+ * Two things set it apart from a picture's movable. It is not copied by itself, because a note
+ * travels with its cell. And when a shift removes every cell under it, it goes back beside its
+ * note instead of taking the note with it.
+ */
+export declare class NoteMovable extends Movable {
+    /**
+     * Beside its note, where a new note's box goes.
+     */
+    protected _processContainerRemoved(): IMovable.AnchorOffset | null;
+    /**
+     * A box is not copied by itself: a note travels with its cell.
+     *
+     * {@inheritDoc IHistory.ISnapshotSource.getSnapshot}
+     */
+    getSnapshot(_bounds?: Bounds | ReferenceableClipboard.CopyOptions, _options?: ReferenceableClipboard.CopyOptions): IHistory.ISnapshot<IMovable.SnapshotDestination, IMovable, Bounds>;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=NoteMovable.d.ts.map

package/types/src/comment/_CommentUtils.d.ts

@@ -1,4 +1,5 @@
 import { IPerson } from '../person';
+import { IMovable } from '../movable';
 import { IComment } from './IComment';
 /**
  * Resolve an {@link IComment.Update} to modifiers: a string is the content, `null` is a remove
@@ -12,11 +13,32 @@ export declare function resolveCommentUpdate(update: IComment.Update | undefined
  */
 export declare function contentToText(content: IComment.Content | null | undefined): string;
 /**
- * Content as it is stored: a string when there are no runs or none carries formatting, otherwise
+ * Content as it is stored: a string when there are no runs or none sets a font property, otherwise
  * the runs, copied.
+ *
+ * A run's font also takes the `bold`, `italic` and boolean `underline` spellings a font update
+ * takes. A run in the shape notes were first saved in — `bold`, `italic`, `size`, `color` and a
+ * `font` name beside the text — is read into this one.
  * @internal
  */
 export declare function normalizeContent(content: IComment.Content | null | undefined): IComment.Content;
+/**
+ * A copy of stored content, runs and fonts included.
+ * @internal
+ */
+export declare function copyContent(content: IComment.Content): IComment.Content;
+/**
+ * Reads the anchor out of a box saved as its whole shape, which is how a note's box was kept
+ * before it was read into an anchor.
+ *
+ * @returns The anchor, its cells counted from the note's, and whether the box was shown; `null`
+ * for markup that names no cell or anchor.
+ * @internal
+ */
+export declare function readLegacyBox(xml: string): {
+    anchor: IMovable.AnchorOffset;
+    shown: boolean;
+} | null;
 /**
  * Resolves the author option to a person id.
  * @internal

package/types/src/comment/_NoteBox.d.ts

@@ -0,0 +1,50 @@
+import { IRange } from '@sheetxl/primitives';
+import { Bounds } from '@sheetxl/utils';
+import { IMovable } from '../movable';
+import { Movable } from '../movable/Movable';
+/**
+ * Where a note's box goes when nothing has moved it, and how a note stores where its box is.
+ *
+ * @remarks
+ * The default is Excel's, probed with hidden COM on a 96-DPI machine (2026-09-30): a 144×79 px
+ * box hung 15 px right of its cell and 10 px above its top, flipped to the other side when it
+ * would pass the sheet's last column or row. It is pixel geometry first and the cells those
+ * pixels fall on second, so tall, narrow and hidden rows and columns need no rule of their own.
+ *
+ * A note stores its box's anchor with the cells counted from the note's own, so a note copied
+ * to another cell keeps its box beside it. The box itself is an ordinary movable anchored to the
+ * sheet's cells; these functions convert between the two.
+ * @internal
+ */
+/** The width of a default box, in pixels. */
+export declare const NOTE_DEFAULT_WIDTH = 144;
+/** The height of a default box, in pixels. */
+export declare const NOTE_DEFAULT_HEIGHT = 79;
+/**
+ * The cell geometry placing a box needs: the same three a movable is built with.
+ */
+export type NoteLayout = Required<Pick<Movable.ConstructorOptions, 'getBoundsAtCoords' | 'getCoordsAtBounds' | 'getMaxBounds'>>;
+/**
+ * The bounds of a note's box when nothing has moved or resized it.
+ */
+export declare function defaultNoteBounds(cell: IRange.CellCoords, layout: NoteLayout): Bounds;
+/**
+ * The cells and offsets a box's corners fall on, as a movable is loaded from.
+ */
+export declare function boundsToAnchor(bounds: Bounds, layout: NoteLayout): IMovable.AnchorOffset;
+/**
+ * An anchor with its cells restated relative to the note's cell, which is how a note stores it.
+ */
+export declare function toRelativeAnchor(anchor: IMovable.AnchorOffset, cell: IRange.CellCoords): IMovable.AnchorOffset;
+/**
+ * A stored anchor with its cells restated as the sheet's, held to the sheet.
+ *
+ * @remarks
+ * A corner whose cell would be off the sheet is held to the sheet's edge; its offset is kept.
+ */
+export declare function toAbsoluteAnchor(anchor: IMovable.AnchorOffset, cell: IRange.CellCoords, entire: IRange.Coords): IMovable.AnchorOffset;
+/**
+ * Whether two boxes are drawn in the same place, to the pixel Excel rounds to.
+ */
+export declare function isEqualBounds(a: Bounds, b: Bounds): boolean;
+//# sourceMappingURL=_NoteBox.d.ts.map

package/types/src/condition/BuiltInOperators/AbstractOperator.d.ts

@@ -63,11 +63,36 @@ export declare abstract class AbstractOperator<P> implements ICondition.IOperato
      * measured 2026-08-21), which is the watch's `arrayFirstCell` evaluation.
      */
     protected _resolveOperand(param: Scalar | ICalculation.IFormula | undefined, ctx: ICondition.IContext): Promise<OperandReader | null>;
+    /**
+     * Whether a comparison operand has not been given: absent, or blank text.
+     *
+     * @remarks
+     * A comparison missing an operand is inert, never a comparison against 0. Excel reads a rule
+     * whose `<formula>` is absent or empty that way — a validation flags nothing, a format paints
+     * nothing (measured, `probe-dv-operands` and `probe-cf-operands`) — and its dialogs refuse to
+     * author one.
+     */
+    protected _isMissingOperand(param: Scalar | ICalculation.IFormula | undefined): boolean;
+    /**
+     * The first problem with a comparison operand under `lhsSelector`, as a message key, or `null`.
+     *
+     * @param allowEmptyText Whether `''` is an operand (equal to empty text) rather than one not given.
+     *
+     * @remarks
+     * The rules Excel's dialogs refuse on (measured, `probe-dv-operands`): an operand is required; a
+     * whole-number rule takes an integer, a text-length rule a non-negative integer, a date a serial
+     * from 0, a time a serial in [0, 1); text where a number belongs is refused; a formula must parse.
+     * With no selector (a format's Cell Value rule) any scalar is an operand — Excel accepts text there.
+     */
+    protected _validateOperand(param: Scalar | ICalculation.IFormula | undefined, lhsSelector: ICondition.ISelector | null | undefined, allowEmptyText?: boolean): string | null;
     /**
      * The shared predicate shape of the ordered comparisons (`greaterThan` … `before`): resolve the
      * operand (formula or literal — see {@link _resolveOperand}), then compare per cell. An ERROR
-     * operand never matches; a `null` return means the operand could not resolve and the condition
-     * is inert.
+     * operand never matches; a `null` return means the operand is missing
+     * ({@link _isMissingOperand}) or could not resolve, and the condition is inert.
+     *
+     * An empty cell arrives as `null` and compares as 0, which is how Excel judges one (measured,
+     * `probe-dv-blank`).
      */
     protected _createComparePredicate(param: Scalar | ICalculation.IFormula | undefined, ctx: ICondition.IContext, compare: (value: number, operand: number) => boolean): Promise<ICondition.Predicate | null>;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/BuiltInOperators/AfterEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class AfterEqualToOperator extends AbstractOperator<number | stri
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=AfterEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/AfterOperator.d.ts

@@ -4,5 +4,7 @@ export declare class AfterOperator extends AbstractOperator<number | string> imp
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=AfterOperator.d.ts.map

package/types/src/condition/BuiltInOperators/AndOperator.d.ts

@@ -5,7 +5,9 @@ export declare class AndOperator extends AbstractOperator<readonly ICondition.In
     /** {@inheritDoc ICondition.IOperator.isCombinator} */
     isCombinator(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
-    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/AverageOperator.d.ts

@@ -4,6 +4,8 @@ export declare class AverageOperator extends AbstractOperator<ICondition.Average
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.AverageOption, ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.AverageOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.AverageOption;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/BuiltInOperators/BeforeEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class BeforeEqualToOperator extends AbstractOperator<number | str
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=BeforeEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/BeforeOperator.d.ts

@@ -4,5 +4,7 @@ export declare class BeforeOperator extends AbstractOperator<number | string> im
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=BeforeOperator.d.ts.map

package/types/src/condition/BuiltInOperators/BetweenOperator.d.ts

@@ -6,6 +6,8 @@ export declare class BetweenOperator extends AbstractOperator<ICondition.Between
     createPredicate(param: ICondition.BetweenOption, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.BetweenOption;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.BetweenOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: ICondition.BetweenOption, lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/ContainsOperator.d.ts

@@ -4,5 +4,7 @@ export declare class ContainsOperator extends AbstractOperator<string> implement
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=ContainsOperator.d.ts.map

package/types/src/condition/BuiltInOperators/EndsWithOperator.d.ts

@@ -4,5 +4,7 @@ export declare class EndsWithOperator extends AbstractOperator<string> implement
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=EndsWithOperator.d.ts.map

package/types/src/condition/BuiltInOperators/EqualToOperator.d.ts

@@ -6,6 +6,8 @@ export declare class EqualToOperator extends AbstractOperator<Scalar> implements
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: Scalar | ICalculation.IFormula, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: Scalar | ICalculation.IFormula, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): Scalar | undefined;
 }

package/types/src/condition/BuiltInOperators/ExpressionOperator.d.ts

@@ -6,6 +6,8 @@ import { AbstractOperator } from './AbstractOperator';
  */
 export declare class ExpressionOperator extends AbstractOperator<ICalculation.IFormula | string> implements ICondition.IOperator<ICalculation.IFormula | string> {
     constructor();
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICalculation.IFormula | string, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): string;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */

package/types/src/condition/BuiltInOperators/GreaterThanEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class GreaterThanEqualToOperator extends AbstractOperator<number
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=GreaterThanEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/GreaterThanOperator.d.ts

@@ -4,5 +4,7 @@ export declare class GreaterThanOperator extends AbstractOperator<number | strin
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=GreaterThanOperator.d.ts.map

package/types/src/condition/BuiltInOperators/InSetOperator.d.ts

@@ -6,6 +6,8 @@ export declare class InSetOperator extends AbstractOperator<ICondition.InSetOpti
     acceptsList(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.InSetOption, ctx: ICondition.IContext): ICondition.Predicate | Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.InSetOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.InSetOption;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/BuiltInOperators/LessThanEqualToOperator.d.ts

@@ -4,5 +4,7 @@ export declare class LessThanEqualToOperator extends AbstractOperator<number | s
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=LessThanEqualToOperator.d.ts.map

package/types/src/condition/BuiltInOperators/LessThanOperator.d.ts

@@ -4,5 +4,7 @@ export declare class LessThanOperator extends AbstractOperator<number | string>
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: number | string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=LessThanOperator.d.ts.map

package/types/src/condition/BuiltInOperators/NotOperator.d.ts

@@ -6,6 +6,8 @@ export declare class NotOperator extends AbstractOperator<ICondition.Input> impl
     isCombinator(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.Input, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.Input, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: ICondition.Input, lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/OrOperator.d.ts

@@ -5,7 +5,9 @@ export declare class OrOperator extends AbstractOperator<readonly ICondition.Inp
     /** {@inheritDoc ICondition.IOperator.isCombinator} */
     isCombinator(): boolean;
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
-    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.toString} */
     toString(param?: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector): string | undefined;
 }

package/types/src/condition/BuiltInOperators/StartsWithOperator.d.ts

@@ -4,5 +4,7 @@ export declare class StartsWithOperator extends AbstractOperator<string> impleme
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: string, lhsSelector?: ICondition.ISelector | null): string | null;
 }
 //# sourceMappingURL=StartsWithOperator.d.ts.map

package/types/src/condition/BuiltInOperators/TimePeriodOperator.d.ts

@@ -3,6 +3,8 @@ import { AbstractOperator } from './AbstractOperator';
 export declare class TimePeriodOperator extends AbstractOperator<ICondition.TimePeriodOption> {
     constructor();
     createPredicate(param: ICondition.TimePeriodOption, ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    /** {@inheritDoc ICondition.IOperator.validateParam} */
+    validateParam(param: ICondition.TimePeriodOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.TimePeriodOption;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/BuiltInOperators/TopNOperator.d.ts

@@ -4,6 +4,12 @@ export declare class TopNOperator extends AbstractOperator<ICondition.TopNOption
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */
     createPredicate(param: ICondition.TopNOption, ctx: ICondition.IContext): ICondition.Predicate;
+    /**
+     * {@inheritDoc ICondition.IOperator.validateParam}
+     *
+     * Excel's Top 10 dialog takes 1 to 1000 items, or 1 to 100 percent.
+     */
+    validateParam(param: ICondition.TopNOption, lhsSelector?: ICondition.ISelector | null): string | null;
     /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
     createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.TopNOption;
     /** {@inheritDoc ICondition.IOperator.toString} */

package/types/src/condition/Condition.d.ts

@@ -15,6 +15,8 @@ export declare class Condition<P = any> implements ICondition<P> {
     getParam(): P;
     /** {@inheritDoc ICondition.isIncludeBlanks} */
     isIncludeBlanks(): boolean;
+    /** {@inheritDoc ICondition.validate} */
+    validate(): string | null;
     /** {@inheritDoc ICondition.toString} */
     toString(): string;
     /** {@inheritDoc ICondition.toJSON} */