@finos/legend-graph 28.1.8 → 29.0.1

package/src/graph/metamodel/pure/packageableElements/mapping/INTERNAL__UnknownSetImplementation.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 {
+  hashArray,
+  type Hashable,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  SetImplementation,
+  type SetImplementationVisitor,
+} from './SetImplementation.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../Core_HashUtils.js';
+
+export class INTERNAL__UnknownSetImplementation
+  extends SetImplementation
+  implements Hashable
+{
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_CLASS_MAPPING,
+      this.id.valueForSerialization ?? '',
+      this.class.valueForSerialization ?? '',
+      this.root.valueForSerialization.toString(),
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+
+  accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
+    return visitor.visit_INTERNAL__UnknownSetImplementation(this);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/mapping/PropertyMapping.ts

@@ -30,9 +30,14 @@ import type { AggregationAwarePropertyMapping } from './aggregationAware/Aggrega
 import type { XStorePropertyMapping } from './xStore/XStorePropertyMapping.js';
 import type { LocalMappingPropertyInfo } from './LocalMappingPropertyInfo.js';
 import type { SetImplementationReference } from './SetImplementationReference.js';
+import type { INTERNAL__UnknownPropertyMapping } from './INTERNAL__UnknownPropertyMapping.js';
 
 export interface PropertyMappingVisitor<T> {
   visit_PropertyMapping(propertyMapping: PropertyMapping): T;
+  visit_INTERNAL__UnknownPropertyMapping(
+    propertyMapping: INTERNAL__UnknownPropertyMapping,
+  ): T;
+
   visit_PurePropertyMapping(propertyMapping: PurePropertyMapping): T;
   visit_FlatDataAssociationPropertyMapping(
     propertyMapping: FlatDataAssociationPropertyMapping,
@@ -88,7 +93,6 @@ export abstract class PropertyMapping implements Hashable {
   sourceSetImplementation: SetImplementationReference;
   targetSetImplementation?: SetImplementationReference | undefined;
   localMappingProperty?: LocalMappingPropertyInfo | undefined;
-  // store?: Store | undefined;
 
   constructor(
     owner: PropertyMappingsImplementation,

package/src/graph/metamodel/pure/packageableElements/mapping/SetImplementation.ts

@@ -32,9 +32,14 @@ import type { InstanceSetImplementation } from './InstanceSetImplementation.js';
 import type { MergeOperationSetImplementation } from './MergeOperationSetImplementation.js';
 import type { TEMPORARY__UnresolvedSetImplementation } from './TEMPORARY__UnresolvedSetImplementation.js';
 import type { Class } from '../domain/Class.js';
+import type { INTERNAL__UnknownSetImplementation } from './INTERNAL__UnknownSetImplementation.js';
 
 export interface SetImplementationVisitor<T> {
   visit_SetImplementation(setImplementation: InstanceSetImplementation): T;
+  visit_INTERNAL__UnknownSetImplementation(
+    setImplementation: INTERNAL__UnknownSetImplementation,
+  ): T;
+
   visit_MergeOperationSetImplementation(
     setImplementation: MergeOperationSetImplementation,
   ): T;

package/src/graph/metamodel/pure/packageableElements/mapping/TEMPORARY__UnresolvedSetImplementation.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { Class } from '../domain/Class.js';
+import { INTERNAL__PseudoClass } from '../domain/INTERNAL__PseudoClass.js';
 import { PackageableElementExplicitReference } from '../PackageableElementReference.js';
 import { InferableMappingElementIdExplicitValue } from './InferableMappingElementId.js';
 import { InferableMappingElementRootExplicitValue } from './InferableMappingElementRoot.js';
@@ -40,7 +40,9 @@ export class TEMPORARY__UnresolvedSetImplementation extends SetImplementation {
     super(
       InferableMappingElementIdExplicitValue.create(id, ''),
       parent,
-      PackageableElementExplicitReference.create(new Class('')),
+      PackageableElementExplicitReference.create(
+        INTERNAL__PseudoClass.INSTANCE,
+      ),
       InferableMappingElementRootExplicitValue.create(false),
     );
   }

package/src/graph/metamodel/pure/packageableElements/store/INTERNAL__PseudoStore.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { UnsupportedOperationError } from '@finos/legend-shared';
+import { Store } from './Store.js';
+import type { PackageableElementVisitor } from '../PackageableElement.js';
+
+export class INTERNAL__PseudoStore extends Store {
+  static readonly NAME = 'INTERNAL__PseudoStore';
+  static readonly INSTANCE = new INTERNAL__PseudoStore();
+
+  private constructor() {
+    super(INTERNAL__PseudoStore.NAME);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    throw new UnsupportedOperationError();
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/INTERNAL__UnknownAuthenticationStrategy.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+  hashArray,
+  type Hashable,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { AuthenticationStrategy } from './AuthenticationStrategy.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../Core_HashUtils.js';
+
+export class INTERNAL__UnknownAuthenticationStrategy
+  extends AuthenticationStrategy
+  implements Hashable
+{
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_AUTHENTICATION_STRATEGY,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/INTERNAL__UnknownDatasourceSpecification.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+  hashArray,
+  type Hashable,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { DatasourceSpecification } from './DatasourceSpecification.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../Core_HashUtils.js';
+
+export class INTERNAL__UnknownDatasourceSpecification
+  extends DatasourceSpecification
+  implements Hashable
+{
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_DATASOURCE_SPECIFICATION,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/RelationalDatabaseConnection.ts

@@ -61,15 +61,12 @@ export abstract class DatabaseConnection extends Connection {
    *
    * @discrepancy model
    */
-  type: DatabaseType;
+  type: string;
   timeZone?: string | undefined;
   quoteIdentifiers?: boolean | undefined;
   postProcessorWithParameter: unknown[] = [];
 
-  constructor(
-    store: PackageableElementReference<Database>,
-    type: DatabaseType,
-  ) {
+  constructor(store: PackageableElementReference<Database>, type: string) {
     super(store);
     this.type = type;
   }
@@ -82,7 +79,7 @@ export class RelationalDatabaseConnection extends DatabaseConnection {
 
   constructor(
     store: PackageableElementReference<Database>,
-    type: DatabaseType,
+    type: string,
     datasourceSpecification: DatasourceSpecification,
     authenticationStrategy: AuthenticationStrategy,
   ) {

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/postprocessor/INTERNAL__UnknownPostProcessor.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+  hashArray,
+  type Hashable,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { PostProcessor } from './PostProcessor.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../../../../Core_HashUtils.js';
+
+export class INTERNAL__UnknownPostProcessor
+  extends PostProcessor
+  implements Hashable
+{
+  content!: PlainObject;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_POST_PROCESSOR,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/valueSpecification/INTERNAL__PropagatedValue.ts

@@ -45,7 +45,7 @@ export class INTERNAL__PropagatedValue
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.INTERNAL_PROPAGATED_VALUE,
+      CORE_HASH_STRUCTURE.INTERNAL__PROPAGATED_VALUE,
       this.genericType?.ownerReference.valueForSerialization ?? '',
       this.multiplicity,
     ]);

package/src/graph/metamodel/pure/valueSpecification/INTERNAL__UnknownValueSpecification.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import { type Hashable, hashArray } from '@finos/legend-shared';
+import {
+  type Hashable,
+  hashArray,
+  type PlainObject,
+} from '@finos/legend-shared';
 import {
   CORE_HASH_STRUCTURE,
   hashObjectWithoutSourceInformation,
@@ -35,9 +39,9 @@ export class INTERNAL__UnknownValueSpecification
   extends ValueSpecification
   implements Hashable
 {
-  readonly content: object;
+  readonly content: PlainObject;
 
-  constructor(content: object) {
+  constructor(content: PlainObject) {
     super(Multiplicity.ZERO);
 
     this.content = content;
@@ -45,7 +49,7 @@ export class INTERNAL__UnknownValueSpecification
 
   get hashCode(): string {
     return hashArray([
-      CORE_HASH_STRUCTURE.INTERNAL_UNKNOWN_VALUE_SPECIFICATION,
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_VALUE_SPECIFICATION,
       hashObjectWithoutSourceInformation(this.content),
       this.genericType?.ownerReference.valueForSerialization ?? '',
     ]);

package/src/graph-manager/AbstractPureGraphManager.ts

@@ -96,6 +96,8 @@ import type { AssociationImplementation } from '../graph/metamodel/pure/packagea
 import { InstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/InstanceSetImplementation.js';
 import { EmbeddedFlatDataPropertyMapping } from '../graph/metamodel/pure/packageableElements/store/flatData/mapping/EmbeddedFlatDataPropertyMapping.js';
 import { EmbeddedRelationalInstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/store/relational/mapping/EmbeddedRelationalInstanceSetImplementation.js';
+import type { SourceInformation } from './action/SourceInformation.js';
+import type { ClassifierPathMapping } from './action/protocol/ClassifierPathMapping.js';
 
 export interface TEMPORARY__EngineSetupConfig {
   env: string;
@@ -103,6 +105,13 @@ export interface TEMPORARY__EngineSetupConfig {
   clientConfig: ServerClientConfig & {
     queryBaseUrl?: string | undefined;
   };
+  /**
+   * This is a workaround we need to manually supply the classifier path mapping
+   * 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;
 }
 
 export interface GraphBuilderOptions {
@@ -265,14 +274,21 @@ export abstract class AbstractPureGraphManager {
 
   // ------------------------------------------- Grammar -------------------------------------------
 
-  abstract graphToPureCode(graph: PureModel): Promise<string>;
+  abstract graphToPureCode(
+    graph: PureModel,
+    options?: { pretty?: boolean | undefined },
+  ): Promise<string>;
   abstract pureCodeToEntities(
     code: string,
     options?: {
+      sourceInformationIndex?: Map<string, SourceInformation>;
       TEMPORARY__keepSectionIndex?: boolean;
     },
   ): Promise<Entity[]>;
-  abstract entitiesToPureCode(entities: Entity[]): Promise<string>;
+  abstract entitiesToPureCode(
+    entities: Entity[],
+    options?: { pretty?: boolean | undefined },
+  ): Promise<string>;
   abstract pureCodeToLambda(
     lambda: string,
     lambdaId?: string,
@@ -414,6 +430,8 @@ export abstract class AbstractPureGraphManager {
     report?: GraphManagerOperationReport,
   ): Promise<ExecutionResult>;
 
+  abstract cancelUserExecutions(broadcastToCluster: boolean): Promise<string>;
+
   abstract DEPRECATED__runLegacyMappingTests(
     tests: {
       test: DEPRECATED__MappingTest;

package/src/graph-manager/action/changeDetection/CoreObserverHelper.ts

@@ -25,6 +25,7 @@ import type { PackageableElement } from '../../../graph/metamodel/pure/packageab
 import type { PackageableElementReference } from '../../../graph/metamodel/pure/packageableElements/PackageableElementReference.js';
 import type { InferableValue } from '../../../graph/metamodel/pure/InferableValue.js';
 import type { PureGraphManagerPlugin } from '../../PureGraphManagerPlugin.js';
+import type { INTERNAL__UnknownPackageableElement } from '../../../graph/metamodel/pure/packageableElements/INTERNAL__UnknownPackageableElement.js';
 
 export class ObserverContext {
   plugins: PureGraphManagerPlugin[] = [];
@@ -66,6 +67,20 @@ export const observe_Abstract_PackageableElement = (
   });
 };
 
+export const observe_INTERNAL__UnknownPackageableElement = skipObserved(
+  (
+    metamodel: INTERNAL__UnknownPackageableElement,
+  ): INTERNAL__UnknownPackageableElement => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable(metamodel, {
+      content: observable,
+    });
+
+    return metamodel;
+  },
+);
+
 export const observe_PackageableElementReference = skipObserved(
   <T extends PackageableElement>(
     metamodel: PackageableElementReference<T>,

package/src/graph-manager/action/changeDetection/DSL_Data_ObserverHelper.ts

@@ -37,6 +37,7 @@ import {
   observe_StereotypeReference,
   observe_TaggedValue,
 } from './DomainObserverHelper.js';
+import { INTERNAL__UnknownEmbeddedData } from '../../../graph/metamodel/pure/data/INTERNAL__UnknownEmbeddedData.js';
 
 export const observe_ExternalFormatData = skipObserved(
   (metamodel: ExternalFormatData): ExternalFormatData => {
@@ -95,11 +96,23 @@ const observe_RelationalCSVData = skipObserved(
   },
 );
 
+export const observe_INTERNAL__UnknownEmbeddedData = skipObserved(
+  (metamodel: INTERNAL__UnknownEmbeddedData): INTERNAL__UnknownEmbeddedData => {
+    makeObservable(metamodel, {
+      content: observable,
+    });
+
+    return metamodel;
+  },
+);
+
 export function observe_EmbeddedData(
   metamodel: EmbeddedData,
   context: ObserverContext,
 ): EmbeddedData {
-  if (metamodel instanceof DataElementReference) {
+  if (metamodel instanceof INTERNAL__UnknownEmbeddedData) {
+    return observe_INTERNAL__UnknownEmbeddedData(metamodel);
+  } else if (metamodel instanceof DataElementReference) {
     return observe_DataElementReference(metamodel);
   } else if (metamodel instanceof ExternalFormatData) {
     return observe_ExternalFormatData(metamodel);

package/src/graph-manager/action/changeDetection/DSL_Mapping_ObserverHelper.ts

@@ -136,6 +136,9 @@ import {
 import type { StoreTestData } from '../../../graph/metamodel/pure/packageableElements/mapping/MappingStoreTestData.js';
 import { observe_EmbeddedData } from './DSL_Data_ObserverHelper.js';
 import { UnsupportedOperationError } from '@finos/legend-shared';
+import type { INTERNAL__UnknownConnection } from '../../../graph/metamodel/pure/packageableElements/connection/INTERNAL__UnknownConnection.js';
+import type { INTERNAL__UnknownPropertyMapping } from '../../../graph/metamodel/pure/packageableElements/mapping/INTERNAL__UnknownPropertyMapping.js';
+import type { INTERNAL__UnknownSetImplementation } from '../../../graph/metamodel/pure/packageableElements/mapping/INTERNAL__UnknownSetImplementation.js';
 
 // ------------------------------------- Store -------------------------------------
 
@@ -341,6 +344,15 @@ export const observe_PurePropertyMapping = skipObservedWithContext(
   },
 );
 
+const observe_INTERNAL__UnknownPropertyMapping = skipObserved(
+  (
+    metamodel: INTERNAL__UnknownPropertyMapping,
+  ): INTERNAL__UnknownPropertyMapping =>
+    makeObservable(metamodel, {
+      content: observable,
+    }),
+);
+
 class PropertyMappingObserver implements PropertyMappingVisitor<void> {
   observerContext: ObserverContext;
 
@@ -366,6 +378,12 @@ class PropertyMappingObserver implements PropertyMappingVisitor<void> {
     }
   }
 
+  visit_INTERNAL__UnknownPropertyMapping(
+    propertyMapping: INTERNAL__UnknownPropertyMapping,
+  ): void {
+    observe_INTERNAL__UnknownPropertyMapping(propertyMapping);
+  }
+
   visit_PurePropertyMapping(propertyMapping: PurePropertyMapping): void {
     observe_PurePropertyMapping(propertyMapping, this.observerContext);
   }
@@ -577,6 +595,20 @@ export const observe_PureInstanceSetImplementation = skipObservedWithContext(
   },
 );
 
+const observe_INTERNAL__UnknownSetImplementation = skipObserved(
+  (
+    metamodel: INTERNAL__UnknownSetImplementation,
+  ): INTERNAL__UnknownSetImplementation => {
+    observe_Abstract_SetImplementation(metamodel);
+
+    makeObservable(metamodel, {
+      content: observable,
+    });
+
+    return metamodel;
+  },
+);
+
 class SetImplementationObserver implements SetImplementationVisitor<void> {
   observerContext: ObserverContext;
 
@@ -602,6 +634,12 @@ class SetImplementationObserver implements SetImplementationVisitor<void> {
     }
   }
 
+  visit_INTERNAL__UnknownSetImplementation(
+    setImplementation: INTERNAL__UnknownSetImplementation,
+  ): void {
+    observe_INTERNAL__UnknownSetImplementation(setImplementation);
+  }
+
   visit_MergeOperationSetImplementation(
     setImplementation: MergeOperationSetImplementation,
   ): void {
@@ -944,6 +982,19 @@ export const observe_ModelChainConnection = skipObserved(
   },
 );
 
+const observe_INTERNAL__UnknownConnection = skipObserved(
+  (metamodel: INTERNAL__UnknownConnection): INTERNAL__UnknownConnection => {
+    observe_Abstract_Connection(metamodel);
+
+    makeObservable(metamodel, {
+      content: observable,
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
 class ConnectionObserver implements ConnectionVisitor<void> {
   observerContext: ObserverContext;
 
@@ -966,6 +1017,12 @@ class ConnectionObserver implements ConnectionVisitor<void> {
     }
   }
 
+  visit_INTERNAL__UnknownConnection(
+    connection: INTERNAL__UnknownConnection,
+  ): void {
+    observe_INTERNAL__UnknownConnection(connection);
+  }
+
   visit_ConnectionPointer(connection: ConnectionPointer): void {
     observe_ConnectionPointer(connection);
   }

package/src/graph-manager/action/changeDetection/GraphObserverHelper.ts

@@ -50,7 +50,8 @@ const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
     | 'generationSpecificationsIndex'
     | 'fileGenerationsIndex'
     | 'dataElementsIndex'
-    | 'executionEnvironmentIndex'
+    | 'executionEnvironmentsIndex'
+    | 'INTERNAL__unknownElementsIndex'
   >(metamodel, {
     elementSectionIndex: observable,
     extensions: observable,
@@ -68,7 +69,8 @@ const observe_Abstract_BasicModel = (metamodel: BasicModel): void => {
     generationSpecificationsIndex: observable,
     fileGenerationsIndex: observable,
     dataElementsIndex: observable,
-    executionEnvironmentIndex: observable,
+    executionEnvironmentsIndex: observable,
+    INTERNAL__unknownElementsIndex: observable,
 
     ownSectionIndices: computed,
     ownProfiles: computed,

package/src/graph-manager/action/changeDetection/PackageableElementObserver.ts

@@ -48,6 +48,7 @@ import {
 import {
   type ObserverContext,
   skipObservedWithContext,
+  observe_INTERNAL__UnknownPackageableElement,
 } from './CoreObserverHelper.js';
 import {
   observe_FileGenerationSpecification,
@@ -65,6 +66,7 @@ import type { DataElement } from '../../../graph/metamodel/pure/packageableEleme
 import { observe_DataElement } from './DSL_Data_ObserverHelper.js';
 import type { ExecutionEnvironmentInstance } from '../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
 import { observe_ExecutionEnvironmentInstance } from './DSL_ExecutionEnvironment_ObseverHelper.js';
+import type { INTERNAL__UnknownPackageableElement } from '../../../graph/metamodel/pure/packageableElements/INTERNAL__UnknownPackageableElement.js';
 
 class PackageableElementObserver implements PackageableElementVisitor<void> {
   observerContext: ObserverContext;
@@ -85,6 +87,12 @@ class PackageableElementObserver implements PackageableElementVisitor<void> {
     }
   }
 
+  visit_INTERNAL__UnknownPackageableElement(
+    element: INTERNAL__UnknownPackageableElement,
+  ): void {
+    observe_INTERNAL__UnknownPackageableElement(element);
+  }
+
   visit_Package(element: Package): void {
     observe_Package(element, this.observerContext);
   }