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

package/dist/components/ContextMenu.d.ts

@@ -3,6 +3,7 @@ import { ContextMenuProps } from '../types';
 export declare const ContextMenu: () => JSX.Element | null;
 export declare const DividerItem: (props: ContextMenuProps) => JSX.Element;
 export declare const CutItem: (props: ContextMenuProps) => JSX.Element;
+export declare const SearchItem: (props: ContextMenuProps) => JSX.Element;
 export declare const CopyItem: (props: ContextMenuProps) => JSX.Element;
 export declare const PasteItem: (props: ContextMenuProps) => JSX.Element;
 export declare const PasteOnlyValueItem: (props: ContextMenuProps) => JSX.Element;

package/dist/components/EditorOptions.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface EditorOptionsProps {
+    filteredOptions: any[];
+    top: number;
+    left: number;
+    selected: number;
+    onOptionMouseDown: (e: React.MouseEvent<HTMLLIElement>, i: number) => void;
+}
+export declare const EditorOptions: React.FC<EditorOptionsProps>;
+export {};
+//# sourceMappingURL=EditorOptions.d.ts.map

package/dist/components/FunctionGuide.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { FunctionHelp } from '../formula/mapping';
+import { AutocompleteOption } from '../policy/core';
+type OptionWithGuide = AutocompleteOption & {
+    isFunction?: boolean;
+    example?: string;
+    category?: string;
+    description?: string;
+    defs?: any[];
+};
+export interface FunctionGuideProps {
+    option?: OptionWithGuide;
+    activeFunctionGuide?: FunctionHelp;
+    activeArgIndex?: number;
+    top?: number;
+    left?: number;
+}
+export declare const FunctionGuide: React.FC<FunctionGuideProps>;
+export {};
+//# sourceMappingURL=FunctionGuide.d.ts.map

package/dist/components/useAutocomplete.d.ts

@@ -0,0 +1,25 @@
+import { FunctionHelp } from '../formula/mapping';
+import { FunctionMapping } from '../formula/functions/__base';
+import { AutocompleteOption } from '../policy/core';
+type UseAutocompleteProps = {
+    inputting: string;
+    selectionStart: number;
+    optionsAll: AutocompleteOption[];
+    functions?: FunctionMapping;
+};
+export declare const useAutocomplete: ({ inputting, selectionStart, optionsAll, functions }: UseAutocompleteProps) => {
+    filteredOptions: any[];
+    selected: number;
+    setSelected: import('react').Dispatch<import('react').SetStateAction<number>>;
+    replaceWithOption: (option: any) => {
+        value: string;
+        selectionStart: any;
+    };
+    handleArrowUp: (e: React.KeyboardEvent<HTMLTextAreaElement>) => boolean;
+    handleArrowDown: (e: React.KeyboardEvent<HTMLTextAreaElement>) => boolean;
+    isFormula: boolean;
+    activeFunctionHelp: FunctionHelp | null;
+    activeArgIndex: number;
+};
+export {};
+//# sourceMappingURL=useAutocomplete.d.ts.map

package/dist/constants.d.ts

@@ -11,20 +11,8 @@ export declare const MIN_HEIGHT = 5;
 export declare const OVERSCAN_X = 5;
 export declare const OVERSCAN_Y = 10;
 export declare const DEFAULT_ALPHABET_CACHE_SIZE = 1000;
-export declare class Special {
-    name: string;
-    constructor(name: string);
-}
-/**
- * Sentinel value representing an in-flight async formula computation.
- * Cells whose solved cache contains a Pending will render a loading indicator.
- * Dependent cells that encounter a Pending value also become pending.
- */
-export declare class Pending {
-    promise: Promise<any>;
-    constructor(promise: Promise<any>);
-}
 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;
@@ -118,6 +111,8 @@ export declare class Parser {
     build(): Expression | undefined;
     private parse;
 }
