@adaptabletools/adaptable 20.1.7 → 20.2.0-canary.0

package/src/layout-manager/src/index.js

@@ -1,8 +1,8 @@
 import { debounce, DeepMap } from '@infinite-table/infinite-react';
 import { isPivotLayoutModel } from './isPivotLayoutModel';
 import { LMEmitter } from './LMEmitter';
-import { GROUP_COLUMN_ID__MULTI_PREFIX, GROUP_COLUMN_ID__SINGLE, normalizeLayoutModel, normalizePivotLayoutModel, normalizeTableLayoutModel, } from './normalizeLayoutModel';
-import { isLayoutEqual, getChanges } from './isLayoutEqual';
+import { AUTO_GROUP_COLUMN_ID__MULTI_PREFIX, AUTO_GROUP_COLUMN_ID__SINGLE, normalizeLayoutModel, normalizePivotLayoutModel, normalizeTableLayoutModel, } from './normalizeLayoutModel';
+import { getChanges, isLayoutEqual } from './isLayoutEqual';
 import { simplifyLayoutModel, simplifyPivotLayoutModel, simplifyTableLayoutModel, } from './simplifyLayoutModel';
 import { sortColumnIdsByOrder } from './sortColumnIdsByOrder';
 import { destructurePivotColumnId } from './destructurePivotColumnId';
