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

package/dist/components/ColumnMenuFilterSection.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { ColMenuSectionProps } from '../lib/menu';
+declare const FilterSection: FC<ColMenuSectionProps>;
+export { FilterSection };
+//# sourceMappingURL=ColumnMenuFilterSection.d.ts.map

package/dist/components/ColumnMenuLabelSection.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { ColMenuSectionProps } from '../lib/menu';
+declare const LabelSection: FC<ColMenuSectionProps>;
+export { LabelSection };
+//# sourceMappingURL=ColumnMenuLabelSection.d.ts.map

package/dist/components/ColumnMenuSortSection.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { ColMenuSectionProps } from '../lib/menu';
+declare const SortSection: FC<ColMenuSectionProps>;
+export { SortSection };
+//# sourceMappingURL=ColumnMenuSortSection.d.ts.map

package/dist/components/ContextMenu.d.ts

@@ -1,21 +1,2 @@
-import { FC } from 'react';
-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;
-export declare const RowsColsOperationDividerItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const InsertRowsAboveItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const InsertRowsBelowItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const InsertColsLeftItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const InsertColsRightItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const RemoveRowsItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const RemoveColsItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const HistoryDeviderItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const UndoItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const RedoItem: (props: ContextMenuProps) => JSX.Element | null;
-export declare const defaultContextMenuItems: FC<ContextMenuProps>[];
 //# sourceMappingURL=ContextMenu.d.ts.map

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/components/GridSheet.d.ts

@@ -1,5 +1,7 @@
-import { Connector, Props } from '../types';
-export declare const createConnector: () => import('react').RefObject<Connector | null>;
-export declare const useConnector: () => import('react').MutableRefObject<Connector | null>;
-export declare function GridSheet({ initialCells, sheetName, connector: initialConnector, options, className, style, hub: initialHub, }: Props): JSX.Element;
+import { SheetHandle, StoreHandle, Props } from '../types';
+export declare const createSheetRef: () => import('react').RefObject<SheetHandle | null>;
+export declare const useSheetRef: () => import('react').MutableRefObject<SheetHandle | null>;
+export declare const createStoreRef: () => import('react').RefObject<StoreHandle | null>;
+export declare const useStoreRef: () => import('react').MutableRefObject<StoreHandle | null>;
+export declare function GridSheet({ initialCells, sheetName, sheetRef: initialSheetRef, storeRef: initialStoreRef, options, className, style, book: initialBook, }: Props): JSX.Element;
 //# sourceMappingURL=GridSheet.d.ts.map

package/dist/components/MenuItem.d.ts

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+type MenuItemProps = {
+    label: string;
+    shortcuts?: string[];
+    disabled?: boolean;
+    /**
+     * undefined  → no check column
+     * true/false → displayed as a toggle row with a checkmark
+     */
+    checked?: boolean;
+    testId?: string;
+    onClick?: () => void;
+    className?: string;
+};
+export declare const MenuItem: FC<MenuItemProps>;
+export declare const MenuDivider: FC;
+export {};
+//# sourceMappingURL=MenuItem.d.ts.map

package/dist/components/PluginBase.d.ts

@@ -4,9 +4,9 @@ import { Dispatcher } from '../store';
 export type PluginContextType = {
     provided: boolean;
     store?: StoreType;
-    sync?: Dispatcher;
+    apply?: Dispatcher;
     setStore: (store: StoreType) => void;
-    setSync: (sync: Dispatcher) => void;
+    setApply: (apply: Dispatcher) => void;
 };
 export declare const PluginContext: import('react').Context<PluginContextType>;
 export declare function useInitialPluginContext(): PluginContextType;

package/dist/components/StoreObserver.d.ts

@@ -1,11 +1,14 @@
 import { FC, MutableRefObject } from 'react';
-import { OptionsType, Connector } from '../types';
+import { OptionsType, SheetHandle, StoreHandle } from '../types';
 type StoreObserverProps = OptionsType & {
     sheetName?: string;
-    connector?: MutableRefObject<Connector | null>;
+    sheetRef?: MutableRefObject<SheetHandle | null>;
+    storeRef?: MutableRefObject<StoreHandle | null>;
 };
-export declare const createConnector: () => import('react').RefObject<Connector | null>;
-export declare const useConnector: () => MutableRefObject<Connector | null>;
+export declare const createSheetRef: () => import('react').RefObject<SheetHandle | null>;
+export declare const useSheetRef: () => MutableRefObject<SheetHandle | null>;
+export declare const createStoreRef: () => import('react').RefObject<StoreHandle | null>;
+export declare const useStoreRef: () => MutableRefObject<StoreHandle | null>;
 export declare const StoreObserver: FC<StoreObserverProps>;
 export {};
 //# sourceMappingURL=StoreObserver.d.ts.map

