@sheetxl/formulas 0.7.26 → 0.7.28-beta.1

package/types/src/mathTrig/Math.d.ts

@@ -0,0 +1,430 @@
+import { IRange, Scalar, IReferenceRange, AcceptError, AcceptRefError, Repeating, Omittable } from '@sheetxl/primitives';
+/**
+ * @summary Returns the absolute value of a number, a number without its sign.
+ * @param number is the real number for which you want the absolute value.
+ */
+export declare function ABS(number: number): number;
+/**
+ * @summary Returns an aggregate in a list or database.
+ * @param functionNum The function to use: 1-19.
+ * @param options The options for the aggregate: 0-7.
+ * @param array The ranges to aggregate.
+ * @param KOrRest If functionNum is 14-19, this is the k value. Otherwise, this is the first of the ranges to aggregate.
+ *
+ * @remarks
+ * | functionNum | Function        |
+ * |--------------|-----------------|
+ * | 1            | AVERAGE         |
+ * | 2            | COUNT           |
+ * | 3            | COUNTA          |
+ * | 4            | MAX             |
+ * | 5            | MIN             |
+ * | 6            | PRODUCT         |
+ * | 7            | STDEV           |
+ * | 8            | STDEVP          |
+ * | 9            | SUM             |
+ * | 10           | VAR             |
+ * | 11           | VARP            |
+ * | 12           | MEDIAN          |
+ * | 13           | MODE.SNGL       |
+ * | 14           | LARGE           |
+ * | 15           | SMALL           |
+ * | 16           | PERCENTILE.INC  |
+ * | 17           | QUARTILE.INC    |
+ * | 18           | PERCENTILE.EXC  |
+ * | 19           | QUARTILE.EXC    |
+ *
+ * | options | Behavior                                              |
+ * |---------|-------------------------------------------------------|
+ * | 0       | Ignore nested SUBTOTAL and AGGREGATE functions        |
+ * | 1       | Ignore hidden rows, nested SUBTOTAL and AGGREGATE     |
+ * | 2       | Ignore error values, nested SUBTOTAL and AGGREGATE    |
+ * | 3       | Ignore hidden rows, errors, nested SUBTOTAL/AGGREGATE |
+ * | 4       | Ignore nothing                                        |
+ * | 5       | Ignore hidden rows                                    |
+ * | 6       | Ignore error values                                   |
+ * | 7       | Ignore hidden rows and error values                   |
+ *
+ * Note: nested SUBTOTAL/AGGREGATE calls within ref ranges are not excluded
+ * from the calculation in this implementation. This matches the behavior of
+ * most spreadsheet engines but differs from Excel in edge cases where
+ * SUBTOTAL results appear within the referenced range.
+ */
+export declare function AGGREGATE(functionNum: number, options: number, array: AcceptRefError<IRange>, ...KOrRest: AcceptRefError<IRange>[]): Scalar;
+/**
+ * @summary Converts a Roman numeral to Arabic.
+ * @param text is the Roman numeral you want to convert.
+ */
+export declare function ARABIC(text: string): number;
+/**
+ * @summary Converts a number into a text representation with the given radix (base).
+ * @param number is the number that you want to convert.
+ * @param radix is the base Radix that you want to convert the number into.
+ * @param minLength is the minimum length of the returned string.
+ */
+export declare function BASE(number: number, radix: number, minLength?: number): string | number;
+/**
+ * @summary Rounds a number up, to the nearest multiple of significance.
+ * @param number is the value you want to round.
+ * @param significance is the multiple to which you want to round.
+ * @category Compatibility
+ */
+export declare function CEILING(number: number, significance: number): number;
+/**
+ * @name CEILING.MATH
+ * @summary Rounds a number up, to the nearest integer or to the nearest multiple of significance.
+ * @param number is the real number you want to round.
+ * @param significance when given and nonzero this function will round away from zero.
+ */
+export declare function CEILING_MATH(number: number, significance?: Omittable<number>, mode?: number): number;
+/**
+ * @name CEILING.PRECISE
+ * @summary Rounds a number up to the nearest integer or to the nearest multiple of significance.
+ * @param number is the real number you want to round.
+ * @param significance is the multiple to which you want to round.
+ * @category Compatibility
+ */
+export declare function CEILING_PRECISE(number: number, significance?: Omittable<number>): number;
+/**
+ * @name ECMA.CEILING
+ * @summary Rounds a number up, to the nearest multiple of significance.
+ * @param number is the value you want to round.
+ * @param significance is the multiple to which you want to round.
+ * @category Compatibility
+ */
+export declare function ECMA_CEILING(number: number, significance: number): number;
+/**
+ * @summary Returns the number of combinations for a given number of items.
+ * @param number is the total number of items.
+ * @param numberChosen is the number of items in each combination.
+ */
+export declare function COMBIN(number: number, numberChosen: number): number;
+/**
+ * @summary Returns the number of combinations with repetitions for a given number of items.
+ * @param number is the total number of items.
+ * @param numberChosen is the number of items in each combination.
+ */
+export declare function COMBINA(number: number, numberChosen: number): number;
+/**
+ * @summary Converts a text representation of a number in a given base into a decimal number.
+ * @param number is the number that you want to convert.
+ * @param radix is the base Radix of the number you are converting.
+ */
+export declare function DECIMAL(number: string, radix: number): number;
+/**
+ * @summary Converts radians to degrees.
+ * @param angle is the angle in radians that you want to convert.
+ */
+export declare function DEGREES(angle: number): number;
+/**
+ * @summary Rounds a positive number up and negative number down to the nearest even integer.
+ * @param number is the value to round.
+ */
+export declare function EVEN(number: number): number;
+/**
+ * @summary Returns e raised to the power of a given number.
+ * @param number is the exponent applied to the base e. The constant e equals 2.71828182845904, the base of the natural logarithm.
+ */
+export declare function EXP(number: number): number;
+/**
+ * @summary Returns the factorial of a number, equal to 1*2*3*...* Number.
+ * @param number is the nonnegative number you want the factorial for.
+ */
+export declare function FACT(number: number): number;
+/**
+ * @summary Returns the double factorial of a number.
+ * @param number is the value for which to return the double factorial.
+ */
+export declare function FACTDOUBLE(number: number): number;
+/**
+ * @summary Rounds a number down to the nearest multiple of significance.
+ * @param number is the real number you want to round.
+ * @param significance is the multiple to which you want to round. Number and Significance must either both be positive or both be negative.
+ * @category Compatibility
+ */
+export declare function FLOOR(number: number, significance: number): number;
+/**
+ * @name FLOOR.MATH
+ * @summary Rounds a number down, to the nearest integer or to the nearest multiple of significance.
+ * @param number is the real number you want to round.
+ * @param significance is the multiple to which you want to round.
+ * @param mode when given and nonzero this function will round towards zero.
+ */
+export declare function FLOOR_MATH(number: number, significance?: Omittable<number>, mode?: Omittable<number>): Scalar;
+/**
+ * @name FLOOR.PRECISE
+ * @summary Rounds a number down to the nearest integer or to the nearest multiple of significance.
+ * @param number is the real number you want to round.
+ * @param significance is the multiple to which you want to round.
+ */
+export declare function FLOOR_PRECISE(number: number, significance?: Omittable<number>): number;
+/**
+ * @summary Returns the greatest common divisor.
+ * @param number are 1 to 255 values.
+ */
+export declare function GCD(number: Scalar[]): number;
+/**
+ * @summary Rounds a number down to the nearest integer.
+ * @param number is the real number you want to round down to an integer.
+ */
+export declare function INT(number: number): number;
+/**
+ * @name ISO.CEILING
+ * @summary Rounds a number up to the nearest integer.
+ * @param number is the real number you want to round up to an integer.
+ * @param significance is the multiple to which you want to round number.
+ * @category Compatibility
+ */
+export declare function ISO_CEILING(number: number, significance?: number): number;
+/**
+ * @summary Returns the least common multiple.
+ * @param number are 1 to 255 values for which you want the least common multiple.
+ */
+export declare function LCM(number: Scalar[]): number;
+/**
+ * @summary Returns the natural logarithm of a number.
+ * @param number is the positive real number for which you want the natural logarithm.
+ */
+export declare function LN(number: number): number;
+/**
+ * @summary Returns the logarithm of a number to the base you specify.
+ * @param number is the positive real number for which you want the logarithm.
+ * @param base is the base of the logarithm.
+ */
+export declare function LOG(number: number, base?: number): number;
+/**
+ * @summary Returns the base-10 logarithm of a number.
+ * @param number is the positive real number for which you want the base-10 logarithm.
+ */
+export declare function LOG10(number: number): number;
+/**
+ * @summary Returns the matrix determinant of an array.
+ * @param array is a numeric array with an equal number of rows and columns, either a cell range or an array constant.
+ */
+export declare function MDETERM(array: IRange<number>): Scalar;
+/**
+ * @summary Returns the inverse matrix for the matrix stored in an array.
+ * @param array is a numeric array with an equal number of rows and columns, either a cell range or an array constant.
+ */
+export declare function MINVERSE(array: IRange<number>): Scalar[][];
+/**
+ * @summary Returns the matrix product of two arrays, an array with the same number of rows as array1 and columns as array2.
+ * @param array1 is the first array of numbers to multiply and must have the same number of columns as Array2 has rows.
+ * @param array2 is the second array of numbers to multiply and must have the same number of columns as Array1 has rows.
+ */
+export declare function MMULT(array1: IRange<number>, array2: IRange<number>): Scalar[][];
+/**
+ * @summary Returns the remainder after a number is divided by a divisor.
+ * @param number is the number for which you want to find the remainder after the division is performed.
+ * @param divisor is the number by which you want to divide Number.
+ */
+export declare function MOD(number: number, divisor: number): number;
+/**
+ * @summary Returns a number rounded to the desired multiple.
+ * @param number is the value to round.
+ * @param multiple is the multiple to which you want to round number.
+ */
+export declare function MROUND(number: number, multiple: number): number;
+/**
+ * @summary Returns the multinomial of a set of numbers.
+ * @param number are 1 to 255 values for which you want the multinomial.
+ */
+export declare function MULTINOMIAL(number: number[]): number;
+/**
+ * @summary Returns the unit matrix for the specified dimension.
+ * @param dimension is an integer specifying the dimension of the unit matrix that you want to return.
+ */
+export declare function MUNIT(dimension: number): IRange;
+/**
+ * @summary Rounds a positive number up and negative number down to the nearest odd integer.
+ * @param number is the value to round.
+ */
+export declare function ODD(number: number): number;
+/**
+ * @summary Returns the percentage of a subset of a given data set.
+ * @param dataSubset is the subset.
+ * @param dataAll is the data set.
+ */
+export declare function PERCENTOF(dataSubset: IRange<number>, dataAll: IRange<number>): number;
+/**
+ * @summary Returns the value of Pi, 3.14159265358979, accurate to 15 digits.
+ */
+export declare function PI(): number;
+/**
+ * @summary Returns the result of a number raised to a power.
+ * @param number is the base number, any real number.
+ * @param power is the exponent, to which the base number is raised.
+ */
+export declare function POWER(number: number, power: number): number;
+/**
+ * @summary Multiplies all the numbers given as arguments.
+ * @param number are 1 to 255 numbers, logical values, or text representations of numbers that you want to multiply.
+ */
+export declare function PRODUCT(number: IRange<number>[]): number;
+/**
+ * @summary Returns the integer portion of a division.
+ * @param numerator is the dividend.
+ * @param denominator is the divisor.
+ */
+export declare function QUOTIENT(numerator: number, denominator: number): number;
+/**
+ * @summary Converts degrees to radians.
+ * @param angle is an angle in degrees that you want to convert.
+ */
+export declare function RADIANS(angle: number): number;
+/**
+ * @summary Returns a random number greater than or equal to 0 and less than 1, evenly distributed (changes on recalculation).
+ */
+export declare function RAND(): number;
+/**
+ * @summary Returns an array of random numbers.
+ * @param rows the number of rows in the returned array.
+ * @param columns the number of columns in the returned array.
+ * @param min the minimum number you would like returned.
+ * @param max the maximum number you would like returned.
+ * @param integer return an integer or a decimal value. TRUE for an integer, FALSE for a decimal number.
+ */
+export declare function RANDARRAY(rows?: number, columns?: number, min?: number, max?: number, integer?: boolean): IRange;
+/**
+ * @summary Returns a random number between the numbers you specify.
+ * @param bottom is the smallest integer RANDBETWEEN will return.
+ * @param top is the largest integer RANDBETWEEN will return.
+ */
+export declare function RANDBETWEEN(bottom: Scalar, top: Scalar): number;
+/**
+ * @summary Converts an Arabic numeral to Roman, as text.
+ * @param number is the Arabic numeral you want to convert.
+ * @param form is the number specifying the type of Roman numeral you want.
+ */
+export declare function ROMAN(number: number, form?: number): Scalar;
+/**
+ * @summary Rounds a number to a specified number of digits.
+ * @param number is the number you want to round.
+ * @param numDigits is the number of digits to which you want to round. Negative rounds to the left of the decimal point to the nearest integer.
+ */
+export declare function ROUND(number: number, numDigits: number): number;
+/**
+ * @summary Rounds a number down, toward zero.
+ * @param number is any real number that you want rounded down.
+ * @param numDigits is the number of digits to which you want to round. Negative rounds to the left of the decimal point to the nearest integer.
+ */
+export declare function ROUNDDOWN(number: number, numDigits: number): number;
+/**
+ * @summary Rounds a number up, away from zero.
+ * @param number is any real number that you want rounded up.
+ * @param numDigits is the number of digits to which you want to round. Negative rounds to the left of the decimal point to the nearest integer.
+ */
+export declare function ROUNDUP(number: number, numDigits: number): number;
+/**
+ * @summary Returns a sequence of numbers.
+ * @param rows the number of rows to return.
+ * @param columns the number of columns to return.
+ * @param start the first number in the sequence.
+ * @param step the amount to increment each subsequent value in the sequence.
+ */
+export declare function SEQUENCE(rows: Omittable<number>, columns?: Omittable<number>, start?: Omittable<number>, step?: Omittable<number>): IRange;
+/**
+ * @summary Returns the sum of a power series based on the formula.
+ * @param x is the input value to the power series.
+ * @param n is the initial power to which you want to raise x.
+ * @param m is the step by which to increase n for each term in the series.
+ * @param coefficients is a set of coefficients by which each successive power of x is multiplied.
+ */
+export declare function SERIESSUM(x: number, n: number, m: number, coefficients: IRange<number>): number;
+/**
+ * @summary Returns the sign of a number: 1 if the number is positive, zero if the number is zero, or -1 if the number is negative.
+ * @param number is any real number.
+ */
+export declare function SIGN(number: number): number;
+/**
+ * @summary Returns the square root of a number.
+ * @param number is the number for which you want the square root.
+ */
+export declare function SQRT(number: number): number;
+/**
+ * @summary Returns the square root of (number * Pi).
+ * @param number is the number by which p is multiplied.
+ */
+export declare function SQRTPI(number: number): number;
+/**
+ * @summary Returns a subtotal in a list or database.
+ * @param functionNum is the number 1 to 11 that specifies the summary function for the subtotal.
+ * @param ref are 1 to 254 ranges or references for which you want the subtotal.
+ *
+ * @remarks
+ * | functionNum (includes hidden rows) | functionNum (ignores hidden rows)  | Function |
+   |-------------------------------------|-------------------------------------|----------|
+   | 1                                   | 101                                 | AVERAGE  |
+   | 2                                   | 102                                 | COUNT    |
+   | 3                                   | 103                                 | COUNTA   |
+   | 4                                   | 104                                 | MAX      |
+   | 5                                   | 105                                 | MIN      |
+   | 6                                   | 106                                 | PRODUCT  |
+   | 7                                   | 107                                 | STDEV    |
+   | 8                                   | 108                                 | STDEVP   |
+   | 9                                   | 109                                 | SUM      |
+   | 10                                  | 110                                 | VAR      |
+   | 11                                  | 111                                 | VARP     |
+ *
+ * Note: nested SUBTOTAL/AGGREGATE calls within ref ranges are not excluded
+ * from the calculation in this implementation. This matches the behavior of
+ * most spreadsheet engines but differs from Excel in edge cases where
+ * SUBTOTAL results appear within the referenced range.
+ */
+export declare function SUBTOTAL(functionNum: number, // 1 - 11
+ref: AcceptError<IReferenceRange>[]): Scalar;
+/**
+ * @summary Adds all the numbers in a range of cells.
+ * @param number are 1 to 255 numbers to sum. Logical values and text are ignored in cells, included if typed as arguments.
+ */
+export declare function SUM(number: IRange<number>[]): number;
+/**
+ * @summary Adds the cells specified by a given condition or criteria.
+ * @param range is the range of cells you want evaluated.
+ * @param criteria is the condition or criteria in the form of a number, expression, or text that defines which cells will be added.
+ * @param sumRange are the actual cells to sum. If omitted, the cells in range are used.
+ */
+export declare function SUMIF(range: AcceptError<IReferenceRange>, criteria: AcceptError<Scalar>, sumRange?: AcceptError<IReferenceRange>): Scalar;
+/**
+ * @summary Adds the cells specified by a given set of conditions or criteria.
+ * @param sumRange are the actual cells to sum.
+ * @param criteria the ranges to evaluate and the conditions to evaluate them against.
+ * @param criteria.criteriaRange is the range of cells you want evaluated for the particular condition.
+ * @param criteria.criteria is the condition or criteria in the form of a number, expression, or text that defines which cells will be added.
+ */
+export declare function SUMIFS(sumRange: AcceptError<IRange>, criteria: Repeating<[criteriaRange: AcceptError<IReferenceRange>, criteria: AcceptError<Scalar>]>): Scalar;
+/**
+ * @summary Returns the sum of the products of corresponding ranges or arrays.
+ * @param array are 2 to 255 arrays for which you want to multiply and then add components. All arrays must have the same dimensions.
+ */
+export declare function SUMPRODUCT(array: IRange[]): number;
+/**
+ * @summary Returns the sum of the squares of the arguments. The arguments can be numbers, arrays, names, or references to cells that contain numbers.
+ * @param number are 1 to 255 numbers, arrays, names, or references to arrays for which you want the sum of the squares.
+ */
+export declare function SUMSQ(number: IRange<number>[]): number;
+/**
+ * @summary Sums the differences between the squares of two corresponding ranges or arrays.
+ * @param arrayX is the first range or array of numbers and can be a number or name, array, or reference that contains numbers.
+ * @param arrayY is the second range or array of numbers and can be a number or name, array, or reference that contains numbers.
+ */
+export declare function SUMX2MY2(arrayX: AcceptError<IRange>, arrayY: AcceptError<IRange>): number;
+/**
+ * @summary Returns the sum total of the sums of squares of numbers in two corresponding ranges or arrays.
+ * @param arrayX is the first range or array of numbers and can be a number or name, array, or reference that contains numbers.
+ * @param arrayY is the second range or array of numbers and can be a number or name, array, or reference that contains numbers.
+ */
+export declare function SUMX2PY2(arrayX: AcceptError<IRange>, arrayY: AcceptError<IRange>): number;
+/**
+ * @summary Sums the squares of the differences in two corresponding ranges or arrays.
+ * @param arrayX is the first range or array of numbers and can be a number or name, array, or reference that contains numbers.
+ * @param arrayY is the second range or array of numbers and can be a number or name, array, or reference that contains numbers.
+ */
+export declare function SUMXMY2(arrayX: AcceptError<IRange>, arrayY: AcceptError<IRange>): number;
+/**
+ * @summary Truncates a number to an integer by removing the decimal, or fractional, part of the number.
+ * @param number is the number you want to truncate.
+ * @param numDigits is a number specifying the precision of the truncation.
+ */
+export declare function TRUNC(number: number, numDigits?: number): number;
+//# sourceMappingURL=Math.d.ts.map