@@ -305,6 +305,7 @@ export class LayoutManager extends LMEmitter {
             ColumnWidths,
             ColumnVisibility: layout.ColumnVisibility,
             RowGroupValues: layout.RowGroupValues,
+            ColumnGroupValues: layout.ColumnGroupValues,
             PivotGroupedColumns: layout.RowGroupedColumns,
             PivotAggregationColumns: layout.TableAggregationColumns,
             GrandTotalRow: layout.GrandTotalRow,
@@ -337,6 +338,7 @@ export class LayoutManager extends LMEmitter {
         let ColumnSorts = [];
         let RowGroupedColumns = [];
         let RowGroupValues = undefined;
+        let ColumnGroupValues = undefined;
         let TableAggregationColumns = [];
         let ColumnPinning = {};
         const gridState = this.gridApi.getState();
@@ -354,14 +356,14 @@ export class LayoutManager extends LMEmitter {
             // we try to infer it from the default width (when display type is single)
             // or from the respective group column (when display type is multi)
             if (initialWidth === undefined) {
-                if (colId === GROUP_COLUMN_ID__SINGLE) {
+                if (colId === AUTO_GROUP_COLUMN_ID__SINGLE) {
                     const groupByColId = this.gridApi.getRowGroupColumns()[0]?.getColId();
                     initialWidth =
                         this.initialColumnWidths[colId] || this.initialColumnWidths[groupByColId];
                 }
-                else if (colId.startsWith(GROUP_COLUMN_ID__MULTI_PREFIX)) {
+                else if (colId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX)) {
                     initialWidth =
-                        this.initialColumnWidths[colId.replace(GROUP_COLUMN_ID__MULTI_PREFIX, '')];
+                        this.initialColumnWidths[colId.replace(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX, '')];
                 }
             }
             // and only add the col width to the layout ColumnWidths
@@ -386,6 +388,16 @@ export class LayoutManager extends LMEmitter {
             }
             return acc;
         }, {});
+        if (gridState.pivot?.pivotMode && gridState.sort?.sortModel) {
+            // for pivot mode, we can't simply take the current sort from the ColumnState
+            // but we have to go via the sortModel from the grid state
+            ColumnSorts = gridState.sort.sortModel.map((sort) => {
+                return {
+                    ColumnId: sort.colId,
+                    SortOrder: sort.sort === 'asc' ? 'Asc' : 'Desc',
+                };
+            });
+        }
         if (gridState.aggregation) {
             TableAggregationColumns = gridState.aggregation.aggregationModel.map((agg) => {
                 const prevAggForColumn = prevAggColumnsMap?.[agg.colId];
@@ -409,11 +421,11 @@ export class LayoutManager extends LMEmitter {
             if (this.currentLayout.RowGroupedColumns?.length) {
                 const groupDisplayType = this.gridApi.getGridOption('groupDisplayType');
                 if (groupDisplayType === 'singleColumn') {
-                    colsInLayout.add(GROUP_COLUMN_ID__SINGLE);
+                    colsInLayout.add(AUTO_GROUP_COLUMN_ID__SINGLE);
                 }
                 else {
                     this.currentLayout.RowGroupedColumns.forEach((colId) => {
-                        colsInLayout.add(`${GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`);
+                        colsInLayout.add(`${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`);
                     });
                 }
             }
@@ -428,7 +440,7 @@ export class LayoutManager extends LMEmitter {
                 // in the current layout - in which case in the prev state of the current layout
                 // we had the group column
                 // but now we will need to include the current column
-                if (colsInLayout.has(`${GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`)) {
+                if (colsInLayout.has(`${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`)) {
                     // ColumnVisibility[colId] = false;
                     return true;
                 }
@@ -507,6 +519,50 @@ export class LayoutManager extends LMEmitter {
                 RowGroupValues = this.currentLayout.RowGroupValues;
             }
         }
+        if (this.currentLayout?.ColumnGroupValues) {
+            const currentColumnGroupValues = this.currentLayout.ColumnGroupValues;
+            if (currentColumnGroupValues.ColumnGroupDisplay === 'always-expanded') {
+                ColumnGroupValues = {
+                    ColumnGroupDisplay: 'always-expanded',
+                };
+            }
+            else if (currentColumnGroupValues.ColumnGroupDisplay === 'always-collapsed') {
+                ColumnGroupValues = {
+                    ColumnGroupDisplay: 'always-collapsed',
+                };
+            }
+            else if (currentColumnGroupValues.ColumnGroupDisplay === 'expanded' ||
+                currentColumnGroupValues.ColumnGroupDisplay === 'collapsed') {
+                const isPivot = this.isCurrentLayoutPivot();
+                const currentColumnGroupState = this.gridApi
+                    .getColumnGroupState()
+                    // if we're in a pivot layout, only include groups that are pivot groups
+                    // as there are other fake groups in the grid as well
+                    .filter((state) => (isPivot ? state.groupId.startsWith('pivotGroup_') : true));
+                if (currentColumnGroupValues.ColumnGroupDisplay === 'expanded') {
+                    const collapsedGroupIds = currentColumnGroupState
+                        .filter((state) => {
+                        return state.open === false;
+                    })
+                        .map((state) => state.groupId);
+                    ColumnGroupValues = {
+                        ColumnGroupDisplay: 'expanded',
+                        Values: collapsedGroupIds,
+                    };
+                }
+                else if (currentColumnGroupValues.ColumnGroupDisplay === 'collapsed') {
+                    const expandedGroupIds = currentColumnGroupState
+                        .filter((state) => {
+                        return state.open === true;
+                    })
+                        .map((state) => state.groupId);
+                    ColumnGroupValues = {
+                        ColumnGroupDisplay: 'collapsed',
+                        Values: expandedGroupIds,
+                    };
+                }
+            }
+        }
         const layout = simplifyTableLayoutModel({
             Ignore_Name: this.currentLayout?.Ignore_Name || 'Default',
             Ignore_GridFilter: this.currentLayout?.Ignore_GridFilter,
@@ -527,6 +583,7 @@ export class LayoutManager extends LMEmitter {
             TableAggregationColumns,
             ColumnPinning: ColumnPinning,
             RowGroupValues,
+            ColumnGroupValues,
             GrandTotalRow: this.gridApi.getGridOption('grandTotalRow'),
             SuppressAggFuncInHeader: this.gridApi.getGridOption('suppressAggFuncInHeader'),
         });
@@ -778,11 +835,22 @@ export class LayoutManager extends LMEmitter {
             this.gridApi.setGridOption('suppressAggFuncInHeader', !!layout.SuppressAggFuncInHeader);
         }
         if (layout.GrandTotalRow) {
-            const grandTotalRow = layout.GrandTotalRow === true || layout.GrandTotalRow === 'top'
-                ? 'top'
-                : layout.GrandTotalRow === 'bottom'
-                    ? 'bottom'
-                    : null;
+            let grandTotalRow = null;
+            if (layout.GrandTotalRow === true) {
+                grandTotalRow = 'top';
+            }
+            else if (typeof layout.GrandTotalRow === 'string') {
+                switch (layout.GrandTotalRow) {
+                    case 'top':
+                    case 'bottom':
+                    case 'pinnedTop':
+                    case 'pinnedBottom':
+                        grandTotalRow = layout.GrandTotalRow;
+                        break;
+                    default:
+                        grandTotalRow = null;
+                }
+            }
             this.gridApi.setGridOption('grandTotalRow', grandTotalRow);
         }
         else {
@@ -831,6 +899,7 @@ export class LayoutManager extends LMEmitter {
             if (hasGroupedColumns && layout.RowGroupValues && !options?.skipApplyRowGroupsExpandedState) {
                 this.applyRowGroupValues(layout.RowGroupValues);
             }
+            this.applyColumnGroupCollapseExpandState(layout);
         });
     }
     getRowGroupNodePathsAs(options) {
@@ -1027,6 +1096,9 @@ export class LayoutManager extends LMEmitter {
         }, {});
         columnState.state.forEach((colState) => {
             const colSortIndex = sortsToIndexes[colState.colId];
+            // we delete them just to know if there are any left
+            // after the forEach is done
+            delete sortsToIndexes[colState.colId];
             const colSort = sorts[colSortIndex];
             if (colSort != undefined) {
                 colState.sort = colSort.SortOrder === 'Asc' ? 'asc' : 'desc';
@@ -1037,6 +1109,21 @@ export class LayoutManager extends LMEmitter {
                 colState.sortIndex = null;
             }
         });
+        if (Object.keys(sortsToIndexes).length) {
+            // if there are some sorts left which were not applied to the columnState
+            // probably those are for pivot result columns, so we need to apply them as well
+            Object.keys(sortsToIndexes).forEach((colId) => {
+                const colSortIndex = sortsToIndexes[colId];
+                const colSort = sorts[colSortIndex];
+                if (colSort != undefined) {
+                    columnState.state.push({
+                        colId,
+                        sort: colSort.SortOrder === 'Asc' ? 'asc' : 'desc',
+                        sortIndex: colSortIndex,
+                    });
+                }
+            });
+        }
     }
     getDefaultColumnWidthForCol(colId, colDef) {
         colDef = colDef ?? this.gridApi.getColumnDef(colId);
@@ -1137,7 +1224,7 @@ export class LayoutManager extends LMEmitter {
                 this.gridApi.setColumnWidths(colWidthForPivotResultColumns);
             }
         }
-        this.applyPivotExpandLevel(layout);
+        this.applyColumnGroupCollapseExpandState(layout);
         const hasGroupedColumns = layout.PivotGroupedColumns && layout.PivotGroupedColumns.length;
         // but also let's not forget to apply the row group values
         if (hasGroupedColumns && layout.RowGroupValues && !options?.skipApplyRowGroupsExpandedState) {
@@ -1178,26 +1265,54 @@ export class LayoutManager extends LMEmitter {
             this.gridApi.setGridOption('pivotColumnGroupTotals', null);
         }
     }
-    applyPivotExpandLevel(layout) {
-        const PivotExpandLevel = layout.PivotExpandLevel ?? -1;
+    applyColumnGroupCollapseExpandState(layout) {
+        const IsPivotLayout = isPivotLayoutModel(layout);
         const allDisplayedColumnGroups = this.gridApi.getAllDisplayedColumnGroups();
+        let PivotExpandLevel = layout.PivotExpandLevel;
+        const ColumnGroupValues = layout.ColumnGroupValues;
+        if (IsPivotLayout && !ColumnGroupValues && PivotExpandLevel === undefined) {
+            PivotExpandLevel = -1;
+        }
         const colGroupDefs = allDisplayedColumnGroups
             .map((colGroup) => colGroup.getDefinition())
             // we need to filter because there are some fake groups as well, no idea what for
             .filter(Boolean);
         const colGroupState = [];
-        const processColGroupDefs = (colGroupDefs) => {
+        const columnGroupExceptions = ColumnGroupValues?.ColumnGroupDisplay === 'collapsed' ||
+            ColumnGroupValues?.ColumnGroupDisplay === 'expanded'
+            ? new Set(ColumnGroupValues.Values)
+            : new Set();
+        const processColGroupDefs = (colGroupDefs, currentLevel) => {
             colGroupDefs.forEach((colGroupDef) => {
                 if ('children' in colGroupDef && colGroupDef.children) {
+                    let open;
+                    if (IsPivotLayout && !ColumnGroupValues) {
+                        open =
+                            PivotExpandLevel === -1 ? true : colGroupDef.pivotKeys?.length <= PivotExpandLevel;
+                    }
+                    if (ColumnGroupValues) {
+                        if (ColumnGroupValues.ColumnGroupDisplay === 'always-expanded') {
+                            open = true;
+                        }
+                        else if (ColumnGroupValues.ColumnGroupDisplay === 'always-collapsed') {
+                            open = false;
+                        }
+                        else if (ColumnGroupValues.ColumnGroupDisplay === 'expanded') {
+                            open = !columnGroupExceptions.has(colGroupDef.groupId);
+                        }
+                        else if (ColumnGroupValues.ColumnGroupDisplay === 'collapsed') {
+                            open = columnGroupExceptions.has(colGroupDef.groupId);
+                        }
+                    }
                     colGroupState.push({
                         groupId: colGroupDef.groupId,
-                        open: PivotExpandLevel === -1 ? true : colGroupDef.pivotKeys?.length <= PivotExpandLevel,
+                        open,
                     });
-                    processColGroupDefs(colGroupDef.children);
+                    processColGroupDefs(colGroupDef.children, currentLevel + 1);
                 }
             });
         };
-        processColGroupDefs(colGroupDefs);
+        processColGroupDefs(colGroupDefs, 1);
         if (colGroupState.length > 0) {
             this.gridApi.setColumnGroupState(colGroupState);
         }

package/src/layout-manager/src/normalizeLayoutModel.d.ts

@@ -1,8 +1,6 @@
 import { PivotLayoutModel, TableLayoutModel } from './LayoutManagerModel';
-export declare const GROUP_COLUMN_ID__SINGLE = "ag-Grid-AutoColumn";
-export declare const GROUP_COLUMN_ID__MULTI_PREFIX = "ag-Grid-AutoColumn-";
-export declare const DEFAULT_COL_WIDTH = 200;
-export declare function isGroupColumn(colId: string): boolean;
+export declare const AUTO_GROUP_COLUMN_ID__SINGLE = "ag-Grid-AutoColumn";
+export declare const AUTO_GROUP_COLUMN_ID__MULTI_PREFIX = "ag-Grid-AutoColumn-";
 export declare function normalizeTableLayoutModel(layout: TableLayoutModel, options?: {
     isTree: boolean;
 }): TableLayoutModel;

package/src/layout-manager/src/normalizeLayoutModel.js

@@ -1,10 +1,6 @@
 import { isPivotLayoutModel } from './isPivotLayoutModel';
-export const GROUP_COLUMN_ID__SINGLE = 'ag-Grid-AutoColumn';
-export const GROUP_COLUMN_ID__MULTI_PREFIX = 'ag-Grid-AutoColumn-';
-export const DEFAULT_COL_WIDTH = 200;
-export function isGroupColumn(colId) {
-    return colId.startsWith(GROUP_COLUMN_ID__MULTI_PREFIX) || colId === GROUP_COLUMN_ID__SINGLE;
-}
+export const AUTO_GROUP_COLUMN_ID__SINGLE = 'ag-Grid-AutoColumn';
+export const AUTO_GROUP_COLUMN_ID__MULTI_PREFIX = 'ag-Grid-AutoColumn-';
 export function normalizeTableLayoutModel(layout, options) {
     layout = structuredClone(layout);
     if (!layout.ColumnVisibility) {
@@ -45,11 +41,11 @@ export function normalizeTableLayoutModel(layout, options) {
         let displayType = layout.RowGroupDisplayType;
         if (!displayType) {
             layout.TableColumns.some((columnId) => {
-                if (columnId === GROUP_COLUMN_ID__SINGLE) {
+                if (columnId === AUTO_GROUP_COLUMN_ID__SINGLE) {
                     displayType = 'single';
                     return true;
                 }
-                else if (columnId.startsWith(GROUP_COLUMN_ID__MULTI_PREFIX)) {
+                else if (columnId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX)) {
                     displayType = 'multi';
                     return true;
                 }
@@ -58,14 +54,14 @@ export function normalizeTableLayoutModel(layout, options) {
             layout.RowGroupDisplayType = displayType;
         }
         if (displayType === 'single') {
-            if (!ColumnOrderSet.has(GROUP_COLUMN_ID__SINGLE)) {
-                layout.TableColumns = [GROUP_COLUMN_ID__SINGLE, ...layout.TableColumns];
+            if (!ColumnOrderSet.has(AUTO_GROUP_COLUMN_ID__SINGLE)) {
+                layout.TableColumns = [AUTO_GROUP_COLUMN_ID__SINGLE, ...layout.TableColumns];
             }
         }
         else {
             const GroupedCols = new Set(layout.RowGroupedColumns);
             [...layout.RowGroupedColumns].reverse().forEach((colId) => {
-                const groupColId = `${GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`;
+                const groupColId = `${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`;
                 if (!ColumnOrderSet.has(groupColId) && !ColumnOrderSet.has(colId)) {
                     // add the col to the beginning of the layout.OrderedColumns
                     layout.TableColumns.unshift(colId);
@@ -76,7 +72,7 @@ export function normalizeTableLayoutModel(layout, options) {
             const MappedColumnOrder = layout.TableColumns.flatMap((colId) => {
                 if (GroupedCols.has(colId)) {
                     // if the column is grouped by
-                    const groupColId = `${GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`;
+                    const groupColId = `${AUTO_GROUP_COLUMN_ID__MULTI_PREFIX}${colId}`;
                     // but there's no column for this group in the layout
                     if (!ColumnOrderSet.has(groupColId)) {
                         // then we assume that the current column is basically the group column
@@ -87,8 +83,8 @@ export function normalizeTableLayoutModel(layout, options) {
                     }
                 }
                 // if this is a group column
-                if (colId.startsWith(GROUP_COLUMN_ID__MULTI_PREFIX)) {
-                    const simpleColId = colId.replace(GROUP_COLUMN_ID__MULTI_PREFIX, '');
+                if (colId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX)) {
+                    const simpleColId = colId.replace(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX, '');
                     // but the corresponding simple column is not in the layout
                     // then let's include it, with visibility set to false
                     if (!ColumnOrderSet.has(simpleColId)) {
@@ -106,8 +102,8 @@ export function normalizeTableLayoutModel(layout, options) {
             };
         }
     }
-    if (options?.isTree && !layout.TableColumns.includes(GROUP_COLUMN_ID__SINGLE)) {
-        layout.TableColumns.unshift(GROUP_COLUMN_ID__SINGLE);
+    if (options?.isTree && !layout.TableColumns.includes(AUTO_GROUP_COLUMN_ID__SINGLE)) {
+        layout.TableColumns.unshift(AUTO_GROUP_COLUMN_ID__SINGLE);
     }
     return layout;
 }

package/src/layout-manager/src/simplifyLayoutModel.js

@@ -1,5 +1,5 @@
 import { isPivotLayoutModel } from './isPivotLayoutModel';
-import { GROUP_COLUMN_ID__MULTI_PREFIX, GROUP_COLUMN_ID__SINGLE } from './normalizeLayoutModel';
+import { AUTO_GROUP_COLUMN_ID__MULTI_PREFIX, AUTO_GROUP_COLUMN_ID__SINGLE, } from './normalizeLayoutModel';
 export function simplifyTableLayoutModel(layout) {
     layout = structuredClone(layout);
     if (layout.ColumnVisibility && !Object.keys(layout.ColumnVisibility).length) {
@@ -32,6 +32,12 @@ export function simplifyTableLayoutModel(layout) {
     if (!layout.RowGroupValues && Object.prototype.hasOwnProperty.call(layout, 'RowGroupValues')) {
         delete layout.RowGroupValues;
     }
+    // if it's a property, but is undefined
+    // make sure we delete it
+    if (!layout.ColumnGroupValues &&
+        Object.prototype.hasOwnProperty.call(layout, 'ColumnGroupValues')) {
+        delete layout.ColumnGroupValues;
+    }
     if (layout.TableAggregationColumns && !layout.TableAggregationColumns.length) {
         delete layout.TableAggregationColumns;
     }
@@ -45,11 +51,11 @@ export function simplifyTableLayoutModel(layout) {
         layout.RowGroupedColumns.length) {
         let displayType = 'single';
         layout.TableColumns.some((columnId) => {
-            if (columnId === GROUP_COLUMN_ID__SINGLE) {
+            if (columnId === AUTO_GROUP_COLUMN_ID__SINGLE) {
                 displayType = 'single';
                 return true;
             }
-            else if (columnId.startsWith(GROUP_COLUMN_ID__MULTI_PREFIX)) {
+            else if (columnId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX)) {
                 displayType = 'multi';
                 return true;
             }
@@ -84,6 +90,12 @@ export function simplifyPivotLayoutModel(layout) {
     if (layout.PivotGrandTotal === undefined) {
         delete layout.PivotGrandTotal;
     }
+    // if it's a property, but is undefined
+    // make sure we delete it
+    if (!layout.ColumnGroupValues &&
+        Object.prototype.hasOwnProperty.call(layout, 'ColumnGroupValues')) {
+        delete layout.ColumnGroupValues;
+    }
     return layout;
 }
 export function simplifyLayoutModel(layout) {

package/src/metamodel/adaptable.metamodel.d.ts

@@ -2357,6 +2357,11 @@ export declare const ADAPTABLE_METAMODEL: {
             ref: string;
         })[];
     };
+    CustomExportParams: {
+        name: string;
+        kind: string;
+        desc: string;
+    };
     CustomGroupColumnMenuItem: {
         name: string;
         kind: string;
@@ -3029,6 +3034,26 @@ export declare const ADAPTABLE_METAMODEL: {
             ref: string;
         })[];
     };
+    ExportDataFormatContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: {
+            name: string;
+            kind: string;
+            desc: string;
+        }[];
+    };
+    ExportDateFormatContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: {
+            name: string;
+            kind: string;
+            desc: string;
+        }[];
+    };
     ExportDestinationType: {
         name: string;
         kind: string;
@@ -5409,6 +5434,24 @@ export declare const ADAPTABLE_METAMODEL: {
         kind: string;
         desc: string;
     };
+    SystemExportDestinationsContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt?: undefined;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            ref: string;
+        })[];
+    };
     SystemFilterPredicateId: {
         name: string;
         kind: string;
@@ -5460,6 +5503,24 @@ export declare const ADAPTABLE_METAMODEL: {
         kind: string;
         desc: string;
     };
+    SystemReportFormatsContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt?: undefined;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            ref: string;
+        })[];
+    };
     SystemReportName: {
         name: string;
         kind: string;
@@ -5470,6 +5531,16 @@ export declare const ADAPTABLE_METAMODEL: {
         kind: string;
         desc: string;
     };
+    SystemReportNamesContext: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: {
+            name: string;
+            kind: string;
+            desc: string;
+        }[];
+    };
     SystemStatusMessageInfo: {
         name: string;
         kind: string;