@gooddata/sdk-ui 10.37.0 → 10.38.0-alpha.2

package/esm/sdk-ui.d.ts

@@ -2941,6 +2941,12 @@ export declare interface IResultMetaMethods {
  */
 export declare function isAnyPlaceholder<T>(obj: unknown): obj is AnyPlaceholder<T>;
 
+/**
+ * Type guard to check if a column definition is an attribute column
+ * @alpha
+ */
+export declare function isAttributeColumnDefinition(columnDefinition: unknown): columnDefinition is ITableAttributeColumnDefinition;
+
 /**
  * Typeguard checking whether input is an instance of {@link BadRequestSdkError};
  *
@@ -3049,6 +3055,12 @@ export declare function isGeoTokenMissing(obj: unknown): obj is GeoTokenMissingS
  */
 export declare function isGoodDataSdkError(obj: unknown): obj is GoodDataSdkError;
 
+/**
+ * Type guard to check if a column definition is a grand total column
+ * @alpha
+ */
+export declare function isGrandTotalColumnDefinition(columnDefinition: unknown): columnDefinition is ITableGrandTotalColumnDefinition;
+
 /**
  * Typeguard checking whether the object is an {@link IHeaderPredicate} instance.
  * @public
@@ -3062,6 +3074,18 @@ export declare function isHeaderPredicate(obj: unknown): obj is IHeaderPredicate
  */
 export declare const isLocale: (locale: unknown) => locale is ILocale;
 
+/**
+ * Type guard to check if a column definition is a measure group header column
+ * @alpha
+ */
+export declare function isMeasureGroupHeaderColumnDefinition(columnDefinition: unknown): columnDefinition is ITableMeasureGroupHeaderColumnDefinition;
+
+/**
+ * Type guard to check if a column definition is a measure group value column
+ * @alpha
+ */
+export declare function isMeasureGroupValueColumnDefinition(columnDefinition: unknown): columnDefinition is ITableMeasureGroupValueColumnDefinition;
+
 /**
  * Typeguard checking whether input is an instance of {@link NegativeValuesSdkError};
  *
@@ -3101,6 +3125,75 @@ export declare function isProtectedReport(obj: unknown): obj is ProtectedReportS
  */
 export declare function isSomeHeaderPredicateMatched(drillablePredicates: IHeaderPredicate[], header: IMappingHeader, dv: DataViewFacade): boolean;
 
+/**
+ * Type guard to check if a column definition is a subtotal column
+ * @alpha
+ */
+export declare function isSubtotalColumnDefinition(columnDefinition: unknown): columnDefinition is ITableSubtotalColumnDefinition;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableAttributeHeaderValue}
+ *
+ * @alpha
+ */
+export declare function isTableAttributeHeaderValue(obj: unknown): obj is ITableAttributeHeaderValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableGrandTotalHeaderValue}
+ *
+ * @alpha
+ */
+export declare function isTableGrandTotalHeaderValue(obj: unknown): obj is ITableGrandTotalHeaderValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableGrandTotalMeasureValue}
+ *
+ * @alpha
+ */
+export declare function isTableGrandTotalMeasureValue(obj: unknown): obj is ITableGrandTotalMeasureValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableGrandTotalSubtotalMeasureValue}
+ *
+ * @alpha
+ */
+export declare function isTableGrandTotalSubtotalMeasureValue(obj: unknown): obj is ITableGrandTotalSubtotalMeasureValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableMeasureHeaderValue}
+ *
+ * @alpha
+ */
+export declare function isTableMeasureHeaderValue(obj: unknown): obj is ITableMeasureHeaderValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableMeasureValue}
+ *
+ * @alpha
+ */
+export declare function isTableMeasureValue(obj: unknown): obj is ITableMeasureValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableOverallTotalMeasureValue}
+ *
+ * @alpha
+ */
+export declare function isTableOverallTotalMeasureValue(obj: unknown): obj is ITableOverallTotalMeasureValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableSubtotalMeasureValue}
+ *
+ * @alpha
+ */
+export declare function isTableSubtotalMeasureValue(obj: unknown): obj is ITableSubtotalMeasureValue;
+
+/**
+ * Type guard checking whether input is an instance of {@link ITableTotalHeaderValue}
+ *
+ * @alpha
+ */
+export declare function isTableTotalHeaderValue(obj: unknown): obj is ITableTotalHeaderValue;
+
 /**
  * Typeguard checking whether input is an instance of {@link UnauthorizedSdkError};
  *
@@ -3116,41 +3209,191 @@ export declare function isUnauthorized(obj: unknown): obj is UnauthorizedSdkErro
 export declare function isUnknownSdkError(obj: unknown): obj is UnexpectedSdkError;
 
 /**
+ * Type guard to check if a column definition is a value column
+ * @alpha
+ */
+export declare function isValueColumnDefinition(columnDefinition: unknown): columnDefinition is ITableValueColumnDefinition;
+
+/**
+ * Defines a column that shows row attribute values (like "Country" or "City").
+ *
+ * **What it does:**
+ * These are the leftmost columns that show your row groupings. If you have
+ * "Country" and "City" in your rows bucket, you'll get two attribute columns.
+ *
+ * **When it's created:**
+ * - Automatically created for each attribute in the rows bucket
+ * - Always appears first (leftmost) in the table
+ * - Created regardless of whether you have measures in rows or columns
+ *
+ * **Real example:**
+ * ```
+ * | Country | City | Sales |  <- "Country" and "City" are attribute columns
+ * |---------|------|-------|
+ * | USA     | NYC  | 100   |
+ * | USA     | LA   | 200   |
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableAttributeColumnDefinition {
+    /**
+     * Always "attribute" - identifies this as an attribute column.
+     */
     type: "attribute";
