@odoo/o-spreadsheet 17.0.85 → 17.0.97

package/dist/types/functions/module_financial.d.ts

@@ -0,0 +1,358 @@
+import { ArgValue, CellValue, Matrix, Maybe } from "../types";
+export declare const ACCRINTM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, issue: Maybe<CellValue>, maturity: Maybe<CellValue>, rate: Maybe<CellValue>, redemption: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const AMORLINC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, cost: Maybe<CellValue>, purchaseDate: Maybe<CellValue>, firstPeriodEnd: Maybe<CellValue>, salvage: Maybe<CellValue>, period: Maybe<CellValue>, rate: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const COUPDAYS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const COUPDAYBS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const COUPDAYSNC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const COUPNCD: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const COUPNUM: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const COUPPCD: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: (this: import("../types").EvalContext) => string;
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const CUMIPMT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>, firstPeriod: Maybe<CellValue>, lastPeriod: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const CUMPRINC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>, firstPeriod: Maybe<CellValue>, lastPeriod: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DB: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, cost: Maybe<CellValue>, salvage: Maybe<CellValue>, life: Maybe<CellValue>, period: Maybe<CellValue>, ...args: Maybe<CellValue>[]) => number;
+    isExported: true;
+};
+export declare const DDB: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, cost: Maybe<CellValue>, salvage: Maybe<CellValue>, life: Maybe<CellValue>, period: Maybe<CellValue>, factor?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DISC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, price: Maybe<CellValue>, redemption: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DOLLARDE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, fractionalPrice: Maybe<CellValue>, unit: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DOLLARFR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, decimalPrice: Maybe<CellValue>, unit: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const DURATION: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, rate: Maybe<CellValue>, securityYield: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const EFFECT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, nominal_rate: Maybe<CellValue>, periods_per_year: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const FV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, paymentAmount: Maybe<CellValue>, presentValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const FVSCHEDULE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, principalAmount: Maybe<CellValue>, rateSchedule: ArgValue) => number;
+    isExported: true;
+};
+export declare const INTRATE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, investment: Maybe<CellValue>, redemption: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const IPMT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, currentPeriod: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const IRR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, cashFlowAmounts: Matrix<CellValue>, rateGuess?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const ISPMT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, currentPeriod: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const MDURATION: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, rate: Maybe<CellValue>, securityYield: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const MIRR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, cashflowAmount: Matrix<CellValue>, financingRate: Maybe<CellValue>, reinvestmentRate: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const NOMINAL: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, effective_rate: Maybe<CellValue>, periods_per_year: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const NPER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, paymentAmount: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const NPV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, discount: Maybe<CellValue>, ...values: ArgValue[]) => number;
+    isExported: true;
+};
+export declare const PDURATION: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PMT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PPMT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, currentPeriod: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, rate: Maybe<CellValue>, numberOfPeriods: Maybe<CellValue>, paymentAmount: Maybe<CellValue>, futureValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PRICE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, rate: Maybe<CellValue>, securityYield: Maybe<CellValue>, redemption: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PRICEDISC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, discount: Maybe<CellValue>, redemption: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const PRICEMAT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, issue: Maybe<CellValue>, rate: Maybe<CellValue>, securityYield: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const RATE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, numberOfPeriods: Maybe<CellValue>, paymentPerPeriod: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue?: Maybe<CellValue>, endOrBeginning?: Maybe<CellValue>, rateGuess?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const RECEIVED: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, investment: Maybe<CellValue>, discount: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const RRI: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, numberOfPeriods: Maybe<CellValue>, presentValue: Maybe<CellValue>, futureValue: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const SLN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, cost: Maybe<CellValue>, salvage: Maybe<CellValue>, life: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const SYD: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    computeFormat: () => string;
+    compute: (this: import("../types").EvalContext, cost: Maybe<CellValue>, salvage: Maybe<CellValue>, life: Maybe<CellValue>, period: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const TBILLPRICE: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, discount: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const TBILLEQ: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, discount: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const TBILLYIELD: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, price: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const VDB: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, cost: Maybe<CellValue>, salvage: Maybe<CellValue>, life: Maybe<CellValue>, startPeriod: Maybe<CellValue>, endPeriod: Maybe<CellValue>, factor?: Maybe<CellValue>, noSwitch?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const XIRR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, cashflowAmounts: Matrix<CellValue>, cashflowDates: Matrix<CellValue>, rateGuess?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const XNPV: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, discount: Maybe<CellValue>, cashflowAmounts: ArgValue, cashflowDates: ArgValue) => number;
+    isExported: true;
+};
+export declare const YIELD: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, rate: Maybe<CellValue>, price: Maybe<CellValue>, redemption: Maybe<CellValue>, frequency: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const YIELDDISC: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, price: Maybe<CellValue>, redemption: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const YIELDMAT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, settlement: Maybe<CellValue>, maturity: Maybe<CellValue>, issue: Maybe<CellValue>, rate: Maybe<CellValue>, price: Maybe<CellValue>, dayCountConvention?: Maybe<CellValue>) => number;
+    isExported: true;
+};

