@gridsheet/preact-core 3.0.0-rc.1 → 3.0.0-rc.2

package/dist/components/FunctionGuide.d.ts

@@ -4,8 +4,9 @@ import { AutocompleteOption } from '../policy/core';
 type OptionWithGuide = AutocompleteOption & {
     isFunction?: boolean;
     example?: string;
-    helpTexts?: string[];
-    helpArgs?: any[];
+    category?: string;
+    description?: string;
+    defs?: any[];
 };
 export interface FunctionGuideProps {
     option?: OptionWithGuide;

package/dist/constants.d.ts

@@ -14,4 +14,5 @@ export declare const DEFAULT_ALPHABET_CACHE_SIZE = 1000;
 export declare const SECONDS_IN_DAY = 86400;
 export declare const FULLDATE_FORMAT_UTC = "YYYY-MM-DDTHH:mm:ss.SSSZ";
 export declare const RESET_ZONE: ZoneType;
+export declare const BASE_DATE: Date;
 //# sourceMappingURL=constants.d.ts.map

package/dist/formula/evaluator.d.ts

@@ -1,5 +1,5 @@
 import { Table } from '../lib/table';
-import { Id, PointType } from '../types';
+import { Id } from '../types';
 type EvaluateProps = {
     table: Table;
 };
@@ -18,14 +18,6 @@ export type DisplayProps = {
     slideY?: number;
     slideX?: number;
 };
-export declare class FormulaError {
-    code: string;
-    message: string;
-    error?: Error;
-    __isFormulaError: boolean;
-    constructor(code: string, message: string, error?: Error);
-    static is(obj: any): boolean;
-}
 declare class Entity<T = any> {
     value: T;
     constructor(value: T);
@@ -66,8 +58,8 @@ export declare class FunctionEntity {
     args: Expression[];
     name: string;
     precedence: number;
-    private origin?;
-    constructor(name: string, precedence?: number, args?: Expression[], origin?: PointType);
+    private at?;
+    constructor(name: string, precedence?: number, args?: Expression[], at?: Id);
     evaluate({ table }: EvaluateProps): any;
 }
 export type Expression = ValueEntity | RefEntity | RangeEntity | IdEntity | IdRangeEntity | FunctionEntity | UnreferencedEntity | InvalidRefEntity;
@@ -76,14 +68,15 @@ export declare class Token {
     type: TokenType;
     entity: any;
     precedence: number;
-    private origin?;
-    constructor(type: TokenType, entity: any, precedence?: number, origin?: PointType);
+    closed: boolean;
+    private at?;
+    constructor(type: TokenType, entity: any, precedence?: number, at?: Id, closed?: boolean);
     length(): number;
     stringify(): string;
     convert(): ValueEntity | UnreferencedEntity | InvalidRefEntity | RefEntity | RangeEntity | IdEntity | IdRangeEntity | FunctionEntity | undefined;
 }
 type LexerOption = {
-    origin?: PointType;
+    at?: Id;
     idMap?: {
         [id: Id]: Id;
     };
@@ -93,7 +86,7 @@ export declare class Lexer {
     private formula;
     tokens: Token[];
     foreign: boolean;
-    private origin?;
+    private at?;
     private idMap;
     constructor(formula: string, options?: LexerOption);
     private isWhiteSpace;

package/dist/formula/formula-error.d.ts

@@ -0,0 +1,10 @@
+export declare class FormulaError {
+    code: string;
+    message: string;
+    error?: Error;
+    __isFormulaError: boolean;
+    constructor(code: string, message: string, error?: Error);
+    static is(obj: any): obj is FormulaError;
+    toString(): string;
+}
+//# sourceMappingURL=formula-error.d.ts.map

package/dist/formula/functions/__async.d.ts

@@ -1,6 +1,6 @@
 import { Pending, Sentinel } from '../../sentinels';
 import { Wire } from '../../lib/hub';
-import { PointType } from '../../types';
+import { Id, PointType } from '../../types';
 /**
  * Sentinel value to distinguish cache miss from user-returned undefined/null.
  * Since user functions can return undefined or null, we need a special marker
@@ -9,6 +9,11 @@ import { PointType } from '../../types';
 export declare const asyncCacheMiss: Sentinel;
 /** Returns true if any element of `args` is a Pending sentinel. */
 export declare const hasPendingArg: (args: any[]) => boolean;
+/**
+ * Recursively check whether any value in the structure is a Pending sentinel.
+ * Handles flat values, nested arrays, and Table objects (via getFieldMatrix).
+ */
+export declare const hasDeepPending: (values: any[], at: Id) => boolean;
 /**
  * Build a cache key from function name + hashed serialised arguments.
  *
@@ -20,7 +25,7 @@ export declare const hasPendingArg: (args: any[]) => boolean;
  * value matrix (`any[][]`) via `getFieldMatrix()` so the key reflects the
  * actual cell values the function will operate on.
  */
-export declare const buildAsyncCacheKey: (funcName: string, bareArgs: any[], hashPrecision?: number) => string;
+export declare const buildAsyncCacheKey: (funcName: string, args: any[], hashPrecision?: number) => string;
 /**
  * Try to retrieve a cached or pending async result for the given cache key.
  *
@@ -32,7 +37,7 @@ export declare const buildAsyncCacheKey: (funcName: string, bareArgs: any[], has
 export declare const getAsyncCache: (table: {
     wire: Wire;
     getId: (p: PointType) => string;
-}, origin: PointType, key: string, useInflight?: boolean) => any;
+}, id: Id, key: string, useInflight?: boolean) => any;
 /**
  * Handle an async (Promise) result returned by BaseFunction.main().
  *
@@ -53,7 +58,7 @@ export declare const getAsyncCache: (table: {
 export declare const awaitAndSave: (promise: Promise<any>, table: {
     wire: Wire;
     getId: (p: PointType) => string;
-}, origin: PointType, key: string, ttlMilliseconds?: number, useInflight?: boolean) => Pending;
+}, id: Id, key: string, ttlMilliseconds?: number, useInflight?: boolean) => Pending;
 /**
  * Create a Pending sentinel that resolves immediately.
  * Used when an argument is already pending — the result is propagated.

package/dist/formula/functions/__base.d.ts

@@ -1,23 +1,45 @@
 import { Table } from '../../lib/table';
-import { PointType } from '../../types';
+import { Id } from '../../types';
 import { Expression } from '../evaluator';
+/** Duck-type check for Table instances (avoids runtime import cycle). */
+export declare const isTable: (v: any) => v is Table;
+export type FunctionCategory = 'math' | 'statistics' | 'text' | 'time' | 'lookup' | 'information' | 'finance' | 'engineering' | 'logical' | 'other';
 export type FunctionProps = {
     args: Expression[];
     table: Table;
-    origin?: PointType;
+    at?: Id;
 };
-export type HelpArg = {
+export type FunctionArgumentType = 'number' | 'string' | 'boolean' | 'date' | 'time' | 'matrix' | 'reference' | 'any';
+export type FunctionArgumentDefinition = {
     name: string;
     description: string;
     optional?: boolean;
-    iterable?: boolean;
-    type?: ('number' | 'string' | 'boolean' | 'date' | 'time' | 'range' | 'reference' | 'any')[];
+    nullable?: boolean;
+    variadic?: boolean;
+    errorTolerant?: boolean;
+    acceptedTypes?: FunctionArgumentType[];
+    /** When true, this argument takes a range/matrix value — broadcasting is suppressed for it. */
+    takesMatrix?: boolean;
 };
-export declare const conditionArg: HelpArg;
+export declare const conditionArg: FunctionArgumentDefinition;
+/**
+ * Check if a value is a "matrix" (Table, Spilling, or 2D array).
+ */
+export declare const isMatrix: (value: any) => boolean;
+/**
+ * Extract the scalar from a 1×1 matrix (Table, Spilling, or plain 2D array).
+ * Returns the value unchanged if it is not a matrix.
+ */
+export declare const stripMatrix: (value: any, at: Id) => any;
+/**
+ * Check if a value is a matrix that is larger than 1×1.
+ */
+export declare const isMultiCell: (value: any) => boolean;
 export declare class BaseFunction {
-    example: string;
-    helpTexts: string[];
-    helpArgs: HelpArg[];
+    defs: FunctionArgumentDefinition[];
+    example: string | undefined;
+    description: string;
+    category: FunctionCategory;
     /** Indicates if this function is async. Override in subclass or use BaseFunctionAsync. */
     protected isAsync: boolean;
     /** Cache TTL in milliseconds. Override in subclass to set expiry. undefined = never expires. */
@@ -26,12 +48,56 @@ export declare class BaseFunction {
     protected hashPrecision: number;
     /** If true, reuse the same in-flight promise for matching cache keys across different cells. */
     protected useInflight: boolean;
-    protected bareArgs: any[];
-    protected table: Table;
-    protected origin?: PointType;
-    constructor({ args, table, origin }: FunctionProps);
-    protected validate(): void;
+    /** If true, broadcasting is unconditionally disabled for this function. */
+    protected broadcastDisabled: boolean;
+    protected args: any[];
+    protected autoSpilling: boolean;
+    table: Table;
+    at: Id;
+    static __name: string;
+    constructor({ args, table, at }: FunctionProps);
+    private _main;
+    /**
+     * Validate and normalise arguments before `main()` is called.
+     *
+     * Checks:
+     * 1. Argument count satisfies defs (respecting optional / variadic).
+     * 2. Each argument's runtime type matches the corresponding def's `type` list.
+     *
+     * Subclasses may override for additional coercion / spreading.
+     */
+    protected validate(args: any[]): any[];
+    eachMatrix: (value: any, callback: (v: any) => void) => void;
+    /**
+     * Extract a 2D array from a matrix value (Spilling, Table, or nested array).
+     * Default behavior for Table is value.solve(). Functions like COL can override
+     * this to preserve Table metadata per cell.
+     */
+    protected toMatrix(value: any): any[][];
+    /**
+     * Collapse a 1×1 matrix value (Table, Spilling, or 2D array) to a scalar.
+     * Non-matrix values pass through unchanged.
+     *
+     * Override in sub-classes that need the original Table / reference
+     * metadata (e.g. COL, ROW) — for instance, to extract position
+     * information before collapsing.
+     */
+    protected toScalar(value: any): any;
     call(): any;
+    /**
+     * If any broadcastable argument is a matrix (multi-cell), expand the call
+     * across all element positions and return a Spilling.
+     * Returns `undefined` when no broadcast is necessary.
+     *
+     * Rules:
+     * - broadcastDisabled = true → never broadcast
+     * - An arg is broadcastable when its corresponding args[].takesMatrix is not true
+     * - A Table/Spilling/2D-array whose size is (1,1) is treated as a scalar
+     *   (not broadcast); only multi-cell matrices trigger broadcast
+     * - For variadic args, extra args are assigned round-robin
+     *   across the variadic helpArg positions
+     */
+    private broadcast;
 }
 /**
  * Base class for sync functions.

package/dist/formula/functions/__utils.d.ts

@@ -1,3 +1,5 @@
+import { Table } from '../../lib/table';
+import { Id, PointType } from '../../types';
 export declare const gt: (left: any, right: any) => boolean;
 export declare const gte: (left: any, right: any) => boolean;
 export declare const lt: (left: any, right: any) => boolean;
@@ -16,4 +18,6 @@ export declare const ensureNumber: (value: any, options?: EnsureNumberOptions) =
 export declare const ensureString: (value: any) => string;
 export declare const ensureBoolean: (value: any, options?: EnsureBooleanOptions) => boolean;
 export declare const check: (value: any, condition: string) => boolean;
+export declare const eachMatrix: (value: any, callback: (v: any, relativePoint: PointType) => void, at: Id) => void;
+export declare const createBooleanMask: (tables: Table[], conditions: string[], at: Id) => boolean[][];
 //# sourceMappingURL=__utils.d.ts.map

package/dist/formula/functions/abs.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class AbsFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(value: number): number;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(value: any): number;
 }
 //# sourceMappingURL=abs.d.ts.map

package/dist/formula/functions/add.d.ts

@@ -1,10 +1,10 @@
-import { BaseFunction, HelpArg } from './__base';
-import { TimeDelta } from '../../lib/time';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+import { Time } from '../../lib/time';
 export declare class AddFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number | Date | TimeDelta, v2: number | Date | TimeDelta): number | Date;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: number | Date | Time, v2: number | Date | Time): number | Date;
 }
 //# sourceMappingURL=add.d.ts.map

package/dist/formula/functions/and.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class AndFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(...values: boolean[]): boolean;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): boolean;
 }
 //# sourceMappingURL=and.d.ts.map

package/dist/formula/functions/arrayformula.d.ts

@@ -0,0 +1,12 @@
+import { Spilling } from '../../sentinels';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class ArrayformulaFunction extends BaseFunction {
+    autoSpilling: boolean;
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected broadcastDisabled: boolean;
+    protected main(value: any): any[] | Spilling;
+}
+//# sourceMappingURL=arrayformula.d.ts.map

package/dist/formula/functions/average.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class AverageFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(...values: number[]): number;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): number;
 }
 //# sourceMappingURL=average.d.ts.map

package/dist/formula/functions/concat.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class ConcatFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: string, v2: string): string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): string;
 }
 //# sourceMappingURL=concat.d.ts.map

package/dist/formula/functions/count.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class CountFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
     protected main(...values: any[]): number;
 }
 //# sourceMappingURL=count.d.ts.map

package/dist/formula/functions/counta.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class CountaFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
     protected main(...values: any[]): number;
 }
 //# sourceMappingURL=counta.d.ts.map

package/dist/formula/functions/divide.d.ts

@@ -1,9 +1,10 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class DivideFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected validate(args: any[]): any[];
     protected main(divided: number, divisor: number): number;
 }
 //# sourceMappingURL=divide.d.ts.map

package/dist/formula/functions/eq.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class EqFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
     protected main(v1: any, v2: any): boolean;
 }
 //# sourceMappingURL=eq.d.ts.map

package/dist/formula/functions/gt.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class GtFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number, v2: number): boolean;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
 }
 //# sourceMappingURL=gt.d.ts.map

package/dist/formula/functions/gte.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class GteFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number, v2: number): boolean;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
 }
 //# sourceMappingURL=gte.d.ts.map

package/dist/formula/functions/if.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class IfFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(condition: boolean, v1: any, v2?: any): any;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(condition: any, v1: any, v2?: any): any;
 }
 //# sourceMappingURL=if.d.ts.map

package/dist/formula/functions/iferror.d.ts

@@ -1,12 +1,10 @@
-import { FunctionProps, HelpArg } from './__base';
-export declare class IfErrorFunction {
+import { FunctionArgumentDefinition, BaseFunction, FunctionCategory } from './__base';
+export declare class IfErrorFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    private args;
-    private table;
-    constructor({ args, table }: FunctionProps);
-    protected validate(): void;
-    call(): any;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected broadcastDisabled: boolean;
+    protected main(value: any, valueIfError?: any): any;
 }
 //# sourceMappingURL=iferror.d.ts.map

package/dist/formula/functions/len.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class LenFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(text: string): number;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(text: any): number;
 }
 //# sourceMappingURL=len.d.ts.map

package/dist/formula/functions/lt.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class LtFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number, v2: number): boolean;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
 }
 //# sourceMappingURL=lt.d.ts.map

package/dist/formula/functions/lte.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class LteFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number, v2: number): boolean;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
 }
 //# sourceMappingURL=lte.d.ts.map

package/dist/formula/functions/max.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class MaxFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(...values: number[]): number;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): number;
 }
 //# sourceMappingURL=max.d.ts.map

package/dist/formula/functions/min.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class MinFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(...values: number[]): number;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): number;
 }
 //# sourceMappingURL=min.d.ts.map

package/dist/formula/functions/minus.d.ts

@@ -1,10 +1,11 @@
-import { TimeDelta } from '../../lib/time';
-import { BaseFunction, HelpArg } from './__base';
+import { Time } from '../../lib/time';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class MinusFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number | Date | TimeDelta, v2: number | Date | TimeDelta): number | Date | TimeDelta;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected validate(args: any[]): any[];
+    protected main(v1: number | Date | Time, v2: number | Date | Time): number | Date | Time;
 }
 //# sourceMappingURL=minus.d.ts.map

package/dist/formula/functions/multiply.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class MultiplyFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: number, v2: number): number;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): number;
 }
 //# sourceMappingURL=multiply.d.ts.map

package/dist/formula/functions/ne.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class NeFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
     protected main(v1: number, v2: number): boolean;
 }
 //# sourceMappingURL=ne.d.ts.map

package/dist/formula/functions/not.d.ts

@@ -1,9 +1,9 @@
-import { BaseFunction, HelpArg } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class NotFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: HelpArg[];
-    protected validate(): void;
-    protected main(v1: boolean): boolean;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any): boolean;
 }
 //# sourceMappingURL=not.d.ts.map