+    /**
+     * Position of this column in the final table (0-based).
+     */
     columnIndex: number;
+    /**
+     * Which attribute from the rows bucket this column represents (0-based).
+     */
     rowHeaderIndex: number;
+    /**
+     * Metadata about this attribute (name, data type, formatting, etc.).
+     * Contains information like the attribute's display name, local identifier, etc.
+     */
     attributeDescriptor: IAttributeDescriptor;
 }
 
 /**
+ * Cell located in {@link ITableAttributeColumnDefinition} – typically the leftmost
+ * part of the table describing the current row's attribute values.
+ *
+ * It represents a single `IResultAttributeHeader` coming from the execution
+ * response and can be present in both value rows and subtotal rows.
+ *
+ * **Visual example**
+ * ```
+ *  Attribute | Measure |
+ * -----------+---------+
+ *  USA       |  100    | <- "USA" is attributeHeader
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableAttributeHeaderValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "attributeHeader";
+    /**
+     * Attribute element value ready to be rendered. (e.g. "United States")
+     */
     formattedValue: string | null;
+    /**
+     * The raw `IResultAttributeHeader` object from the execution response.
+     */
     value: IResultAttributeHeader;
+    /**
+     * Zero-based row position of this cell in the final `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position of this cell in the final `data` matrix.
+     */
     columnIndex: number;
-    rowDefinition: ITableRowDefinition;
+    /**
+     * Full row context describing which row this cell belongs to
+     * (value, subtotal, or grand-total row).
+     */
+    rowDefinition: ITableValueRowDefinition | ITableSubtotalRowDefinition;
+    /**
+     * Full column context describing which attribute column this cell belongs to.
+     * Always an attribute column since this interface is for attribute headers.
+     */
     columnDefinition: ITableAttributeColumnDefinition;
 }
 
 /**
+ * Represents all possible column types in a pivot table structure.
+ *
+ * Think of a pivot table as having these column types from left to right:
+ * 1. **Attribute columns** - Show row grouping labels (like "Country", "City")
+ * 2. **Measure header column** - Shows measure names (only when measures are in rows)
+ * 3. **Value/Total columns** - Show actual numbers and totals
+ *
+ * The exact combination depends on your data setup:
+ *
+ * **When measures are in columns (normal pivot table):**
+ * ```
+ * |         |        | Brand > Product     |                |                |
+ * |         |        |---------------------|----------------|----------------|
+ * |         |        | GoodData            |                | ColMin Σ       |
+ * |         |        |---------------------|----------------|                |
+ * |         |        | Panther  | Bear     | Sum A          |                |
+ * |---------|--------|---------------------|----------------|----------------|
+ * | Country | City   | Sales    | Sales    | Sales          | Sales          |
+ * |---------|--------|----------|----------|----------------|----------------|
+ * | USA     | NYC    | 100      | 150      | 250            | 100            |
+ * | USA     | LA     | 200      | 250      | 450            | 200            |
+ * ```
+ * - Country, City are {@link ITableAttributeColumnDefinition}
+ * - Sales is {@link ITableValueColumnDefinition}
+ * - Sum A is {@link ITableSubtotalColumnDefinition}
+ * - ColSum Σ is {@link ITableGrandTotalColumnDefinition}
+ *
+ * **When measures are in rows (transposed + non-pivoted):**
+ * ```
+ * | Country | City | MeasureGroupHeader  | MeasureGroupValue     |
+ * |---------|------|---------------------|-----------------------|
+ * | USA     | NYC  | Sales               | 100                   |
+ * | USA     | NYC  | Profit              | 20                    |
+ * ```
+ * - Country, City are {@link ITableAttributeColumnDefinition}
+ * - MeasureGroupHeader is {@link ITableMeasureGroupHeaderColumnDefinition}
+ * - MeasureGroupValue is {@link ITableMeasureGroupValueColumnDefinition}
+ *
+ * **When measures are in rows (transposed + pivoted):**
+ * ```
+ * |                                        | Quarter        |                |
+ * |----------------------------------------|----------------|                |
+ * | Country | City | MeasureGroupHeader    | Q1             | ColSum Σ       |
+ * |---------|------|-----------------------|----------------|----------------|
+ * | USA     | NYC  | Sales                 | 250            | 500            |
+ * | USA     | NYC  | Profit                | 450            | 900            |
+ * ```
+ * - Country, City are {@link ITableAttributeColumnDefinition}
+ * - MeasureGroupHeader is {@link ITableMeasureGroupHeaderColumnDefinition}
+ * - Q1 is {@link ITableValueColumnDefinition}
+ * - ColSum Σ is {@link ITableGrandTotalColumnDefinition}
+ *
  * @alpha
  */
 export declare type ITableColumnDefinition = ITableAttributeColumnDefinition | ITableValueColumnDefinition | ITableMeasureGroupHeaderColumnDefinition | ITableMeasureGroupValueColumnDefinition | ITableSubtotalColumnDefinition | ITableGrandTotalColumnDefinition;
 
 /**
+ * **The complete table data structure**.
+ *
+ * This is the main interface that represents a fully processed table data with all the metadata
+ * needed to render pivot tables, flat tables, and transposed tables.
+ *
+ * It contains the structural definitions (rows/columns), the actual cell data, and flags
+ * that describe the table layout and data interpretation.
+ *
  * @alpha
  */
 export declare type ITableData = {
+    /**
+     * Array of column definitions that describe the structure and meaning of each column.
+     */
     columnDefinitions: ITableColumnDefinition[];
+    /**
+     * Array of row definitions that describe the structure and meaning of each row.
+     */
     rowDefinitions: ITableRowDefinition[];
+    /**
+     * 2D array of table cell data where `data[rowIndex][columnIndex]` contains
+     * the formatted and raw values for that specific table position.
+     */
     data: ITableDataValue[][];
+    /**
+     * Whether the table uses pivoting (attributes in columns bucket).
+     */
     isPivoted: boolean;
+    /**
+     * Whether measures are transposed from columns into rows.
+     */
     isTransposed: boolean;
 };
 
