@finos/legend-graph
Version:
Legend graph and graph manager
364 lines • 26.1 kB
TypeScript
/**
* 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 type { ExecutionResult, EXECUTION_SERIALIZATION_FORMAT, ExecutionResultWithMetadata } from './action/execution/ExecutionResult.js';
import type { ServiceRegistrationResult, ServiceRegistrationSuccess } from './action/service/ServiceRegistrationResult.js';
import type { Service } from '../graph/metamodel/pure/packageableElements/service/Service.js';
import type { FileGenerationSpecification } from '../graph/metamodel/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
import type { GenerationOutput } from './action/generation/GenerationOutput.js';
import type { PackageableElement } from '../graph/metamodel/pure/packageableElements/PackageableElement.js';
import { PureModel, CoreModel, SystemModel, GenerationModel, type GraphTextInputOption } from '../graph/PureModel.js';
import type { Mapping } from '../graph/metamodel/pure/packageableElements/mapping/Mapping.js';
import type { Runtime } from '../graph/metamodel/pure/packageableElements/runtime/Runtime.js';
import { DependencyManager } from '../graph/DependencyManager.js';
import type { Class } from '../graph/metamodel/pure/packageableElements/domain/Class.js';
import type { RawLambda } from '../graph/metamodel/pure/rawValueSpecification/RawLambda.js';
import type { GenerationConfigurationDescription, GenerationMode } from './action/generation/GenerationConfigurationDescription.js';
import type { ValueSpecification } from '../graph/metamodel/pure/valueSpecification/ValueSpecification.js';
import type { RawValueSpecification } from '../graph/metamodel/pure/rawValueSpecification/RawValueSpecification.js';
import type { ServiceExecutionMode } from './action/service/ServiceExecutionMode.js';
import type { TEMPORARY__AbstractEngineConfig } from './action/TEMPORARY__AbstractEngineConfig.js';
import type { DatabaseBuilderInput } from './action/generation/DatabaseBuilderInput.js';
import type { RawRelationalOperationElement } from '../graph/metamodel/pure/packageableElements/store/relational/model/RawRelationalOperationElement.js';
import type { ExecutionPlan, RawExecutionPlan } from '../graph/metamodel/pure/executionPlan/ExecutionPlan.js';
import type { ExecutionNode } from '../graph/metamodel/pure/executionPlan/nodes/ExecutionNode.js';
import { type ContentType, type LogService, type PlainObject, type ServerClientConfig, type TracerService, ActionState } from '@finos/legend-shared';
import type { LightQuery, Query, QueryInfo } from './action/query/Query.js';
import type { EntitiesWithOrigin, Entity } from '@finos/legend-storage';
import type { QuerySearchSpecification } from './action/query/QuerySearchSpecification.js';
import type { ExternalFormatDescription } from './action/externalFormat/ExternalFormatDescription.js';
import type { ConfigurationProperty } from '../graph/metamodel/pure/packageableElements/fileGeneration/ConfigurationProperty.js';
import type { GraphManagerOperationReport } from './GraphManagerStatistics.js';
import type { RunTestsTestableInput } from '../graph/metamodel/pure/test/result/RunTestsTestableInput.js';
import type { TestResult } from '../graph/metamodel/pure/test/result/TestResult.js';
import type { GraphManagerPluginManager } from './GraphManagerPluginManager.js';
import type { MappingModelCoverageAnalysisResult, RawMappingModelCoverageAnalysisResult } from './action/analytics/MappingModelCoverageAnalysis.js';
import type { SchemaSet } from '../graph/metamodel/pure/packageableElements/externalFormat/schemaSet/DSL_ExternalFormat_SchemaSet.js';
import type { CompilationResult, TextCompilationResult } from './action/compilation/CompilationResult.js';
import type { ParameterValue, PostValidationAssertionResult } from '../DSL_Service_Exports.js';
import type { ModelUnit } from '../graph/metamodel/pure/packageableElements/externalFormat/store/DSL_ExternalFormat_ModelUnit.js';
import type { DatasetEntitlementReport, DatasetSpecification } from './action/analytics/StoreEntitlementAnalysis.js';
import type { GraphDataOrigin } from '../graph/GraphDataOrigin.js';
import type { GraphData } from './GraphData.js';
import type { DEPRECATED__MappingTest } from '../graph/metamodel/pure/packageableElements/mapping/DEPRECATED__MappingTest.js';
import type { EnumerationMapping } from '../graph/metamodel/pure/packageableElements/mapping/EnumerationMapping.js';
import type { SetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/SetImplementation.js';
import type { AssociationImplementation } from '../graph/metamodel/pure/packageableElements/mapping/AssociationImplementation.js';
import { InstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/InstanceSetImplementation.js';
import type { SourceInformation } from './action/SourceInformation.js';
import type { ClassifierPathMapping, SubtypeInfo } from './action/protocol/ProtocolInfo.js';
import type { FunctionActivatorConfiguration } from './action/functionActivator/FunctionActivatorConfiguration.js';
import type { RelationalDatabaseTypeConfiguration } from './action/relational/RelationalDatabaseTypeConfiguration.js';
import type { FunctionActivator } from '../graph/metamodel/pure/packageableElements/function/FunctionActivator.js';
import type { RelationalDatabaseConnection } from '../STO_Relational_Exports.js';
import type { ArtifactGenerationExtensionResult } from './action/generation/ArtifactGenerationExtensionResult.js';
import type { TestDataGenerationResult } from '../graph/metamodel/pure/packageableElements/service/TestGenerationResult.js';
import type { TableRowIdentifiers } from '../graph/metamodel/pure/packageableElements/service/TableRowIdentifiers.js';
import type { EngineError } from './action/EngineError.js';
import type { TestDebug } from '../graph/metamodel/pure/test/result/DebugTestsResult.js';
import type { RelationTypeMetadata } from './action/relation/RelationTypeMetadata.js';
import type { CodeCompletionResult } from './action/compilation/Completion.js';
import type { DeploymentResult } from './action/DeploymentResult.js';
import type { LightPersistentDataCube, PersistentDataCube } from './action/query/PersistentDataCube.js';
export interface TEMPORARY__EngineSetupConfig {
env: string;
tabSize: number;
clientConfig: ServerClientConfig;
/**
* Theses are workarounds we need to manually supply the configuration data
* for roundtrip grammar test, as the network call to engine is blocked in test
* environment, till we figure out the best way to do this, we can remove this
* config
*/
TEMPORARY__classifierPathMapping?: ClassifierPathMapping[] | undefined;
TEMPORARY__subtypeInfo?: SubtypeInfo | undefined;
}
export interface GraphBuilderOptions {
/**
* This flag will be kept until we have full support for section index
* See https://github.com/finos/legend-studio/issues/1067
*/
TEMPORARY__preserveSectionIndex?: boolean;
/**
* If strict mode is enabled, certain validations, which, in normal mode, are often considered as warnings or non-problems,
* will be treated as error and will be thrown. This is to compensate for discrepancies in strictness between engine compilation
* and graph builder algorithm. Ideally, a lot of these errors will eventually be treated as errors by engine compilation.
*
* See https://github.com/finos/legend-studio/issues/941
*/
strict?: boolean;
/**
* This ties a graph to an sdlc pointer. Meaning the graph is immutable and tied to a specific `versioned` SDLC.
*/
origin?: GraphDataOrigin | undefined;
}
export interface ExecutionOptions {
/**
* Use lossless algorithm while parsing the execution result object.
* NOTE: This will result in numeric values being stored as object instead of primitive type number values.
*/
useLosslessParse?: boolean | undefined;
convertUnsafeNumbersToString?: boolean | undefined;
serializationFormat?: EXECUTION_SERIALIZATION_FORMAT | undefined;
parameterValues?: ParameterValue[];
abortController?: AbortController | undefined;
preservedResponseHeadersList?: string[];
tracingtags?: PlainObject | undefined;
}
export interface ServiceRegistrationOptions {
TEMPORARY__useStoreModel?: boolean | undefined;
TEMPORARY__semiInteractiveOverridePattern?: string | undefined;
TEMPORARY__useGenerateLineage?: boolean | undefined;
TEMPORARY__useGenerateOpenApi?: boolean | undefined;
}
export declare abstract class AbstractPureGraphManagerExtension {
graphManager: AbstractPureGraphManager;
constructor(graphManager: AbstractPureGraphManager);
abstract getSupportedProtocolVersion(): string;
}
export declare abstract class AbstractPureGraphManager {
readonly extensions: AbstractPureGraphManagerExtension[];
readonly pluginManager: GraphManagerPluginManager;
readonly logService: LogService;
constructor(pluginManager: GraphManagerPluginManager, logService: LogService);
/**
* TODO: we should not expose a fixed config like this, we probably
* should not mention anything about engine because it is an internal construct
* used by the graph manager, different graph manager may not need engine.
*
* As such, we should expose a generic config instead.
* See https://github.com/finos/legend-studio/issues/407
*/
abstract TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig;
abstract initialize(config: TEMPORARY__EngineSetupConfig, options?: {
tracerService?: TracerService | undefined;
disableGraphConfiguration?: boolean | undefined;
}): Promise<void>;
abstract getSupportedProtocolVersion(): string;
/**
* Removes the SectionIndex from the list of enitites
*/
abstract getElementEntities(entities: Entity[]): Entity[];
/**
* Build immutable system models
*
* NOTE: Ideally should only be build once since the elements will never change in these models
* System models MUST not depend on the main model, dependency models, nor generation models.
*/
abstract buildSystem(coreModel: CoreModel, systemModel: SystemModel, buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
/**
* Build immutable models which holds dependencies.
* Dependency models MUST not depend on the main model.
*
* NOTE: loading all dependencies in the graph like this can be costly and definitely not scalable, so we might need to modify this in the future
* As such, we might want to compress the dependency models to a smaller shape (or this could be done in the server) and only maintain that
* so the app can use less memory
*/
abstract buildDependencies(coreModel: CoreModel, systemModel: SystemModel, dependencyManager: DependencyManager, dependencyEntitiesIndex: Map<string, EntitiesWithOrigin>, buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
/**
* Process entities and build the main graph.
*/
abstract buildGraph(graph: PureModel, entities: Entity[], buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
/**
* Process entities and build the light graph.
*/
abstract buildLightGraph(graph: PureModel, entities: Entity[], buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
abstract buildGenerations(graph: PureModel, generationEntities: Map<string, Entity[]>, buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
abstract graphToPureCode(graph: PureModel, options?: {
pretty?: boolean | undefined;
excludeUnknown?: boolean | undefined;
}): Promise<string>;
abstract pureCodeToEntities(code: string, options?: {
sourceInformationIndex?: Map<string, SourceInformation>;
TEMPORARY__keepSectionIndex?: boolean;
}): Promise<Entity[]>;
abstract entitiesToPureCode(entities: Entity[], options?: {
pretty?: boolean | undefined;
}): Promise<string>;
abstract pureCodeToLambda(lambda: string, lambdaId?: string, options?: {
pruneSourceInformation?: boolean;
}): Promise<RawLambda>;
abstract prettyLambdaContent(lambda: string): Promise<string>;
abstract lambdaToPureCode(lambda: RawLambda, pretty?: boolean): Promise<string>;
abstract lambdasToPureCode(lambdas: Map<string, RawLambda>, pretty?: boolean): Promise<Map<string, string>>;
abstract valueSpecificationsToPureCode(lambdas: Map<string, ValueSpecification>, pretty?: boolean): Promise<Map<string, string>>;
abstract valueSpecificationToPureCode(valSpec: PlainObject<ValueSpecification>, pretty?: boolean): Promise<string>;
abstract pureCodeToValueSpecification(valSpec: string, returnSourceInformation?: boolean): Promise<PlainObject<ValueSpecification>>;
abstract pureCodeToValueSpecifications(lambdas: Map<string, string>, graph: PureModel): Promise<Map<string, ValueSpecification>>;
abstract pureCodeToRelationalOperationElement(operation: string, operationId: string): Promise<RawRelationalOperationElement>;
abstract relationalOperationElementToPureCode(operations: Map<string, RawRelationalOperationElement>): Promise<Map<string, string>>;
abstract compileEntities(entities: Entity[]): Promise<void>;
abstract compileGraph(graph: PureModel, options?: {
onError?: () => void;
keepSourceInformation?: boolean;
}, report?: GraphManagerOperationReport): Promise<CompilationResult>;
abstract compileText(graphGrammar: string, graph: PureModel, options?: {
onError?: () => void;
}, report?: GraphManagerOperationReport): Promise<TextCompilationResult>;
abstract getLambdaReturnType(lambda: RawLambda, graph: PureModel, options?: {
keepSourceInformation?: boolean;
}): Promise<string>;
abstract getLambdaRelationType(lambda: RawLambda, graph: PureModel, options?: {
keepSourceInformation?: boolean;
}): Promise<RelationTypeMetadata>;
abstract getCodeComplete(codeBlock: string, graph: PureModel, offset: number | undefined, options?: {
ignoreElements: string[] | undefined;
}): Promise<CodeCompletionResult>;
abstract getLambdasReturnType(lambdas: Map<string, RawLambda>, graph: PureModel): Promise<{
results: Map<string, string>;
errors: Map<string, EngineError>;
}>;
abstract createSandboxProject(): Promise<{
projectId: string;
webUrl: string | undefined;
owner: string;
}>;
abstract userHasPrototypeProjectAccess(userId: string): Promise<boolean>;
abstract runTests(inputs: RunTestsTestableInput[], graph: PureModel): Promise<TestResult[]>;
abstract debugTests(inputs: RunTestsTestableInput[], graph: PureModel): Promise<TestDebug[]>;
abstract buildValueSpecification(json: PlainObject, graph: PureModel): ValueSpecification;
abstract serializeValueSpecification(valueSpecification: ValueSpecification): PlainObject;
abstract transformValueSpecToRawValueSpec(valueSpecification: ValueSpecification, graph: PureModel): RawValueSpecification;
abstract buildRawValueSpecification(valuSpec: object, graph: PureModel): RawValueSpecification;
abstract serializeRawValueSpecification(rawValueSpecification: RawValueSpecification): PlainObject;
abstract createGetAllRawLambda(_class: Class): RawLambda;
abstract createDefaultBasicRawLambda(options?: {
addDummyParameter?: boolean;
}): RawLambda;
abstract getAvailableGenerationConfigurationDescriptions(): Promise<GenerationConfigurationDescription[]>;
abstract generateArtifacts(graph: PureModel, graphOptions?: GraphTextInputOption): Promise<ArtifactGenerationExtensionResult>;
abstract generateFile(fileGeneration: FileGenerationSpecification, generationMode: GenerationMode, graph: PureModel, graphOptions?: GraphTextInputOption): Promise<GenerationOutput[]>;
abstract generateModel(generationElement: PackageableElement, graph: PureModel, graphOptions?: GraphTextInputOption): Promise<Entity[]>;
abstract generateTestData(query: RawLambda, mapping: string, runtime: string, graph: PureModel): Promise<TestDataGenerationResult>;
abstract getAvailableExternalFormatsDescriptions(): Promise<ExternalFormatDescription[]>;
abstract generateModelFromExternalFormat(schemaSet: SchemaSet, targetBinding: string | undefined, configs: ConfigurationProperty[], graph: PureModel): Promise<string>;
abstract generateSchemaFromExternalFormatConfig(modelUnit: ModelUnit, targetBinding: string | undefined, configurationProperties: ConfigurationProperty[], graph: PureModel): Promise<SchemaSet[]>;
abstract getExamplePureProtocolText(): string;
abstract getExampleExternalFormatImportText(): string;
abstract entitiesToPureProtocolText(entities: Entity[]): Promise<string>;
abstract pureProtocolTextToEntities(protocol: string): Entity[];
abstract runQuery(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, options?: ExecutionOptions, report?: GraphManagerOperationReport): Promise<ExecutionResultWithMetadata>;
abstract runQueryWithUncompiledGraph(lambda: RawLambda | string, mapping: string | undefined, runtime: string | undefined, graph: PureModel, options?: ExecutionOptions, report?: GraphManagerOperationReport): Promise<ExecutionResultWithMetadata>;
abstract exportData(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, options?: ExecutionOptions | undefined, report?: GraphManagerOperationReport | undefined, contentType?: ContentType | undefined): Promise<Response>;
abstract cancelUserExecutions(broadcastToCluster: boolean): Promise<string>;
abstract DEPRECATED__runLegacyMappingTests(tests: {
test: DEPRECATED__MappingTest;
runtime: Runtime;
handleResult: (val: ExecutionResult) => void;
handleError: (message: Error) => void;
}[], mapping: Mapping, graph: PureModel, options?: ExecutionOptions, _report?: GraphManagerOperationReport): Promise<void>;
abstract generateExecutionPlan(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, report?: GraphManagerOperationReport): Promise<RawExecutionPlan>;
abstract debugExecutionPlanGeneration(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, report?: GraphManagerOperationReport): Promise<{
plan: RawExecutionPlan;
debug: string;
}>;
abstract generateExecuteTestData(lambda: RawLambda, parameters: (string | number | boolean)[], mapping: Mapping, runtime: Runtime, graph: PureModel, options?: {
anonymizeGeneratedData?: boolean;
parameterValues?: ParameterValue[];
}, report?: GraphManagerOperationReport): Promise<string>;
abstract generateExecuteTestDataWithSeedData(lambda: RawLambda, tableRowIdentifiers: TableRowIdentifiers[], mapping: Mapping, runtime: Runtime, graph: PureModel, options?: {
anonymizeGeneratedData?: boolean;
parameterValues?: ParameterValue[];
}, report?: GraphManagerOperationReport): Promise<string>;
abstract buildExecutionPlan(executionPlanJson: RawExecutionPlan, graph: PureModel): ExecutionPlan;
abstract serializeExecutionPlan(executionPlan: ExecutionPlan): RawExecutionPlan;
abstract serializeExecutionNode(executionNode: ExecutionNode): object;
abstract analyzeExecuteInput(data: PlainObject, executablePath: string): Promise<{
origin: GraphDataOrigin;
entities: Entity[];
}>;
abstract searchQueries(searchSpecification: QuerySearchSpecification): Promise<LightQuery[]>;
abstract getQueries(queryIds: string[]): Promise<LightQuery[]>;
abstract getLightQuery(queryId: string): Promise<LightQuery>;
abstract getQuery(queryId: string, graph: PureModel): Promise<Query>;
abstract getQueryInfo(queryId: string): Promise<QueryInfo>;
abstract createQuery(query: Query, graph: PureModel): Promise<Query>;
abstract updateQuery(query: Query, graph: PureModel): Promise<Query>;
abstract patchQuery(query: Partial<Query>, graph: PureModel): Promise<Query>;
abstract renameQuery(queryId: string, queryName: string): Promise<LightQuery>;
abstract deleteQuery(queryId: string): Promise<void>;
abstract productionizeQueryToServiceEntity(query: QueryInfo, serviceConfig: {
name: string;
packageName: string;
pattern: string;
serviceOwners: string[];
}, graph: Entity[]): Promise<Entity>;
abstract resolveQueryInfoExecutionContext(query: QueryInfo, graphLoader: () => Promise<PlainObject<Entity>[]>): Promise<{
mapping: string | undefined;
runtime: string;
}>;
abstract searchDataCubes(searchSpecification: QuerySearchSpecification): Promise<LightPersistentDataCube[]>;
abstract getDataCubes(ids: string[]): Promise<LightPersistentDataCube[]>;
abstract getDataCube(id: string): Promise<PersistentDataCube>;
abstract createDataCube(dataCube: PersistentDataCube): Promise<PersistentDataCube>;
abstract updateDataCube(dataCube: PersistentDataCube): Promise<PersistentDataCube>;
abstract deleteDataCube(id: string): Promise<void>;
abstract analyzeMappingModelCoverage(mapping: Mapping, graph: PureModel): Promise<MappingModelCoverageAnalysisResult>;
abstract buildMappingModelCoverageAnalysisResult(input: RawMappingModelCoverageAnalysisResult, mapping: Mapping): MappingModelCoverageAnalysisResult;
abstract surveyDatasets(mapping: string, runtime: string, query: RawLambda | undefined, graphData: GraphData): Promise<DatasetSpecification[]>;
abstract checkDatasetEntitlements(datasets: DatasetSpecification[], mapping: string, runtime: string, query: RawLambda | undefined, graphData: GraphData): Promise<DatasetEntitlementReport[]>;
/**
* TODO: Move these to store relational extension
*
* @modularize
* See https://github.com/finos/legend-studio/issues/65
*/
abstract buildDatabase(input: DatabaseBuilderInput): Promise<Entity[]>;
abstract executeRawSQL(connection: RelationalDatabaseConnection, sql: string): Promise<string>;
abstract getAvailableFunctionActivatorConfigurations(coreModel: CoreModel, systemModel: SystemModel): Promise<FunctionActivatorConfiguration[]>;
abstract validateFunctionActivator(functionActivator: FunctionActivator, graphData: GraphData): Promise<void>;
abstract publishFunctionActivatorToSandbox(functionActivator: FunctionActivator, graphData: GraphData): Promise<DeploymentResult>;
abstract generateModelsFromDatabaseSpecification(databasePath: string, targetPackage: undefined | string, graph: PureModel): Promise<Entity[]>;
abstract getAvailableRelationalDatabaseTypeConfigurations(): Promise<RelationalDatabaseTypeConfiguration[] | undefined>;
/**
* @modularize
* See https://github.com/finos/legend-studio/issues/65
*/
abstract registerService(service: Service, graph: PureModel, groupId: string, artifactId: string, version: string | undefined, server: string, executionMode: ServiceExecutionMode, options?: ServiceRegistrationOptions): Promise<ServiceRegistrationSuccess>;
abstract bulkServiceRegistration(service: Service[], graph: PureModel, groupId: string, artifactId: string, version: string | undefined, server: string, executionMode: ServiceExecutionMode, options?: ServiceRegistrationOptions): Promise<ServiceRegistrationResult[]>;
abstract activateService(serviceUrl: string, serviceId: string): Promise<void>;
abstract runServicePostValidations(service: Service, graph: PureModel, assertionId: string): Promise<PostValidationAssertionResult>;
abstract buildHashesIndex(entities: Entity[]): Promise<Map<string, string>>;
abstract elementToEntity(element: PackageableElement, options?: {
pruneSourceInformation?: boolean;
}): Entity;
abstract elementsToPureCode(elements: PackageableElement[], options?: {
pruneSourceInformation?: boolean;
}): Promise<string>;
createBasicGraph(options?: {
initializeSystem?: boolean;
}): Promise<PureModel>;
createDependencyManager(): DependencyManager;
createGenerationModel(): GenerationModel;
/**
* Check if a mapping element is an instance set implementation
*
* NOTE: This would account for embedded property mappings as well
* these are technically instance of `InstanceSetImplementation`
* but since unlike Pure, Typescript cannot do multiple inheritance
* we only can make embedded property mapping extends `PropertyMapping`
*
* Potentially, we might need to apply an extension mechanism on this
*/
isInstanceSetImplementation(setImplementation: EnumerationMapping | SetImplementation | AssociationImplementation): setImplementation is InstanceSetImplementation;
/**
* Filter the list of system elements that will be shown in selection options
* to users. This is helpful to avoid overwhelming and confusing users in form
* mode since many system elements are needed to build the graph, but should
* not present at all as selection options in form mode.
*/
collectExposedSystemElements<T extends PackageableElement>(systemElements: T[]): T[];
}
//# sourceMappingURL=AbstractPureGraphManager.d.ts.map