package/dist/constants.d.ts

@@ -14,4 +14,8 @@ 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;
+export declare const DEFAULT_KEY = "default";
+export declare const DEFAULT_COL_KEY = "defaultCol";
+export declare const DEFAULT_ROW_KEY = "defaultRow";
 //# sourceMappingURL=constants.d.ts.map

package/dist/formula/evaluator.d.ts

@@ -1,33 +1,30 @@
-import { Table } from '../lib/table';
-import { Id, PointType } from '../types';
+import { Sheet } from '../lib/sheet';
+import { Id } from '../types';
 type EvaluateProps = {
-    table: Table;
+    sheet: Sheet;
 };
-export type IdentifyProps = {
-    table: Table;
+type IdentityBaseProps = {
     slideY?: number;
     slideX?: number;
     operation?: 'move' | 'removeRows' | 'removeCols';
-    dependency: string;
+    dependency: Id;
+};
+export type ProcessFormulaProps = IdentityBaseProps & {
     idMap?: {
         [id: string]: string;
     };
 };
+export type IdentifyProps = IdentityBaseProps & {
+    sheet: Sheet;
+};
 export type DisplayProps = {
-    table: Table;
+    sheet: Sheet;
     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;
+    ids: string[];
     constructor(value: T);
 }
 export declare class ValueEntity extends Entity {
@@ -42,33 +39,33 @@ export declare class InvalidRefEntity extends Entity<string> {
 export declare class RefEntity extends Entity<string> {
     constructor(value: string);
     stringify(): string;
-    evaluate({ table }: EvaluateProps): Table;
+    evaluate({ sheet }: EvaluateProps): Sheet;
     identify(props: IdentifyProps): string;
 }
 export declare class RangeEntity extends Entity<string> {
     stringify(): string;
-    evaluate({ table }: EvaluateProps): Table;
+    evaluate({ sheet }: EvaluateProps): Sheet;
     identify(props: IdentifyProps): string;
 }
 export declare class IdEntity extends Entity<string> {
     private parse;
-    evaluate({ table }: EvaluateProps): Table;
-    display({ table, slideY, slideX }: DisplayProps): string;
+    evaluate({ sheet }: EvaluateProps): Sheet;
+    display({ sheet, slideY, slideX }: DisplayProps): string;
     identify(props: IdentifyProps): string;
 }
 export declare class IdRangeEntity extends Entity<string> {
     private parse;
-    evaluate({ table }: EvaluateProps): Table;
-    display({ table, slideY, slideX }: DisplayProps): string;
-    identify(props: IdentifyProps): string | undefined;
+    evaluate({ sheet }: EvaluateProps): Sheet;
+    display({ sheet, slideY, slideX }: DisplayProps): string;
+    identify(props: IdentifyProps): string;
 }
 export declare class FunctionEntity {
     args: Expression[];
     name: string;
     precedence: number;
-    private origin?;
-    constructor(name: string, precedence?: number, args?: Expression[], origin?: PointType);
-    evaluate({ table }: EvaluateProps): any;
+    private at?;
+    constructor(name: string, precedence?: number, args?: Expression[], at?: Id);
+    evaluate({ sheet }: EvaluateProps): any;
 }
 export type Expression = ValueEntity | RefEntity | RangeEntity | IdEntity | IdRangeEntity | FunctionEntity | UnreferencedEntity | InvalidRefEntity;
 export type TokenType = 'VALUE' | 'REF' | 'RANGE' | 'ID' | 'ID_RANGE' | 'FUNCTION' | 'PREFIX_OPERATOR' | 'INFIX_OPERATOR' | 'POSTFIX_OPERATOR' | 'OPEN' | 'CLOSE' | 'COMMA' | 'SPACE' | 'UNREFERENCED' | 'INVALID_REF';
@@ -76,25 +73,24 @@ 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;
-    idMap?: {
-        [id: Id]: Id;
-    };
+    at?: Id;
 };
 export declare class Lexer {
     private index;
     private formula;
     tokens: Token[];
     foreign: boolean;
-    private origin?;
-    private idMap;
+    identifiedFormula: string;
+    dependencyIds: string[];
+    private at?;
     constructor(formula: string, options?: LexerOption);
     private isWhiteSpace;
     private next;
@@ -103,12 +99,13 @@ export declare class Lexer {
     getTokenIndexByCharPosition(pos: number): [number, boolean];
     getTokenPositionRange(index: number, slide?: number): [number, number];
     stringify(): string;
-    identify(props: IdentifyProps): string;
-    display({ table }: DisplayProps): string;
-    tokenize(): void;
+    identify(props: IdentifyProps): void;
+    display({ sheet }: DisplayProps): string;
+    tokenize(idMap?: {
+        [id: Id]: Id;
+    }): void;
     private skipSpaces;
     private getString;
-    private resolveIdRange;
 }
 export declare class Parser {
     index: number;
@@ -120,14 +117,13 @@ export declare class Parser {
 }
 /** 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): {
     sheetName: string | undefined;
     addresses: string[];
 };
-export declare const parseRef: (ref: string, { table, operation, dependency }: IdentifyProps) => {
-    table: Table;
+export declare const parseRef: (ref: string, { sheet, operation, dependency }: IdentifyProps) => {
+    sheet: Sheet;
     sheetId?: number;
     formula?: string;
     sheetName?: string;

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

@@ -0,0 +1,10 @@
+export declare class FormulaError {
+    code: string;
+    message: string;
+    error?: Error;
+    readonly __gsType: "FormulaError";
+    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 { Registry } from '../../lib/book';
+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 Sheet objects (via getFieldMatrix).
+ */
+export declare const hasDeepPending: (values: any[], at: Id) => boolean;
 /**
  * Build a cache key from function name + hashed serialised arguments.
  *
@@ -16,11 +21,11 @@ export declare const hasPendingArg: (args: any[]) => boolean;
  *   - length: byte length of the JSON-serialised args
  *   - hash:   cyrb53 hash of the JSON string, repeated hashPrecision times with different seeds
  *
- * When a Table appears as an argument its trimmed area is converted to a
+ * When a Sheet appears as an argument its trimmed area is converted to a
  * 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.
  *
@@ -29,16 +34,16 @@ export declare const buildAsyncCacheKey: (funcName: string, bareArgs: any[], has
  * - Pending if there is an in-flight promise for this cell
  * - asyncCacheMiss if no cache/pending exists (distinguishes from user-returned undefined/null)
  */
-export declare const getAsyncCache: (table: {
-    wire: Wire;
+export declare const getAsyncCache: (sheet: {
+    registry: Registry;
     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().
  *
  * 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.
+ * In-flight tracking uses Binding.asyncPending (keyed by cell ID).
+ * If useInflight is true, also tracks by cache key in Binding.asyncInflight.
  *
  * Flow:
  * 1. If cell has asyncCache and the key matches (inputs unchanged) and not expired → return cached value
@@ -50,10 +55,10 @@ export declare const getAsyncCache: (table: {
  * @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 awaitAndSave: (promise: Promise<any>, table: {
-    wire: Wire;
+export declare const awaitAndSave: (promise: Promise<any>, sheet: {
+    registry: Registry;
     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 { Sheet } from '../../lib/sheet';
+import { Id } from '../../types';
 import { Expression } from '../evaluator';
+/** Duck-type check for Sheet instances (avoids runtime import cycle). */
+export declare const isSheet: (v: any) => v is Sheet;
+export type FunctionCategory = 'math' | 'statistics' | 'text' | 'time' | 'lookup' | 'information' | 'finance' | 'engineering' | 'logical' | 'other';
 export type FunctionProps = {
     args: Expression[];
-    table: Table;
-    origin?: PointType;
+    sheet: Sheet;
+    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" (Sheet, Spilling, or 2D array).
+ */
+export declare const isMatrix: (value: any) => boolean;
+/**
+ * Extract the scalar from a 1×1 matrix (Sheet, 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,19 +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;
+    sheet: Sheet;
+    at: Id;
+    static __name: string;
+    constructor({ args, sheet, 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, Sheet, or nested array).
+     * Default behavior for Sheet is value.solve(). Functions like COL can override
+     * this to preserve Sheet metadata per cell.
+     */
+    protected toMatrix(value: any): any[][];
+    /**
+     * Collapse a 1×1 matrix value (Sheet, Spilling, or 2D array) to a scalar.
+     * Non-matrix values pass through unchanged.
+     *
+     * Override in sub-classes that need the original Sheet / reference
+     * metadata (e.g. COL, ROW) — for instance, to extract position
+     * information before collapsing.
+     */
+    protected toScalar(value: any): any;
     call(): any;
-}
-/**
- * Base class for sync functions.
- * Extend this class to create sync functions that support caching.
- */
-export declare class BaseFunctionSync extends BaseFunction {
-    protected isAsync: boolean;
+    /**
+     * 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 Sheet/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 async functions.

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

@@ -1,3 +1,5 @@
+import { Sheet } from '../../lib/sheet';
+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: (sheets: Sheet[], 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