@@ -3173,6 +3416,17 @@ export declare interface ITableDataAttributeTotalScope {
 }
 
 /**
+ * Union of all possible scope types that identify what a specific row or column represents.
+ *
+ * **Think of scopes as the "address" system for table data:**
+ * - Each row has a `rowScope: ITableDataHeaderScope[]` array
+ * - Each column has a `columnScope: ITableDataHeaderScope[]` array
+ * - These arrays describe the "path" to identify exactly what data belongs in each cell
+ *
+ * When all scopes are regular scopes (attributes and measures) it represents value column or value row.
+ * When scopes are mixed regular and total scopes, it represents subtotal column or subtotal row.
+ * When all scopes are total scopes it represents grand total column or grand total row.
+ *
  * @alpha
  */
 export declare type ITableDataHeaderScope = ITableDataAttributeScope | ITableDataAttributeTotalScope | ITableDataMeasureScope | ITableDataMeasureTotalScope | ITableDataMeasureGroupScope;
@@ -3204,53 +3458,204 @@ export declare interface ITableDataMeasureTotalScope {
 }
 
 /**
+ * Union of **all possible cell value shapes** that can appear in the table
+ * `data` matrix. Each variant corresponds to a concrete column × row
+ * intersection produced by `dataViewToTableData`.
+ *
+ * - Header cells (`attributeHeader`, `measureHeader`, `totalHeader`)
+ * - Numeric cells with raw measure data (`value`)
+ * - Aggregations (`subtotalValue`, `grandTotalValue`, `grandTotalSubtotalValue`, `overallTotalValue`)
+ *
+ * When interpreting the `data` matrix you should always rely on the concrete subtype.
+ *
+ * **Example table without transposition:**
+ * ```
+ * Attr A    | Col A   | Sum A   | ColSum Σ |
+ * ----------+---------+---------+----------+
+ * Row X     |  100    |  200    | 300      |
+ * Sum B     |  400    |  600    | 1000     |
+ * RowSum Σ  |  500    |  800    | 1300     |
+ * ```
+ * - Attr A is attribute column, Col A is value column, Sum A is subtotal column, ColSum Σ is grand total column
+ * - Row X is value row, Sum B is subtotal row, RowSum Σ is grand total row
+ *
+ * In this example:
+ * - Row X is `attributeHeader`
+ * - Sum B is `totalHeader`
+ * - RowSum Σ is `grandTotalHeader`
+ * - Row X : Col A - `100` is `value`
+ * - Row X : Sum A - `200` is `subtotalValue`
+ * - Row X : ColSum Σ - `300` is `grandTotalValue`
+ * - Sum B : Col A - `400` is `subtotalValue`
+ * - Sum B : Sum A - `600` is `subtotalValue`
+ * - Sum B : ColSum Σ - `1000` is `grandTotalSubtotalValue`
+ * - RowSum Σ : Col A - `500` is `grandTotalValue`
+ * - RowSum Σ : Sum A - `800` is `grandTotalSubtotalValue`
+ * - RowSum Σ : ColSum Σ - `1300` is `overallTotalValue`
+ *
  * @alpha
  */
 export declare type ITableDataValue = ITableAttributeHeaderValue | ITableMeasureHeaderValue | ITableTotalHeaderValue | ITableMeasureValue | ITableSubtotalMeasureValue | ITableGrandTotalHeaderValue | ITableGrandTotalMeasureValue | ITableGrandTotalSubtotalMeasureValue | ITableOverallTotalMeasureValue;
 
 /**
+ * Defines columns that show grand total values.
+ *
+ * **What it does:**
+ * Shows grand totals - these are columns that show the aggregation of values for the top level pivoting attribute,
+ * always appears as the rightmost columns.
+ *
+ * **When it's created:**
+ * - Only when you have at least 1 attribute in the columns bucket (pivoting).
+ * - Only when you set total for the leftmost column attribute.
+ * - In the example, total is set for Brand x Sales.
+ *
+ * **Real example:**
+ * ```
+ * |         |        | Brand > Product     |                |
+ * |         |        |---------------------|----------------|
+ * |         |        | GoodData            | ColMin Σ       |
+ * |         |        |---------------------|                |
+ * |         |        | Panther  | Bear     |                |
+ * |---------|--------|---------------------|----------------|
+ * | Country | City   | Sales    | Sales    | Sales          |
+ * |---------|--------|----------|----------|----------------|
+ * | USA     | NYC    | 100      | 150      | 100            |
+ * | USA     | LA     | 200      | 250      | 200            |
+ * ```
+ *
  * @alpha
  */
