@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

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

@@ -0,0 +1,12 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class BetweenOperator extends AbstractOperator<ICondition.BetweenOption> implements ICondition.IOperator<ICondition.BetweenOption> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: ICondition.BetweenOption, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
+    createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.BetweenOption;
+    /** {@inheritDoc ICondition.IOperator.toString} */
+    toString(param?: ICondition.BetweenOption, lhsSelector?: ICondition.ISelector): string | undefined;
+}
+//# sourceMappingURL=BetweenOperator.d.ts.map

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

@@ -0,0 +1,9 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ICondition } from '../ICondition';
+import { AbstractOperator, ConstructorOptions } from './AbstractOperator';
+export declare class BlankOperator extends AbstractOperator<Scalar> implements ICondition.IOperator<Scalar> {
+    constructor(options?: ConstructorOptions);
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: Scalar, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=BlankOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class ColorOperator extends AbstractOperator<ICondition.ColorOption> implements ICondition.IOperator<ICondition.ColorOption> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: ICondition.ColorOption, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=ColorOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class ContainsOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=ContainsOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class EndsWithOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=EndsWithOperator.d.ts.map

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

@@ -0,0 +1,11 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class EqualToOperator extends AbstractOperator<Scalar> implements ICondition.IOperator<Scalar> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: Scalar, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
+    createDefaultParam(lhsSelector?: ICondition.ISelector): Scalar | undefined;
+}
+//# sourceMappingURL=EqualToOperator.d.ts.map

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

@@ -0,0 +1,9 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ICondition } from '../ICondition';
+import { AbstractOperator, ConstructorOptions } from './AbstractOperator';
+export declare class ErrorOperator extends AbstractOperator<Scalar> implements ICondition.IOperator<Scalar> {
+    constructor(options?: ConstructorOptions);
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: Scalar, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=ErrorOperator.d.ts.map

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

@@ -0,0 +1,17 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+/**
+ * Evaluates a formula expression against the value of the cell.
+ */
+export declare class ExpressionOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
+    createDefaultParam(lhsSelector?: ICondition.ISelector): string;
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+}
+/**
+ * Creates a temporary range. This is for illustrations only.
+ */
+export declare const ExpressionRuleAccumulate: ICondition.IOperator<string>;
+//# sourceMappingURL=ExpressionOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class GreaterThanEqualToOperator extends AbstractOperator<number | string> implements ICondition.IOperator<number | string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+}
+//# sourceMappingURL=GreaterThanEqualToOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class GreaterThanOperator extends AbstractOperator<number | string> implements ICondition.IOperator<number | string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+}
+//# sourceMappingURL=GreaterThanOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class IconOperator extends AbstractOperator<ICondition.IconOption> implements ICondition.IOperator<ICondition.IconOption> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: ICondition.IconOption, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=IconOperator.d.ts.map

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

@@ -0,0 +1,14 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class InSetOperator extends AbstractOperator<ICondition.InSetOption> implements ICondition.IOperator<ICondition.InSetOption> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.acceptsList} */
+    acceptsList(): boolean;
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: ICondition.InSetOption, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
+    createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.InSetOption;
+    /** {@inheritDoc ICondition.IOperator.toString} */
+    toString(param?: ICondition.InSetOption, lhsSelector?: ICondition.ISelector): string | undefined;
+}
+//# sourceMappingURL=InSetOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class LessThanEqualToOperator extends AbstractOperator<number | string> implements ICondition.IOperator<number | string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+}
+//# sourceMappingURL=LessThanEqualToOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class LessThanOperator extends AbstractOperator<number | string> implements ICondition.IOperator<number | string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: number | string, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+}
+//# sourceMappingURL=LessThanOperator.d.ts.map

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

@@ -0,0 +1,12 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class NotOperator extends AbstractOperator<ICondition.Input> implements ICondition.IOperator<ICondition.Input> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.isCombinator} */
+    isCombinator(): boolean;
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: ICondition.Input, ctx: ICondition.IContext): Promise<ICondition.Predicate | null>;
+    /** {@inheritDoc ICondition.IOperator.toString} */
+    toString(param?: ICondition.Input, lhsSelector?: ICondition.ISelector): string | undefined;
+}
+//# sourceMappingURL=NotOperator.d.ts.map

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

