@rowsncolumns/functions 15.0.2 → 15.1.1

package/dist/cjs/function-descriptions.js

@@ -9805,4 +9805,937 @@ exports.functionDescriptions = [
             },
         ],
     },
+    {
+        datatype: "Logical",
+        title: "LET",
+        syntax: "LET(name1, value1, [name2, value2], …, calculation)",
+        description: "Assigns names to calculation results so a value is computed once and reused by name inside the final calculation.",
+        example: "LET(x, A1*2, x+x)",
+        usage: [
+            "LET(x, A1*2, x+x)",
+            "LET(total, SUM(A1:A10), count, COUNT(A1:A10), total/count)",
+        ],
+        parameters: [
+            {
+                title: "name1",
+                description: "The first name to assign. Must begin with a letter and cannot look like a cell reference.",
+            },
+            {
+                title: "value1",
+                description: "The value assigned to name1.",
+            },
+            {
+                title: "name2, value2, … [OPTIONAL]",
+                description: "Additional name/value pairs; each value can use the names assigned before it.",
+            },
+            {
+                title: "calculation",
+                description: "The expression that uses the assigned names; its result is the result of LET.",
+            },
+        ],
+    },
+    {
+        datatype: "Logical",
+        title: "LAMBDA",
+        syntax: "LAMBDA([parameter1, parameter2, …,] calculation)",
+        description: "Creates a reusable custom function from its parameters and a calculation. Call it in place with LAMBDA(…)(arguments), give it a name in the Name Manager, or pass it to MAP, BYROW, REDUCE and the other helper functions.",
+        example: "LAMBDA(x, y, x+y)(1, 2)",
+        usage: ["LAMBDA(x, y, x+y)(1, 2)", "MAP(A1:A5, LAMBDA(v, v*2))"],
+        parameters: [
+            {
+                title: "parameter1, parameter2, … [OPTIONAL]",
+                description: "Names for the values passed when the function is called. Wrap a name in square brackets to make it optional (see ISOMITTED).",
+            },
+            {
+                title: "calculation",
+                description: "The formula evaluated with the parameters; always the last argument and the function's result.",
+            },
+        ],
+    },
+    {
+        datatype: "Info",
+        title: "ISOMITTED",
+        syntax: "ISOMITTED(argument)",
+        description: "Returns TRUE when the named LAMBDA parameter was left out of the call, so a custom function can supply a default.",
+        example: "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5)",
+        usage: [
+            "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5)",
+            "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5, 2)",
+        ],
+        parameters: [
+            {
+                title: "argument",
+                description: "The LAMBDA parameter to test.",
+            },
+        ],
+    },
+    {
+        datatype: "Lookup",
+        title: "XMATCH",
+        syntax: "XMATCH(lookup_value, lookup_array, [match_mode], [search_mode])",
+        description: "Returns the position of a value in a range or array. Exact match by default, with the same match and search modes as XLOOKUP.",
+        example: "XMATCH(E2, B2:B10)",
+        usage: ["XMATCH(E2, B2:B10)", "XMATCH(E2, B2:B10, 1)", 'XMATCH("gr*", B2:B10, 2)'],
+        parameters: [
+            {
+                title: "lookup_value",
+                description: "The value to search for.",
+            },
+            {
+                title: "lookup_array",
+                description: "The range or array to search in.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for exact match (default), -1 for exact or next smaller, 1 for exact or next larger, 2 for wildcard match.",
+            },
+            {
+                title: "search_mode [OPTIONAL]",
+                description: "1 to search first to last (default), -1 last to first, 2 binary search on ascending data, -2 binary search on descending data.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "VSTACK",
+        syntax: "VSTACK(array1, [array2], …)",
+        description: "Appends arrays vertically, one below the other, into a single array; narrower arrays are padded with #N/A.",
+        example: "VSTACK(A1:C3, E1:G2)",
+        usage: ["VSTACK(A1:C3, E1:G2)", "VSTACK({1,2}, {3,4})"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The first range or array to stack.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional ranges or arrays appended below the previous one.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "HSTACK",
+        syntax: "HSTACK(array1, [array2], …)",
+        description: "Appends arrays horizontally, side by side, into a single array; shorter arrays are padded with #N/A.",
+        example: "HSTACK(A1:A3, C1:C3)",
+        usage: ["HSTACK(A1:A3, C1:C3)", "HSTACK({1;2}, {3;4})"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The first range or array to stack.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional ranges or arrays appended to the right of the previous one.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "CHOOSECOLS",
+        syntax: "CHOOSECOLS(array, col_num1, [col_num2], …)",
+        description: "Returns the specified columns of an array, in the order given; negative numbers count from the last column.",
+        example: "CHOOSECOLS(A1:E10, 1, 3)",
+        usage: ["CHOOSECOLS(A1:E10, 1, 3)", "CHOOSECOLS(A1:E10, -1)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to pick columns from.",
+            },
+            {
+                title: "col_num1",
+                description: "The first column to return; negative counts from the end.",
+            },
+            {
+                title: "col_num2, … [OPTIONAL]",
+                description: "Additional columns to return, in output order.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "CHOOSEROWS",
+        syntax: "CHOOSEROWS(array, row_num1, [row_num2], …)",
+        description: "Returns the specified rows of an array, in the order given; negative numbers count from the last row.",
+        example: "CHOOSEROWS(A1:E10, 1, 3)",
+        usage: ["CHOOSEROWS(A1:E10, 1, 3)", "CHOOSEROWS(A1:E10, -1)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to pick rows from.",
+            },
+            {
+                title: "row_num1",
+                description: "The first row to return; negative counts from the end.",
+            },
+            {
+                title: "row_num2, … [OPTIONAL]",
+                description: "Additional rows to return, in output order.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "TOCOL",
+        syntax: "TOCOL(array, [ignore], [scan_by_column])",
+        description: "Returns an array as a single column, reading it row by row unless scan_by_column is TRUE.",
+        example: "TOCOL(A1:C3)",
+        usage: ["TOCOL(A1:C3)", "TOCOL(A1:C3, 1)", "TOCOL(A1:C3, 0, TRUE)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to flatten.",
+            },
+            {
+                title: "ignore [OPTIONAL]",
+                description: "0 keeps every value (default), 1 ignores blanks, 2 ignores errors, 3 ignores blanks and errors.",
+            },
+            {
+                title: "scan_by_column [OPTIONAL]",
+                description: "TRUE to read the array column by column. Defaults to FALSE (row by row).",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "TOROW",
+        syntax: "TOROW(array, [ignore], [scan_by_column])",
+        description: "Returns an array as a single row, reading it row by row unless scan_by_column is TRUE.",
+        example: "TOROW(A1:C3)",
+        usage: ["TOROW(A1:C3)", "TOROW(A1:C3, 1)", "TOROW(A1:C3, 0, TRUE)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to flatten.",
+            },
+            {
+                title: "ignore [OPTIONAL]",
+                description: "0 keeps every value (default), 1 ignores blanks, 2 ignores errors, 3 ignores blanks and errors.",
+            },
+            {
+                title: "scan_by_column [OPTIONAL]",
+                description: "TRUE to read the array column by column. Defaults to FALSE (row by row).",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "WRAPROWS",
+        syntax: "WRAPROWS(vector, wrap_count, [pad_with])",
+        description: "Wraps a single row or column of values into rows of wrap_count values each; the last row is padded with pad_with (#N/A by default).",
+        example: "WRAPROWS(A1:A10, 3)",
+        usage: ["WRAPROWS(A1:A10, 3)", 'WRAPROWS(A1:A10, 3, "")'],
+        parameters: [
+            {
+                title: "vector",
+                description: "The single row or column to wrap.",
+            },
+            {
+                title: "wrap_count",
+                description: "Maximum number of values per row.",
+            },
+            {
+                title: "pad_with [OPTIONAL]",
+                description: "Value used to fill the last row. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "WRAPCOLS",
+        syntax: "WRAPCOLS(vector, wrap_count, [pad_with])",
+        description: "Wraps a single row or column of values into columns of wrap_count values each; the last column is padded with pad_with (#N/A by default).",
+        example: "WRAPCOLS(A1:A10, 3)",
+        usage: ["WRAPCOLS(A1:A10, 3)", 'WRAPCOLS(A1:A10, 3, "")'],
+        parameters: [
+            {
+                title: "vector",
+                description: "The single row or column to wrap.",
+            },
+            {
+                title: "wrap_count",
+                description: "Maximum number of values per column.",
+            },
+            {
+                title: "pad_with [OPTIONAL]",
+                description: "Value used to fill the last column. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "BYROW",
+        syntax: "BYROW(array, lambda(row))",
+        description: "Applies a LAMBDA to each row of an array and returns one result per row, as a column.",
+        example: "BYROW(A1:C5, LAMBDA(row, SUM(row)))",
+        usage: ["BYROW(A1:C5, LAMBDA(row, SUM(row)))", "BYROW(A1:C5, LAMBDA(row, MAX(row)))"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array whose rows are processed.",
+            },
+            {
+                title: "lambda(row)",
+                description: "A LAMBDA with one parameter that receives a row and returns a single value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "BYCOL",
+        syntax: "BYCOL(array, lambda(column))",
+        description: "Applies a LAMBDA to each column of an array and returns one result per column, as a row.",
+        example: "BYCOL(A1:C5, LAMBDA(col, SUM(col)))",
+        usage: ["BYCOL(A1:C5, LAMBDA(col, SUM(col)))", "BYCOL(A1:C5, LAMBDA(col, MAX(col)))"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array whose columns are processed.",
+            },
+            {
+                title: "lambda(column)",
+                description: "A LAMBDA with one parameter that receives a column and returns a single value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "MAP",
+        syntax: "MAP(array1, [array2, …], lambda(value1, [value2, …]))",
+        description: "Applies a LAMBDA to each value of one or more arrays and returns an array of the same shape.",
+        example: "MAP(A1:A5, LAMBDA(v, v*2))",
+        usage: ["MAP(A1:A5, LAMBDA(v, v*2))", "MAP(A1:A5, B1:B5, LAMBDA(a, b, a&b))"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The range or array to map.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional arrays of the same shape, passed to the LAMBDA as further parameters.",
+            },
+            {
+                title: "lambda(value1, [value2, …])",
+                description: "A LAMBDA with one parameter per array that returns the new value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "REDUCE",
+        syntax: "REDUCE([initial_value], array, lambda(accumulator, value))",
+        description: "Folds an array into a single value by calling a LAMBDA with the running accumulator and each value in turn.",
+        example: "REDUCE(0, A1:A5, LAMBDA(acc, v, acc+v))",
+        usage: ["REDUCE(0, A1:A5, LAMBDA(acc, v, acc+v))", "REDUCE(1, A1:A5, LAMBDA(acc, v, acc*v))"],
+        parameters: [
+            {
+                title: "initial_value [OPTIONAL]",
+                description: "The accumulator's starting value.",
+            },
+            {
+                title: "array",
+                description: "The range or array to fold.",
+            },
+            {
+                title: "lambda(accumulator, value)",
+                description: "A LAMBDA with two parameters that returns the next accumulator.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "SCAN",
+        syntax: "SCAN([initial_value], array, lambda(accumulator, value))",
+        description: "Like REDUCE, but returns every intermediate accumulator as an array of the same shape as the input.",
+        example: "SCAN(0, A1:A5, LAMBDA(acc, v, acc+v))",
+        usage: ["SCAN(0, A1:A5, LAMBDA(acc, v, acc+v))", 'SCAN("", A1:A5, LAMBDA(acc, v, acc&v))'],
+        parameters: [
+            {
+                title: "initial_value [OPTIONAL]",
+                description: "The accumulator's starting value.",
+            },
+            {
+                title: "array",
+                description: "The range or array to scan.",
+            },
+            {
+                title: "lambda(accumulator, value)",
+                description: "A LAMBDA with two parameters that returns the next accumulator.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "MAKEARRAY",
+        syntax: "MAKEARRAY(rows, columns, lambda(row, column))",
+        description: "Builds an array of the given size by calling a LAMBDA with each row and column number.",
+        example: "MAKEARRAY(3, 3, LAMBDA(r, c, r*c))",
+        usage: ["MAKEARRAY(3, 3, LAMBDA(r, c, r*c))", 'MAKEARRAY(2, 2, LAMBDA(r, c, "R"&r&"C"&c))'],
+        parameters: [
+            {
+                title: "rows",
+                description: "Number of rows in the result.",
+            },
+            {
+                title: "columns",
+                description: "Number of columns in the result.",
+            },
+            {
+                title: "lambda(row, column)",
+                description: "A LAMBDA with two parameters that returns the value for that row and column (both 1-based).",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TEXTBEFORE",
+        syntax: "TEXTBEFORE(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
+        description: "Returns the text that comes before the nth occurrence of a delimiter; a negative instance number counts occurrences from the end.",
+        example: 'TEXTBEFORE("Red riding hood", " ")',
+        usage: [
+            'TEXTBEFORE("Red riding hood", " ")',
+            'TEXTBEFORE("Red riding hood", " ", -1)',
+            'TEXTBEFORE("a-b-c", "-", 2)',
+        ],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to search in.",
+            },
+            {
+                title: "delimiter",
+                description: "The text (or array of texts) that marks the point before which to extract.",
+            },
+            {
+                title: "instance_num [OPTIONAL]",
+                description: "Which occurrence of the delimiter to use. Defaults to 1; negative counts from the end.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for case-sensitive (default) or 1 for case-insensitive delimiter matching.",
+            },
+            {
+                title: "match_end [OPTIONAL]",
+                description: "1 treats the end of the text as a delimiter. Defaults to 0.",
+            },
+            {
+                title: "if_not_found [OPTIONAL]",
+                description: "Value returned when the delimiter is not found. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TEXTAFTER",
+        syntax: "TEXTAFTER(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
+        description: "Returns the text that comes after the nth occurrence of a delimiter; a negative instance number counts occurrences from the end.",
+        example: 'TEXTAFTER("Red riding hood", " ")',
+        usage: [
+            'TEXTAFTER("Red riding hood", " ")',
+            'TEXTAFTER("Red riding hood", " ", -1)',
+            'TEXTAFTER("a-b-c", "-", 2)',
+        ],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to search in.",
+            },
+            {
+                title: "delimiter",
+                description: "The text (or array of texts) that marks the point after which to extract.",
+            },
+            {
+                title: "instance_num [OPTIONAL]",
+                description: "Which occurrence of the delimiter to use. Defaults to 1; negative counts from the end.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for case-sensitive (default) or 1 for case-insensitive delimiter matching.",
+            },
+            {
+                title: "match_end [OPTIONAL]",
+                description: "1 treats the start of the text as a delimiter. Defaults to 0.",
+            },
+            {
+                title: "if_not_found [OPTIONAL]",
+                description: "Value returned when the delimiter is not found. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "GROUPBY",
+        syntax: "GROUPBY(row_fields, values, function, [field_headers], [total_depth], [sort_order], [filter_array], [field_relationship])",
+        description: "Groups the rows of values by the values in row_fields and aggregates each group with the given function, returning a summary table with totals.",
+        example: "GROUPBY(A2:A20, C2:C20, SUM)",
+        usage: ["GROUPBY(A2:A20, C2:C20, SUM)", "GROUPBY(A2:A20, C2:C20, AVERAGE, 0, 0, -2)"],
+        parameters: [
+            {
+                title: "row_fields",
+                description: "Column-oriented range or array containing the values to group by.",
+            },
+            {
+                title: "values",
+                description: "Column-oriented range or array containing the values to aggregate.",
+            },
+            {
+                title: "function",
+                description: "The aggregation to apply to each group: SUM, PERCENTOF, AVERAGE, MEDIAN, COUNT, COUNTA, MAX, MIN, PRODUCT, ARRAYTOTEXT, CONCAT, STDEV.S, STDEV.P, VAR.S, VAR.P, MODE.SNGL, or a LAMBDA.",
+            },
+            {
+                title: "field_headers [OPTIONAL]",
+                description: "0 no headers, 1 headers in the data but not shown, 2 no headers but generate them, 3 headers in the data and shown. Inferred from the data when omitted.",
+            },
+            {
+                title: "total_depth [OPTIONAL]",
+                description: "0 no totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals above the data.",
+            },
+            {
+                title: "sort_order [OPTIONAL]",
+                description: "Column number to sort the result by; negative sorts descending.",
+            },
+            {
+                title: "filter_array [OPTIONAL]",
+                description: "Column-oriented array of TRUE/FALSE values selecting the rows to include.",
+            },
+            {
+                title: "field_relationship [OPTIONAL]",
+                description: "With more than one row field: 0 for a hierarchy (default) or 1 for a table.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "PIVOTBY",
+        syntax: "PIVOTBY(row_fields, col_fields, values, function, [field_headers], [row_total_depth], [row_sort_order], [col_total_depth], [col_sort_order], [filter_array], [relative_to])",
+        description: "Groups the rows of values by row_fields down the side and col_fields across the top, aggregating each cell with the given function, like a pivot table without the pivot.",
+        example: "PIVOTBY(A2:A20, B2:B20, C2:C20, SUM)",
+        usage: [
+            "PIVOTBY(A2:A20, B2:B20, C2:C20, SUM)",
+            "PIVOTBY(A2:A20, B2:B20, C2:C20, PERCENTOF, 0, 0, 0, 0, 0, , 0)",
+        ],
+        parameters: [
+            {
+                title: "row_fields",
+                description: "Column-oriented range or array containing the values that become rows.",
+            },
+            {
+                title: "col_fields",
+                description: "Column-oriented range or array containing the values that become columns.",
+            },
+            {
+                title: "values",
+                description: "Column-oriented range or array containing the values to aggregate.",
+            },
+            {
+                title: "function",
+                description: "The aggregation to apply to each cell: SUM, PERCENTOF, AVERAGE, MEDIAN, COUNT, COUNTA, MAX, MIN, PRODUCT, ARRAYTOTEXT, CONCAT, STDEV.S, STDEV.P, VAR.S, VAR.P, MODE.SNGL, or a LAMBDA.",
+            },
+            {
+                title: "field_headers [OPTIONAL]",
+                description: "0 no headers, 1 headers in the data but not shown, 2 no headers but generate them, 3 headers in the data and shown. Inferred from the data when omitted.",
+            },
+            {
+                title: "row_total_depth [OPTIONAL]",
+                description: "0 no row totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals above the data.",
+            },
+            {
+                title: "row_sort_order [OPTIONAL]",
+                description: "Column number to sort the rows by; negative sorts descending.",
+            },
+            {
+                title: "col_total_depth [OPTIONAL]",
+                description: "0 no column totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals before the data.",
+            },
+            {
+                title: "col_sort_order [OPTIONAL]",
+                description: "Row number to sort the columns by; negative sorts descending.",
+            },
+            {
+                title: "filter_array [OPTIONAL]",
+                description: "Column-oriented array of TRUE/FALSE values selecting the rows to include.",
+            },
+            {
+                title: "relative_to [OPTIONAL]",
+                description: "For PERCENTOF: 0 column totals (default), 1 row totals, 2 grand total, 3 parent column total, 4 parent row total.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBEKPIMEMBER",
+        syntax: "CUBEKPIMEMBER(connection, kpi_name, kpi_property, [caption])",
+        description: "Returns a key performance indicator (KPI) property from an OLAP cube. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBEKPIMEMBER(\"Sales\",\"MySalesKPI\",1)",
+        usage: ["CUBEKPIMEMBER(\"Sales\",\"MySalesKPI\",1)"],
+        parameters: [
+            {
+                title: "connection",
+                description: "The name of the workbook connection to the cube.",
+            },
+            {
+                title: "kpi_name",
+                description: "The name of the KPI in the cube.",
+            },
+            {
+                title: "kpi_property",
+                description: "The KPI component returned (1 value, 2 goal, 3 status, 4 trend, 5 weight, 6 current time member).",
+            },
+            {
+                title: "caption [OPTIONAL]",
+                description: "Text shown in the cell instead of the KPI name.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBEMEMBER",
+        syntax: "CUBEMEMBER(connection, member_expression, [caption])",
+        description: "Returns a member or tuple from an OLAP cube. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBEMEMBER(\"Sales\",\"[Time].[Fiscal].[2024]\")",
+        usage: ["CUBEMEMBER(\"Sales\",\"[Time].[Fiscal].[2024]\")"],
+        parameters: [
+            {
+                title: "connection",
+                description: "The name of the workbook connection to the cube.",
+            },
+            {
+                title: "member_expression",
+                description: "An MDX expression that evaluates to a unique member or tuple.",
+            },
+            {
+                title: "caption [OPTIONAL]",
+                description: "Text shown in the cell instead of the member caption.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBEMEMBERPROPERTY",
+        syntax: "CUBEMEMBERPROPERTY(connection, member_expression, property)",
+        description: "Returns the value of a member property from an OLAP cube. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBEMEMBERPROPERTY(\"Sales\",\"[Store].[MyFavoriteStore]\",\"[Store].[Store Name].[Store Sqft]\")",
+        usage: ["CUBEMEMBERPROPERTY(\"Sales\",\"[Store].[MyFavoriteStore]\",\"[Store].[Store Name].[Store Sqft]\")"],
+        parameters: [
+            {
+                title: "connection",
+                description: "The name of the workbook connection to the cube.",
+            },
+            {
+                title: "member_expression",
+                description: "An MDX expression for the member.",
+            },
+            {
+                title: "property",
+                description: "The name of the property to return.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBERANKEDMEMBER",
+        syntax: "CUBERANKEDMEMBER(connection, set_expression, rank, [caption])",
+        description: "Returns the nth, or ranked, member of a set from an OLAP cube. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBERANKEDMEMBER(\"Sales\",$D$4,1,\"Top Month\")",
+        usage: ["CUBERANKEDMEMBER(\"Sales\",$D$4,1,\"Top Month\")"],
+        parameters: [
+            {
+                title: "connection",
+                description: "The name of the workbook connection to the cube.",
+            },
+            {
+                title: "set_expression",
+                description: "A set expression or a reference to a CUBESET cell.",
+            },
+            {
+                title: "rank",
+                description: "The position of the member to return.",
+            },
+            {
+                title: "caption [OPTIONAL]",
+                description: "Text shown in the cell instead of the member caption.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBESET",
+        syntax: "CUBESET(connection, set_expression, [caption], [sort_order], [sort_by])",
+        description: "Defines a calculated set of members or tuples on an OLAP cube. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBESET(\"Sales\",\"[Product].[All Products].Children\",\"Products\",1,\"[Measures].[Sales Amount]\")",
+        usage: ["CUBESET(\"Sales\",\"[Product].[All Products].Children\",\"Products\",1,\"[Measures].[Sales Amount]\")"],
+        parameters: [
+            {
+                title: "connection",
+                description: "The name of the workbook connection to the cube.",
+            },
+            {
+                title: "set_expression",
+                description: "An MDX expression that results in a set.",
+            },
+            {
+                title: "caption [OPTIONAL]",
+                description: "Text shown in the cell.",
+            },
+            {
+                title: "sort_order [OPTIONAL]",
+                description: "How the set is sorted (0 none to 6 descending natural).",
+            },
+            {
+                title: "sort_by [OPTIONAL]",
+                description: "The value to sort by.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBESETCOUNT",
+        syntax: "CUBESETCOUNT(set)",
+        description: "Returns the number of items in a cube set. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBESETCOUNT(CUBESET(\"Sales\",\"[Product].[All Products].Children\"))",
+        usage: ["CUBESETCOUNT(CUBESET(\"Sales\",\"[Product].[All Products].Children\"))"],
+        parameters: [
+            {
+                title: "set",
+                description: "A CUBESET result or a reference to a CUBESET cell.",
+            },
+        ],
+    },
+    {
+        datatype: "Database",
+        title: "CUBEVALUE",
+        syntax: "CUBEVALUE(connection, [member_expression1], ...)",
+        description: "Returns an aggregated value from an OLAP cube. Athena has no connection to this provider, so the call returns #NAME?, as Excel does without a cube connection.",
+        example: "CUBEVALUE(\"Sales\",\"[Measures].[Profit]\",\"[Time].[2024]\")",
+        usage: ["CUBEVALUE(\"Sales\",\"[Measures].[Profit]\",\"[Time].[2024]\")"],
+        parameters: [
+            {
+                title: "connection",
+                description: "The name of the workbook connection to the cube.",
+            },
+            {
+                title: "member_expression1 [OPTIONAL]",
+                description: "An MDX expression for a member or tuple; more may follow.",
+            },
+        ],
+    },
+    {
+        datatype: "Lookup",
+        title: "RTD",
+        syntax: "RTD(prog_id, server, topic1, [topic2], ...)",
+        description: "Retrieves real-time data from a program that supports COM automation. Athena has no real-time data server, so the call returns #N/A, as Excel does when the server is not installed.",
+        example: "RTD(\"mytest.rtd\",,\"Price\")",
+        usage: ["RTD(\"mytest.rtd\",,\"Price\")"],
+        parameters: [
+            {
+                title: "prog_id",
+                description: "The registered ProgID of the RTD server.",
+            },
+            {
+                title: "server",
+                description: "The server that runs the RTD server; blank for the local machine.",
+            },
+            {
+                title: "topic1",
+                description: "The data to retrieve; up to 253 topics.",
+            },
+        ],
+    },
+    {
+        datatype: "Info",
+        title: "STOCKHISTORY",
+        syntax: "STOCKHISTORY(stock, start_date, [end_date], [interval], [headers], [property0], ...)",
+        description: "Retrieves historical data about a financial instrument as an array. Athena has no connection to the stock data service, so the call returns #CONNECT!.",
+        example: "STOCKHISTORY(\"MSFT\",\"1/1/2024\",\"1/31/2024\")",
+        usage: ["STOCKHISTORY(\"MSFT\",\"1/1/2024\",\"1/31/2024\")"],
+        parameters: [
+            {
+                title: "stock",
+                description: "A ticker symbol in quotes or a Stocks data type.",
+            },
+            {
+                title: "start_date",
+                description: "The earliest date to retrieve.",
+            },
+            {
+                title: "end_date [OPTIONAL]",
+                description: "The latest date to retrieve; defaults to start_date.",
+            },
+            {
+                title: "interval [OPTIONAL]",
+                description: "0 daily (default), 1 weekly, 2 monthly.",
+            },
+            {
+                title: "headers [OPTIONAL]",
+                description: "0 no headers, 1 headers (default), 2 instrument identifier and headers.",
+            },
+            {
+                title: "property0 [OPTIONAL]",
+                description: "Columns to return: 0 Date, 1 Close, 2 Open, 3 High, 4 Low, 5 Volume.",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TRANSLATE",
+        syntax: "TRANSLATE(text, [source_language], [target_language])",
+        description: "Translates text from one language to another. Athena has no connection to the translation service, so the call returns #CONNECT!.",
+        example: "TRANSLATE(\"Hello\",\"en\",\"fr\")",
+        usage: ["TRANSLATE(\"Hello\",\"en\",\"fr\")"],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to translate.",
+            },
+            {
+                title: "source_language [OPTIONAL]",
+                description: "Language code of the text; detected when omitted.",
+            },
+            {
+                title: "target_language [OPTIONAL]",
+                description: "Language code to translate into.",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "DETECTLANGUAGE",
+        syntax: "DETECTLANGUAGE(text)",
+        description: "Identifies the language of a text. Athena has no connection to the translation service, so the call returns #CONNECT!.",
+        example: "DETECTLANGUAGE(\"Bonjour\")",
+        usage: ["DETECTLANGUAGE(\"Bonjour\")"],
+        parameters: [
+            {
+                title: "text",
+                description: "The text whose language to detect.",
+            },
+        ],
+    },
+    {
+        datatype: "Financial",
+        title: "EUROCONVERT",
+        syntax: "EUROCONVERT(number, source, target, [full_precision], [triangulation_precision])",
+        description: "Converts a number to euros, from euros to a euro member currency, or between member currencies through the euro, at the fixed EU conversion rates.",
+        example: "EUROCONVERT(1.2,\"DEM\",\"EUR\")",
+        usage: ["EUROCONVERT(1.2,\"DEM\",\"EUR\")"],
+        parameters: [
+            {
+                title: "number",
+                description: "The amount to convert.",
+            },
+            {
+                title: "source",
+                description: "ISO code of the source currency: EUR, BEF, LUF, DEM, ESP, FRF, IEP, ITL, NLG, ATS, PTE, FIM, GRD or SIT.",
+            },
+            {
+                title: "target",
+                description: "ISO code of the target currency.",
+            },
+            {
+                title: "full_precision [OPTIONAL]",
+                description: "TRUE keeps every digit; FALSE (default) rounds to the target currency's decimals.",
+            },
+            {
+                title: "triangulation_precision [OPTIONAL]",
+                description: "Decimals (3 or more) for the intermediate euro value.",
+            },
+        ],
+    },
+    {
+        datatype: "Web",
+        title: "IMPORTTEXT",
+        syntax: "IMPORTTEXT(path, [delimiter], [skip_rows], [take_rows], [encoding], [locale])",
+        description: "Imports a text file (CSV, TSV, TXT) as an array. Athena cannot read files from a local path, so the call returns #BLOCKED!.",
+        example: "IMPORTTEXT(\"C:\\\\data\\\\sales.txt\",\",\")",
+        usage: ["IMPORTTEXT(\"C:\\\\data\\\\sales.txt\",\",\")"],
+        parameters: [
+            {
+                title: "path",
+                description: "The file path or URL of the text file.",
+            },
+            {
+                title: "delimiter [OPTIONAL]",
+                description: "The column delimiter; tab by default.",
+            },
+            {
+                title: "skip_rows [OPTIONAL]",
+                description: "Rows to skip from the start (negative: from the end).",
+            },
+            {
+                title: "take_rows [OPTIONAL]",
+                description: "Rows to return (negative: from the end).",
+            },
+            {
+                title: "encoding [OPTIONAL]",
+                description: "The file encoding; UTF-8 by default.",
+            },
+            {
+                title: "locale [OPTIONAL]",
+                description: "The locale for numbers and dates.",
+            },
+        ],
+    },
+    {
+        datatype: "Web",
+        title: "IMPORTCSV",
+        syntax: "IMPORTCSV(path, [skip_rows], [take_rows], [locale])",
+        description: "Imports a CSV file as an array. Athena cannot read files from a local path, so the call returns #BLOCKED!.",
+        example: "IMPORTCSV(\"C:\\\\data\\\\sales.csv\")",
+        usage: ["IMPORTCSV(\"C:\\\\data\\\\sales.csv\")"],
+        parameters: [
+            {
+                title: "path",
+                description: "The file path or URL of the CSV file.",
+            },
+            {
+                title: "skip_rows [OPTIONAL]",
+                description: "Rows to skip from the start (negative: from the end).",
+            },
+            {
+                title: "take_rows [OPTIONAL]",
+                description: "Rows to return (negative: from the end).",
+            },
+            {
+                title: "locale [OPTIONAL]",
+                description: "The locale for numbers and dates.",
+            },
+        ],
+    },
+    {
+        datatype: "Info",
+        title: "PY",
+        syntax: "PY(python_code, return_type)",
+        description: "Runs Python code (Python in Excel). Athena has no Python in Excel runtime, so the call returns #BLOCKED!.",
+        example: "PY(\"1+1\",0)",
+        usage: ["PY(\"1+1\",0)"],
+        parameters: [
+            {
+                title: "python_code",
+                description: "The Python code to run.",
+            },
+            {
+                title: "return_type",
+                description: "0 returns an Excel value, 1 a Python object.",
+            },
+        ],
+    },
+    {
+        datatype: "Info",
+        title: "FIELDVALUE",
+        syntax: "FIELDVALUE(value, field_name)",
+        description: "Returns a field from a linked data type value, the same as value.field_name. Athena has no linked data types, so the call returns #FIELD!.",
+        example: "FIELDVALUE(A2,\"Price\")",
+        usage: ["FIELDVALUE(A2,\"Price\")"],
+        parameters: [
+            {
+                title: "value",
+                description: "A cell holding a linked data type.",
+            },
+            {
+                title: "field_name",
+                description: "The name of the field to return.",
+            },
+        ],
+    },
 ];