-export declare interface ITableGrandTotalColumnDefinition {
+export declare type ITableGrandTotalColumnDefinition = {
+    /**
+     * Always "grandTotal" - identifies this as a grand total column.
+     */
     type: "grandTotal";
+    /**
+     * Position of this column in the final table (0-based).
+     * Usually the rightmost column in the table.
+     */
     columnIndex: number;
+    /**
+     * Position in the original column headers array.
+     */
     columnHeaderIndex: number;
+    /**
+     * Describes exactly what this column represents.
+     */
     columnScope: ITableDataHeaderScope[];
-}
+} & (/**
+* Handles case, when pivoting and measures are in rows.
+*/ {
+    isEmpty: false;
+    isTransposed: true;
+    totalHeader: IResultTotalHeader;
+    attributeDescriptor: IAttributeDescriptor;
+} | /**
+* Handles standard pivoting case without transposition.
+*/ {
+    isEmpty: false;
+    isTransposed: false;
+    totalHeader: IResultTotalHeader;
+    measureDescriptor: IMeasureDescriptor;
+});
 
 /**
+ * Header cell labeling a **grand-total row** (usually located in the first columns).
+ *
+ * **Visual example:**
+ * ```
+ *            |  Q1 |  Q2 | ColSum Σ |
+ * -----------+-----+-----+----------+
+ *  USA       | 100 | 120 |   220    |
+ *  CAN       |  80 |  90 |   170    |
+ *  RowSum Σ  | 180 | 210 |   390    | <- RowSum Σ is grandTotalHeader
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableGrandTotalHeaderValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "grandTotalHeader";
+    /**
+     * Display text for the grand total row label (e.g., "Sum", "Total").
+     * Usually shows the aggregation type or a localized "Total" label.
+     */
     formattedValue: string | null;
+    /**
+     * Zero-based row position in the `data` matrix.
+     * Points to a grand-total row that this header cell labels.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     * Usually points to the first attribute column (leftmost) or
+     * measure header column (when measures are transposed).
+     */
     columnIndex: number;
-    rowDefinition: ITableRowDefinition;
-    columnDefinition: ITableColumnDefinition;
-    grandTotalInfo?: {
-        type: TotalType;
-        measure: IMeasureDescriptor;
-        attribute: IAttributeDescriptor;
-    };
+    /**
+     * Row context - grand-total row since this header
+     * cell is labeling a grand-total row.
+     */
+    rowDefinition: ITableGrandTotalRowDefinition;
+    /**
+     * Column context - typically an attribute column or measure header column
+     * where the grand total label appears.
+     */
+    columnDefinition: ITableAttributeColumnDefinition | ITableMeasureGroupHeaderColumnDefinition;
 }
 
 /**
+ * Numeric cell containing **grand totals** – totals across rows or columns.
+ *
+ * **Visual example**
+ * ```
+ * // Column grand total:
+ *            |  Q1 | ColSum Σ |
+ * -----------+-----+----------+
+ *  USA       | 100 |   220    | <- 220 is grandTotalValue
+ *
+ * // Row grand total:
+ *            |  Q1 |  Q2 |
+ * -----------+-----+-----+
+ *  USA       | 100 | 120 |
+ *  RowSum Σ  | 180 | 210 | <- 180 and 210 are grandTotalValue cells
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableGrandTotalMeasureValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "grandTotalValue";
+    /**
+     * Human-readable formatted grand total value (e.g., "$10,000.00").
+     * Uses the measure's format string and locale settings.
+     */
     formattedValue: string | null;
