@finos/legend-extension-dsl-data-space 9.2.4 → 9.2.6

package/src/stores/DataSpaceModelsDocumentationState.ts

@@ -0,0 +1,588 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { action, computed, makeObservable, observable } from 'mobx';
+import type { DataSpaceViewerState } from './DataSpaceViewerState.js';
+import { FuzzySearchAdvancedConfigState } from '@finos/legend-application/components';
+import { type TreeData, type TreeNodeData } from '@finos/legend-art';
+import {
+  ActionState,
+  filterByType,
+  guaranteeNonNullable,
+  FuzzySearchEngine,
+} from '@finos/legend-shared';
+import {
+  DataSpaceAssociationDocumentationEntry,
+  DataSpaceClassDocumentationEntry,
+  DataSpaceEnumerationDocumentationEntry,
+  DataSpaceModelDocumentationEntry,
+  type NormalizedDataSpaceDocumentationEntry,
+} from '../graphManager/action/analytics/DataSpaceAnalysis.js';
+import { CORE_PURE_PATH, ELEMENT_PATH_DELIMITER } from '@finos/legend-graph';
+
+export enum ModelsDocumentationFilterTreeNodeCheckType {
+  CHECKED,
+  UNCHECKED,
+  PARTIALLY_CHECKED,
+}
+
+export abstract class ModelsDocumentationFilterTreeNodeData
+  implements TreeNodeData
+{
+  readonly id: string;
+  readonly label: string;
+  readonly parentNode: ModelsDocumentationFilterTreeNodeData | undefined;
+  isOpen = false;
+  childrenIds: string[] = [];
+  childrenNodes: ModelsDocumentationFilterTreeNodeData[] = [];
+  // By default all nodes are checked
+  checkType = ModelsDocumentationFilterTreeNodeCheckType.CHECKED;
+
+  constructor(
+    id: string,
+    label: string,
+    parentNode: ModelsDocumentationFilterTreeNodeData | undefined,
+  ) {
+    makeObservable(this, {
+      isOpen: observable,
+      checkType: observable,
+      setIsOpen: action,
+      setCheckType: action,
+    });
+
+    this.id = id;
+    this.label = label;
+    this.parentNode = parentNode;
+  }
+
+  setIsOpen(val: boolean): void {
+    this.isOpen = val;
+  }
+
+  setCheckType(val: ModelsDocumentationFilterTreeNodeCheckType): void {
+    this.checkType = val;
+  }
+}
+
+export class ModelsDocumentationFilterTreeRootNodeData extends ModelsDocumentationFilterTreeNodeData {}
+
+export class ModelsDocumentationFilterTreePackageNodeData extends ModelsDocumentationFilterTreeNodeData {
+  declare parentNode: ModelsDocumentationFilterTreeNodeData;
+  packagePath: string;
+
+  constructor(
+    id: string,
+    label: string,
+    parentNode: ModelsDocumentationFilterTreeNodeData,
+    packagePath: string,
+  ) {
+    super(id, label, parentNode);
+    this.packagePath = packagePath;
+  }
+}
+
+export class ModelsDocumentationFilterTreeElementNodeData extends ModelsDocumentationFilterTreeNodeData {
+  declare parentNode: ModelsDocumentationFilterTreeNodeData;
+  elementPath: string;
+  typePath: CORE_PURE_PATH | undefined;
+
+  constructor(
+    id: string,
+    label: string,
+    parentNode: ModelsDocumentationFilterTreeNodeData,
+    elementPath: string,
+    typePath: CORE_PURE_PATH | undefined,
+  ) {
+    super(id, label, parentNode);
+    this.elementPath = elementPath;
+    this.typePath = typePath;
+  }
+}
+
+export class ModelsDocumentationFilterTreeTypeNodeData extends ModelsDocumentationFilterTreeNodeData {
+  declare parentNode: ModelsDocumentationFilterTreeNodeData;
+  typePath: CORE_PURE_PATH;
+
+  constructor(
+    id: string,
+    label: string,
+    parentNode: ModelsDocumentationFilterTreeNodeData,
+    typePath: CORE_PURE_PATH,
+  ) {
+    super(id, label, parentNode);
+    this.typePath = typePath;
+  }
+}
+
+const trickleDownUncheckNodeChildren = (
+  node: ModelsDocumentationFilterTreeNodeData,
+): void => {
+  node.setCheckType(ModelsDocumentationFilterTreeNodeCheckType.UNCHECKED);
+  node.childrenNodes.forEach((childNode) =>
+    trickleDownUncheckNodeChildren(childNode),
+  );
+};
+
+const trickleUpUncheckNode = (
+  node: ModelsDocumentationFilterTreeNodeData,
+): void => {
+  const parentNode = node.parentNode;
+  if (!parentNode) {
+    return;
+  }
+  if (
+    parentNode.childrenNodes.some(
+      (childNode) =>
+        childNode.checkType ===
+        ModelsDocumentationFilterTreeNodeCheckType.CHECKED,
+    )
+  ) {
+    parentNode.setCheckType(
+      ModelsDocumentationFilterTreeNodeCheckType.PARTIALLY_CHECKED,
+    );
+  } else {
+    parentNode.setCheckType(
+      ModelsDocumentationFilterTreeNodeCheckType.UNCHECKED,
+    );
+  }
+
+  trickleUpUncheckNode(parentNode);
+};
+
+export const uncheckFilterTreeNode = (
+  node: ModelsDocumentationFilterTreeNodeData,
+): void => {
+  trickleDownUncheckNodeChildren(node);
+  trickleUpUncheckNode(node);
+};
+
+const trickleDownCheckNode = (
+  node: ModelsDocumentationFilterTreeNodeData,
+): void => {
+  node.setCheckType(ModelsDocumentationFilterTreeNodeCheckType.CHECKED);
+  node.childrenNodes.forEach((childNode) => trickleDownCheckNode(childNode));
+};
+
+const trickleUpCheckNode = (
+  node: ModelsDocumentationFilterTreeNodeData,
+): void => {
+  const parentNode = node.parentNode;
+  if (!parentNode) {
+    return;
+  }
+  if (
+    parentNode.childrenNodes.every(
+      (childNode) =>
+        childNode.checkType ===
+        ModelsDocumentationFilterTreeNodeCheckType.CHECKED,
+    )
+  ) {
+    parentNode.setCheckType(ModelsDocumentationFilterTreeNodeCheckType.CHECKED);
+  } else {
+    parentNode.setCheckType(
+      ModelsDocumentationFilterTreeNodeCheckType.PARTIALLY_CHECKED,
+    );
+  }
+
+  trickleUpCheckNode(parentNode);
+};
+
+export const checkFilterTreeNode = (
+  node: ModelsDocumentationFilterTreeNodeData,
+): void => {
+  trickleDownCheckNode(node);
+  trickleUpCheckNode(node);
+};
+
+export const uncheckAllFilterTree = (
+  treeData: TreeData<ModelsDocumentationFilterTreeNodeData>,
+): void => {
+  treeData.nodes.forEach((node) =>
+    node.setCheckType(ModelsDocumentationFilterTreeNodeCheckType.UNCHECKED),
+  );
+};
+
+const buildTypeFilterTreeData =
+  (): TreeData<ModelsDocumentationFilterTreeNodeData> => {
+    const rootIds: string[] = [];
+    const nodes = new Map<string, ModelsDocumentationFilterTreeNodeData>();
+
+    // all node
+    const allNode = new ModelsDocumentationFilterTreeRootNodeData(
+      'all',
+      'All Types',
+      undefined,
+    );
+    rootIds.push(allNode.id);
+    allNode.setIsOpen(true); // open the root node by default
+    nodes.set(allNode.id, allNode);
+
+    // type nodes
+    const classNode = new ModelsDocumentationFilterTreeTypeNodeData(
+      'class',
+      'Class',
+      allNode,
+      CORE_PURE_PATH.CLASS,
+    );
+    allNode.childrenIds.push(classNode.id);
+    nodes.set(classNode.id, classNode);
+
+    const enumerationNode = new ModelsDocumentationFilterTreeTypeNodeData(
+      'enumeration',
+      'Enumeration',
+      allNode,
+      CORE_PURE_PATH.ENUMERATION,
+    );
+    allNode.childrenIds.push(enumerationNode.id);
+    nodes.set(enumerationNode.id, enumerationNode);
+
+    const associationNode = new ModelsDocumentationFilterTreeTypeNodeData(
+      'association',
+      'Association',
+      allNode,
+      CORE_PURE_PATH.ASSOCIATION,
+    );
+    allNode.childrenIds.push(associationNode.id);
+    nodes.set(associationNode.id, associationNode);
+    allNode.childrenNodes = [classNode, enumerationNode, associationNode];
+
+    return {
+      rootIds,
+      nodes,
+    };
+  };
+
+const buildPackageFilterTreeData = (
+  modelDocEntries: DataSpaceModelDocumentationEntry[],
+): TreeData<ModelsDocumentationFilterTreeNodeData> => {
+  const rootIds: string[] = [];
+  const nodes = new Map<string, ModelsDocumentationFilterTreeNodeData>();
+
+  // all node
+  const allNode = new ModelsDocumentationFilterTreeRootNodeData(
+    'all',
+    'All Packages',
+    undefined,
+  );
+  rootIds.push(allNode.id);
+  allNode.setIsOpen(true); // open the root node by default
+  nodes.set(allNode.id, allNode);
+
+  modelDocEntries.forEach((entry) => {
+    const path = entry.path;
+    const chunks = path.split(ELEMENT_PATH_DELIMITER);
+    let currentParentNode = allNode;
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = guaranteeNonNullable(chunks[i]);
+      const elementPath = `${
+        currentParentNode === allNode
+          ? ''
+          : `${currentParentNode.id}${ELEMENT_PATH_DELIMITER}`
+      }${chunk}`;
+      const nodeId = elementPath;
+      let node = nodes.get(nodeId);
+      if (!node) {
+        if (i === chunks.length - 1) {
+          node = new ModelsDocumentationFilterTreeElementNodeData(
+            nodeId,
+            chunk,
+            currentParentNode,
+            elementPath,
+            entry instanceof DataSpaceClassDocumentationEntry
+              ? CORE_PURE_PATH.CLASS
+              : entry instanceof DataSpaceEnumerationDocumentationEntry
+              ? CORE_PURE_PATH.ENUMERATION
+              : entry instanceof DataSpaceAssociationDocumentationEntry
+              ? CORE_PURE_PATH.ASSOCIATION
+              : undefined,
+          );
+        } else {
+          node = new ModelsDocumentationFilterTreePackageNodeData(
+            nodeId,
+            chunk,
+            currentParentNode,
+            elementPath,
+          );
+        }
+        nodes.set(nodeId, node);
+        currentParentNode.childrenIds.push(nodeId);
+        currentParentNode.childrenNodes.push(node);
+      }
+      currentParentNode = node;
+    }
+  });
+
+  return {
+    rootIds,
+    nodes,
+  };
+};
+
+export class DataSpaceViewerModelsDocumentationState {
+  readonly dataSpaceViewerState: DataSpaceViewerState;
+
+  showHumanizedForm = true;
+
+  // search text
+  private readonly searchEngine: FuzzySearchEngine<NormalizedDataSpaceDocumentationEntry>;
+  searchConfigurationState: FuzzySearchAdvancedConfigState;
+  readonly searchState = ActionState.create();
+  searchText: string;
+  searchResults: NormalizedDataSpaceDocumentationEntry[] = [];
+  showSearchConfigurationMenu = false;
+
+  // filter
+  showFilterPanel = false;
+  typeFilterTreeData: TreeData<ModelsDocumentationFilterTreeNodeData>;
+  packageFilterTreeData: TreeData<ModelsDocumentationFilterTreeNodeData>;
+  filterTypes: string[] = [];
+  filterPaths: string[] = [];
+
+  constructor(dataSpaceViewerState: DataSpaceViewerState) {
+    makeObservable(this, {
+      showHumanizedForm: observable,
+      searchText: observable,
+      // NOTE: we use `observable.struct` for these to avoid unnecessary re-rendering of the grid
+      searchResults: observable.struct,
+      filterTypes: observable.struct,
+      filterPaths: observable.struct,
+      showSearchConfigurationMenu: observable,
+      showFilterPanel: observable,
+      typeFilterTreeData: observable.ref,
+      packageFilterTreeData: observable.ref,
+      filteredSearchResults: computed,
+      isTypeFilterCustomized: computed,
+      isPackageFilterCustomized: computed,
+      isFilterCustomized: computed,
+      setShowHumanizedForm: action,
+      setSearchText: action,
+      resetSearch: action,
+      search: action,
+      setShowSearchConfigurationMenu: action,
+      setShowFilterPanel: action,
+      resetTypeFilterTreeData: action,
+      resetPackageFilterTreeData: action,
+      updateTypeFilter: action,
+      updatePackageFilter: action,
+      resetTypeFilter: action,
+      resetPackageFilter: action,
+      resetAllFilters: action,
+    });
+
+    this.dataSpaceViewerState = dataSpaceViewerState;
+    this.searchEngine = new FuzzySearchEngine(
+      this.dataSpaceViewerState.dataSpaceAnalysisResult.elementDocs,
+      {
+        includeScore: true,
+        // NOTE: we must not sort/change the order in the grid since
+        // we want to ensure the element row is on top
+        shouldSort: false,
+        // Ignore location when computing the search score
+        // See https://fusejs.io/concepts/scoring-theory.html
+        ignoreLocation: true,
+        // This specifies the point the search gives up
+        // `0.0` means exact match where `1.0` would match anything
+        // We set a relatively low threshold to filter out irrelevant results
+        threshold: 0.2,
+        keys: [
+          {
+            name: 'text',
+            weight: 3,
+          },
+          {
+            name: 'humanizedText',
+            weight: 3,
+          },
+          {
+            name: 'elementEntry.name',
+            weight: 3,
+          },
+          {
+            name: 'elementEntry.humanizedName',
+            weight: 3,
+          },
+          {
+            name: 'entry.name',
+            weight: 2,
+          },
+          {
+            name: 'entry.humanizedName',
+            weight: 2,
+          },
+          {
+            name: 'documentation',
+            weight: 4,
+          },
+        ],
+        // extended search allows for exact word match through single quote
+        // See https://fusejs.io/examples.html#extended-search
+        useExtendedSearch: true,
+      },
+    );
+    this.searchConfigurationState = new FuzzySearchAdvancedConfigState(
+      (): void => this.search(),
+    );
+    this.searchText = '';
+    this.searchResults =
+      this.dataSpaceViewerState.dataSpaceAnalysisResult.elementDocs;
+
+    this.typeFilterTreeData = buildTypeFilterTreeData();
+    this.packageFilterTreeData = buildPackageFilterTreeData(
+      this.dataSpaceViewerState.dataSpaceAnalysisResult.elementDocs
+        .map((entry) => entry.entry)
+        .filter(filterByType(DataSpaceModelDocumentationEntry)),
+    );
+    this.updateTypeFilter();
+    this.updatePackageFilter();
+  }
+
+  get filteredSearchResults(): NormalizedDataSpaceDocumentationEntry[] {
+    return (
+      this.searchResults
+        // filter by types
+        .filter(
+          (result) =>
+            (this.filterTypes.includes(CORE_PURE_PATH.CLASS) &&
+              result.elementEntry instanceof
+                DataSpaceClassDocumentationEntry) ||
+            (this.filterTypes.includes(CORE_PURE_PATH.ENUMERATION) &&
+              result.elementEntry instanceof
+                DataSpaceEnumerationDocumentationEntry) ||
+            (this.filterTypes.includes(CORE_PURE_PATH.ASSOCIATION) &&
+              result.elementEntry instanceof
+                DataSpaceAssociationDocumentationEntry),
+        )
+        // filter by paths
+        .filter((result) => this.filterPaths.includes(result.elementEntry.path))
+    );
+  }
+
+  get isTypeFilterCustomized(): boolean {
+    return Array.from(this.typeFilterTreeData.nodes.values()).some(
+      (node) =>
+        node.checkType === ModelsDocumentationFilterTreeNodeCheckType.UNCHECKED,
+    );
+  }
+
+  get isPackageFilterCustomized(): boolean {
+    return Array.from(this.packageFilterTreeData.nodes.values()).some(
+      (node) =>
+        node.checkType === ModelsDocumentationFilterTreeNodeCheckType.UNCHECKED,
+    );
+  }
+
+  get isFilterCustomized(): boolean {
+    return this.isTypeFilterCustomized || this.isPackageFilterCustomized;
+  }
+
+  setShowHumanizedForm(val: boolean): void {
+    this.showHumanizedForm = val;
+  }
+
+  setSearchText(val: string): void {
+    this.searchText = val;
+  }
+
+  resetSearch(): void {
+    this.searchText = '';
+    this.searchResults =
+      this.dataSpaceViewerState.dataSpaceAnalysisResult.elementDocs;
+    this.searchState.complete();
+  }
+
+  search(): void {
+    if (!this.searchText) {
+      this.searchResults =
+        this.dataSpaceViewerState.dataSpaceAnalysisResult.elementDocs;
+      return;
+    }
+    this.searchState.inProgress();
+    this.searchResults = Array.from(
+      this.searchEngine
+        .search(
+          this.searchConfigurationState.generateSearchText(this.searchText),
+        )
+        .values(),
+    ).map((result) => result.item);
+
+    this.searchState.complete();
+  }
+
+  setShowSearchConfigurationMenu(val: boolean): void {
+    this.showSearchConfigurationMenu = val;
+  }
+
+  setShowFilterPanel(val: boolean): void {
+    this.showFilterPanel = val;
+  }
+
+  resetTypeFilterTreeData(): void {
+    this.typeFilterTreeData = { ...this.typeFilterTreeData };
+  }
+
+  resetPackageFilterTreeData(): void {
+    this.packageFilterTreeData = { ...this.packageFilterTreeData };
+  }
+
+  updateTypeFilter(): void {
+    const types: string[] = [];
+    this.typeFilterTreeData.nodes.forEach((node) => {
+      if (
+        node instanceof ModelsDocumentationFilterTreeTypeNodeData &&
+        node.checkType === ModelsDocumentationFilterTreeNodeCheckType.CHECKED
+      ) {
+        types.push(node.typePath);
+      }
+    });
+    // NOTE: sort to avoid unnecessary re-computation of filtered search results
+    this.filterTypes = types.sort((a, b) => a.localeCompare(b));
+  }
+
+  updatePackageFilter(): void {
+    const elementPaths: string[] = [];
+    this.packageFilterTreeData.nodes.forEach((node) => {
+      if (
+        node instanceof ModelsDocumentationFilterTreeElementNodeData &&
+        node.checkType === ModelsDocumentationFilterTreeNodeCheckType.CHECKED
+      ) {
+        elementPaths.push(node.elementPath);
+      }
+    });
+    // NOTE: sort to avoid unnecessary re-computation of filtered search results
+    this.filterPaths = elementPaths.sort((a, b) => a.localeCompare(b));
+  }
+
+  resetTypeFilter(): void {
+    this.typeFilterTreeData.nodes.forEach((node) =>
+      node.setCheckType(ModelsDocumentationFilterTreeNodeCheckType.CHECKED),
+    );
+    this.updateTypeFilter();
+    this.resetTypeFilterTreeData();
+  }
+
+  resetPackageFilter(): void {
+    this.packageFilterTreeData.nodes.forEach((node) =>
+      node.setCheckType(ModelsDocumentationFilterTreeNodeCheckType.CHECKED),
+    );
+    this.updatePackageFilter();
+    this.resetPackageFilterTreeData();
+  }
+
+  resetAllFilters(): void {
+    this.resetTypeFilter();
+    this.resetPackageFilter();
+  }
+}