package/types/src/mathTrig/Trig.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @summary Returns the arccosine of a number, in radians in the range 0 to Pi. The arccosine is the angle whose cosine is Number.
+ * @param number is the cosine of the angle you want and must be from -1 to 1.
+ */
+export declare function ACOS(number: number): number;
+/**
+ * @summary Returns the inverse hyperbolic cosine of a number.
+ * @param number is any real number equal to or greater than 1.
+ */
+export declare function ACOSH(number: number): number;
+/**
+ * @summary Returns the arccotangent of a number, in radians in the range 0 to Pi.
+ * @param number is the cotangent of the angle you want.
+ */
+export declare function ACOT(number: number): number;
+/**
+ * @summary Returns the inverse hyperbolic cotangent of a number.
+ * @param number is the hyperbolic cotangent of the angle that you want.
+ */
+export declare function ACOTH(number: number): number;
+/**
+ * @summary Returns the arcsine of a number in radians, in the range -Pi/2 to Pi/2.
+ * @param number is the sine of the angle you want and must be from -1 to 1.
+ */
+export declare function ASIN(number: number): number;
+/**
+ * @summary Returns the inverse hyperbolic sine of a number.
+ * @param number is any real number equal to or greater than 1.
+ */
+export declare function ASINH(number: number): number;
+/**
+ * @summary Returns the arctangent of a number in radians, in the range -Pi/2 to Pi/2.
+ * @param number is the tangent of the angle you want.
+ */
+export declare function ATAN(number: number): number;
+/**
+ * @summary Returns the arctangent of the specified x- and y- coordinates, in radians between -Pi and Pi, excluding -Pi.
+ * @param x is the x-coordinate of the point.
+ * @param y is the y-coordinate of the point.
+ */
+export declare function ATAN2(x: number, y: number): number;
+/**
+ * @summary Returns the inverse hyperbolic tangent of a number.
+ * @param number is any real number between -1 and 1 excluding -1 and 1.
+ */
+export declare function ATANH(number: number): number;
+/**
+ * @summary Returns the cosine of an angle.
+ * @param number is the angle in radians for which you want the cosine.
+ */
+export declare function COS(number: number): number;
+/**
+ * @summary Returns the hyperbolic cosine of a number.
+ * @param number is any real number.
+ */
+export declare function COSH(number: number): number;
+/**
+ * @summary Returns the cotangent of an angle.
+ * @param number is the angle in radians for which you want the cotangent.
+ */
+export declare function COT(number: number): number;
+/**
+ * @summary Returns the hyperbolic cotangent of a number.
+ * @param number is the angle in radians for which you want the hyperbolic cotangent.
+ */
+export declare function COTH(number: number): number;
+/**
+ * @summary Returns the cosecant of an angle.
+ * @param number is the angle in radians for which you want the cosecant.
+ */
+export declare function CSC(number: number): number;
+/**
+ * @summary Returns the hyperbolic cosecant of an angle.
+ * @param number is the angle in radians for which you want the hyperbolic cosecant.
+ */
+export declare function CSCH(number: number): number;
+/**
+ * @summary Returns the secant of an angle.
+ * @param number is the angle in radians for which you want the secant.
+ */
+export declare function SEC(number: number): number;
+/**
+ * @summary Returns the hyperbolic secant of an angle.
+ * @param number is the angle in radians for which you want the hyperbolic secant.
+ */
+export declare function SECH(number: number): number;
+/**
+ * @summary Returns the sine of an angle.
+ * @param number is the angle in radians for which you want the sine. Degrees * PI()/180 = radians.
+ */
+export declare function SIN(number: number): number;
+/**
+ * @summary Returns the hyperbolic sine of a number.
+ * @param number is any real number.
+ */
+export declare function SINH(number: number): number;
+/**
+ * @summary Returns the tangent of an angle.
+ * @param number is the angle in radians for which you want the tangent. Degrees * PI()/180 = radians.
+ */
+export declare function TAN(number: number): number;
+/**
+ * @summary Returns the hyperbolic tangent of a number.
+ * @param number is any real number.
+ */
+export declare function TANH(number: number): number;
+//# sourceMappingURL=Trig.d.ts.map