+    /**
+     * Raw aggregated grand total value from the backend.
+     * Result of aggregating across all rows or columns for this measure.
+     */
     value: DataValue;
+    /**
+     * Zero-based row position in the `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     */
     columnIndex: number;
-    rowDefinition: ITableRowDefinition;
-    columnDefinition: ITableColumnDefinition;
-    grandTotalInfo?: {
-        type: TotalType;
-        measure: IMeasureDescriptor;
-        attribute: IAttributeDescriptor;
-    };
+    /**
+     * Row context - value or grand-total row.
+     */
+    rowDefinition: ITableValueRowDefinition | ITableGrandTotalRowDefinition;
+    /**
+     * Column context - value column, grand-total column, or measure group value column.
+     */
+    columnDefinition: ITableValueColumnDefinition | ITableGrandTotalColumnDefinition | ITableMeasureGroupValueColumnDefinition;
 }
 
 /**
@@ -3266,111 +3671,434 @@ export declare interface ITableGrandTotalRowDefinition {
 }
 
 /**
+ * Numeric cell at the **intersection of row and column subtotals + grandtotals** – the *subtotals of grandtotals*.
+ *
+ * **Visual example**
+ * ```
+ * // Column grand total + row subtotal:
+ *            |  Q1 | ColSum Σ |
+ * -----------+-----+----------+
+ *  Sum A     | 100 |   220    | <- 220 is grandTotalSubtotalValue
+ *
+ * // Row grand total + column subtotal:
+ *            |  Q1 | Sum A |
+ * -----------+-----+-------+
+ *  USA       | 100 | 120   |
+ *  RowSum Σ  | 180 | 210   | <- 210 is grandTotalSubtotalValue
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableGrandTotalSubtotalMeasureValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "grandTotalSubtotalValue";
+    /**
+     * Human-readable formatted intersection total value (e.g., "$15,000.00").
+     */
     formattedValue: string | null;
+    /**
+     * Raw aggregated value at the intersection of row and column totals.
+     */
     value: DataValue;
+    /**
+     * Zero-based row position in the `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     */
     columnIndex: number;
-    rowDefinition: ITableRowDefinition;
-    columnDefinition: ITableColumnDefinition;
-    grandTotalInfo?: {
-        type: TotalType;
-        measure: IMeasureDescriptor;
-        attribute: IAttributeDescriptor;
-    };
+    /**
+     * Row context - grand-total row or subtotal row.
+     */
+    rowDefinition: ITableSubtotalRowDefinition | ITableGrandTotalRowDefinition;
+    /**
+     * Column context - subtotal column or grand-total column.
+     */
+    columnDefinition: ITableSubtotalColumnDefinition | ITableGrandTotalColumnDefinition;
 }
 
 /**
+ * Defines the column that shows measure names when measures are in rows.
+ *
+ * **What it does:**
+ * When you put measures in rows instead of columns, you need a column to show
+ * which measure each row represents ("Sales", "Profit", etc.).
+ *
+ * **When it's created:**
+ * - Only when `measureDimension === "rows"` (measures are transposed)
+ * - Always created when you have measures in rows
+ * - Appears right after your attribute columns
+ *
+ * **Real example:**
+ * ```
+ * | Country | City | Measure | Q1  | Q2  |  <- "Measure" column shows measure names
+ * |---------|------|---------|-----|-----|
+ * | USA     | NYC  | Sales   | 100 | 150 |
+ * | USA     | NYC  | Profit  | 20  | 30  |
+ * | USA     | LA   | Sales   | 200 | 250 |
+ * | USA     | LA   | Profit  | 40  | 50  |
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableMeasureGroupHeaderColumnDefinition {
+    /**
+     * Always "measureGroupHeader" - identifies this as a measure names column.
+     */
     type: "measureGroupHeader";
+    /**
+     * Position of this column in the final table (0-based).
+     * Always appears right after attribute columns, before value columns.
+     */
     columnIndex: number;
+    /**
+     * Metadata about the group of measures being displayed.
+     * Contains information about all measures that will appear in rows.
+     */
     measureGroupDescriptor: IMeasureGroupDescriptor;