@@ -0,0 +1,12 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class OrOperator extends AbstractOperator<readonly ICondition.Input[]> implements ICondition.IOperator<readonly ICondition.Input[]> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.isCombinator} */
+    isCombinator(): boolean;
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: readonly ICondition.Input[], ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+    /** {@inheritDoc ICondition.IOperator.toString} */
+    toString(param?: readonly ICondition.Input[], lhsSelector?: ICondition.ISelector): string | undefined;
+}
+//# sourceMappingURL=OrOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class StartsWithOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=StartsWithOperator.d.ts.map

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

@@ -0,0 +1,13 @@
+import { ICondition } from '../ICondition';
+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.createDefaultParam} */
+    createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.TimePeriodOption;
+    /** {@inheritDoc ICondition.IOperator.toString} */
+    toString(param?: ICondition.TimePeriodOption, lhsSelector?: ICondition.ISelector): string | undefined;
+    private _computeRange;
+    private _quarterRange;
+}
+//# sourceMappingURL=TimePeriodOperator.d.ts.map

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

@@ -0,0 +1,12 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class TopNOperator extends AbstractOperator<ICondition.TopNOption> implements ICondition.IOperator<ICondition.TopNOption> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: ICondition.TopNOption, ctx: ICondition.IContext): ICondition.Predicate;
+    /** {@inheritDoc ICondition.IOperator.createDefaultParam} */
+    createDefaultParam(lhsSelector?: ICondition.ISelector): ICondition.TopNOption;
+    /** {@inheritDoc ICondition.IOperator.toString} */
+    toString(param?: ICondition.TopNOption, lhsSelector?: ICondition.ISelector): string | undefined;
+}
+//# sourceMappingURL=TopNOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class UniqueOperator extends AbstractOperator<any> implements ICondition.IOperator<any> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: any, ctx: ICondition.IContext): Promise<ICondition.Predicate>;
+}
+//# sourceMappingURL=UniqueOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class ValidEmailOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=ValidEmailOperator.d.ts.map

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

@@ -0,0 +1,8 @@
+import { ICondition } from '../ICondition';
+import { AbstractOperator } from './AbstractOperator';
+export declare class ValidUrlOperator extends AbstractOperator<string> implements ICondition.IOperator<string> {
+    constructor();
+    /** {@inheritDoc ICondition.IOperator.createPredicate} */
+    createPredicate(param: string, ctx: ICondition.IContext): ICondition.Predicate;
+}
+//# sourceMappingURL=ValidUrlOperator.d.ts.map

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