package/src/stores/DataSpaceViewerState.ts

@@ -43,6 +43,7 @@ import {
   PURE_DATA_SPACE_INFO_PROFILE_VERIFIED_STEREOTYPE,
 } from '../graphManager/DSL_DataSpace_PureGraphManagerPlugin.js';
 import { DataSpaceViewerDataAccessState } from './DataSpaceViewerDataAccessState.js';
+import { DataSpaceViewerModelsDocumentationState } from './DataSpaceModelsDocumentationState.js';
 
 export enum DATA_SPACE_VIEWER_ACTIVITY_MODE {
   DESCRIPTION = 'description',
@@ -107,6 +108,7 @@ export class DataSpaceViewerState {
     | undefined;
 
   readonly dataAccessState: DataSpaceViewerDataAccessState;
+  readonly modelsDocumentationState: DataSpaceViewerModelsDocumentationState;
 
   _renderer?: DiagramRenderer | undefined;
   currentDiagram?: DataSpaceDiagramAnalysisResult | undefined;
@@ -114,6 +116,8 @@ export class DataSpaceViewerState {
   currentExecutionContext: DataSpaceExecutionContextAnalysisResult;
   currentRuntime: PackageableRuntime;
 
+  TEMPORARY__enableExperimentalFeatures = false;
+
   constructor(
     applicationStore: GenericLegendApplicationStore,
     graphManagerState: BasicGraphManagerState,
@@ -137,6 +141,9 @@ export class DataSpaceViewerState {
       onDiagramClassDoubleClick: (classView: ClassView) => void;
       onZoneChange?: ((zone: NavigationZone | undefined) => void) | undefined;
     },
+    options?: {
+      TEMPORARY__enableExperimentalFeatures?: boolean | undefined;
+    },
   ) {
     makeObservable(this, {
       _renderer: observable,
@@ -174,6 +181,13 @@ export class DataSpaceViewerState {
     this.onZoneChange = actions.onZoneChange;
 
     this.dataAccessState = new DataSpaceViewerDataAccessState(this);
+    this.modelsDocumentationState = new DataSpaceViewerModelsDocumentationState(
+      this,
+    );
+
+    this.TEMPORARY__enableExperimentalFeatures = Boolean(
+      options?.TEMPORARY__enableExperimentalFeatures,
+    );
   }
 
   get diagramRenderer(): DiagramRenderer {

package/tsconfig.json

@@ -46,7 +46,6 @@
     "./src/graphManager/DSL_DataSpace_PureGraphManagerPlugin.ts",
     "./src/graphManager/action/analytics/DataSpaceAnalysis.ts",
     "./src/graphManager/action/analytics/DataSpaceAnalysisHelper.ts",
-    "./src/graphManager/action/analytics/HACKY__DataSpaceUsageShowcase.ts",
     "./src/graphManager/action/changeDetection/DSL_DataSpace_ObserverHelper.ts",
     "./src/graphManager/protocol/pure/DSL_DataSpace_PureGraphManagerExtension.ts",
     "./src/graphManager/protocol/pure/DSL_DataSpace_PureGraphManagerExtensionBuilder.ts",
@@ -57,6 +56,7 @@
     "./src/graphManager/protocol/pure/v1/transformation/pureGraph/V1_DSL_DataSpace_GraphBuilderHelper.ts",
     "./src/graphManager/protocol/pure/v1/transformation/pureProtocol/V1_DSL_DataSpace_ProtocolHelper.ts",
     "./src/stores/DSL_DataSpace_LegendApplicationPlugin_Extension.ts",
+    "./src/stores/DataSpaceModelsDocumentationState.ts",
     "./src/stores/DataSpaceViewerDataAccessState.ts",
     "./src/stores/DataSpaceViewerState.ts",
     "./src/stores/query/DataSpaceAdvancedSearchState.ts",

package/lib/graphManager/action/analytics/HACKY__DataSpaceUsageShowcase.d.ts

@@ -1,57 +0,0 @@
-/**
- * Copyright (c) 2020-present, Goldman Sachs
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export declare abstract class HACKY__DataSpaceUsageShowcaseSampleOutput {
-}
-export declare abstract class HACKY__DataSpaceUsageShowcaseOutputDescription {
-    readonly sampleOutput: HACKY__DataSpaceUsageShowcaseSampleOutput;
-    constructor(sampleOutput: HACKY__DataSpaceUsageShowcaseSampleOutput);
-}
-type SampleData = boolean | string | number | undefined;
-export declare class HACKY__DataSpaceUsageShowcaseTDSSampleOutput extends HACKY__DataSpaceUsageShowcaseSampleOutput {
-    readonly headers: string[];
-    readonly rows: SampleData[][];
-    constructor(headers: string[], rows: SampleData[][]);
-}
-declare class HACKY__DataSpaceUsageShowcaseTDSColumnInfo {
-    readonly uuid: string;
-    readonly name: string;
-    readonly description?: string | undefined;
-    readonly sampleValues: SampleData[];
-    constructor(name: string, description: string | undefined, sampleValues: SampleData[]);
-}
-export declare class HACKY__DataSpaceUsageShowcaseTDSOutputDescription extends HACKY__DataSpaceUsageShowcaseOutputDescription {
-    readonly columns: HACKY__DataSpaceUsageShowcaseTDSColumnInfo[];
-    constructor(columns: HACKY__DataSpaceUsageShowcaseTDSColumnInfo[]);
-}
-export declare class HACKY__DataSpaceUsageShowcase {
-    readonly uuid: string;
-    readonly title: string;
-    readonly description?: string | undefined;
-    readonly query: string;
-    readonly outputDescription: HACKY__DataSpaceUsageShowcaseOutputDescription;
-    showQuery: boolean;
-    showOutputDescription: boolean;
-    showSampleOutput: boolean;
-    constructor(title: string, description: string | undefined, query: string, outputDescription: HACKY__DataSpaceUsageShowcaseOutputDescription);
-    setShowQuery(val: boolean): void;
-    setShowOutputDescription(val: boolean): void;
-    setShowSampleOutput(val: boolean): void;
-}
-export declare const HACKY__SHOWCASE1: HACKY__DataSpaceUsageShowcase;
-export declare const HACKY__SHOWCASE2: HACKY__DataSpaceUsageShowcase;
-export declare const HACKY__SHOWCASE3: HACKY__DataSpaceUsageShowcase;
-export {};
-//# sourceMappingURL=HACKY__DataSpaceUsageShowcase.d.ts.map