+    /**
+     * Descriptors for attributes that are in the columns bucket.
+     */
     attributeDescriptors: IAttributeDescriptor[];
 }
 
 /**
+ * Defines the single value column when measures are in rows and there are no column attributes.
+ *
+ * **What it does:**
+ * When measures are in rows and you don't have any attributes in columns,
+ * you get one simple "Values" column that shows all the numbers.
+ *
+ * **When it's created:**
+ * - Only when measures are in rows and there are no pivoting columns.
+ * - Appears as the rightmost column after the measure header column
+ *
+ * **Real example:**
+ * ```
+ * | Country | City | Measure | Value |  <- "Value" is the measure group value column
+ * |---------|------|---------|-------|
+ * | USA     | NYC  | Sales   | 100   |
+ * | USA     | NYC  | Profit  | 20    |
+ * | USA     | LA   | Sales   | 200   |
+ * | USA     | LA   | Profit  | 40    |
+ * ```
+ *
+ * **What happens if you DO have column attributes:**
+ * If you have attributes in columns (like "Q1", "Q2"), then instead of this single
+ * column, you get multiple `ITableValueColumnDefinition` columns - one for each
+ * column attribute combination.
+ *
  * @alpha
  */
 export declare interface ITableMeasureGroupValueColumnDefinition {
+    /**
+     * Always "measureGroupValue" - identifies this as the single values column
+     * when measures are in rows and there are no column attributes.
+     */
     type: "measureGroupValue";
+    /**
+     * Position of this column in the final table (0-based).
+     * Always the rightmost column when this type is used.
+     */
     columnIndex: number;
+    /**
+     * Metadata about the group of measures whose values are shown.
+     */
     measureGroupDescriptor: IMeasureGroupDescriptor;
 }
 
 /**
+ * Cell inside the {@link ITableMeasureGroupHeaderColumnDefinition}.
+ * Appears **only when measures are transposed into rows**.
+ * Each cell corresponds to one `IResultMeasureHeader` and labels the measure for that specific row.
+ *
+ * **Visual example**
+ * ```
+ *  Attribute | Measure | Value |
+ * -----------+---------+-------+
+ *  USA       |  Sales  |  100  | <- "Sales" is measureHeader
+ *  USA       |  Cost   |   80  | <- "Cost" is measureHeader
+ * ```
+ * The "Sales" and "Cost" **names** in the "Measure" column are `measureHeader` cells.
+ * The numeric values (100, 80) are regular `value` cells.
+ *
+ * **When measures are in columns (no transposition), this interface is NOT used.**
+ * Instead, measure names appear as regular column headers in the table structure.
+ *
  * @alpha
  */
 export declare interface ITableMeasureHeaderValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "measureHeader";
+    /**
+     * Display name of the measure (e.g., "Sales", "Revenue").
+     */
     formattedValue: string | null;
+    /**
+     * The raw `IResultMeasureHeader` object.
+     */
     value: IResultMeasureHeader;
+    /**
+     * Zero-based row position in the `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     */
     columnIndex: number;
-    rowDefinition: ITableRowDefinition;
-    columnDefinition: ITableColumnDefinition;
+    /**
+     * Row context - can be only value row.
+     */
+    rowDefinition: ITableValueRowDefinition;
+    /**
+     * Column context - always a `measureGroupHeader` column.
+     */
+    columnDefinition: ITableMeasureGroupHeaderColumnDefinition;
 }
 
 /**
+ * Numeric cell containing a **raw measure value** for regular (non-aggregated) row/column intersections.
+ *
+ * **Visual examples:**
+ * ```
+ * // Normal (measures in columns):
+ * Country    | Sales  |
+ * -----------+--------+
+ *  USA       |  100   | <- 100 is value cell
+ *
+ * // Transposed (measures in rows):
+ * Country    |         |       |
+ * -----------+---------+-------+
+ *  USA       |  Sales  |  100  | <- 100 is value cell
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableMeasureValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "value";
+    /**
+     * Human-readable formatted number ready for display (e.g., "$1,234.56").
+     * Formatted using the measure's format string and respects locale settings.
+     * Null if the raw value is null/missing.
+     */
     formattedValue: string | null;
+    /**
+     * Raw numeric value from the backend execution response.
+     * Can be number, string, or null depending on the measure data.
+     */
     value: DataValue;
+    /**
+     * Zero-based row position in the `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     */
     columnIndex: number;
+    /**
+     * Row context - value or subtotal row.
+     */
     rowDefinition: ITableValueRowDefinition | ITableSubtotalRowDefinition;
+    /**
+     * Column context - value column or measureGroupValue column.
+     */
     columnDefinition: ITableValueColumnDefinition | ITableMeasureGroupValueColumnDefinition;
 }
 
 /**
+ * Numeric cell at the **overall grand-total** intersection (bottom-right corner)
+ * aggregating across *all* rows and columns.
+ *
+ * **Visual example:**
+ * ```
+ *            |  Q1 |  Q2 | ColSum Σ |
+ * -----------+-----+-----+----------+
+ *  USA       | 100 | 120 |   220    |
+ *  CAN       |  80 |  90 |   170    |
+ *  RowSum Σ  | 180 | 210 |   390    | <- 390 is overallTotalValue
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableOverallTotalMeasureValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "overallTotalValue";
+    /**
+     * Human-readable formatted overall total value (e.g., "$50,000.00").
+     */
     formattedValue: string | null;
+    /**
+     * Raw overall total value from the backend.
+     */
     value: DataValue;