@@ -0,0 +1,59 @@
+import { AverageOperator } from './AverageOperator';
+import { BetweenOperator } from './BetweenOperator';
+import { BlankOperator } from './BlankOperator';
+import { ErrorOperator } from './ErrorOperator';
+import { GreaterThanOperator } from './GreaterThanOperator';
+import { GreaterThanEqualToOperator } from './GreaterThanEqualToOperator';
+import { LessThanOperator } from './LessThanOperator';
+import { LessThanEqualToOperator } from './LessThanEqualToOperator';
+import { EqualToOperator } from './EqualToOperator';
+import { AfterOperator } from './AfterOperator';
+import { AfterEqualToOperator } from './AfterEqualToOperator';
+import { BeforeOperator } from './BeforeOperator';
+import { BeforeEqualToOperator } from './BeforeEqualToOperator';
+import { UniqueOperator } from './UniqueOperator';
+import { ExpressionOperator } from './ExpressionOperator';
+import { ColorOperator } from './ColorOperator';
+import { IconOperator } from './IconOperator';
+import { InSetOperator } from './InSetOperator';
+import { ValidEmailOperator } from './ValidEmailOperator';
+import { ValidUrlOperator } from './ValidUrlOperator';
+import { StartsWithOperator } from './StartsWithOperator';
+import { EndsWithOperator } from './EndsWithOperator';
+import { ContainsOperator } from './ContainsOperator';
+import { TimePeriodOperator } from './TimePeriodOperator';
+import { TopNOperator } from './TopNOperator';
+import { AndOperator } from './AndOperator';
+import { OrOperator } from './OrOperator';
+import { NotOperator } from './NotOperator';
+export declare const BuiltInOperators: {
+    Blank: BlankOperator;
+    Error: ErrorOperator;
+    Average: AverageOperator;
+    Between: BetweenOperator;
+    EqualTo: EqualToOperator;
+    GreaterThan: GreaterThanOperator;
+    GreaterThanEqualTo: GreaterThanEqualToOperator;
+    LessThan: LessThanOperator;
+    LessThanEqualTo: LessThanEqualToOperator;
+    After: AfterOperator;
+    AfterOrEqualTo: AfterEqualToOperator;
+    Before: BeforeOperator;
+    BeforeOrEqualTo: BeforeEqualToOperator;
+    Unique: UniqueOperator;
+    Expression: ExpressionOperator;
+    InSet: InSetOperator;
+    Icon: IconOperator;
+    Color: ColorOperator;
+    TextStartsWith: StartsWithOperator;
+    TextEndsWith: EndsWithOperator;
+    TextContains: ContainsOperator;
+    TextEmail: ValidEmailOperator;
+    TextIsUrl: ValidUrlOperator;
+    TimePeriod: TimePeriodOperator;
+    TopN: TopNOperator;
+    And: AndOperator;
+    Or: OrOperator;
+    Not: NotOperator;
+};
+//# sourceMappingURL=index.d.ts.map

package/types/src/condition/BuiltinSelectors/BaseSelector.d.ts

@@ -0,0 +1,43 @@
+import { InteropScalarType, Scalar } from '@sheetxl/primitives';
+import { MaybePromise } from '@sheetxl/utils';
+import { ICondition } from '../ICondition';
+export declare class BaseSelector<T extends Scalar = Scalar, I extends Scalar = T> implements ICondition.ISelector<T, I> {
+    protected _name: string;
+    protected _type: InteropScalarType | null;
+    protected _inputType: InteropScalarType | null;
+    protected _title: string | undefined;
+    protected _description: string | undefined;
+    protected _renderingHints: readonly string[] | null;
+    constructor(options: ConstructorOptions);
+    /** {@inheritDoc ICondition.ISelector.createTransformer} */
+    createTransformer(ctx: ICondition.IContext): MaybePromise<ICondition.Transformer<T, I> | null>;
+    /** {@inheritDoc ICondition.ISelector.getName} */
+    getName(): string;
+    /** {@inheritDoc ICondition.ISelector.getSelectType} */
+    getSelectType(): InteropScalarType | null;
+    /** {@inheritDoc ICondition.ISelector.getInputType} */
+    getInputType(): InteropScalarType | null;
+    /**
+     * {@inheritDoc ICondition.ISelector.getTitle}
+     *
+     * Selectors are long-lived singletons, so an authored title is stored as a KEY (`messageKey`) and
+     * resolved HERE, at display — otherwise it would freeze at the language active when the module
+     * first loaded. Falls back to the prettified canonical name.
+     *
+     * (Previously this ignored `_title` outright, so an authored title never reached the UI.)
+     */
+    getTitle(): string;
+    /** {@inheritDoc ICondition.ISelector.getDescription} — resolved at display; see {@link getTitle}. */
+    getDescription(): string;
+    /** {@inheritDoc ICondition.ISelector.getRenderHints} */
+    getRenderHints(): readonly string[] | null;
+}
+export interface ConstructorOptions {
+    name: string;
+    type: InteropScalarType | null;
+    inputType?: InteropScalarType | null;
+    title?: string;
+    description?: string;
+    renderingHints?: string | string[];
+}
+//# sourceMappingURL=BaseSelector.d.ts.map

package/types/src/condition/BuiltinSelectors/DateSelector.d.ts