package/types/src/operators/Operators.d.ts

@@ -0,0 +1,107 @@
+import { Scalar } from '@sheetxl/primitives';
+/**
+ * @summary Returns the sum of two numbers. Equal to the '+' operator.
+ * @param value1 The first number to add.
+ * @param value2 The second number to add.
+ * @category Sheets
+ */
+export declare function ADD(value1: number, value2: number): number;
+/**
+ * @summary Returns the result of dividing one number by another. Equal to the '/' operator.
+ * @param dividend The number to be divided.
+ * @param divisor The number to divide by.
+ * @category Sheets
+ */
+export declare function DIVIDE(dividend: number, divisor: number): number;
+/**
+ * @summary Returns TRUE if the two specified values are equal. Equal to the '=' operator.
+ * @param value1 The first value to compare.
+ * @param value2 The second value to compare.
+ * @category Sheets
+ */
+export declare function EQ(value1: Scalar, value2: Scalar): boolean;
+/**
+ * @summary Returns TRUE if the first value is greater than the second. Equal to the '>' operator.
+ * @param value1 The first value to compare.
+ * @param value2 The second value to compare.
+ * @category Sheets
+ */
+export declare function GT(value1: Scalar, value2: Scalar): boolean;
+/**
+ * @summary Returns TRUE if the first value is greater than or equal to the second. Equal to the '>=' operator.
+ * @param value1 The first value to compare.
+ * @param value2 The second value to compare.
+ * @category Sheets
+ */
+export declare function GTE(value1: Scalar, value2: Scalar): boolean;
+/**
+ * @summary Returns TRUE if the first value is less than the second. Equal to the '<' operator.
+ * @param value1 The first value to compare.
+ * @param value2 The second value to compare.
+ * @category Sheets
+ */
+export declare function LT(value1: Scalar, value2: Scalar): boolean;
+/**
+ * @summary Returns TRUE if the first value is less than or equal to the second. Equal to the '<=' operator.
+ * @param value1 The first value to compare.
+ * @param value2 The second value to compare.
+ * @category Sheets
+ */
+export declare function LTE(value1: Scalar, value2: Scalar): boolean;
+/**
+ * @summary Returns the difference of two numbers. Equal to the '-' operator.
+ * @param value1 The number from which to subtract.
+ * @param value2 The number to subtract.
+ * @category Sheets
+ */
+export declare function MINUS(value1: number, value2: number): number;
+/**
+ * @summary Returns the product of two numbers. Equal to the '*' operator.
+ * @param value1 The first number to multiply.
+ * @param value2 The second number to multiply.
+ * @category Sheets
+ */
+export declare function MULTIPLY(value1: number, value2: number): number;
+/**
+ * @summary Returns TRUE if the two specified values are not equal. Equal to the '<>' operator.
+ * @param value1 The first value to compare.
+ * @param value2 The second value to compare.
+ * @category Sheets
+ */
+export declare function NE(value1: Scalar, value2: Scalar): boolean;
+/**
+ * @summary Returns a number raised to a power. Equal to the '^' operator.
+ * @param base The number to raise to a power.
+ * @param exponent The power to raise the base to.
+ * @category Sheets
+ */
+export declare function POW(base: number, exponent: number): number;
+/**
+ * @summary Returns the negation of a number. Equal to the unary '-' operator.
+ * @param value The number to negate.
+ * @category Sheets
+ */
+export declare function UMINUS(value: number): number;
+/**
+ * @summary Converts a number to a percentage. Equal to the '%' operator.
+ * @param value The number to convert to a percentage.
+ * @category Sheets
+ */
+export declare function UNARY_PERCENT(value: number): number;
+/**
+ * @summary Returns a number unchanged. Equal to the unary '+' operator.
+ * @param value The number to return.
+ * @category Sheets
+ */
+export declare function UPLUS(value: number): number;
+/**
+ * @summary Checks whether a number is between two numbers, inclusive by default.
+ * @param value The value to test.
+ * @param lower The lower bound.
+ * @param upper The upper bound.
+ * @param lowerInclusive Whether the lower bound is inclusive. Default TRUE.
+ * @param upperInclusive Whether the upper bound is inclusive. Default TRUE.
+ * @category Sheets
+ */
+export declare function ISBETWEEN(value: number, lower: number, upper: number, lowerInclusive?: boolean, upperInclusive?: boolean): boolean;
+//# sourceMappingURL=Operators.d.ts.map