+    /**
+     * Zero-based row position in the `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     */
     columnIndex: number;
+    /**
+     * Row context - grand-total row since this is the
+     * grand-total row × grand-total column intersection.
+     */
     rowDefinition: ITableGrandTotalRowDefinition;
+    /**
+     * Column context - grand-total column since this is the
+     * grand-total row × grand-total column intersection.
+     */
     columnDefinition: ITableGrandTotalColumnDefinition;
-    grandTotalInfo?: {
-        type: TotalType;
-        measure: IMeasureDescriptor;
-        attribute: IAttributeDescriptor;
-    };
 }
 
 /**
+ * Union of all possible row types in the table data structure.
+ *
+ * Think of the final table as a stack of these row types:
+ * 1. **Value rows** – normal data rows (one per combination of row attributes)
+ * 2. **Subtotal rows** – subtotal rows (only when subtotals are configured)
+ * 3. **Grand-total rows** – grand-total rows (only when grand totals are configured)
+ *
+ * The exact mix depends on your configuration (pivoting, transposition, totals settings).
+ *
+ * **Example layout (no transposition, subtotals + grand totals enabled):**
+ * ```
+ * | Country     | City     | Q1 Sales | Q2 Sales |
+ * |-------------|----------|----------|----------|
+ * | USA         | NYC      |      100 |      150 |   <- value row
+ * | USA         | LA       |      200 |      250 |   <- value row
+ * | USA         | SUBTOTAL |      300 |      400 |   <- subtotal row
+ * | CAN         | TOR      |       80 |       90 |   <- value row
+ * | CAN         | SUBTOTAL |       80 |       90 |   <- subtotal row
+ * | GRAND TOTAL |          |      380 |      490 |   <- grand-total row
+ * ```
+ *
  * @alpha
  */
 export declare type ITableRowDefinition = ITableValueRowDefinition | ITableSubtotalRowDefinition | ITableGrandTotalRowDefinition;
 
 /**
+ * Defines columns that show subtotal values.
+ *
+ * **What it does:**
+ * Shows subtotals - these are columns that show the aggregation of values for a specific attribute pivoting subgroup.
+ *
+ * **When it's created:**
+ * - Only when you have at least 2 attributes in the columns bucket (pivoting).
+ * - Only when you set total for pivoting subgroup (not the leftmost column attribute - then it's grand total).
+ * - In the example, total is set for Product x Sales.
+ *
+ * **Real example:**
+ * ```
+ * |         |        | Brand > Product     |                |
+ * |         |        |---------------------|----------------|
+ * |         |        | GoodData            |                |
+ * |         |        |---------------------|----------------|
+ * |         |        | Panther  | Bear     | Sum A          |
+ * |---------|--------|---------------------|----------------|
+ * | Country | City   | Sales    | Sales    | Sales          |
+ * |---------|--------|----------|----------|----------------|
+ * | USA     | NYC    | 100      | 150      | 250            |
+ * | USA     | LA     | 200      | 250      | 450            |
+ * ```
+ *
  * @alpha
  */
-export declare interface ITableSubtotalColumnDefinition {
+export declare type ITableSubtotalColumnDefinition = {
+    /**
+     * Always "subtotal" - identifies this as a subtotal column.
+     */
     type: "subtotal";
+    /**
+     * Position of this column in the final table (0-based).
+     * Usually appears after regular value columns for each pivot subgroup.
+     */
     columnIndex: number;
+    /**
+     * Position in the original headers array.
+     */
     columnHeaderIndex: number;
+    /**
+     * Describes exactly what this column represents.
+     * For subtotal, its always mix of regular attribute / measure scopes and total scopes.
+     */
     columnScope: ITableDataHeaderScope[];
+} & (/**
+* Handles case, when pivoting and measures are in rows.
+*/ {
+    isEmpty: false;
+    isTransposed: true;
+    totalHeader: IResultTotalHeader;
+    attributeDescriptor: IAttributeDescriptor;
 }
+/**
+* Handles standard pivoting case without transposition.
+*/
+| {
+    isEmpty: false;
+    isTransposed: false;
+    totalHeader: IResultTotalHeader;
+    measureDescriptor: IMeasureDescriptor;
+});
 
 /**
+ * Numeric cell containing **subtotals** aggregated across sibling rows/columns.
+ *
+ * **Visual example**
+ * ```
+ * // Row subtotal:
+ *            | Sales  |
+ * -----------+--------+
+ *  USA       |  100   |
+ *  Sum A     |  170   | <- 170 is subtotalValue
+ *
+ * // Column subtotal:
+ *            | Q1  | Sum A   |
+ * -----------+-----+---------+
+ *  USA       | 100 |   220   | <- 220 is subtotalValue
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableSubtotalMeasureValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "subtotalValue";
+    /**
+     * Human-readable formatted subtotal value (e.g., "$2,345.67").
+     */
     formattedValue: string | null;
+    /**
+     * Raw aggregated subtotal value from the backend.
+     * Result of summing/averaging/etc. across sibling rows or columns.
+     */
     value: DataValue;
+    /**
+     * Zero-based row position in the `data` matrix.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     */
     columnIndex: number;
+    /**
+     * Row context - value or subtotal row.
+     */
     rowDefinition: ITableValueRowDefinition | ITableSubtotalRowDefinition;
+    /**
+     * Column context - value column or subtotal column.
+     */
     columnDefinition: ITableValueColumnDefinition | ITableSubtotalColumnDefinition;
 }
 