@@ -0,0 +1,14 @@
+import { MaybePromise } from '@sheetxl/utils';
+import { ICondition } from '../ICondition';
+import { BaseSelector } from './BaseSelector';
+/**
+ * DateSelector:
+ *
+ * Returns the date portion of a date time.
+ */
+export declare class DateSelector extends BaseSelector<number, number> {
+    constructor();
+    /** {@inheritDoc ICondition.ISelector.createTransformer} */
+    createTransformer(ctx: ICondition.IContext): MaybePromise<ICondition.Transformer<number, number> | null>;
+}
+//# sourceMappingURL=DateSelector.d.ts.map

package/types/src/condition/BuiltinSelectors/ListSelector.d.ts

@@ -0,0 +1,12 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ICondition } from '../ICondition';
+import { BaseSelector, ConstructorOptions } from './BaseSelector';
+/**
+ * ListSelector:
+ */
+export declare class ListSelector<T extends Scalar = Scalar, I extends Scalar = T> extends BaseSelector<T, I> implements ICondition.IListSelector<T, I> {
+    constructor(options: ConstructorOptions);
+    /** {@inheritDoc ICondition.IListSelector.isList} */
+    get isList(): true;
+}
+//# sourceMappingURL=ListSelector.d.ts.map

package/types/src/condition/BuiltinSelectors/TextLengthSelector.d.ts

@@ -0,0 +1,16 @@
+import { MaybePromise } from '@sheetxl/utils';
+import { ICondition } from '../ICondition';
+import { BaseSelector } from './BaseSelector';
+/**
+ * TextLengthSelector:
+ *
+ * Selector: Transforms string -> number (length)
+ * Operator: Standard comparison (>, <, =, etc.) from Scalar
+ * Result: Predicate that checks if text.length meets condition
+ */
+export declare class TextLengthSelector extends BaseSelector<number, string> {
+    constructor();
+    /** {@inheritDoc ICondition.ISelector.createTransformer} */
+    createTransformer(ctx: ICondition.IContext): MaybePromise<ICondition.Transformer<number, string> | null>;
+}
+//# sourceMappingURL=TextLengthSelector.d.ts.map

package/types/src/condition/BuiltinSelectors/TimeSelector.d.ts

@@ -0,0 +1,14 @@
+import { MaybePromise } from '@sheetxl/utils';
+import { ICondition } from '../ICondition';
+import { BaseSelector } from './BaseSelector';
+/**
+ * TimeSelector:
+ *
+ * Returns the time portion of a date time.
+ */
+export declare class TimeSelector extends BaseSelector<number, number> {
+    constructor();
+    /** {@inheritDoc ICondition.ISelector.createTransformer} */
+    createTransformer(ctx: ICondition.IContext): MaybePromise<ICondition.Transformer<number, number> | null>;
+}
+//# sourceMappingURL=TimeSelector.d.ts.map

package/types/src/condition/BuiltinSelectors/WholeSelector.d.ts

@@ -0,0 +1,14 @@
+import { MaybePromise } from '@sheetxl/utils';
+import { ICondition } from '../ICondition';
+import { BaseSelector } from './BaseSelector';
+/**
+ * WholeSelector:
+ *
+ * Returns the whole portion of a number.
+ */
+export declare class WholeSelector extends BaseSelector<number, number> {
+    constructor();
+    /** {@inheritDoc ICondition.ISelector.createTransformer} */
+    createTransformer(ctx: ICondition.IContext): MaybePromise<ICondition.Transformer<number, number> | null>;
+}
+//# sourceMappingURL=WholeSelector.d.ts.map

package/types/src/condition/BuiltinSelectors/index.d.ts