+/** Alias for Parser, exported for external tooling (e.g. Debugger). */
+export declare const FormulaParser: typeof Parser;
 export declare const identifyFormula: (value: any, { idMap, ...props }: IdentifyProps) => any;
 export declare const stripSheetName: (sheetName: string) => string;
 export declare function splitRef(ref: string): {

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,14 +1,19 @@
-import { Pending, Special } from '../../constants';
+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
  * to indicate "no cache entry found" vs "cache entry is undefined".
  */
-export declare const asyncCacheMiss: Special;
+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,25 +37,28 @@ export declare const buildAsyncCacheKey: (funcName: string, bareArgs: any[], has
 export declare const getAsyncCache: (table: {
     wire: Wire;
     getId: (p: PointType) => string;
-}, origin: PointType, key: string) => any;
+}, id: Id, key: string, useInflight?: boolean) => any;
 /**
  * Handle an async (Promise) result returned by BaseFunction.main().
  *
  * Cache is stored per-cell in cell.asyncCache.
  * In-flight tracking uses Wire.asyncPending (keyed by cell ID).
+ * If useInflight is true, also tracks by cache key in Wire.asyncInflight.
  *
  * Flow:
  * 1. If cell has asyncCache and the key matches (inputs unchanged) and not expired → return cached value
  * 2. If there is already an in-flight promise for this cell → return its Pending
- * 3. Otherwise start the async work, return a new Pending, and on completion
+ * 3. If useInflight is true and there is an in-flight promise for this key → return its Pending
+ * 4. Otherwise start the async work, return a new Pending, and on completion
  *    write the result into cell.asyncCache and trigger a re-render.
  *
  * @param ttlMilliseconds - Cache time-to-live in **milliseconds**. undefined = never expires.
+ * @param useInflight - If true, reuse the same promise for matching cache keys across different cells.
  */
-export declare const getOrSaveAsyncCache: (promise: Promise<any>, table: {
+export declare const awaitAndSave: (promise: Promise<any>, table: {
     wire: Wire;
     getId: (p: PointType) => string;
-}, origin: PointType, key: string, ttlMilliseconds?: number) => any;
+}, 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,29 +1,117 @@
 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 FunctionArgumentType = 'number' | 'string' | 'boolean' | 'date' | 'time' | 'matrix' | 'reference' | 'any';
+export type FunctionArgumentDefinition = {
+    name: string;
+    description: string;
+    optional?: boolean;
+    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: 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: {
-        name: string;
-        description: string;
-    }[];
+    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. */
     protected ttlMilliseconds?: number;
     /** Hash precision for cache key generation. Higher values reduce collision risk. Default: 1 */
     protected hashPrecision: number;
-    protected bareArgs: any[];
-    protected table: Table;
-    protected origin?: PointType;
-    constructor({ args, table, origin }: FunctionProps);
-    protected validate(): void;
-    private get isMainAsync();
+    /** If true, reuse the same in-flight promise for matching cache keys across different cells. */
+    protected useInflight: boolean;
+    /** 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.
+ * Extend this class to create sync functions that support caching.
+ */
+export declare class BaseFunctionSync extends BaseFunction {
+    protected isAsync: boolean;
+}
+/**
+ * Base class for async functions.
+ * Extend this class to create async functions that support caching.
+ */
+export declare class BaseFunctionAsync extends BaseFunction {
+    protected isAsync: boolean;
 }
 export type FunctionMapping = {
     [functionName: string]: typeof BaseFunction;

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,12 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class AbsFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: {
-        name: string;
-        description: string;
-    }[];
-    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,13 +1,10 @@
-import { BaseFunction } 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: {
-        name: string;
-        description: string;
-    }[];
-    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,19 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class AndFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: ({
-        name: string;
-        description: string;
-        optional?: undefined;
-        iterable?: undefined;
-    } | {
-        name: string;
-        description: string;
-        optional: boolean;
-        iterable: boolean;
-    })[];
-    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,19 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class AverageFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: ({
-        name: string;
-        description: string;
-        optional?: undefined;
-        iterable?: undefined;
-    } | {
-        name: string;
-        description: string;
-        optional: boolean;
-        iterable: boolean;
-    })[];
-    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,12 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class ConcatFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: {
-        name: string;
-        description: string;
-    }[];
-    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,19 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class CountFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: ({
-        name: string;
-        description: string;
-        optional?: undefined;
-        iterable?: undefined;
-    } | {
-        name: string;
-        description: string;
-        optional: boolean;
-        iterable: boolean;
-    })[];
-    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,19 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class CountaFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: ({
-        name: string;
-        description: string;
-        optional?: undefined;
-        iterable?: undefined;
-    } | {
-        name: string;
-        description: string;
-        optional: boolean;
-        iterable: boolean;
-    })[];
-    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,12 +1,10 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class DivideFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: {
-        name: string;
-        description: string;
-    }[];
-    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,12 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class EqFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: {
-        name: string;
-        description: string;
-    }[];
-    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,12 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class GtFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: {
-        name: string;
-        description: string;
-    }[];
-    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,12 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class GteFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: {
-        name: string;
-        description: string;
-    }[];
-    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,17 +1,9 @@
-import { BaseFunction } from './__base';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
 export declare class IfFunction extends BaseFunction {
     example: string;
-    helpText: string[];
-    helpArgs: ({
-        name: string;
-        description: string;
-        optional?: undefined;
-    } | {
-        name: string;
-        description: string;
-        optional: boolean;
-    })[];
-    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