package/dist/types/functions/module_info.d.ts

@@ -0,0 +1,64 @@
+import { CellValue, Maybe } from "../types";
+export declare const ISERR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISERROR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISLOGICAL: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISNA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISNONTEXT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISNUMBER: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISTEXT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const ISBLANK: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (value: () => Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const NA: {
+    description: string;
+    args: never[];
+    returns: ["BOOLEAN"];
+    compute: (value: Maybe<CellValue>) => boolean;
+    isExported: true;
+};

package/dist/types/functions/module_logical.d.ts

@@ -0,0 +1,59 @@
+import { AddFunctionDescription, ArgValue, CellValue, Maybe, ValueAndFormat } from "../types";
+export declare const AND: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (...logicalExpressions: ArgValue[]) => boolean;
+    isExported: true;
+};
+export declare const FALSE: AddFunctionDescription;
+export declare const IF: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (logicalExpression: Maybe<ValueAndFormat>, valueIfTrue: () => Maybe<ValueAndFormat>, valueIfFalse?: () => Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const IFERROR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (value: () => Maybe<ValueAndFormat>, valueIfError?: () => Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const IFNA: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (value: () => Maybe<ValueAndFormat>, valueIfError?: () => Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const IFS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (...values: (() => Maybe<ValueAndFormat>)[]) => ValueAndFormat;
+    isExported: true;
+};
+export declare const NOT: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (logicalExpression: Maybe<CellValue>) => boolean;
+    isExported: true;
+};
+export declare const OR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (...logicalExpressions: ArgValue[]) => boolean;
+    isExported: true;
+};
+export declare const TRUE: AddFunctionDescription;
+export declare const XOR: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["BOOLEAN"];
+    compute: (...logicalExpressions: ArgValue[]) => boolean;
+    isExported: true;
+};

package/dist/types/functions/module_lookup.d.ts

@@ -0,0 +1,72 @@
+import { AddFunctionDescription, Arg, ArgValue, CellValue, Matrix, Maybe, ValueAndFormat } from "../types";
+export declare const ADDRESS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["STRING"];
+    compute: (this: import("../types").EvalContext, row: Maybe<CellValue>, column: Maybe<CellValue>, absoluteRelativeMode: Maybe<CellValue>, useA1Notation: Maybe<CellValue>, sheet: Maybe<CellValue> | undefined) => string;
+    isExported: true;
+};
+export declare const COLUMN: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, cellReference: string) => number;
+    isExported: true;
+};
+export declare const COLUMNS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (range: string) => number;
+    isExported: true;
+};
+export declare const HLOOKUP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (this: import("../types").EvalContext, searchKey: Maybe<ValueAndFormat>, range: Arg, index: Maybe<ValueAndFormat>, isSorted?: Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const INDEX: AddFunctionDescription;
+export declare const LOOKUP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (searchKey: Maybe<ValueAndFormat>, searchArray: Arg, resultRange: Arg) => ValueAndFormat;
+    isExported: true;
+};
+export declare const MATCH: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, searchKey: Maybe<CellValue>, range: ArgValue, searchType?: Maybe<CellValue>) => number;
+    isExported: true;
+};
+export declare const ROW: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (this: import("../types").EvalContext, cellReference?: string) => number;
+    isExported: true;
+};
+export declare const ROWS: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["NUMBER"];
+    compute: (range: string) => number;
+    isExported: true;
+};
+export declare const VLOOKUP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (this: import("../types").EvalContext, searchKey: Maybe<ValueAndFormat>, range: Arg, index: Maybe<ValueAndFormat>, isSorted?: Maybe<ValueAndFormat>) => ValueAndFormat;
+    isExported: true;
+};
+export declare const XLOOKUP: {
+    description: string;
+    args: import("../types").ArgDefinition[];
+    returns: ["ANY"];
+    computeValueAndFormat: (this: import("../types").EvalContext, searchKey: Maybe<ValueAndFormat>, lookupRange: Arg, returnRange: Arg, defaultValue?: () => Maybe<ValueAndFormat>, matchMode?: Maybe<ValueAndFormat>, searchMode?: Maybe<ValueAndFormat>) => Matrix<ValueAndFormat>;
+    isExported: true;
+};