@@ -0,0 +1,18 @@
+import { BaseSelector } from './BaseSelector';
+import { ListSelector } from './ListSelector';
+import { DateSelector } from './DateSelector';
+import { TimeSelector } from './TimeSelector';
+import { WholeSelector } from './WholeSelector';
+import { TextLengthSelector } from './TextLengthSelector';
+export declare const BuiltinSelectors: {
+    readonly List: ListSelector<import('@sheetxl/primitives').Scalar, import('@sheetxl/primitives').Scalar>;
+    readonly Logical: BaseSelector<import('@sheetxl/primitives').Scalar, import('@sheetxl/primitives').Scalar>;
+    readonly DateTime: BaseSelector<import('@sheetxl/primitives').Scalar, import('@sheetxl/primitives').Scalar>;
+    readonly Date: DateSelector;
+    readonly Time: TimeSelector;
+    readonly Text: BaseSelector<import('@sheetxl/primitives').Scalar, import('@sheetxl/primitives').Scalar>;
+    readonly TextLength: TextLengthSelector;
+    readonly Number: BaseSelector<import('@sheetxl/primitives').Scalar, import('@sheetxl/primitives').Scalar>;
+    readonly Whole: WholeSelector;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,123 @@
+import { Registry } from '../type';
+import { ICondition } from './ICondition';
+import { resolveInput as _resolveInput, fromJSON as _fromJSON } from './_ConditionUtils';
+export declare class Condition<P = any> implements ICondition<P> {
+    protected _selector: ICondition.ISelector | null;
+    protected _operator: ICondition.IOperator | null;
+    protected _param: P;
+    protected _includeBlanks: boolean;
+    constructor(selector: ICondition.ISelector | null, operator: ICondition.IOperator | null, param?: P, includeBlanks?: boolean);
+    /** {@inheritDoc ICondition.getSelector} */
+    getSelector(): ICondition.ISelector | null;
+    /** {@inheritDoc ICondition.getOperator} */
+    getOperator(): ICondition.IOperator | null;
+    /** {@inheritDoc ICondition.getParam} */
+    getParam(): P;
+    /** {@inheritDoc ICondition.isIncludeBlanks} */
+    isIncludeBlanks(): boolean;
+    /** {@inheritDoc ICondition.toString} */
+    toString(): string;
+    /** {@inheritDoc ICondition.toJSON} */
+    toJSON(): ICondition.JSON<P>;
+    /** {@inheritDoc ICondition.isICondition} */
+    get isICondition(): true;
+}
+/**
+ * @namespace Condition
+ *
+ * A namespace for condition-related functionalities.
+ */
+export declare namespace Condition {
+    /**
+     * Built-in condition selectors (static instances).
+     *
+     * For runtime lookup by string name, use `Condition.Selectors.get(name)`.
+     */
+    const BuiltInSelectors: {
+        readonly List: import("./BuiltinSelectors/ListSelector").ListSelector<import("@sheetxl/primitives").Scalar, import("@sheetxl/primitives").Scalar>;
+        readonly Logical: import("./BuiltinSelectors/BaseSelector").BaseSelector<import("@sheetxl/primitives").Scalar, import("@sheetxl/primitives").Scalar>;
+        readonly DateTime: import("./BuiltinSelectors/BaseSelector").BaseSelector<import("@sheetxl/primitives").Scalar, import("@sheetxl/primitives").Scalar>;
+        readonly Date: import("./BuiltinSelectors/DateSelector").DateSelector;
+        readonly Time: import("./BuiltinSelectors/TimeSelector").TimeSelector;
+        readonly Text: import("./BuiltinSelectors/BaseSelector").BaseSelector<import("@sheetxl/primitives").Scalar, import("@sheetxl/primitives").Scalar>;
+        readonly TextLength: import("./BuiltinSelectors/TextLengthSelector").TextLengthSelector;
+        readonly Number: import("./BuiltinSelectors/BaseSelector").BaseSelector<import("@sheetxl/primitives").Scalar, import("@sheetxl/primitives").Scalar>;
+        readonly Whole: import("./BuiltinSelectors/WholeSelector").WholeSelector;
+    };
+    /**
+     * Built-in condition operators (static instances).
+     *
+     * For runtime lookup by string name, use `Condition.Operators.get(name)`.
+     */
+    const BuiltInOperators: {
+        Blank: import("./BuiltInOperators/BlankOperator").BlankOperator;
+        Error: import("./BuiltInOperators/ErrorOperator").ErrorOperator;
+        Average: import("./BuiltInOperators/AverageOperator").AverageOperator;
+        Between: import("./BuiltInOperators/BetweenOperator").BetweenOperator;
+        EqualTo: import("./BuiltInOperators/EqualToOperator").EqualToOperator;
+        GreaterThan: import("./BuiltInOperators/GreaterThanOperator").GreaterThanOperator;
+        GreaterThanEqualTo: import("./BuiltInOperators/GreaterThanEqualToOperator").GreaterThanEqualToOperator;
+        LessThan: import("./BuiltInOperators/LessThanOperator").LessThanOperator;
+        LessThanEqualTo: import("./BuiltInOperators/LessThanEqualToOperator").LessThanEqualToOperator;
+        After: import("./BuiltInOperators/AfterOperator").AfterOperator;
+        AfterOrEqualTo: import("./BuiltInOperators/AfterEqualToOperator").AfterEqualToOperator;
+        Before: import("./BuiltInOperators/BeforeOperator").BeforeOperator;
+        BeforeOrEqualTo: import("./BuiltInOperators/BeforeEqualToOperator").BeforeEqualToOperator;
+        Unique: import("./BuiltInOperators/UniqueOperator").UniqueOperator;
+        Expression: import("./BuiltInOperators/ExpressionOperator").ExpressionOperator;
+        InSet: import("./BuiltInOperators/InSetOperator").InSetOperator;
+        Icon: import("./BuiltInOperators/IconOperator").IconOperator;
+        Color: import("./BuiltInOperators/ColorOperator").ColorOperator;
+        TextStartsWith: import("./BuiltInOperators/StartsWithOperator").StartsWithOperator;
+        TextEndsWith: import("./BuiltInOperators/EndsWithOperator").EndsWithOperator;
+        TextContains: import("./BuiltInOperators/ContainsOperator").ContainsOperator;
+        TextEmail: import("./BuiltInOperators/ValidEmailOperator").ValidEmailOperator;
+        TextIsUrl: import("./BuiltInOperators/ValidUrlOperator").ValidUrlOperator;
+        TimePeriod: import("./BuiltInOperators/TimePeriodOperator").TimePeriodOperator;
+        TopN: import("./BuiltInOperators/TopNOperator").TopNOperator;
+        And: import("./BuiltInOperators/AndOperator").AndOperator;
+        Or: import("./BuiltInOperators/OrOperator").OrOperator;
+        Not: import("./BuiltInOperators/NotOperator").NotOperator;
+    };
+    /**
+     * Registry for selectors (built-in + custom).
+     *
+     * @remarks
+     * Use this for:
+     * - Runtime lookup by name: `Selectors.get('wholeNumber')`
+     * - Registering custom selectors: `Selectors.register(mySelector)`
+     * - Getting all selectors: `Selectors.getAll()`
+     *
+     * Pre-populated with all built-in selectors.
+     */
+    const Selectors: Registry<ICondition.ISelector<any, any>>;
+    /**
+     * Registry for operators (built-in + custom).
+     *
+     * @remarks
+     * Use this for:
+     * - Runtime lookup by name: `Operators.get('greaterThan')`
+     * - Registering custom operators: `Operators.register(myOperator)`
+     * - Getting all operators: `Operators.getAll()`
+     *
+     * Pre-populated with all built-in operators.
+     */
+    const Operators: Registry<ICondition.IOperator<any>>;
+    /**
+     * Resolves a condition input (which can be in various forms) into a proper `ICondition` instance.
+     *
+     * @remarks
+     * Throws if a selector or operator name is not registered. Use {@link fromJSON} when loading
+     * persisted state, where an unknown name must not cost the caller the rule.
+     */
+    const resolveInput: typeof _resolveInput;
+    /**
+     * Resolves a persisted condition, never throwing.
+     *
+     * @remarks
+     * A selector or operator the registry does not know is kept verbatim: the condition serializes
+     * back exactly as it arrived and evaluates to nothing until the name is registered.
+     */
+    const fromJSON: typeof _fromJSON;
+}
+//# sourceMappingURL=Condition.d.ts.map