@@ -3384,27 +4112,132 @@ export declare interface ITableSubtotalRowDefinition {
 }
 
 /**
+ * Cell that represents total header.
+ * Each cell corresponds to one `IResultTotalHeader` and labels the total for that specific row / column.
+ *
+ * **Visual example**
+ * ```
+ *  Attribute | Value |
+ * -----------+-------+
+ *  USA       |  100  |
+ *  Sum A     |   80  | <- "Sum A" is totalHeader
+ * ```
+ *
  * @alpha
  */
 export declare interface ITableTotalHeaderValue {
+    /**
+     * Discriminator literal for narrowing the `ITableDataValue` union.
+     */
     type: "totalHeader";
+    /**
+     * Display text for the total header (e.g., "Sum", "Avg", "Max").
+     */
     formattedValue: string | null;
+    /**
+     * The raw `IResultTotalHeader` object containing total metadata
+     * like totalType, measureIndex, etc.
+     */
     value: IResultTotalHeader;
+    /**
+     * Zero-based row position in the `data` matrix.
+     * Usually points to a subtotal or grand-total row.
+     */
     rowIndex: number;
+    /**
+     * Zero-based column position in the `data` matrix.
+     * Points to the measure header column when measures are transposed.
+     */
     columnIndex: number;
-    rowDefinition: ITableRowDefinition;
-    columnDefinition: ITableColumnDefinition;
+    /**
+     * Row context - subtotal or value row.
+     */
+    rowDefinition: ITableValueRowDefinition | ITableSubtotalRowDefinition;
+    /**
+     * Column context - value column, subtotal column, measure group header column, or attribute column.
+     */
+    columnDefinition: ITableValueColumnDefinition | ITableSubtotalColumnDefinition | ITableMeasureGroupHeaderColumnDefinition | ITableAttributeColumnDefinition;
 }
 
 /**
+ * Defines columns that contain actual data values (values and subtotals).
+ *
+ * **What it does:**
+ * These columns show your actual data - sales numbers, counts, percentages, etc.
+ * The `columnScope` tells you exactly what this column represents.
+ *
+ * **When it's created:**
+ * The system creates these based on your column headers. Here's how:
+ *
+ * **Simple case - just measures:**
+ * ```
+ * | Country | Sales | Profit |  <- Sales and Profit are value columns
+ * |---------|-------|--------|
+ * | USA     | 100   | 20     |
+ * ```
+ *
+ * **Pivoted case - attributes + measures in columns:**
+ * ```
+ * | Country | East Sales | East Profit | West Sales | West Profit |
+ * |---------|------------|-------------|------------|-------------|
+ * | USA     | 100        | 20          | 150        | 30          |
+ * ```
+ *
+ * **Transposed case - measures in rows, attributes in columns:**
+ * ```
+ * | Country | Measure | East | West |
+ * |---------|---------|------|------|
+ * | USA     | Sales   | 100  | 150  |
+ * | USA     | Profit  | 20   | 30   |
+ * ```
+ *
  * @alpha
  */
-export declare interface ITableValueColumnDefinition {
+export declare type ITableValueColumnDefinition = {
+    /**
+     * Always "value" - identifies this as a value column.
+     */
     type: "value";
+    /**
+     * Position of this column in the final table (0-based).
+     * Comes after all row attribute columns.
+     */
     columnIndex: number;
+    /**
+     * Position in the original column headers array.
+     */
     columnHeaderIndex: number;
+    /**
+     * Describes exactly what this column represents.
+     * For value, its always only regular attribute / measure scopes.
+     */
     columnScope: ITableDataHeaderScope[];
+} & (/**
+* Handles case, when pivoting and measures are in rows.
+*/ {
+    isEmpty: false;
+    isTransposed: true;
+    attributeHeader: IResultAttributeHeader;
+    attributeDescriptor: IAttributeDescriptor;
 }
+/**
+* Handles standard pivoting case without transposition.
+*/
+| {
+    isEmpty: false;
+    isTransposed: false;
+    measureHeader: IResultMeasureHeader;
+    measureDescriptor: IMeasureDescriptor;
+}
+/**
+* Handles case, when pivoting, but there are no measures.
+*/
+| {
+    isEmpty: true;
+    isTransposed: false;
+    attributeHeader: IResultAttributeHeader;
+    attributeDescriptor: IAttributeDescriptor;
+});
 
 /**
  * @alpha