From bdf335f7db3f9cc7d835132029032dfa9fd6d832 Mon Sep 17 00:00:00 2001 From: Niko Date: Thu, 18 Dec 2025 22:27:05 +0100 Subject: [PATCH 1/7] Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. --- CHANGELOG.md | 1 + build/LionWeb-CSharp-Build/Generate.cs | 4 + .../TestLanguagesDefinitions.cs | 29 ++++++ .../Impl/DefinitionGenerator.cs | 2 +- .../Generated/V2023_1/ALang.g.cs | 18 ++-- .../Generated/V2023_1/BLang.g.cs | 18 ++-- .../Generated/V2023_1/Deprecated.g.cs | 18 ++-- .../Generated/V2023_1/GeneralNodeLang.g.cs | 18 ++-- .../Generated/V2023_1/MultiInheritLang.g.cs | 18 ++-- .../Generated/V2023_1/NamedLang.g.cs | 18 ++-- .../V2023_1/NamedReadInterfaces.g.cs | 18 ++-- .../V2023_1/NamespaceContainsLionWebLang.g.cs | 94 +++++++++++++++++++ .../NamespaceStartsWithLionWebLang.g.cs | 94 +++++++++++++++++++ .../NullableReferencesTestLanguage.g.cs | 22 ++--- .../Generated/V2023_1/Shapes.g.cs | 22 ++--- .../Generated/V2023_1/TestLanguage.g.cs | 22 ++--- .../Generated/V2023_1/TinyRefLang.g.cs | 18 ++-- .../Generated/V2023_1/WithEnum.g.cs | 18 ++-- .../Generated/V2023_1/library.g.cs | 18 ++-- .../Generated/V2023_1/multi.g.cs | 18 ++-- .../Generated/V2024_1/ALang.g.cs | 18 ++-- .../Generated/V2024_1/BLang.g.cs | 18 ++-- .../Generated/V2024_1/Deprecated.g.cs | 18 ++-- .../Generated/V2024_1/GeneralNodeLang.g.cs | 18 ++-- .../Generated/V2024_1/MYUpperCaseLang.g.cs | 18 ++-- .../V2024_1/MixedBaseConceptLang.g.cs | 18 ++-- .../V2024_1/MixedBaseContainmentLang.g.cs | 14 +-- .../V2024_1/MixedBasePropertyLang.g.cs | 14 +-- .../V2024_1/MixedBaseReferenceLang.g.cs | 14 +-- .../Generated/V2024_1/MixedConceptLang.g.cs | 14 +-- .../V2024_1/MixedDirectEnumLang.g.cs | 14 +-- .../Generated/V2024_1/MixedDirectSdtLang.g.cs | 14 +-- .../V2024_1/MixedNestedEnumLang.g.cs | 14 +-- .../Generated/V2024_1/MixedNestedSdtLang.g.cs | 14 +-- .../Generated/V2024_1/MultiInheritLang.g.cs | 18 ++-- .../Generated/V2024_1/NamedLang.g.cs | 18 ++-- .../V2024_1/NamedReadInterfaces.g.cs | 18 ++-- .../V2024_1/NamespaceContainsLionWebLang.g.cs | 94 +++++++++++++++++++ .../NamespaceStartsWithLionWebLang.g.cs | 94 +++++++++++++++++++ .../NullableReferencesTestLanguage.g.cs | 22 ++--- .../Generated/V2024_1/SDTLang.g.cs | 18 ++-- .../Generated/V2024_1/Shapes.g.cs | 22 ++--- .../Generated/V2024_1/TestLanguage.g.cs | 22 ++--- .../Generated/V2024_1/TinyRefLang.g.cs | 18 ++-- .../Generated/V2024_1/WithEnum.g.cs | 18 ++-- .../Generated/V2024_1/class.g.cs | 18 ++-- .../Generated/V2024_1/library.g.cs | 18 ++-- .../Generated/V2024_1/multi.g.cs | 18 ++-- .../Generated/V2024_1/myLowerCaseLang.g.cs | 18 ++-- .../Generated/V2025_1/ALang.g.cs | 18 ++-- .../Generated/V2025_1/BLang.g.cs | 18 ++-- .../Generated/V2025_1/Deprecated.g.cs | 18 ++-- .../Generated/V2025_1/GeneralNodeLang.g.cs | 18 ++-- .../Generated/V2025_1/MYUpperCaseLang.g.cs | 18 ++-- .../V2025_1/MixedBaseConceptLang.g.cs | 18 ++-- .../V2025_1/MixedBaseContainmentLang.g.cs | 14 +-- .../V2025_1/MixedBasePropertyLang.g.cs | 14 +-- .../V2025_1/MixedBaseReferenceLang.g.cs | 14 +-- .../Generated/V2025_1/MixedConceptLang.g.cs | 14 +-- .../V2025_1/MixedDirectEnumLang.g.cs | 14 +-- .../Generated/V2025_1/MixedDirectSdtLang.g.cs | 14 +-- .../V2025_1/MixedNestedEnumLang.g.cs | 14 +-- .../Generated/V2025_1/MixedNestedSdtLang.g.cs | 14 +-- .../Generated/V2025_1/MultiInheritLang.g.cs | 18 ++-- .../Generated/V2025_1/NamedLang.g.cs | 18 ++-- .../V2025_1/NamedReadInterfaces.g.cs | 18 ++-- .../V2025_1/NamespaceContainsLionWebLang.g.cs | 94 +++++++++++++++++++ .../NamespaceStartsWithLionWebLang.g.cs | 94 +++++++++++++++++++ .../NullableReferencesTestLanguage.g.cs | 22 ++--- .../Generated/V2025_1/SDTLang.g.cs | 18 ++-- .../Generated/V2025_1/Shapes.g.cs | 22 ++--- .../Generated/V2025_1/TestLanguage.g.cs | 22 ++--- .../Generated/V2025_1/TinyRefLang.g.cs | 18 ++-- .../Generated/V2025_1/WithEnum.g.cs | 18 ++-- .../Generated/V2025_1/class.g.cs | 18 ++-- .../Generated/V2025_1/library.g.cs | 18 ++-- .../Generated/V2025_1/multi.g.cs | 18 ++-- .../Generated/V2025_1/myLowerCaseLang.g.cs | 18 ++-- 78 files changed, 1197 insertions(+), 599 deletions(-) create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceContainsLionWebLang.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceStartsWithLionWebLang.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceContainsLionWebLang.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceStartsWithLionWebLang.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceContainsLionWebLang.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceStartsWithLionWebLang.g.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index 86ed80fd1..a616e7dc5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ and this project adheres _loosely_ to [Semantic Versioning](https://semver.org/s ## [0.4.0] - tbd ### Added +* Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. * `GeneratorFacade` now exposes `Correlations` property. This correlates LionWeb language elements to their corresponding C# syntax nodes. * Added the following check for a new node received via a delta event: If a delta event adds a new node, the node itself and its sub nodes have to be new (not present in the model) according to delta specification. If this is not the case, we warn the user by throwing an invalid notification exception. For the replacement logic, we allow replacing if a new node is a both existing and to be replaced node, we allow this because after replacement model is valid. * Moved `WebSocketServer` and `WebSocketClient` to separate project in core repo for reuse. diff --git a/build/LionWeb-CSharp-Build/Generate.cs b/build/LionWeb-CSharp-Build/Generate.cs index 86247d486..434eef47f 100644 --- a/build/LionWeb-CSharp-Build/Generate.cs +++ b/build/LionWeb-CSharp-Build/Generate.cs @@ -70,6 +70,8 @@ var generalNodeLang = testLanguagesDefinitions.GeneralNodeLang; var lowerCaseLang = testLanguagesDefinitions.LowerCaseLang; var upperCaseLang = testLanguagesDefinitions.UpperCaseLang; + var namespaceStartsWithLionWebLang = testLanguagesDefinitions.NamespaceStartsWithLionWebLang; + var namespaceContainsLionWebLang = testLanguagesDefinitions.NamespaceContainsLionWebLang; var lionWebVersionNamespace = "V" + lionWebVersion.VersionString.Replace('.', '_'); string prefix = $"LionWeb.Core.Test.Languages.Generated.{lionWebVersionNamespace}"; @@ -90,6 +92,8 @@ new(generalNodeLang, $"{prefix}.GeneralNodeLang"), new(testLanguage, $"{prefix}.TestLanguage"), new(nullableReferencesTestLanguage, $"{prefix}.NullableReferencesTestLang"), + new(namespaceStartsWithLionWebLang, $"LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang"), + new(namespaceContainsLionWebLang, $"io.LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang") // We don't really want these file in tests project, but update the version in Generator. // However, it's not worth writing a separate code path for this one language (as we want to externalize it anyways). // Step 3: Uncomment the line below diff --git a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs index 87de2e603..194e78521 100644 --- a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs +++ b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs @@ -38,6 +38,9 @@ public class TestLanguagesDefinitions public Language GeneralNodeLang { get; private set; } public Language? LowerCaseLang { get; private set; } public Language? UpperCaseLang { get; private set; } + public Language NamespaceStartsWithLionWebLang { get; private set; } + public Language NamespaceContainsLionWebLang { get; private set; } + public List MixedLangs { get; private set; } = []; public TestLanguagesDefinitions(LionWebVersions lionWebVersion) @@ -49,6 +52,8 @@ public TestLanguagesDefinitions(LionWebVersions lionWebVersion) CreateMultiInheritLang(); CreateNamedLang(); CreateGeneralNodeLang(); + CreateNamespaceStartsWithLionWebLang(); + CreateNamespaceContainsLionWebLang(); if (lionWebVersion.LionCore is ILionCoreLanguageWithStructuredDataType) { @@ -519,4 +524,28 @@ private void CreateUpperCaseLang() UpperCaseLang = casingLang; } + + private void CreateNamespaceStartsWithLionWebLang() + { + var lwLang = new DynamicLanguage("id-NamespaceStartsWithLionWebLang-lang", _lionWebVersion) + { + Name = "NamespaceStartsWithLionWebLang", Key = "key-NamespaceStartsWithLionWebLang", Version = "1" + }; + + lwLang.Concept("id-concept", "key-concept", "MYConcept"); + + NamespaceStartsWithLionWebLang = lwLang; + } + + private void CreateNamespaceContainsLionWebLang() + { + var lwLang = new DynamicLanguage("id-NamespaceContainsLionWebLang-lang", _lionWebVersion) + { + Name = "NamespaceContainsLionWebLang", Key = "key-NamespaceContainsLionWebLang", Version = "1" + }; + + lwLang.Concept("id-concept", "key-concept", "MYConcept"); + + NamespaceContainsLionWebLang = lwLang; + } } \ No newline at end of file diff --git a/src/LionWeb.Generator/Impl/DefinitionGenerator.cs b/src/LionWeb.Generator/Impl/DefinitionGenerator.cs index 00bd27156..8e65db50f 100644 --- a/src/LionWeb.Generator/Impl/DefinitionGenerator.cs +++ b/src/LionWeb.Generator/Impl/DefinitionGenerator.cs @@ -83,7 +83,7 @@ private UsingDirectiveSyntax[] CollectUsings() => .Prepend(_builtIns.GetType().Namespace) .Distinct() .Order() - .Select(n => UsingDirective(ParseName(n))) + .Select(n => UsingDirective(ParseName($"global::{n}"))) .Concat(PrimitiveTypesAsUsings()) .ToArray(); diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/ALang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/ALang.g.cs index 4d607064b..f38a9f835 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/ALang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/ALang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.Circular.A; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-ALang", Version = "1")] public partial class ALangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/BLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/BLang.g.cs index 3761bfee8..50c48ee4f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/BLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/BLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.Circular.B; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; /// bLang desc /// diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Deprecated.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Deprecated.g.cs index 710159b9f..3c419528a 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Deprecated.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Deprecated.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.DeprecatedLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using DeprDatatype = string; [LionCoreLanguage(Key = "MDkzNjAxODQtODU5OC00NGU3LTliZjUtZmIxY2U0NWE0ODBh", Version = "0")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/GeneralNodeLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/GeneralNodeLang.g.cs index 341fb7f63..77d5897af 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/GeneralNodeLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/GeneralNodeLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.GeneralNodeLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-GeneralNodeLang", Version = "1")] public partial class GeneralNodeLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/MultiInheritLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/MultiInheritLang.g.cs index f3c4e3d83..bb35f867f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/MultiInheritLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/MultiInheritLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.MultiInheritLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-MultiInheritLang", Version = "1")] public partial class MultiInheritLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedLang.g.cs index 5c7728590..b95462e16 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.NamedLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-NamedLang", Version = "1")] public partial class NamedLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedReadInterfaces.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedReadInterfaces.g.cs index f24aa6def..2dd0b7aa5 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedReadInterfaces.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamedReadInterfaces.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.NamedLangReadInterfaces; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-NamedLang", Version = "1")] public partial class NamedReadInterfacesLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceContainsLionWebLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceContainsLionWebLang.g.cs new file mode 100644 index 000000000..e9784e372 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceContainsLionWebLang.g.cs @@ -0,0 +1,94 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace io.LionWeb.Generated.V2023_1.namespaceStartsWithLionWebLang; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; + +[LionCoreLanguage(Key = "key-NamespaceContainsLionWebLang", Version = "1")] +public partial class NamespaceContainsLionWebLangLanguage : LanguageBase +{ + public static readonly NamespaceContainsLionWebLangLanguage Instance = new Lazy(() => new("id-NamespaceContainsLionWebLang-lang")).Value; + public NamespaceContainsLionWebLangLanguage(string id) : base(id, LionWebVersions.v2023_1) + { + _mYConcept = new(() => new ConceptBase("id-concept", this) { Key = "key-concept", Name = "MYConcept", Abstract = false, Partition = false }); + _factory = new NamespaceContainsLionWebLangFactory(this); + } + + /// + public override IReadOnlyList Entities => [MYConcept]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-NamespaceContainsLionWebLang"; + /// + public override string Key => _key; + + private const string _name = "NamespaceContainsLionWebLang"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _mYConcept; + public Concept MYConcept => _mYConcept.Value; +} + +public partial interface INamespaceContainsLionWebLangFactory : INodeFactory +{ + public MYConcept NewMYConcept(string id); + public MYConcept CreateMYConcept(); +} + +public class NamespaceContainsLionWebLangFactory : AbstractBaseNodeFactory, INamespaceContainsLionWebLangFactory +{ + private readonly NamespaceContainsLionWebLangLanguage _language; + public NamespaceContainsLionWebLangFactory(NamespaceContainsLionWebLangLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.MYConcept.EqualsIdentity(classifier)) + return NewMYConcept(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual MYConcept NewMYConcept(string id) => new(id); + public virtual MYConcept CreateMYConcept() => NewMYConcept(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(NamespaceContainsLionWebLangLanguage), Key = "key-concept")] +public partial class MYConcept : ConceptInstanceBase +{ + public MYConcept(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => NamespaceContainsLionWebLangLanguage.Instance.MYConcept; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceStartsWithLionWebLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceStartsWithLionWebLang.g.cs new file mode 100644 index 000000000..aacb802c1 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NamespaceStartsWithLionWebLang.g.cs @@ -0,0 +1,94 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Generated.V2023_1.namespaceStartsWithLionWebLang; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; + +[LionCoreLanguage(Key = "key-NamespaceStartsWithLionWebLang", Version = "1")] +public partial class NamespaceStartsWithLionWebLangLanguage : LanguageBase +{ + public static readonly NamespaceStartsWithLionWebLangLanguage Instance = new Lazy(() => new("id-NamespaceStartsWithLionWebLang-lang")).Value; + public NamespaceStartsWithLionWebLangLanguage(string id) : base(id, LionWebVersions.v2023_1) + { + _mYConcept = new(() => new ConceptBase("id-concept", this) { Key = "key-concept", Name = "MYConcept", Abstract = false, Partition = false }); + _factory = new NamespaceStartsWithLionWebLangFactory(this); + } + + /// + public override IReadOnlyList Entities => [MYConcept]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-NamespaceStartsWithLionWebLang"; + /// + public override string Key => _key; + + private const string _name = "NamespaceStartsWithLionWebLang"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _mYConcept; + public Concept MYConcept => _mYConcept.Value; +} + +public partial interface INamespaceStartsWithLionWebLangFactory : INodeFactory +{ + public MYConcept NewMYConcept(string id); + public MYConcept CreateMYConcept(); +} + +public class NamespaceStartsWithLionWebLangFactory : AbstractBaseNodeFactory, INamespaceStartsWithLionWebLangFactory +{ + private readonly NamespaceStartsWithLionWebLangLanguage _language; + public NamespaceStartsWithLionWebLangFactory(NamespaceStartsWithLionWebLangLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.MYConcept.EqualsIdentity(classifier)) + return NewMYConcept(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual MYConcept NewMYConcept(string id) => new(id); + public virtual MYConcept CreateMYConcept() => NewMYConcept(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(NamespaceStartsWithLionWebLangLanguage), Key = "key-concept")] +public partial class MYConcept : ConceptInstanceBase +{ + public MYConcept(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => NamespaceStartsWithLionWebLangLanguage.Instance.MYConcept; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NullableReferencesTestLanguage.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NullableReferencesTestLanguage.g.cs index 3e2efb494..58a227feb 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NullableReferencesTestLanguage.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/NullableReferencesTestLanguage.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.NullableReferencesTestLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "TestLanguage", Version = "0")] public partial class NullableReferencesTestLanguageLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Shapes.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Shapes.g.cs index f97f30ef4..572c94d7a 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Shapes.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/Shapes.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.Shapes.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using Time = string; [LionCoreLanguage(Key = "key-Shapes", Version = "1")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TestLanguage.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TestLanguage.g.cs index 1ca1c2ca0..965b0845d 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TestLanguage.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TestLanguage.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.TestLanguage; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "TestLanguage", Version = "0")] public partial class TestLanguageLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TinyRefLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TinyRefLang.g.cs index b184bba57..1fb09b729 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TinyRefLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/TinyRefLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.TinyRefLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-tinyRefLang", Version = "0")] public partial class TinyRefLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/WithEnum.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/WithEnum.g.cs index a18e0fe6d..183230a7b 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/WithEnum.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/WithEnum.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.WithEnum.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "WithEnum", Version = "1")] public partial class WithEnumLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/library.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/library.g.cs index 72978509e..02790f186 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/library.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/library.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.Library.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "library", Version = "1")] public partial class LibraryLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/multi.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/multi.g.cs index eccc086ab..ec0d63543 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/multi.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/multi.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2023_1.Multi.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2023_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "multi", Version = "1")] public partial class MultiLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/ALang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/ALang.g.cs index feb5eaa20..b14e9887f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/ALang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/ALang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Circular.A; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-ALang", Version = "1")] public partial class ALangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/BLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/BLang.g.cs index d459070e6..6f20c8bbb 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/BLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/BLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Circular.B; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; /// bLang desc /// diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Deprecated.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Deprecated.g.cs index 2884ead2f..480cba08a 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Deprecated.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Deprecated.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.DeprecatedLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using DeprDatatype = string; [LionCoreLanguage(Key = "MDkzNjAxODQtODU5OC00NGU3LTliZjUtZmIxY2U0NWE0ODBh", Version = "0")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/GeneralNodeLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/GeneralNodeLang.g.cs index b0bc1dbb8..c62832050 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/GeneralNodeLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/GeneralNodeLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.GeneralNodeLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-GeneralNodeLang", Version = "1")] public partial class GeneralNodeLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MYUpperCaseLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MYUpperCaseLang.g.cs index 0412445fa..a393d2bc4 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MYUpperCaseLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MYUpperCaseLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.MYUpperCaseLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-UpperCaseLang", Version = "1")] public partial class MYUpperCaseLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseConceptLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseConceptLang.g.cs index ee6eebac9..cc9f93848 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseConceptLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseConceptLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedBaseConceptLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-mixedBaseConceptLang", Version = "1")] public partial class MixedBaseConceptLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseContainmentLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseContainmentLang.g.cs index 2b0a23359..5749c050f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseContainmentLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseContainmentLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedBaseContainmentLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedBaseContainmentLang", Version = "1")] public partial class MixedBaseContainmentLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBasePropertyLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBasePropertyLang.g.cs index ae29dd8f7..f8c273565 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBasePropertyLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBasePropertyLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedBasePropertyLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedBasePropertyLang", Version = "1")] public partial class MixedBasePropertyLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseReferenceLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseReferenceLang.g.cs index 04f62aab7..029e35194 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseReferenceLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedBaseReferenceLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedBaseReferenceLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedBaseReferenceLang", Version = "1")] public partial class MixedBaseReferenceLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedConceptLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedConceptLang.g.cs index 1790a7892..98dcd473f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedConceptLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedConceptLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedConceptLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedConceptLang", Version = "1")] public partial class MixedConceptLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectEnumLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectEnumLang.g.cs index 982efb467..71ea44465 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectEnumLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectEnumLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedDirectEnumLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedDirectEnumLang", Version = "1")] public partial class MixedDirectEnumLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectSdtLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectSdtLang.g.cs index d1db21028..8edc71085 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectSdtLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedDirectSdtLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedDirectSdtLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedDirectSdtLang", Version = "1")] public partial class MixedDirectSdtLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedEnumLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedEnumLang.g.cs index d699726b0..a82d353f8 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedEnumLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedEnumLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedNestedEnumLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedNestedEnumLang", Version = "1")] public partial class MixedNestedEnumLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedSdtLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedSdtLang.g.cs index bcc98df94..1e7bbfff1 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedSdtLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MixedNestedSdtLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Mixed.MixedNestedSdtLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedNestedSdtLang", Version = "1")] public partial class MixedNestedSdtLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MultiInheritLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MultiInheritLang.g.cs index 24dc3bbc7..566abef13 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MultiInheritLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/MultiInheritLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.MultiInheritLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-MultiInheritLang", Version = "1")] public partial class MultiInheritLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedLang.g.cs index 84e0853c1..2d873141f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.NamedLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-NamedLang", Version = "1")] public partial class NamedLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedReadInterfaces.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedReadInterfaces.g.cs index 272daaee3..e42c289f0 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedReadInterfaces.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamedReadInterfaces.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.NamedLangReadInterfaces; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-NamedLang", Version = "1")] public partial class NamedReadInterfacesLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceContainsLionWebLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceContainsLionWebLang.g.cs new file mode 100644 index 000000000..ad9751d61 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceContainsLionWebLang.g.cs @@ -0,0 +1,94 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace io.LionWeb.Generated.V2024_1.namespaceStartsWithLionWebLang; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; + +[LionCoreLanguage(Key = "key-NamespaceContainsLionWebLang", Version = "1")] +public partial class NamespaceContainsLionWebLangLanguage : LanguageBase +{ + public static readonly NamespaceContainsLionWebLangLanguage Instance = new Lazy(() => new("id-NamespaceContainsLionWebLang-lang")).Value; + public NamespaceContainsLionWebLangLanguage(string id) : base(id, LionWebVersions.v2024_1) + { + _mYConcept = new(() => new ConceptBase("id-concept", this) { Key = "key-concept", Name = "MYConcept", Abstract = false, Partition = false }); + _factory = new NamespaceContainsLionWebLangFactory(this); + } + + /// + public override IReadOnlyList Entities => [MYConcept]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-NamespaceContainsLionWebLang"; + /// + public override string Key => _key; + + private const string _name = "NamespaceContainsLionWebLang"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _mYConcept; + public Concept MYConcept => _mYConcept.Value; +} + +public partial interface INamespaceContainsLionWebLangFactory : INodeFactory +{ + public MYConcept NewMYConcept(string id); + public MYConcept CreateMYConcept(); +} + +public class NamespaceContainsLionWebLangFactory : AbstractBaseNodeFactory, INamespaceContainsLionWebLangFactory +{ + private readonly NamespaceContainsLionWebLangLanguage _language; + public NamespaceContainsLionWebLangFactory(NamespaceContainsLionWebLangLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.MYConcept.EqualsIdentity(classifier)) + return NewMYConcept(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual MYConcept NewMYConcept(string id) => new(id); + public virtual MYConcept CreateMYConcept() => NewMYConcept(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(NamespaceContainsLionWebLangLanguage), Key = "key-concept")] +public partial class MYConcept : ConceptInstanceBase +{ + public MYConcept(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => NamespaceContainsLionWebLangLanguage.Instance.MYConcept; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceStartsWithLionWebLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceStartsWithLionWebLang.g.cs new file mode 100644 index 000000000..29a67ae64 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NamespaceStartsWithLionWebLang.g.cs @@ -0,0 +1,94 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Generated.V2024_1.namespaceStartsWithLionWebLang; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; + +[LionCoreLanguage(Key = "key-NamespaceStartsWithLionWebLang", Version = "1")] +public partial class NamespaceStartsWithLionWebLangLanguage : LanguageBase +{ + public static readonly NamespaceStartsWithLionWebLangLanguage Instance = new Lazy(() => new("id-NamespaceStartsWithLionWebLang-lang")).Value; + public NamespaceStartsWithLionWebLangLanguage(string id) : base(id, LionWebVersions.v2024_1) + { + _mYConcept = new(() => new ConceptBase("id-concept", this) { Key = "key-concept", Name = "MYConcept", Abstract = false, Partition = false }); + _factory = new NamespaceStartsWithLionWebLangFactory(this); + } + + /// + public override IReadOnlyList Entities => [MYConcept]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-NamespaceStartsWithLionWebLang"; + /// + public override string Key => _key; + + private const string _name = "NamespaceStartsWithLionWebLang"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _mYConcept; + public Concept MYConcept => _mYConcept.Value; +} + +public partial interface INamespaceStartsWithLionWebLangFactory : INodeFactory +{ + public MYConcept NewMYConcept(string id); + public MYConcept CreateMYConcept(); +} + +public class NamespaceStartsWithLionWebLangFactory : AbstractBaseNodeFactory, INamespaceStartsWithLionWebLangFactory +{ + private readonly NamespaceStartsWithLionWebLangLanguage _language; + public NamespaceStartsWithLionWebLangFactory(NamespaceStartsWithLionWebLangLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.MYConcept.EqualsIdentity(classifier)) + return NewMYConcept(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual MYConcept NewMYConcept(string id) => new(id); + public virtual MYConcept CreateMYConcept() => NewMYConcept(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(NamespaceStartsWithLionWebLangLanguage), Key = "key-concept")] +public partial class MYConcept : ConceptInstanceBase +{ + public MYConcept(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => NamespaceStartsWithLionWebLangLanguage.Instance.MYConcept; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NullableReferencesTestLanguage.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NullableReferencesTestLanguage.g.cs index ae5f50a8c..fcff5236e 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NullableReferencesTestLanguage.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/NullableReferencesTestLanguage.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.NullableReferencesTestLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "TestLanguage", Version = "0")] public partial class NullableReferencesTestLanguageLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/SDTLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/SDTLang.g.cs index d741476b9..641e32bf3 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/SDTLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/SDTLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.SDTLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-SDTLang", Version = "0")] public partial class SDTLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Shapes.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Shapes.g.cs index accccd716..457cd690c 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Shapes.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/Shapes.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Shapes.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using Time = string; [LionCoreLanguage(Key = "key-Shapes", Version = "1")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TestLanguage.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TestLanguage.g.cs index 11990f300..a0418ed32 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TestLanguage.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TestLanguage.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.TestLanguage; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "TestLanguage", Version = "0")] public partial class TestLanguageLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TinyRefLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TinyRefLang.g.cs index 185d90bf8..7943f4117 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TinyRefLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/TinyRefLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.TinyRefLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-tinyRefLang", Version = "0")] public partial class TinyRefLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/WithEnum.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/WithEnum.g.cs index d657ee296..6114e336a 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/WithEnum.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/WithEnum.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.WithEnum.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "WithEnum", Version = "1")] public partial class WithEnumLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/class.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/class.g.cs index 5e3888f68..876f63537 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/class.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/class.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace @namespace.@int.@public.V2024_1; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using @base = string; [LionCoreLanguage(Key = "class", Version = "struct")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/library.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/library.g.cs index 69fc99fd8..efed1ce4d 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/library.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/library.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Library.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "library", Version = "1")] public partial class LibraryLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/multi.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/multi.g.cs index d67ee8654..ee9b3e7bd 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/multi.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/multi.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.Multi.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "multi", Version = "1")] public partial class MultiLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/myLowerCaseLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/myLowerCaseLang.g.cs index 480f74e1f..31f5195f3 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/myLowerCaseLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/myLowerCaseLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2024_1.myLowerCaseLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2024_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-LowerCaseLang", Version = "1")] public partial class MyLowerCaseLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/ALang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/ALang.g.cs index df343dc1c..e0d73924d 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/ALang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/ALang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Circular.A; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-ALang", Version = "1")] public partial class ALangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/BLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/BLang.g.cs index 68927cb76..f9e2d8eb3 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/BLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/BLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Circular.B; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; /// bLang desc /// diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Deprecated.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Deprecated.g.cs index 386e72e65..fd3511443 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Deprecated.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Deprecated.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.DeprecatedLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using DeprDatatype = string; [LionCoreLanguage(Key = "MDkzNjAxODQtODU5OC00NGU3LTliZjUtZmIxY2U0NWE0ODBh", Version = "0")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/GeneralNodeLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/GeneralNodeLang.g.cs index 5482de852..be9fa5257 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/GeneralNodeLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/GeneralNodeLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.GeneralNodeLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-GeneralNodeLang", Version = "1")] public partial class GeneralNodeLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MYUpperCaseLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MYUpperCaseLang.g.cs index 87170650b..31b2b46ca 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MYUpperCaseLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MYUpperCaseLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.MYUpperCaseLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-UpperCaseLang", Version = "1")] public partial class MYUpperCaseLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseConceptLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseConceptLang.g.cs index 81125efbd..5d511d5d1 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseConceptLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseConceptLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedBaseConceptLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-mixedBaseConceptLang", Version = "1")] public partial class MixedBaseConceptLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseContainmentLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseContainmentLang.g.cs index e2f2fcc64..9f5226c26 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseContainmentLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseContainmentLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedBaseContainmentLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedBaseContainmentLang", Version = "1")] public partial class MixedBaseContainmentLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBasePropertyLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBasePropertyLang.g.cs index c73a9e399..e35c496dd 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBasePropertyLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBasePropertyLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedBasePropertyLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedBasePropertyLang", Version = "1")] public partial class MixedBasePropertyLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseReferenceLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseReferenceLang.g.cs index d26662a3d..adbb4061a 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseReferenceLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedBaseReferenceLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedBaseReferenceLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedBaseReferenceLang", Version = "1")] public partial class MixedBaseReferenceLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedConceptLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedConceptLang.g.cs index dc616b1b6..6a10badff 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedConceptLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedConceptLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedConceptLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedConceptLang", Version = "1")] public partial class MixedConceptLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectEnumLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectEnumLang.g.cs index 74184fddb..4f9aaa875 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectEnumLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectEnumLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedDirectEnumLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedDirectEnumLang", Version = "1")] public partial class MixedDirectEnumLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectSdtLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectSdtLang.g.cs index 08c1e28c1..bc96dd324 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectSdtLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedDirectSdtLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedDirectSdtLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedDirectSdtLang", Version = "1")] public partial class MixedDirectSdtLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedEnumLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedEnumLang.g.cs index 615055d78..09b7edac7 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedEnumLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedEnumLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedNestedEnumLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedNestedEnumLang", Version = "1")] public partial class MixedNestedEnumLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedSdtLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedSdtLang.g.cs index e63317c2e..29bab63eb 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedSdtLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MixedNestedSdtLang.g.cs @@ -5,13 +5,13 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Mixed.MixedNestedSdtLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; [LionCoreLanguage(Key = "key-mixedNestedSdtLang", Version = "1")] public partial class MixedNestedSdtLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MultiInheritLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MultiInheritLang.g.cs index 6b087bb1e..6f0a76c68 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MultiInheritLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/MultiInheritLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.MultiInheritLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-MultiInheritLang", Version = "1")] public partial class MultiInheritLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedLang.g.cs index 687a34a45..84fd379af 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.NamedLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-NamedLang", Version = "1")] public partial class NamedLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedReadInterfaces.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedReadInterfaces.g.cs index 0742c44fe..8fd51444e 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedReadInterfaces.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamedReadInterfaces.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.NamedLangReadInterfaces; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-NamedLang", Version = "1")] public partial class NamedReadInterfacesLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceContainsLionWebLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceContainsLionWebLang.g.cs new file mode 100644 index 000000000..2d46e1839 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceContainsLionWebLang.g.cs @@ -0,0 +1,94 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace io.LionWeb.Generated.V2025_1.namespaceStartsWithLionWebLang; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; + +[LionCoreLanguage(Key = "key-NamespaceContainsLionWebLang", Version = "1")] +public partial class NamespaceContainsLionWebLangLanguage : LanguageBase +{ + public static readonly NamespaceContainsLionWebLangLanguage Instance = new Lazy(() => new("id-NamespaceContainsLionWebLang-lang")).Value; + public NamespaceContainsLionWebLangLanguage(string id) : base(id, LionWebVersions.v2025_1) + { + _mYConcept = new(() => new ConceptBase("id-concept", this) { Key = "key-concept", Name = "MYConcept", Abstract = false, Partition = false }); + _factory = new NamespaceContainsLionWebLangFactory(this); + } + + /// + public override IReadOnlyList Entities => [MYConcept]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-NamespaceContainsLionWebLang"; + /// + public override string Key => _key; + + private const string _name = "NamespaceContainsLionWebLang"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _mYConcept; + public Concept MYConcept => _mYConcept.Value; +} + +public partial interface INamespaceContainsLionWebLangFactory : INodeFactory +{ + public MYConcept NewMYConcept(string id); + public MYConcept CreateMYConcept(); +} + +public class NamespaceContainsLionWebLangFactory : AbstractBaseNodeFactory, INamespaceContainsLionWebLangFactory +{ + private readonly NamespaceContainsLionWebLangLanguage _language; + public NamespaceContainsLionWebLangFactory(NamespaceContainsLionWebLangLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.MYConcept.EqualsIdentity(classifier)) + return NewMYConcept(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual MYConcept NewMYConcept(string id) => new(id); + public virtual MYConcept CreateMYConcept() => NewMYConcept(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(NamespaceContainsLionWebLangLanguage), Key = "key-concept")] +public partial class MYConcept : ConceptInstanceBase +{ + public MYConcept(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => NamespaceContainsLionWebLangLanguage.Instance.MYConcept; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceStartsWithLionWebLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceStartsWithLionWebLang.g.cs new file mode 100644 index 000000000..0c724e714 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NamespaceStartsWithLionWebLang.g.cs @@ -0,0 +1,94 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Generated.V2025_1.namespaceStartsWithLionWebLang; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; + +[LionCoreLanguage(Key = "key-NamespaceStartsWithLionWebLang", Version = "1")] +public partial class NamespaceStartsWithLionWebLangLanguage : LanguageBase +{ + public static readonly NamespaceStartsWithLionWebLangLanguage Instance = new Lazy(() => new("id-NamespaceStartsWithLionWebLang-lang")).Value; + public NamespaceStartsWithLionWebLangLanguage(string id) : base(id, LionWebVersions.v2025_1) + { + _mYConcept = new(() => new ConceptBase("id-concept", this) { Key = "key-concept", Name = "MYConcept", Abstract = false, Partition = false }); + _factory = new NamespaceStartsWithLionWebLangFactory(this); + } + + /// + public override IReadOnlyList Entities => [MYConcept]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-NamespaceStartsWithLionWebLang"; + /// + public override string Key => _key; + + private const string _name = "NamespaceStartsWithLionWebLang"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _mYConcept; + public Concept MYConcept => _mYConcept.Value; +} + +public partial interface INamespaceStartsWithLionWebLangFactory : INodeFactory +{ + public MYConcept NewMYConcept(string id); + public MYConcept CreateMYConcept(); +} + +public class NamespaceStartsWithLionWebLangFactory : AbstractBaseNodeFactory, INamespaceStartsWithLionWebLangFactory +{ + private readonly NamespaceStartsWithLionWebLangLanguage _language; + public NamespaceStartsWithLionWebLangFactory(NamespaceStartsWithLionWebLangLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.MYConcept.EqualsIdentity(classifier)) + return NewMYConcept(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual MYConcept NewMYConcept(string id) => new(id); + public virtual MYConcept CreateMYConcept() => NewMYConcept(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(NamespaceStartsWithLionWebLangLanguage), Key = "key-concept")] +public partial class MYConcept : ConceptInstanceBase +{ + public MYConcept(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => NamespaceStartsWithLionWebLangLanguage.Instance.MYConcept; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NullableReferencesTestLanguage.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NullableReferencesTestLanguage.g.cs index 0f05f8720..2efa2a15c 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NullableReferencesTestLanguage.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/NullableReferencesTestLanguage.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.NullableReferencesTestLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "TestLanguage", Version = "0")] public partial class NullableReferencesTestLanguageLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/SDTLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/SDTLang.g.cs index 8c7c8227c..ad048ff3c 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/SDTLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/SDTLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.SDTLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-SDTLang", Version = "0")] public partial class SDTLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Shapes.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Shapes.g.cs index b86b5ef0d..4e1c4aeb3 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Shapes.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/Shapes.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Shapes.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using Time = string; [LionCoreLanguage(Key = "key-Shapes", Version = "1")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TestLanguage.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TestLanguage.g.cs index 762816a30..46614f7b2 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TestLanguage.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TestLanguage.g.cs @@ -5,17 +5,17 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.TestLanguage; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Notification.Partition; -using LionWeb.Core.Notification.Pipe; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Notification.Partition; +using global::LionWeb.Core.Notification.Pipe; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "TestLanguage", Version = "0")] public partial class TestLanguageLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TinyRefLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TinyRefLang.g.cs index b7070a6c3..f976c083e 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TinyRefLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/TinyRefLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.TinyRefLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-tinyRefLang", Version = "0")] public partial class TinyRefLangLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/WithEnum.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/WithEnum.g.cs index b2ac453d9..0ccc73404 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/WithEnum.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/WithEnum.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.WithEnum.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "WithEnum", Version = "1")] public partial class WithEnumLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/class.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/class.g.cs index b97001987..5f5c8900e 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/class.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/class.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace @namespace.@int.@public.V2025_1; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; using @base = string; [LionCoreLanguage(Key = "class", Version = "struct")] diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/library.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/library.g.cs index 025e4f6b2..fdf11969d 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/library.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/library.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Library.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "library", Version = "1")] public partial class LibraryLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/multi.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/multi.g.cs index 15364403c..e4876239c 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/multi.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/multi.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.Multi.M2; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "multi", Version = "1")] public partial class MultiLanguage : LanguageBase diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/myLowerCaseLang.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/myLowerCaseLang.g.cs index f75e42325..975c5b93f 100644 --- a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/myLowerCaseLang.g.cs +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/myLowerCaseLang.g.cs @@ -5,15 +5,15 @@ #pragma warning disable 1591 #nullable enable namespace LionWeb.Core.Test.Languages.Generated.V2025_1.myLowerCaseLang; -using LionWeb.Core; -using LionWeb.Core.M2; -using LionWeb.Core.M3; -using LionWeb.Core.Notification; -using LionWeb.Core.Utilities; -using LionWeb.Core.VersionSpecific.V2025_1; -using System; -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; [LionCoreLanguage(Key = "key-LowerCaseLang", Version = "1")] public partial class MyLowerCaseLangLanguage : LanguageBase From 7749d7d03fe8e08a72986462977559052f14f84d Mon Sep 17 00:00:00 2001 From: Niko Date: Fri, 19 Dec 2025 00:46:33 +0100 Subject: [PATCH 2/7] Generator escapes user language names conflicting with framework names --- CHANGELOG.md | 3 +- build/LionWeb-CSharp-Build/Generate.cs | 4 +- .../TestLanguagesDefinitions.cs | 205 + .../Impl/FeatureGeneratorBase.cs | 4 + .../Impl/FeatureMethodsGenerator.cs | 6 +- src/LionWeb.Generator/Impl/GeneratorBase.cs | 4 - .../Impl/LanguageGeneratorBase.cs | 10 +- src/LionWeb.Generator/Names/Names.cs | 178 +- .../Names/UniqueFeatureNames.cs | 1 + .../LanguageWithLionWebNamedConcepts.g.cs | 4649 +++++++++++++++++ .../LanguageWithLionWebNamedConcepts.g.cs | 4649 +++++++++++++++++ .../LanguageWithLionWebNamedConcepts.g.cs | 4649 +++++++++++++++++ 12 files changed, 14345 insertions(+), 17 deletions(-) create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2023_1/LanguageWithLionWebNamedConcepts.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2024_1/LanguageWithLionWebNamedConcepts.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2025_1/LanguageWithLionWebNamedConcepts.g.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index a616e7dc5..42013ba43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,6 @@ and this project adheres _loosely_ to [Semantic Versioning](https://semver.org/s ## [0.4.0] - tbd ### Added -* Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. * `GeneratorFacade` now exposes `Correlations` property. This correlates LionWeb language elements to their corresponding C# syntax nodes. * Added the following check for a new node received via a delta event: If a delta event adds a new node, the node itself and its sub nodes have to be new (not present in the model) according to delta specification. If this is not the case, we warn the user by throwing an invalid notification exception. For the replacement logic, we allow replacing if a new node is a both existing and to be replaced node, we allow this because after replacement model is valid. * Moved `WebSocketServer` and `WebSocketClient` to separate project in core repo for reuse. @@ -29,6 +28,8 @@ and this project adheres _loosely_ to [Semantic Versioning](https://semver.org/s * Bugfix: `DeltaDeserializerHandler` is made public. This handler enables deserializer to accept node id that appears both in received delta(s) and local nodes. In the context of delta protocol, this enables replacing a node in a model with a new node with the same id, which results in a valid model. * `a.InsertBefore(b)` / `a.InsertAfter(b)` work correctly if both `a` and `b` are siblings. ### Changed +* Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. +* Generator escapes user language names conflicting with framework names. * Use `IReferenceTarget` both as return and parameter type of `IDeserializerHandler.UnresolvableReferenceTarget()`. * Factored out mutation code from generated classes into base class methods Simplifies changes and reduces the amount of generated code diff --git a/build/LionWeb-CSharp-Build/Generate.cs b/build/LionWeb-CSharp-Build/Generate.cs index 434eef47f..19c024b51 100644 --- a/build/LionWeb-CSharp-Build/Generate.cs +++ b/build/LionWeb-CSharp-Build/Generate.cs @@ -72,6 +72,7 @@ var upperCaseLang = testLanguagesDefinitions.UpperCaseLang; var namespaceStartsWithLionWebLang = testLanguagesDefinitions.NamespaceStartsWithLionWebLang; var namespaceContainsLionWebLang = testLanguagesDefinitions.NamespaceContainsLionWebLang; + var languageWithLionWebNamedConcepts = testLanguagesDefinitions.LanguageWithLionWebNamedConcepts; var lionWebVersionNamespace = "V" + lionWebVersion.VersionString.Replace('.', '_'); string prefix = $"LionWeb.Core.Test.Languages.Generated.{lionWebVersionNamespace}"; @@ -93,7 +94,8 @@ new(testLanguage, $"{prefix}.TestLanguage"), new(nullableReferencesTestLanguage, $"{prefix}.NullableReferencesTestLang"), new(namespaceStartsWithLionWebLang, $"LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang"), - new(namespaceContainsLionWebLang, $"io.LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang") + new(namespaceContainsLionWebLang, $"io.LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang"), + new(languageWithLionWebNamedConcepts, $"{prefix}.LanguageWithLionWebNamedConcepts"), // We don't really want these file in tests project, but update the version in Generator. // However, it's not worth writing a separate code path for this one language (as we want to externalize it anyways). // Step 3: Uncomment the line below diff --git a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs index 194e78521..d424ce998 100644 --- a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs +++ b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs @@ -21,6 +21,8 @@ using LionWeb.Core; using LionWeb.Core.M2; using LionWeb.Core.M3; +using LionWeb.Core.Utilities; +using System.Reflection; // ReSharper disable SuggestVarOrType_SimpleTypes @@ -40,6 +42,7 @@ public class TestLanguagesDefinitions public Language? UpperCaseLang { get; private set; } public Language NamespaceStartsWithLionWebLang { get; private set; } public Language NamespaceContainsLionWebLang { get; private set; } + public Language LanguageWithLionWebNamedConcepts { get; private set; } public List MixedLangs { get; private set; } = []; @@ -54,6 +57,7 @@ public TestLanguagesDefinitions(LionWebVersions lionWebVersion) CreateGeneralNodeLang(); CreateNamespaceStartsWithLionWebLang(); CreateNamespaceContainsLionWebLang(); + CreateLanguageWithLionWebNamedConcepts(); if (lionWebVersion.LionCore is ILionCoreLanguageWithStructuredDataType) { @@ -548,4 +552,205 @@ private void CreateNamespaceContainsLionWebLang() NamespaceContainsLionWebLang = lwLang; } + + private void CreateLanguageWithLionWebNamedConcepts() + { + var lang = new DynamicLanguage("id-LanguageWithLionWebNamedConcepts-lang", _lionWebVersion) + { + Name = "LanguageWithLionWebNamedConcepts", Key = "key-LanguageWithLionWebNamedConcepts", Version = "1" + }; + + BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance; + + HashSet conceptNames = + [ + // M3 + "Language", + "EnumerationLiteral", + "Link", + "Containment", + "Reference", + "Property", + "Field", + "LanguageEntity", + "Classifier", + "Annotation", + "Concept", + "Interface", + "Datatype", + "Enumeration", + "PrimitiveType", + "StructuredDataType", + + // M3 base + "LanguageBase", + "EnumerationLiteralBase", + "ContainmentBase", + "ReferenceBase", + "PropertyBase", + "FieldBase", + "AnnotationBase", + "ConceptBase", + "InterfaceBase", + "DatatypeBase", + "EnumerationBase", + "PrimitiveTypeBase", + "StructuredDataTypeBase", + + // Framework + "Abstract", + "AbstractBaseNodeFactory", + "AddChildRaw", + "AddContainmentsRaw", + "AddInternal", + "AddOptionalMultipleContainment", + "AddOptionalMultipleReference", + "AddReferencesRaw", + "AddRequiredMultipleContainment", + "AddRequiredMultipleReference", + "AnnotatesLazy", + "AnnotationInstanceBase", + "ArgumentOutOfRangeException", + "Bool", + "Boolean", + // "boolean", + "Char", + "Character", + "CodeAnalysis", + "CollectAllSetFeatures", + "Collections", + "ConceptInstanceBase", + "Core", + "Decimal", + "DetachChild", + "Diagnostics", + "Enum", + "ExchangeChildRaw", + "ExchangeChildrenRaw", + "FeaturesLazy", + "FieldsLazy", + "Generic", + "GetAnnotation", + "GetConcept", + "GetContainmentOf", + "GetInternal", + "IEnumerable", + "IFieldValues", + "INamed", + "INamedWritable", + "INode", + "INodeFactory", + "IPartitionInstance", + "IReadOnlyList", + "IReadableNode", + "IStructuredDataTypeInstance", + "IWritableNode", + "ImplementsLazy", + "InsertChildRaw", + "InsertInternal", + "InsertOptionalMultipleContainment", + "InsertOptionalMultipleReference", + "InsertReferencesRaw", + "InsertRequiredMultipleContainment", + "InsertRequiredMultipleReference", + "Instance", + "Integer", + // "integer", + "InvalidValueException", + "Key", + "Lazy", + "LionCoreFeature", + "LionCoreFeatureKind", + "LionCoreLanguage", + "LionCoreMetaPointer", + "LionWeb", + "LionWebVersions", + "List", + "LiteralsLazy", + "M2", + "M3", + "Multiple", + "Name", + // "_name", + "NotNullWhenAttribute", + "Notification", + "Optional", + "Partition", + "Pipe", + "ReferenceEquals", + "RemoveChildRaw", + "RemoveInternal", + "RemoveOptionalMultipleContainment", + "RemoveOptionalMultipleReference", + "RemoveReferencesRaw", + "RemoveRequiredMultipleContainment", + "RemoveRequiredMultipleReference", + "RemoveSelfParentRaw", + "SetContainmentRaw", + "SetInternal", + "SetName", + "SetNameRaw", + "SetOptionalMultipleContainment", + "SetOptionalMultipleReference", + "SetOptionalSingleContainment", + "SetOptionalSingleReference", + "SetPropertyRaw", + "SetReferenceRaw", + "SetReferencesRaw", + "SetRequiredMultipleContainment", + "SetRequiredMultipleReference", + "SetRequiredReferenceTypeProperty", + "SetRequiredSingleContainment", + "SetRequiredSingleReference", + "SetRequiredValueTypeProperty", + "String", + "System", + "TryGetContainmentRaw", + "TryGetContainmentsRaw", + "TryGetName", + "TryGetPropertyRaw", + "TryGetReferenceRaw", + "TryGetReferencesRaw", + "Type", + "UnsetFeatureException", + "UnsetFieldException", + "UnsupportedClassifierException", + "UnsupportedEnumerationLiteralException", + "UnsupportedStructuredDataTypeException", + "Utilities", + "V2023_1", + "V2024_1", + "V2024_1_Compatible", + "V2025_1", + "V2025_1_Compatible", + "VersionSpecific", + "_builtIns", + "result", + // "v2023_1", + // "v2024_1", + // "v2024_1_Compatible", + // "v2025_1", + // "v2025_1_Compatible", + ..typeof(ReadableNodeBase<>).GetMembers(bindingFlags) + .Concat(typeof(NodeBase).GetMembers(bindingFlags)) + .OfType() + .Select(i => i.Name) + .Where(n => !n.Contains('.')) + .Where(IdUtils.IsValid) + ]; + + foreach (var conceptName in conceptNames) + { + lang.Concept(conceptName); + } + + LanguageWithLionWebNamedConcepts = lang; + } +} + +internal static class LanguageExtensions +{ + internal static DynamicConcept Concept(this DynamicLanguage language, string name) => + language.Concept($"id-{name}", $"key-{name}", name); + } \ No newline at end of file diff --git a/src/LionWeb.Generator/Impl/FeatureGeneratorBase.cs b/src/LionWeb.Generator/Impl/FeatureGeneratorBase.cs index 8e5de3839..346db9ec6 100644 --- a/src/LionWeb.Generator/Impl/FeatureGeneratorBase.cs +++ b/src/LionWeb.Generator/Impl/FeatureGeneratorBase.cs @@ -365,4 +365,8 @@ protected ExpressionSyntax FeatureSet() => protected string FeatureTryGetParam() => _names.FeatureParam(feature); + + /// + protected ExpressionSyntax FeatureProperty(Feature feature) => + _names.FeatureProperty(feature, classifier); } \ No newline at end of file diff --git a/src/LionWeb.Generator/Impl/FeatureMethodsGenerator.cs b/src/LionWeb.Generator/Impl/FeatureMethodsGenerator.cs index 1873e95fd..0f0a4c164 100644 --- a/src/LionWeb.Generator/Impl/FeatureMethodsGenerator.cs +++ b/src/LionWeb.Generator/Impl/FeatureMethodsGenerator.cs @@ -106,7 +106,7 @@ private MethodDeclarationSyntax GenGetInternal() => private StatementSyntax GenGetInternal(Feature feature) => IfStatement(GenEqualsIdentityFeature(feature), AsStatements([ - Assignment("result", FeatureProperty(feature)), + Assignment("result", _names.FeatureProperty(feature, classifier)), ReturnTrue() ]) ); @@ -678,13 +678,13 @@ private List GenRemoveInternalMultipleContainment(Containment c #region CollectAllSetFeatures private MethodDeclarationSyntax GenCollectAllSetFeatures() => - Method("CollectAllSetFeatures", AsType(typeof(IEnumerable))) + Method("CollectAllSetFeatures", AsType(typeof(IEnumerable<>), AsType(typeof(Feature)))) .WithModifiers(AsModifiers(SyntaxKind.PublicKeyword, SyntaxKind.OverrideKeyword)) .Xdoc(XdocInheritDoc()) .WithBody(AsStatements( new List { - ParseStatement("List result = base.CollectAllSetFeatures().ToList();") + Variable("result", AsType(typeof(List<>), AsType(typeof(Feature))), ParseExpression("base.CollectAllSetFeatures().ToList()")) } .Concat(FeaturesToImplement(classifier).Select(GenCollectAllSetFeatures)) .Append(ReturnStatement(IdentifierName("result"))) diff --git a/src/LionWeb.Generator/Impl/GeneratorBase.cs b/src/LionWeb.Generator/Impl/GeneratorBase.cs index 6879a5e0b..f5ce3acef 100644 --- a/src/LionWeb.Generator/Impl/GeneratorBase.cs +++ b/src/LionWeb.Generator/Impl/GeneratorBase.cs @@ -112,10 +112,6 @@ protected ExpressionSyntax LinkRemoveRaw(Link link) => protected ExpressionSyntax FeatureField(Feature feature) => _names.FeatureField(feature); - /// - protected ExpressionSyntax FeatureProperty(Feature feature) => - _names.FeatureProperty(feature); - /// protected ExpressionSyntax FieldField(Field field) => _names.FieldField(field); diff --git a/src/LionWeb.Generator/Impl/LanguageGeneratorBase.cs b/src/LionWeb.Generator/Impl/LanguageGeneratorBase.cs index 752ab4854..c1df298b1 100644 --- a/src/LionWeb.Generator/Impl/LanguageGeneratorBase.cs +++ b/src/LionWeb.Generator/Impl/LanguageGeneratorBase.cs @@ -39,19 +39,19 @@ protected LanguageGeneratorBase(GeneratorInputParameters generatorInputParameter /// _myEntity protected string LanguageFieldName(LanguageEntity entity) => - $"_{entity.Name.ToFirstLower()}"; + Names.EscapeLanguageInternal($"_{entity.Name.ToFirstLower()}"); /// _myClassifier_MyFeature protected string LanguageFieldName(Feature feature) => - $"_{feature.GetFeatureClassifier().Name.ToFirstLower()}_{feature.Name}"; + Names.EscapeLanguageInternal($"_{feature.GetFeatureClassifier().Name.ToFirstLower()}_{feature.Name}"); /// myEnum_MyEnumLiteral protected string LanguageFieldName(EnumerationLiteral literal) => - $"_{literal.GetEnumeration().Name.ToFirstLower()}_{literal.Name}"; + Names.EscapeLanguageInternal($"_{literal.GetEnumeration().Name.ToFirstLower()}_{literal.Name}"); /// myStructuredDataType_MyField protected string LanguageFieldName(Field field) => - $"_{field.GetStructuredDataType().Name.ToFirstLower()}_{field.Name}"; + Names.EscapeLanguageInternal($"_{field.GetStructuredDataType().Name.ToFirstLower()}_{field.Name}"); /// Returns FQN if entity's language is part of . /// @@ -66,7 +66,7 @@ protected ExpressionSyntax AsProperty(LanguageEntity entity) return QualifiedName( _names.MetaProperty(entity.GetLanguage()), - IdentifierName(entity.Name) + IdentifierName(Names.EscapeLanguageInternal(entity.Name)) ); } diff --git a/src/LionWeb.Generator/Names/Names.cs b/src/LionWeb.Generator/Names/Names.cs index 8a9d024b1..8df53b987 100644 --- a/src/LionWeb.Generator/Names/Names.cs +++ b/src/LionWeb.Generator/Names/Names.cs @@ -18,12 +18,14 @@ namespace LionWeb.Generator.Names; using Core; +using Core.M1; using Core.M2; using Core.M3; using Core.Utilities; using Impl; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; +using System.Diagnostics.CodeAnalysis; using System.Text.RegularExpressions; using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; @@ -107,6 +109,122 @@ public void AddNamespaceMapping(Language lang, string nsName) => /// public string NamespaceName => _namespaceName; + private static readonly HashSet _languageInternalNames = + [ + "CollectAllSetFeatures", + "DependsOn", + "Entities", + "Equals", + "Get", + "GetAnnotations", + "GetAnnotationsRaw", + "GetClassifier", + "GetConcept", + "GetFactory", + "GetHashCode", + "GetId", + "GetNotificationSender", + "GetParent", + "GetType", + "Instance", + "Key", + "LionWebVersion", + "MemberwiseClone", + "Name", + "ReferenceEquals", + "SetFactory", + "ToString", + "TryGet", + "TryGetContainmentRaw", + "TryGetContainmentsRaw", + "TryGetKey", + "TryGetName", + "TryGetPropertyRaw", + "TryGetReferenceRaw", + "TryGetReferencesRaw", + "TryGetVersion", + "Version", + "_builtIns", + "_factory", + "_key", + "_m3", + "_name", + "_version", + ]; + + protected internal static string EscapeLanguageInternal(string name) => + _languageInternalNames.Contains(name) + ? name + "_" + : name; + + private static readonly HashSet _internalTypes = + [ + // M3 + typeof(Language), + typeof(EnumerationLiteral), + typeof(Feature), + typeof(Link), + typeof(Containment), + typeof(Reference), + typeof(Property), + typeof(Field), + typeof(LanguageEntity), + typeof(Classifier), + typeof(Annotation), + typeof(Concept), + typeof(Interface), + typeof(Datatype), + typeof(Enumeration), + typeof(PrimitiveType), + typeof(StructuredDataType), + + // M3 Base + typeof(LanguageBase<>), + typeof(EnumerationLiteralBase<>), + typeof(ContainmentBase<>), + typeof(ReferenceBase<>), + typeof(PropertyBase<>), + typeof(FieldBase<>), + typeof(AnnotationBase<>), + typeof(ConceptBase<>), + typeof(InterfaceBase<>), + typeof(EnumerationBase<>), + typeof(PrimitiveTypeBase<>), + typeof(StructuredDataTypeBase<>), + + // Framework + typeof(AbstractBaseNodeFactory), + typeof(AnnotationInstanceBase), + typeof(ArgumentOutOfRangeException), + typeof(ConceptInstanceBase), + typeof(Enum), + typeof(IEnumerable<>), + typeof(IFieldValues), + typeof(INamed), + typeof(INamedWritable), + typeof(INode), + typeof(INodeFactory), + typeof(IPartitionInstance), + typeof(IReadOnlyList<>), + typeof(IReadableNode), + typeof(IStructuredDataTypeInstance), + typeof(IWritableNode), + typeof(InvalidValueException), + typeof(Lazy<>), + typeof(LionCoreLanguage), + typeof(LionCoreMetaPointer), + typeof(LionWebVersions), + typeof(List<>), + typeof(NotNullWhenAttribute), + typeof(PartitionInstanceBase), + typeof(Type), + typeof(UnsetFeatureException), + typeof(UnsetFieldException), + typeof(UnsupportedClassifierException), + typeof(UnsupportedEnumerationLiteralException), + typeof(UnsupportedStructuredDataTypeException) + ]; + /// public TypeSyntax AsType(Type type, params TypeSyntax?[] generics) { @@ -139,6 +257,60 @@ public TypeSyntax AsType(Type type, params TypeSyntax?[] generics) return result; } + private static readonly HashSet _typeInternalNames = + [ + // "Add", + // "AddAnnotations", + // "AddAnnotationsRaw", + "AddContainmentsRaw", + "AddInternal", + "AddReferencesRaw", + "CollectAllSetFeatures", + "DetachChild", + "DetachFromParent", + // "Equals", + // "Finalize", + // "Get", + // "GetAnnotations", + // "GetAnnotationsRaw", + "GetClassifier", + "GetConcept", + "GetContainmentOf", + // "GetHashCode", + // "GetId", + "GetInternal", + // "GetParent", + "GetPartitionNotificationProducer", + // "Insert", + // "InsertAnnotations", + "InsertContainmentsRaw", + "InsertInternal", + "InsertReferencesRaw", + // "Remove", + // "RemoveAnnotations", + "RemoveContainmentsRaw", + "RemoveInternal", + "RemoveReferencesRaw", + // "Set", + "SetContainmentRaw", + "SetInternal", + "SetPropertyRaw", + "SetRaw", + "SetReferenceRaw", + // "ToString", + "TryGet", + "TryGetContainmentRaw", + "TryGetContainmentsRaw", + "TryGetPropertyRaw", + "TryGetReferenceRaw", + "TryGetReferencesRaw" + ]; + + protected internal static string EscapeTypeInternal(string name) => + _typeInternalNames.Contains(name) + ? name + "_" + : name; + /// public TypeSyntax AsType(Classifier classifier, bool disambiguate = false, bool writeable = false) { @@ -154,10 +326,10 @@ public TypeSyntax AsType(Classifier classifier, bool disambiguate = false, bool if (_namespaceMappings.TryGetValue(classifier.GetLanguage(), out var ns)) { - return QualifiedName(ParseName(ns), IdentifierName(classifier.Name.PrefixKeyword())); + return QualifiedName(ParseName(ns), IdentifierName(EscapeTypeInternal(classifier.Name.PrefixKeyword()))); } - var type = IdentifierName(classifier.Name.PrefixKeyword()); + var type = IdentifierName(EscapeTypeInternal(classifier.Name.PrefixKeyword())); if (!disambiguate) return type; return QualifiedName(ParseName(NamespaceName), type); @@ -227,7 +399,7 @@ public string Use(Type type) /// public IdentifierNameSyntax AsProperty(LanguageEntity classifier) => - IdentifierName(classifier.Name.PrefixKeyword()); + IdentifierName(EscapeLanguageInternal(classifier.Name.PrefixKeyword())); /// public IdentifierNameSyntax AsProperty(Feature feature) => diff --git a/src/LionWeb.Generator/Names/UniqueFeatureNames.cs b/src/LionWeb.Generator/Names/UniqueFeatureNames.cs index 9832859be..6c358451f 100644 --- a/src/LionWeb.Generator/Names/UniqueFeatureNames.cs +++ b/src/LionWeb.Generator/Names/UniqueFeatureNames.cs @@ -17,6 +17,7 @@ namespace LionWeb.Generator.Names; +using Core.M2; using Core.M3; using Impl; using Microsoft.CodeAnalysis.CSharp.Syntax; diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/LanguageWithLionWebNamedConcepts.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/LanguageWithLionWebNamedConcepts.g.cs new file mode 100644 index 000000000..a313169cc --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/LanguageWithLionWebNamedConcepts.g.cs @@ -0,0 +1,4649 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Core.Test.Languages.Generated.V2023_1.LanguageWithLionWebNamedConcepts; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; + +[global::LionWeb.Core.M2.LionCoreLanguage(Key = "key-LanguageWithLionWebNamedConcepts", Version = "1")] +public partial class LanguageWithLionWebNamedConceptsLanguage : LanguageBase +{ + public static readonly LanguageWithLionWebNamedConceptsLanguage Instance = new Lazy(() => new("id-LanguageWithLionWebNamedConcepts-lang")).Value; + public LanguageWithLionWebNamedConceptsLanguage(string id) : base(id, global::LionWeb.Core.LionWebVersions.v2023_1) + { + __builtIns = new(() => new ConceptBase("id-_builtIns", this) { Key = "key-_builtIns", Name = "_builtIns", Abstract = false, Partition = false }); + _abstract = new(() => new ConceptBase("id-Abstract", this) { Key = "key-Abstract", Name = "Abstract", Abstract = false, Partition = false }); + _abstractBaseNodeFactory = new(() => new ConceptBase("id-AbstractBaseNodeFactory", this) { Key = "key-AbstractBaseNodeFactory", Name = "AbstractBaseNodeFactory", Abstract = false, Partition = false }); + _add = new(() => new ConceptBase("id-Add", this) { Key = "key-Add", Name = "Add", Abstract = false, Partition = false }); + _addAnnotations = new(() => new ConceptBase("id-AddAnnotations", this) { Key = "key-AddAnnotations", Name = "AddAnnotations", Abstract = false, Partition = false }); + _addAnnotationsRaw = new(() => new ConceptBase("id-AddAnnotationsRaw", this) { Key = "key-AddAnnotationsRaw", Name = "AddAnnotationsRaw", Abstract = false, Partition = false }); + _addChildRaw = new(() => new ConceptBase("id-AddChildRaw", this) { Key = "key-AddChildRaw", Name = "AddChildRaw", Abstract = false, Partition = false }); + _addContainmentsRaw = new(() => new ConceptBase("id-AddContainmentsRaw", this) { Key = "key-AddContainmentsRaw", Name = "AddContainmentsRaw", Abstract = false, Partition = false }); + _addInternal = new(() => new ConceptBase("id-AddInternal", this) { Key = "key-AddInternal", Name = "AddInternal", Abstract = false, Partition = false }); + _addOptionalMultipleContainment = new(() => new ConceptBase("id-AddOptionalMultipleContainment", this) { Key = "key-AddOptionalMultipleContainment", Name = "AddOptionalMultipleContainment", Abstract = false, Partition = false }); + _addOptionalMultipleReference = new(() => new ConceptBase("id-AddOptionalMultipleReference", this) { Key = "key-AddOptionalMultipleReference", Name = "AddOptionalMultipleReference", Abstract = false, Partition = false }); + _addReferencesRaw = new(() => new ConceptBase("id-AddReferencesRaw", this) { Key = "key-AddReferencesRaw", Name = "AddReferencesRaw", Abstract = false, Partition = false }); + _addRequiredMultipleContainment = new(() => new ConceptBase("id-AddRequiredMultipleContainment", this) { Key = "key-AddRequiredMultipleContainment", Name = "AddRequiredMultipleContainment", Abstract = false, Partition = false }); + _addRequiredMultipleReference = new(() => new ConceptBase("id-AddRequiredMultipleReference", this) { Key = "key-AddRequiredMultipleReference", Name = "AddRequiredMultipleReference", Abstract = false, Partition = false }); + _annotatesLazy = new(() => new ConceptBase("id-AnnotatesLazy", this) { Key = "key-AnnotatesLazy", Name = "AnnotatesLazy", Abstract = false, Partition = false }); + _annotation = new(() => new ConceptBase("id-Annotation", this) { Key = "key-Annotation", Name = "Annotation", Abstract = false, Partition = false }); + _annotationBase = new(() => new ConceptBase("id-AnnotationBase", this) { Key = "key-AnnotationBase", Name = "AnnotationBase", Abstract = false, Partition = false }); + _annotationInstanceBase = new(() => new ConceptBase("id-AnnotationInstanceBase", this) { Key = "key-AnnotationInstanceBase", Name = "AnnotationInstanceBase", Abstract = false, Partition = false }); + _annotationRemover = new(() => new ConceptBase("id-AnnotationRemover", this) { Key = "key-AnnotationRemover", Name = "AnnotationRemover", Abstract = false, Partition = false }); + _argumentOutOfRangeException = new(() => new ConceptBase("id-ArgumentOutOfRangeException", this) { Key = "key-ArgumentOutOfRangeException", Name = "ArgumentOutOfRangeException", Abstract = false, Partition = false }); + _asList = new(() => new ConceptBase("id-AsList", this) { Key = "key-AsList", Name = "AsList", Abstract = false, Partition = false }); + _asNonEmptyReadOnly = new(() => new ConceptBase("id-AsNonEmptyReadOnly", this) { Key = "key-AsNonEmptyReadOnly", Name = "AsNonEmptyReadOnly", Abstract = false, Partition = false }); + _assureAnnotations = new(() => new ConceptBase("id-AssureAnnotations", this) { Key = "key-AssureAnnotations", Name = "AssureAnnotations", Abstract = false, Partition = false }); + _assureInRange = new(() => new ConceptBase("id-AssureInRange", this) { Key = "key-AssureInRange", Name = "AssureInRange", Abstract = false, Partition = false }); + _assureNonEmpty = new(() => new ConceptBase("id-AssureNonEmpty", this) { Key = "key-AssureNonEmpty", Name = "AssureNonEmpty", Abstract = false, Partition = false }); + _assureNoSelfMove = new(() => new ConceptBase("id-AssureNoSelfMove", this) { Key = "key-AssureNoSelfMove", Name = "AssureNoSelfMove", Abstract = false, Partition = false }); + _assureNotClearing = new(() => new ConceptBase("id-AssureNotClearing", this) { Key = "key-AssureNotClearing", Name = "AssureNotClearing", Abstract = false, Partition = false }); + _assureNotNull = new(() => new ConceptBase("id-AssureNotNull", this) { Key = "key-AssureNotNull", Name = "AssureNotNull", Abstract = false, Partition = false }); + _assureNotNullInstance = new(() => new ConceptBase("id-AssureNotNullInstance", this) { Key = "key-AssureNotNullInstance", Name = "AssureNotNullInstance", Abstract = false, Partition = false }); + _assureNotNullMembers = new(() => new ConceptBase("id-AssureNotNullMembers", this) { Key = "key-AssureNotNullMembers", Name = "AssureNotNullMembers", Abstract = false, Partition = false }); + _assureNullableInstance = new(() => new ConceptBase("id-AssureNullableInstance", this) { Key = "key-AssureNullableInstance", Name = "AssureNullableInstance", Abstract = false, Partition = false }); + _attachChild = new(() => new ConceptBase("id-AttachChild", this) { Key = "key-AttachChild", Name = "AttachChild", Abstract = false, Partition = false }); + _bool = new(() => new ConceptBase("id-Bool", this) { Key = "key-Bool", Name = "Bool", Abstract = false, Partition = false }); + _boolean = new(() => new ConceptBase("id-Boolean", this) { Key = "key-Boolean", Name = "Boolean", Abstract = false, Partition = false }); + _char = new(() => new ConceptBase("id-Char", this) { Key = "key-Char", Name = "Char", Abstract = false, Partition = false }); + _character = new(() => new ConceptBase("id-Character", this) { Key = "key-Character", Name = "Character", Abstract = false, Partition = false }); + _classifier = new(() => new ConceptBase("id-Classifier", this) { Key = "key-Classifier", Name = "Classifier", Abstract = false, Partition = false }); + _codeAnalysis = new(() => new ConceptBase("id-CodeAnalysis", this) { Key = "key-CodeAnalysis", Name = "CodeAnalysis", Abstract = false, Partition = false }); + _collectAllSetFeatures = new(() => new ConceptBase("id-CollectAllSetFeatures", this) { Key = "key-CollectAllSetFeatures", Name = "CollectAllSetFeatures", Abstract = false, Partition = false }); + _collections = new(() => new ConceptBase("id-Collections", this) { Key = "key-Collections", Name = "Collections", Abstract = false, Partition = false }); + _concept = new(() => new ConceptBase("id-Concept", this) { Key = "key-Concept", Name = "Concept", Abstract = false, Partition = false }); + _conceptBase = new(() => new ConceptBase("id-ConceptBase", this) { Key = "key-ConceptBase", Name = "ConceptBase", Abstract = false, Partition = false }); + _conceptInstanceBase = new(() => new ConceptBase("id-ConceptInstanceBase", this) { Key = "key-ConceptInstanceBase", Name = "ConceptInstanceBase", Abstract = false, Partition = false }); + _containment = new(() => new ConceptBase("id-Containment", this) { Key = "key-Containment", Name = "Containment", Abstract = false, Partition = false }); + _containmentBase = new(() => new ConceptBase("id-ContainmentBase", this) { Key = "key-ContainmentBase", Name = "ContainmentBase", Abstract = false, Partition = false }); + _containmentRemover = new(() => new ConceptBase("id-ContainmentRemover", this) { Key = "key-ContainmentRemover", Name = "ContainmentRemover", Abstract = false, Partition = false }); + _core = new(() => new ConceptBase("id-Core", this) { Key = "key-Core", Name = "Core", Abstract = false, Partition = false }); + _datatype = new(() => new ConceptBase("id-Datatype", this) { Key = "key-Datatype", Name = "Datatype", Abstract = false, Partition = false }); + _datatypeBase = new(() => new ConceptBase("id-DatatypeBase", this) { Key = "key-DatatypeBase", Name = "DatatypeBase", Abstract = false, Partition = false }); + _decimal = new(() => new ConceptBase("id-Decimal", this) { Key = "key-Decimal", Name = "Decimal", Abstract = false, Partition = false }); + _detachChild = new(() => new ConceptBase("id-DetachChild", this) { Key = "key-DetachChild", Name = "DetachChild", Abstract = false, Partition = false }); + _detachChildInternal = new(() => new ConceptBase("id-DetachChildInternal", this) { Key = "key-DetachChildInternal", Name = "DetachChildInternal", Abstract = false, Partition = false }); + _detachFromParent = new(() => new ConceptBase("id-DetachFromParent", this) { Key = "key-DetachFromParent", Name = "DetachFromParent", Abstract = false, Partition = false }); + _diagnostics = new(() => new ConceptBase("id-Diagnostics", this) { Key = "key-Diagnostics", Name = "Diagnostics", Abstract = false, Partition = false }); + _enum = new(() => new ConceptBase("id-Enum", this) { Key = "key-Enum", Name = "Enum", Abstract = false, Partition = false }); + _enumeration = new(() => new ConceptBase("id-Enumeration", this) { Key = "key-Enumeration", Name = "Enumeration", Abstract = false, Partition = false }); + _enumerationBase = new(() => new ConceptBase("id-EnumerationBase", this) { Key = "key-EnumerationBase", Name = "EnumerationBase", Abstract = false, Partition = false }); + _enumerationLiteral = new(() => new ConceptBase("id-EnumerationLiteral", this) { Key = "key-EnumerationLiteral", Name = "EnumerationLiteral", Abstract = false, Partition = false }); + _enumerationLiteralBase = new(() => new ConceptBase("id-EnumerationLiteralBase", this) { Key = "key-EnumerationLiteralBase", Name = "EnumerationLiteralBase", Abstract = false, Partition = false }); + _equals = new(() => new ConceptBase("id-Equals", this) { Key = "key-Equals", Name = "Equals", Abstract = false, Partition = false }); + _exchangeChildRaw = new(() => new ConceptBase("id-ExchangeChildRaw", this) { Key = "key-ExchangeChildRaw", Name = "ExchangeChildRaw", Abstract = false, Partition = false }); + _exchangeChildrenRaw = new(() => new ConceptBase("id-ExchangeChildrenRaw", this) { Key = "key-ExchangeChildrenRaw", Name = "ExchangeChildrenRaw", Abstract = false, Partition = false }); + _featuresLazy = new(() => new ConceptBase("id-FeaturesLazy", this) { Key = "key-FeaturesLazy", Name = "FeaturesLazy", Abstract = false, Partition = false }); + _field = new(() => new ConceptBase("id-Field", this) { Key = "key-Field", Name = "Field", Abstract = false, Partition = false }); + _fieldBase = new(() => new ConceptBase("id-FieldBase", this) { Key = "key-FieldBase", Name = "FieldBase", Abstract = false, Partition = false }); + _fieldsLazy = new(() => new ConceptBase("id-FieldsLazy", this) { Key = "key-FieldsLazy", Name = "FieldsLazy", Abstract = false, Partition = false }); + _finalize = new(() => new ConceptBase("id-Finalize", this) { Key = "key-Finalize", Name = "Finalize", Abstract = false, Partition = false }); + _generic = new(() => new ConceptBase("id-Generic", this) { Key = "key-Generic", Name = "Generic", Abstract = false, Partition = false }); + _get = new(() => new ConceptBase("id-Get", this) { Key = "key-Get", Name = "Get", Abstract = false, Partition = false }); + _get__builtIns = new(() => new ConceptBase("id-get__builtIns", this) { Key = "key-get__builtIns", Name = "get__builtIns", Abstract = false, Partition = false }); + _get__m3 = new(() => new ConceptBase("id-get__m3", this) { Key = "key-get__m3", Name = "get__m3", Abstract = false, Partition = false }); + _getAnnotation = new(() => new ConceptBase("id-GetAnnotation", this) { Key = "key-GetAnnotation", Name = "GetAnnotation", Abstract = false, Partition = false }); + _getAnnotations = new(() => new ConceptBase("id-GetAnnotations", this) { Key = "key-GetAnnotations", Name = "GetAnnotations", Abstract = false, Partition = false }); + _getAnnotationsRaw = new(() => new ConceptBase("id-GetAnnotationsRaw", this) { Key = "key-GetAnnotationsRaw", Name = "GetAnnotationsRaw", Abstract = false, Partition = false }); + _getClassifier = new(() => new ConceptBase("id-GetClassifier", this) { Key = "key-GetClassifier", Name = "GetClassifier", Abstract = false, Partition = false }); + _getConcept = new(() => new ConceptBase("id-GetConcept", this) { Key = "key-GetConcept", Name = "GetConcept", Abstract = false, Partition = false }); + _getContainmentOf = new(() => new ConceptBase("id-GetContainmentOf", this) { Key = "key-GetContainmentOf", Name = "GetContainmentOf", Abstract = false, Partition = false }); + _getHashCode = new(() => new ConceptBase("id-GetHashCode", this) { Key = "key-GetHashCode", Name = "GetHashCode", Abstract = false, Partition = false }); + _getId = new(() => new ConceptBase("id-GetId", this) { Key = "key-GetId", Name = "GetId", Abstract = false, Partition = false }); + _getInternal = new(() => new ConceptBase("id-GetInternal", this) { Key = "key-GetInternal", Name = "GetInternal", Abstract = false, Partition = false }); + _getParent = new(() => new ConceptBase("id-GetParent", this) { Key = "key-GetParent", Name = "GetParent", Abstract = false, Partition = false }); + _getPartitionNotificationProducer = new(() => new ConceptBase("id-GetPartitionNotificationProducer", this) { Key = "key-GetPartitionNotificationProducer", Name = "GetPartitionNotificationProducer", Abstract = false, Partition = false }); + _getRequiredNonNullReferences = new(() => new ConceptBase("id-GetRequiredNonNullReferences", this) { Key = "key-GetRequiredNonNullReferences", Name = "GetRequiredNonNullReferences", Abstract = false, Partition = false }); + _getRequiredNullableReferences = new(() => new ConceptBase("id-GetRequiredNullableReferences", this) { Key = "key-GetRequiredNullableReferences", Name = "GetRequiredNullableReferences", Abstract = false, Partition = false }); + _getRequiredReference = new(() => new ConceptBase("id-GetRequiredReference", this) { Key = "key-GetRequiredReference", Name = "GetRequiredReference", Abstract = false, Partition = false }); + _getType = new(() => new ConceptBase("id-GetType", this) { Key = "key-GetType", Name = "GetType", Abstract = false, Partition = false }); + _iEnumerable = new(() => new ConceptBase("id-IEnumerable", this) { Key = "key-IEnumerable", Name = "IEnumerable", Abstract = false, Partition = false }); + _iFieldValues = new(() => new ConceptBase("id-IFieldValues", this) { Key = "key-IFieldValues", Name = "IFieldValues", Abstract = false, Partition = false }); + _implementsLazy = new(() => new ConceptBase("id-ImplementsLazy", this) { Key = "key-ImplementsLazy", Name = "ImplementsLazy", Abstract = false, Partition = false }); + _iNamed = new(() => new ConceptBase("id-INamed", this) { Key = "key-INamed", Name = "INamed", Abstract = false, Partition = false }); + _iNamedWritable = new(() => new ConceptBase("id-INamedWritable", this) { Key = "key-INamedWritable", Name = "INamedWritable", Abstract = false, Partition = false }); + _iNode = new(() => new ConceptBase("id-INode", this) { Key = "key-INode", Name = "INode", Abstract = false, Partition = false }); + _iNodeFactory = new(() => new ConceptBase("id-INodeFactory", this) { Key = "key-INodeFactory", Name = "INodeFactory", Abstract = false, Partition = false }); + _insert = new(() => new ConceptBase("id-Insert", this) { Key = "key-Insert", Name = "Insert", Abstract = false, Partition = false }); + _insertAnnotations = new(() => new ConceptBase("id-InsertAnnotations", this) { Key = "key-InsertAnnotations", Name = "InsertAnnotations", Abstract = false, Partition = false }); + _insertAnnotationsRaw = new(() => new ConceptBase("id-InsertAnnotationsRaw", this) { Key = "key-InsertAnnotationsRaw", Name = "InsertAnnotationsRaw", Abstract = false, Partition = false }); + _insertChildRaw = new(() => new ConceptBase("id-InsertChildRaw", this) { Key = "key-InsertChildRaw", Name = "InsertChildRaw", Abstract = false, Partition = false }); + _insertContainmentsRaw = new(() => new ConceptBase("id-InsertContainmentsRaw", this) { Key = "key-InsertContainmentsRaw", Name = "InsertContainmentsRaw", Abstract = false, Partition = false }); + _insertInternal = new(() => new ConceptBase("id-InsertInternal", this) { Key = "key-InsertInternal", Name = "InsertInternal", Abstract = false, Partition = false }); + _insertOptionalMultipleContainment = new(() => new ConceptBase("id-InsertOptionalMultipleContainment", this) { Key = "key-InsertOptionalMultipleContainment", Name = "InsertOptionalMultipleContainment", Abstract = false, Partition = false }); + _insertOptionalMultipleReference = new(() => new ConceptBase("id-InsertOptionalMultipleReference", this) { Key = "key-InsertOptionalMultipleReference", Name = "InsertOptionalMultipleReference", Abstract = false, Partition = false }); + _insertReferencesRaw = new(() => new ConceptBase("id-InsertReferencesRaw", this) { Key = "key-InsertReferencesRaw", Name = "InsertReferencesRaw", Abstract = false, Partition = false }); + _insertRequiredMultipleContainment = new(() => new ConceptBase("id-InsertRequiredMultipleContainment", this) { Key = "key-InsertRequiredMultipleContainment", Name = "InsertRequiredMultipleContainment", Abstract = false, Partition = false }); + _insertRequiredMultipleReference = new(() => new ConceptBase("id-InsertRequiredMultipleReference", this) { Key = "key-InsertRequiredMultipleReference", Name = "InsertRequiredMultipleReference", Abstract = false, Partition = false }); + _instance = new(() => new ConceptBase("id-Instance", this) { Key = "key-Instance", Name = "Instance", Abstract = false, Partition = false }); + _integer = new(() => new ConceptBase("id-Integer", this) { Key = "key-Integer", Name = "Integer", Abstract = false, Partition = false }); + _interface = new(() => new ConceptBase("id-Interface", this) { Key = "key-Interface", Name = "Interface", Abstract = false, Partition = false }); + _interfaceBase = new(() => new ConceptBase("id-InterfaceBase", this) { Key = "key-InterfaceBase", Name = "InterfaceBase", Abstract = false, Partition = false }); + _invalidValueException = new(() => new ConceptBase("id-InvalidValueException", this) { Key = "key-InvalidValueException", Name = "InvalidValueException", Abstract = false, Partition = false }); + _iPartitionInstance = new(() => new ConceptBase("id-IPartitionInstance", this) { Key = "key-IPartitionInstance", Name = "IPartitionInstance", Abstract = false, Partition = false }); + _iReadableNode = new(() => new ConceptBase("id-IReadableNode", this) { Key = "key-IReadableNode", Name = "IReadableNode", Abstract = false, Partition = false }); + _iReadOnlyList = new(() => new ConceptBase("id-IReadOnlyList", this) { Key = "key-IReadOnlyList", Name = "IReadOnlyList", Abstract = false, Partition = false }); + _isInRange = new(() => new ConceptBase("id-IsInRange", this) { Key = "key-IsInRange", Name = "IsInRange", Abstract = false, Partition = false }); + _iStructuredDataTypeInstance = new(() => new ConceptBase("id-IStructuredDataTypeInstance", this) { Key = "key-IStructuredDataTypeInstance", Name = "IStructuredDataTypeInstance", Abstract = false, Partition = false }); + _iWritableNode = new(() => new ConceptBase("id-IWritableNode", this) { Key = "key-IWritableNode", Name = "IWritableNode", Abstract = false, Partition = false }); + _key_ = new(() => new ConceptBase("id-Key", this) { Key = "key-Key", Name = "Key", Abstract = false, Partition = false }); + _language = new(() => new ConceptBase("id-Language", this) { Key = "key-Language", Name = "Language", Abstract = false, Partition = false }); + _languageBase = new(() => new ConceptBase("id-LanguageBase", this) { Key = "key-LanguageBase", Name = "LanguageBase", Abstract = false, Partition = false }); + _languageEntity = new(() => new ConceptBase("id-LanguageEntity", this) { Key = "key-LanguageEntity", Name = "LanguageEntity", Abstract = false, Partition = false }); + _lazy = new(() => new ConceptBase("id-Lazy", this) { Key = "key-Lazy", Name = "Lazy", Abstract = false, Partition = false }); + _link = new(() => new ConceptBase("id-Link", this) { Key = "key-Link", Name = "Link", Abstract = false, Partition = false }); + _lionCoreFeature = new(() => new ConceptBase("id-LionCoreFeature", this) { Key = "key-LionCoreFeature", Name = "LionCoreFeature", Abstract = false, Partition = false }); + _lionCoreFeatureKind = new(() => new ConceptBase("id-LionCoreFeatureKind", this) { Key = "key-LionCoreFeatureKind", Name = "LionCoreFeatureKind", Abstract = false, Partition = false }); + _lionCoreLanguage = new(() => new ConceptBase("id-LionCoreLanguage", this) { Key = "key-LionCoreLanguage", Name = "LionCoreLanguage", Abstract = false, Partition = false }); + _lionCoreMetaPointer = new(() => new ConceptBase("id-LionCoreMetaPointer", this) { Key = "key-LionCoreMetaPointer", Name = "LionCoreMetaPointer", Abstract = false, Partition = false }); + _lionWeb = new(() => new ConceptBase("id-LionWeb", this) { Key = "key-LionWeb", Name = "LionWeb", Abstract = false, Partition = false }); + _lionWebVersions = new(() => new ConceptBase("id-LionWebVersions", this) { Key = "key-LionWebVersions", Name = "LionWebVersions", Abstract = false, Partition = false }); + _list = new(() => new ConceptBase("id-List", this) { Key = "key-List", Name = "List", Abstract = false, Partition = false }); + _literalsLazy = new(() => new ConceptBase("id-LiteralsLazy", this) { Key = "key-LiteralsLazy", Name = "LiteralsLazy", Abstract = false, Partition = false }); + _m2 = new(() => new ConceptBase("id-M2", this) { Key = "key-M2", Name = "M2", Abstract = false, Partition = false }); + _m3_ = new(() => new ConceptBase("id-M3", this) { Key = "key-M3", Name = "M3", Abstract = false, Partition = false }); + _memberwiseClone = new(() => new ConceptBase("id-MemberwiseClone", this) { Key = "key-MemberwiseClone", Name = "MemberwiseClone", Abstract = false, Partition = false }); + _multiple = new(() => new ConceptBase("id-Multiple", this) { Key = "key-Multiple", Name = "Multiple", Abstract = false, Partition = false }); + _name_ = new(() => new ConceptBase("id-Name", this) { Key = "key-Name", Name = "Name", Abstract = false, Partition = false }); + _notification = new(() => new ConceptBase("id-Notification", this) { Key = "key-Notification", Name = "Notification", Abstract = false, Partition = false }); + _notNullWhenAttribute = new(() => new ConceptBase("id-NotNullWhenAttribute", this) { Key = "key-NotNullWhenAttribute", Name = "NotNullWhenAttribute", Abstract = false, Partition = false }); + _optional = new(() => new ConceptBase("id-Optional", this) { Key = "key-Optional", Name = "Optional", Abstract = false, Partition = false }); + _partition = new(() => new ConceptBase("id-Partition", this) { Key = "key-Partition", Name = "Partition", Abstract = false, Partition = false }); + _pipe = new(() => new ConceptBase("id-Pipe", this) { Key = "key-Pipe", Name = "Pipe", Abstract = false, Partition = false }); + _primitiveType = new(() => new ConceptBase("id-PrimitiveType", this) { Key = "key-PrimitiveType", Name = "PrimitiveType", Abstract = false, Partition = false }); + _primitiveTypeBase = new(() => new ConceptBase("id-PrimitiveTypeBase", this) { Key = "key-PrimitiveTypeBase", Name = "PrimitiveTypeBase", Abstract = false, Partition = false }); + _property = new(() => new ConceptBase("id-Property", this) { Key = "key-Property", Name = "Property", Abstract = false, Partition = false }); + _propertyBase = new(() => new ConceptBase("id-PropertyBase", this) { Key = "key-PropertyBase", Name = "PropertyBase", Abstract = false, Partition = false }); + _reference = new(() => new ConceptBase("id-Reference", this) { Key = "key-Reference", Name = "Reference", Abstract = false, Partition = false }); + _referenceBase = new(() => new ConceptBase("id-ReferenceBase", this) { Key = "key-ReferenceBase", Name = "ReferenceBase", Abstract = false, Partition = false }); + _referenceEquals = new(() => new ConceptBase("id-ReferenceEquals", this) { Key = "key-ReferenceEquals", Name = "ReferenceEquals", Abstract = false, Partition = false }); + _referenceRemover = new(() => new ConceptBase("id-ReferenceRemover", this) { Key = "key-ReferenceRemover", Name = "ReferenceRemover", Abstract = false, Partition = false }); + _referenceTargetNonNullTarget = new(() => new ConceptBase("id-ReferenceTargetNonNullTarget", this) { Key = "key-ReferenceTargetNonNullTarget", Name = "ReferenceTargetNonNullTarget", Abstract = false, Partition = false }); + _referenceTargetNonNullTargets = new(() => new ConceptBase("id-ReferenceTargetNonNullTargets", this) { Key = "key-ReferenceTargetNonNullTargets", Name = "ReferenceTargetNonNullTargets", Abstract = false, Partition = false }); + _referenceTargetNullableTarget = new(() => new ConceptBase("id-ReferenceTargetNullableTarget", this) { Key = "key-ReferenceTargetNullableTarget", Name = "ReferenceTargetNullableTarget", Abstract = false, Partition = false }); + _referenceTargetNullableTargets = new(() => new ConceptBase("id-ReferenceTargetNullableTargets", this) { Key = "key-ReferenceTargetNullableTargets", Name = "ReferenceTargetNullableTargets", Abstract = false, Partition = false }); + _remove = new(() => new ConceptBase("id-Remove", this) { Key = "key-Remove", Name = "Remove", Abstract = false, Partition = false }); + _removeAll = new(() => new ConceptBase("id-RemoveAll", this) { Key = "key-RemoveAll", Name = "RemoveAll", Abstract = false, Partition = false }); + _removeAnnotations = new(() => new ConceptBase("id-RemoveAnnotations", this) { Key = "key-RemoveAnnotations", Name = "RemoveAnnotations", Abstract = false, Partition = false }); + _removeAnnotationsRaw = new(() => new ConceptBase("id-RemoveAnnotationsRaw", this) { Key = "key-RemoveAnnotationsRaw", Name = "RemoveAnnotationsRaw", Abstract = false, Partition = false }); + _removeChildRaw = new(() => new ConceptBase("id-RemoveChildRaw", this) { Key = "key-RemoveChildRaw", Name = "RemoveChildRaw", Abstract = false, Partition = false }); + _removeContainmentsRaw = new(() => new ConceptBase("id-RemoveContainmentsRaw", this) { Key = "key-RemoveContainmentsRaw", Name = "RemoveContainmentsRaw", Abstract = false, Partition = false }); + _removeInternal = new(() => new ConceptBase("id-RemoveInternal", this) { Key = "key-RemoveInternal", Name = "RemoveInternal", Abstract = false, Partition = false }); + _removeOptionalMultipleContainment = new(() => new ConceptBase("id-RemoveOptionalMultipleContainment", this) { Key = "key-RemoveOptionalMultipleContainment", Name = "RemoveOptionalMultipleContainment", Abstract = false, Partition = false }); + _removeOptionalMultipleReference = new(() => new ConceptBase("id-RemoveOptionalMultipleReference", this) { Key = "key-RemoveOptionalMultipleReference", Name = "RemoveOptionalMultipleReference", Abstract = false, Partition = false }); + _removeReferencesRaw = new(() => new ConceptBase("id-RemoveReferencesRaw", this) { Key = "key-RemoveReferencesRaw", Name = "RemoveReferencesRaw", Abstract = false, Partition = false }); + _removeRequiredMultipleContainment = new(() => new ConceptBase("id-RemoveRequiredMultipleContainment", this) { Key = "key-RemoveRequiredMultipleContainment", Name = "RemoveRequiredMultipleContainment", Abstract = false, Partition = false }); + _removeRequiredMultipleReference = new(() => new ConceptBase("id-RemoveRequiredMultipleReference", this) { Key = "key-RemoveRequiredMultipleReference", Name = "RemoveRequiredMultipleReference", Abstract = false, Partition = false }); + _removeSelfParent = new(() => new ConceptBase("id-RemoveSelfParent", this) { Key = "key-RemoveSelfParent", Name = "RemoveSelfParent", Abstract = false, Partition = false }); + _removeSelfParentRaw = new(() => new ConceptBase("id-RemoveSelfParentRaw", this) { Key = "key-RemoveSelfParentRaw", Name = "RemoveSelfParentRaw", Abstract = false, Partition = false }); + _result = new(() => new ConceptBase("id-result", this) { Key = "key-result", Name = "result", Abstract = false, Partition = false }); + _set = new(() => new ConceptBase("id-Set", this) { Key = "key-Set", Name = "Set", Abstract = false, Partition = false }); + _setContainmentRaw = new(() => new ConceptBase("id-SetContainmentRaw", this) { Key = "key-SetContainmentRaw", Name = "SetContainmentRaw", Abstract = false, Partition = false }); + _setInternal = new(() => new ConceptBase("id-SetInternal", this) { Key = "key-SetInternal", Name = "SetInternal", Abstract = false, Partition = false }); + _setInternalAnnotation = new(() => new ConceptBase("id-SetInternalAnnotation", this) { Key = "key-SetInternalAnnotation", Name = "SetInternalAnnotation", Abstract = false, Partition = false }); + _setName = new(() => new ConceptBase("id-SetName", this) { Key = "key-SetName", Name = "SetName", Abstract = false, Partition = false }); + _setNameRaw = new(() => new ConceptBase("id-SetNameRaw", this) { Key = "key-SetNameRaw", Name = "SetNameRaw", Abstract = false, Partition = false }); + _setOptionalMultipleContainment = new(() => new ConceptBase("id-SetOptionalMultipleContainment", this) { Key = "key-SetOptionalMultipleContainment", Name = "SetOptionalMultipleContainment", Abstract = false, Partition = false }); + _setOptionalMultipleReference = new(() => new ConceptBase("id-SetOptionalMultipleReference", this) { Key = "key-SetOptionalMultipleReference", Name = "SetOptionalMultipleReference", Abstract = false, Partition = false }); + _setOptionalReferenceTypeProperty = new(() => new ConceptBase("id-SetOptionalReferenceTypeProperty", this) { Key = "key-SetOptionalReferenceTypeProperty", Name = "SetOptionalReferenceTypeProperty", Abstract = false, Partition = false }); + _setOptionalSingleContainment = new(() => new ConceptBase("id-SetOptionalSingleContainment", this) { Key = "key-SetOptionalSingleContainment", Name = "SetOptionalSingleContainment", Abstract = false, Partition = false }); + _setOptionalSingleReference = new(() => new ConceptBase("id-SetOptionalSingleReference", this) { Key = "key-SetOptionalSingleReference", Name = "SetOptionalSingleReference", Abstract = false, Partition = false }); + _setOptionalValueTypeProperty = new(() => new ConceptBase("id-SetOptionalValueTypeProperty", this) { Key = "key-SetOptionalValueTypeProperty", Name = "SetOptionalValueTypeProperty", Abstract = false, Partition = false }); + _setParentInternal = new(() => new ConceptBase("id-SetParentInternal", this) { Key = "key-SetParentInternal", Name = "SetParentInternal", Abstract = false, Partition = false }); + _setParentNull = new(() => new ConceptBase("id-SetParentNull", this) { Key = "key-SetParentNull", Name = "SetParentNull", Abstract = false, Partition = false }); + _setPropertyRaw = new(() => new ConceptBase("id-SetPropertyRaw", this) { Key = "key-SetPropertyRaw", Name = "SetPropertyRaw", Abstract = false, Partition = false }); + _setRaw = new(() => new ConceptBase("id-SetRaw", this) { Key = "key-SetRaw", Name = "SetRaw", Abstract = false, Partition = false }); + _setReferenceRaw = new(() => new ConceptBase("id-SetReferenceRaw", this) { Key = "key-SetReferenceRaw", Name = "SetReferenceRaw", Abstract = false, Partition = false }); + _setReferencesRaw = new(() => new ConceptBase("id-SetReferencesRaw", this) { Key = "key-SetReferencesRaw", Name = "SetReferencesRaw", Abstract = false, Partition = false }); + _setRequiredMultipleContainment = new(() => new ConceptBase("id-SetRequiredMultipleContainment", this) { Key = "key-SetRequiredMultipleContainment", Name = "SetRequiredMultipleContainment", Abstract = false, Partition = false }); + _setRequiredMultipleReference = new(() => new ConceptBase("id-SetRequiredMultipleReference", this) { Key = "key-SetRequiredMultipleReference", Name = "SetRequiredMultipleReference", Abstract = false, Partition = false }); + _setRequiredReferenceTypeProperty = new(() => new ConceptBase("id-SetRequiredReferenceTypeProperty", this) { Key = "key-SetRequiredReferenceTypeProperty", Name = "SetRequiredReferenceTypeProperty", Abstract = false, Partition = false }); + _setRequiredSingleContainment = new(() => new ConceptBase("id-SetRequiredSingleContainment", this) { Key = "key-SetRequiredSingleContainment", Name = "SetRequiredSingleContainment", Abstract = false, Partition = false }); + _setRequiredSingleReference = new(() => new ConceptBase("id-SetRequiredSingleReference", this) { Key = "key-SetRequiredSingleReference", Name = "SetRequiredSingleReference", Abstract = false, Partition = false }); + _setRequiredValueTypeProperty = new(() => new ConceptBase("id-SetRequiredValueTypeProperty", this) { Key = "key-SetRequiredValueTypeProperty", Name = "SetRequiredValueTypeProperty", Abstract = false, Partition = false }); + _setSelfParent = new(() => new ConceptBase("id-SetSelfParent", this) { Key = "key-SetSelfParent", Name = "SetSelfParent", Abstract = false, Partition = false }); + _setSelfParentRaw = new(() => new ConceptBase("id-SetSelfParentRaw", this) { Key = "key-SetSelfParentRaw", Name = "SetSelfParentRaw", Abstract = false, Partition = false }); + _string = new(() => new ConceptBase("id-String", this) { Key = "key-String", Name = "String", Abstract = false, Partition = false }); + _structuredDataType = new(() => new ConceptBase("id-StructuredDataType", this) { Key = "key-StructuredDataType", Name = "StructuredDataType", Abstract = false, Partition = false }); + _structuredDataTypeBase = new(() => new ConceptBase("id-StructuredDataTypeBase", this) { Key = "key-StructuredDataTypeBase", Name = "StructuredDataTypeBase", Abstract = false, Partition = false }); + _system = new(() => new ConceptBase("id-System", this) { Key = "key-System", Name = "System", Abstract = false, Partition = false }); + _toString = new(() => new ConceptBase("id-ToString", this) { Key = "key-ToString", Name = "ToString", Abstract = false, Partition = false }); + _tryGet = new(() => new ConceptBase("id-TryGet", this) { Key = "key-TryGet", Name = "TryGet", Abstract = false, Partition = false }); + _tryGetContainmentRaw = new(() => new ConceptBase("id-TryGetContainmentRaw", this) { Key = "key-TryGetContainmentRaw", Name = "TryGetContainmentRaw", Abstract = false, Partition = false }); + _tryGetContainmentsRaw = new(() => new ConceptBase("id-TryGetContainmentsRaw", this) { Key = "key-TryGetContainmentsRaw", Name = "TryGetContainmentsRaw", Abstract = false, Partition = false }); + _tryGetName = new(() => new ConceptBase("id-TryGetName", this) { Key = "key-TryGetName", Name = "TryGetName", Abstract = false, Partition = false }); + _tryGetPropertyRaw = new(() => new ConceptBase("id-TryGetPropertyRaw", this) { Key = "key-TryGetPropertyRaw", Name = "TryGetPropertyRaw", Abstract = false, Partition = false }); + _tryGetReference = new(() => new ConceptBase("id-TryGetReference", this) { Key = "key-TryGetReference", Name = "TryGetReference", Abstract = false, Partition = false }); + _tryGetReferenceRaw = new(() => new ConceptBase("id-TryGetReferenceRaw", this) { Key = "key-TryGetReferenceRaw", Name = "TryGetReferenceRaw", Abstract = false, Partition = false }); + _tryGetReferencesRaw = new(() => new ConceptBase("id-TryGetReferencesRaw", this) { Key = "key-TryGetReferencesRaw", Name = "TryGetReferencesRaw", Abstract = false, Partition = false }); + _type = new(() => new ConceptBase("id-Type", this) { Key = "key-Type", Name = "Type", Abstract = false, Partition = false }); + _unsetFeatureException = new(() => new ConceptBase("id-UnsetFeatureException", this) { Key = "key-UnsetFeatureException", Name = "UnsetFeatureException", Abstract = false, Partition = false }); + _unsetFieldException = new(() => new ConceptBase("id-UnsetFieldException", this) { Key = "key-UnsetFieldException", Name = "UnsetFieldException", Abstract = false, Partition = false }); + _unsupportedClassifierException = new(() => new ConceptBase("id-UnsupportedClassifierException", this) { Key = "key-UnsupportedClassifierException", Name = "UnsupportedClassifierException", Abstract = false, Partition = false }); + _unsupportedEnumerationLiteralException = new(() => new ConceptBase("id-UnsupportedEnumerationLiteralException", this) { Key = "key-UnsupportedEnumerationLiteralException", Name = "UnsupportedEnumerationLiteralException", Abstract = false, Partition = false }); + _unsupportedStructuredDataTypeException = new(() => new ConceptBase("id-UnsupportedStructuredDataTypeException", this) { Key = "key-UnsupportedStructuredDataTypeException", Name = "UnsupportedStructuredDataTypeException", Abstract = false, Partition = false }); + _utilities = new(() => new ConceptBase("id-Utilities", this) { Key = "key-Utilities", Name = "Utilities", Abstract = false, Partition = false }); + _v2023_1 = new(() => new ConceptBase("id-V2023_1", this) { Key = "key-V2023_1", Name = "V2023_1", Abstract = false, Partition = false }); + _v2024_1 = new(() => new ConceptBase("id-V2024_1", this) { Key = "key-V2024_1", Name = "V2024_1", Abstract = false, Partition = false }); + _v2024_1_Compatible = new(() => new ConceptBase("id-V2024_1_Compatible", this) { Key = "key-V2024_1_Compatible", Name = "V2024_1_Compatible", Abstract = false, Partition = false }); + _v2025_1 = new(() => new ConceptBase("id-V2025_1", this) { Key = "key-V2025_1", Name = "V2025_1", Abstract = false, Partition = false }); + _v2025_1_Compatible = new(() => new ConceptBase("id-V2025_1_Compatible", this) { Key = "key-V2025_1_Compatible", Name = "V2025_1_Compatible", Abstract = false, Partition = false }); + _versionSpecific = new(() => new ConceptBase("id-VersionSpecific", this) { Key = "key-VersionSpecific", Name = "VersionSpecific", Abstract = false, Partition = false }); + _factory = new LanguageWithLionWebNamedConceptsFactory(this); + } + + /// + public override IReadOnlyList Entities => [_builtIns_, Abstract, AbstractBaseNodeFactory, Add, AddAnnotations, AddAnnotationsRaw, AddChildRaw, AddContainmentsRaw, AddInternal, AddOptionalMultipleContainment, AddOptionalMultipleReference, AddReferencesRaw, AddRequiredMultipleContainment, AddRequiredMultipleReference, AnnotatesLazy, Annotation, AnnotationBase, AnnotationInstanceBase, AnnotationRemover, ArgumentOutOfRangeException, AsList, AsNonEmptyReadOnly, AssureAnnotations, AssureInRange, AssureNonEmpty, AssureNoSelfMove, AssureNotClearing, AssureNotNull, AssureNotNullInstance, AssureNotNullMembers, AssureNullableInstance, AttachChild, Bool, Boolean, Char, Character, Classifier, CodeAnalysis, CollectAllSetFeatures_, Collections, Concept, ConceptBase, ConceptInstanceBase, Containment, ContainmentBase, ContainmentRemover, Core, Datatype, DatatypeBase, Decimal, DetachChild, DetachChildInternal, DetachFromParent, Diagnostics, Enum, Enumeration, EnumerationBase, EnumerationLiteral, EnumerationLiteralBase, Equals_, ExchangeChildRaw, ExchangeChildrenRaw, FeaturesLazy, Field, FieldBase, FieldsLazy, Finalize, Generic, Get_, get__builtIns, get__m3, GetAnnotation, GetAnnotations_, GetAnnotationsRaw_, GetClassifier_, GetConcept_, GetContainmentOf, GetHashCode_, GetId_, GetInternal, GetParent_, GetPartitionNotificationProducer, GetRequiredNonNullReferences, GetRequiredNullableReferences, GetRequiredReference, GetType_, IEnumerable, IFieldValues, ImplementsLazy, INamed, INamedWritable, INode, INodeFactory, Insert, InsertAnnotations, InsertAnnotationsRaw, InsertChildRaw, InsertContainmentsRaw, InsertInternal, InsertOptionalMultipleContainment, InsertOptionalMultipleReference, InsertReferencesRaw, InsertRequiredMultipleContainment, InsertRequiredMultipleReference, Instance_, Integer, Interface, InterfaceBase, InvalidValueException, IPartitionInstance, IReadableNode, IReadOnlyList, IsInRange, IStructuredDataTypeInstance, IWritableNode, Key_, Language, LanguageBase, LanguageEntity, Lazy, Link, LionCoreFeature, LionCoreFeatureKind, LionCoreLanguage, LionCoreMetaPointer, LionWeb, LionWebVersions, List, LiteralsLazy, M2, M3, MemberwiseClone_, Multiple, Name_, Notification, NotNullWhenAttribute, Optional, Partition, Pipe, PrimitiveType, PrimitiveTypeBase, Property, PropertyBase, Reference, ReferenceBase, ReferenceEquals_, ReferenceRemover, ReferenceTargetNonNullTarget, ReferenceTargetNonNullTargets, ReferenceTargetNullableTarget, ReferenceTargetNullableTargets, Remove, RemoveAll, RemoveAnnotations, RemoveAnnotationsRaw, RemoveChildRaw, RemoveContainmentsRaw, RemoveInternal, RemoveOptionalMultipleContainment, RemoveOptionalMultipleReference, RemoveReferencesRaw, RemoveRequiredMultipleContainment, RemoveRequiredMultipleReference, RemoveSelfParent, RemoveSelfParentRaw, result, Set, SetContainmentRaw, SetInternal, SetInternalAnnotation, SetName, SetNameRaw, SetOptionalMultipleContainment, SetOptionalMultipleReference, SetOptionalReferenceTypeProperty, SetOptionalSingleContainment, SetOptionalSingleReference, SetOptionalValueTypeProperty, SetParentInternal, SetParentNull, SetPropertyRaw, SetRaw, SetReferenceRaw, SetReferencesRaw, SetRequiredMultipleContainment, SetRequiredMultipleReference, SetRequiredReferenceTypeProperty, SetRequiredSingleContainment, SetRequiredSingleReference, SetRequiredValueTypeProperty, SetSelfParent, SetSelfParentRaw, String, StructuredDataType, StructuredDataTypeBase, System, ToString_, TryGet_, TryGetContainmentRaw_, TryGetContainmentsRaw_, TryGetName_, TryGetPropertyRaw_, TryGetReference, TryGetReferenceRaw_, TryGetReferencesRaw_, Type, UnsetFeatureException, UnsetFieldException, UnsupportedClassifierException, UnsupportedEnumerationLiteralException, UnsupportedStructuredDataTypeException, Utilities, V2023_1, V2024_1, V2024_1_Compatible, V2025_1, V2025_1_Compatible, VersionSpecific]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-LanguageWithLionWebNamedConcepts"; + /// + public override string Key => _key; + + private const string _name = "LanguageWithLionWebNamedConcepts"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy __builtIns; + public global::LionWeb.Core.M3.Concept _builtIns_ => __builtIns.Value; + + private readonly Lazy _abstract; + public global::LionWeb.Core.M3.Concept Abstract => _abstract.Value; + + private readonly Lazy _abstractBaseNodeFactory; + public global::LionWeb.Core.M3.Concept AbstractBaseNodeFactory => _abstractBaseNodeFactory.Value; + + private readonly Lazy _add; + public global::LionWeb.Core.M3.Concept Add => _add.Value; + + private readonly Lazy _addAnnotations; + public global::LionWeb.Core.M3.Concept AddAnnotations => _addAnnotations.Value; + + private readonly Lazy _addAnnotationsRaw; + public global::LionWeb.Core.M3.Concept AddAnnotationsRaw => _addAnnotationsRaw.Value; + + private readonly Lazy _addChildRaw; + public global::LionWeb.Core.M3.Concept AddChildRaw => _addChildRaw.Value; + + private readonly Lazy _addContainmentsRaw; + public global::LionWeb.Core.M3.Concept AddContainmentsRaw => _addContainmentsRaw.Value; + + private readonly Lazy _addInternal; + public global::LionWeb.Core.M3.Concept AddInternal => _addInternal.Value; + + private readonly Lazy _addOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept AddOptionalMultipleContainment => _addOptionalMultipleContainment.Value; + + private readonly Lazy _addOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept AddOptionalMultipleReference => _addOptionalMultipleReference.Value; + + private readonly Lazy _addReferencesRaw; + public global::LionWeb.Core.M3.Concept AddReferencesRaw => _addReferencesRaw.Value; + + private readonly Lazy _addRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept AddRequiredMultipleContainment => _addRequiredMultipleContainment.Value; + + private readonly Lazy _addRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept AddRequiredMultipleReference => _addRequiredMultipleReference.Value; + + private readonly Lazy _annotatesLazy; + public global::LionWeb.Core.M3.Concept AnnotatesLazy => _annotatesLazy.Value; + + private readonly Lazy _annotation; + public global::LionWeb.Core.M3.Concept Annotation => _annotation.Value; + + private readonly Lazy _annotationBase; + public global::LionWeb.Core.M3.Concept AnnotationBase => _annotationBase.Value; + + private readonly Lazy _annotationInstanceBase; + public global::LionWeb.Core.M3.Concept AnnotationInstanceBase => _annotationInstanceBase.Value; + + private readonly Lazy _annotationRemover; + public global::LionWeb.Core.M3.Concept AnnotationRemover => _annotationRemover.Value; + + private readonly Lazy _argumentOutOfRangeException; + public global::LionWeb.Core.M3.Concept ArgumentOutOfRangeException => _argumentOutOfRangeException.Value; + + private readonly Lazy _asList; + public global::LionWeb.Core.M3.Concept AsList => _asList.Value; + + private readonly Lazy _asNonEmptyReadOnly; + public global::LionWeb.Core.M3.Concept AsNonEmptyReadOnly => _asNonEmptyReadOnly.Value; + + private readonly Lazy _assureAnnotations; + public global::LionWeb.Core.M3.Concept AssureAnnotations => _assureAnnotations.Value; + + private readonly Lazy _assureInRange; + public global::LionWeb.Core.M3.Concept AssureInRange => _assureInRange.Value; + + private readonly Lazy _assureNonEmpty; + public global::LionWeb.Core.M3.Concept AssureNonEmpty => _assureNonEmpty.Value; + + private readonly Lazy _assureNoSelfMove; + public global::LionWeb.Core.M3.Concept AssureNoSelfMove => _assureNoSelfMove.Value; + + private readonly Lazy _assureNotClearing; + public global::LionWeb.Core.M3.Concept AssureNotClearing => _assureNotClearing.Value; + + private readonly Lazy _assureNotNull; + public global::LionWeb.Core.M3.Concept AssureNotNull => _assureNotNull.Value; + + private readonly Lazy _assureNotNullInstance; + public global::LionWeb.Core.M3.Concept AssureNotNullInstance => _assureNotNullInstance.Value; + + private readonly Lazy _assureNotNullMembers; + public global::LionWeb.Core.M3.Concept AssureNotNullMembers => _assureNotNullMembers.Value; + + private readonly Lazy _assureNullableInstance; + public global::LionWeb.Core.M3.Concept AssureNullableInstance => _assureNullableInstance.Value; + + private readonly Lazy _attachChild; + public global::LionWeb.Core.M3.Concept AttachChild => _attachChild.Value; + + private readonly Lazy _bool; + public global::LionWeb.Core.M3.Concept Bool => _bool.Value; + + private readonly Lazy _boolean; + public global::LionWeb.Core.M3.Concept Boolean => _boolean.Value; + + private readonly Lazy _char; + public global::LionWeb.Core.M3.Concept Char => _char.Value; + + private readonly Lazy _character; + public global::LionWeb.Core.M3.Concept Character => _character.Value; + + private readonly Lazy _classifier; + public global::LionWeb.Core.M3.Concept Classifier => _classifier.Value; + + private readonly Lazy _codeAnalysis; + public global::LionWeb.Core.M3.Concept CodeAnalysis => _codeAnalysis.Value; + + private readonly Lazy _collectAllSetFeatures; + public global::LionWeb.Core.M3.Concept CollectAllSetFeatures_ => _collectAllSetFeatures.Value; + + private readonly Lazy _collections; + public global::LionWeb.Core.M3.Concept Collections => _collections.Value; + + private readonly Lazy _concept; + public global::LionWeb.Core.M3.Concept Concept => _concept.Value; + + private readonly Lazy _conceptBase; + public global::LionWeb.Core.M3.Concept ConceptBase => _conceptBase.Value; + + private readonly Lazy _conceptInstanceBase; + public global::LionWeb.Core.M3.Concept ConceptInstanceBase => _conceptInstanceBase.Value; + + private readonly Lazy _containment; + public global::LionWeb.Core.M3.Concept Containment => _containment.Value; + + private readonly Lazy _containmentBase; + public global::LionWeb.Core.M3.Concept ContainmentBase => _containmentBase.Value; + + private readonly Lazy _containmentRemover; + public global::LionWeb.Core.M3.Concept ContainmentRemover => _containmentRemover.Value; + + private readonly Lazy _core; + public global::LionWeb.Core.M3.Concept Core => _core.Value; + + private readonly Lazy _datatype; + public global::LionWeb.Core.M3.Concept Datatype => _datatype.Value; + + private readonly Lazy _datatypeBase; + public global::LionWeb.Core.M3.Concept DatatypeBase => _datatypeBase.Value; + + private readonly Lazy _decimal; + public global::LionWeb.Core.M3.Concept Decimal => _decimal.Value; + + private readonly Lazy _detachChild; + public global::LionWeb.Core.M3.Concept DetachChild => _detachChild.Value; + + private readonly Lazy _detachChildInternal; + public global::LionWeb.Core.M3.Concept DetachChildInternal => _detachChildInternal.Value; + + private readonly Lazy _detachFromParent; + public global::LionWeb.Core.M3.Concept DetachFromParent => _detachFromParent.Value; + + private readonly Lazy _diagnostics; + public global::LionWeb.Core.M3.Concept Diagnostics => _diagnostics.Value; + + private readonly Lazy _enum; + public global::LionWeb.Core.M3.Concept Enum => _enum.Value; + + private readonly Lazy _enumeration; + public global::LionWeb.Core.M3.Concept Enumeration => _enumeration.Value; + + private readonly Lazy _enumerationBase; + public global::LionWeb.Core.M3.Concept EnumerationBase => _enumerationBase.Value; + + private readonly Lazy _enumerationLiteral; + public global::LionWeb.Core.M3.Concept EnumerationLiteral => _enumerationLiteral.Value; + + private readonly Lazy _enumerationLiteralBase; + public global::LionWeb.Core.M3.Concept EnumerationLiteralBase => _enumerationLiteralBase.Value; + + private readonly Lazy _equals; + public global::LionWeb.Core.M3.Concept Equals_ => _equals.Value; + + private readonly Lazy _exchangeChildRaw; + public global::LionWeb.Core.M3.Concept ExchangeChildRaw => _exchangeChildRaw.Value; + + private readonly Lazy _exchangeChildrenRaw; + public global::LionWeb.Core.M3.Concept ExchangeChildrenRaw => _exchangeChildrenRaw.Value; + + private readonly Lazy _featuresLazy; + public global::LionWeb.Core.M3.Concept FeaturesLazy => _featuresLazy.Value; + + private readonly Lazy _field; + public global::LionWeb.Core.M3.Concept Field => _field.Value; + + private readonly Lazy _fieldBase; + public global::LionWeb.Core.M3.Concept FieldBase => _fieldBase.Value; + + private readonly Lazy _fieldsLazy; + public global::LionWeb.Core.M3.Concept FieldsLazy => _fieldsLazy.Value; + + private readonly Lazy _finalize; + public global::LionWeb.Core.M3.Concept Finalize => _finalize.Value; + + private readonly Lazy _generic; + public global::LionWeb.Core.M3.Concept Generic => _generic.Value; + + private readonly Lazy _get; + public global::LionWeb.Core.M3.Concept Get_ => _get.Value; + + private readonly Lazy _get__builtIns; + public global::LionWeb.Core.M3.Concept get__builtIns => _get__builtIns.Value; + + private readonly Lazy _get__m3; + public global::LionWeb.Core.M3.Concept get__m3 => _get__m3.Value; + + private readonly Lazy _getAnnotation; + public global::LionWeb.Core.M3.Concept GetAnnotation => _getAnnotation.Value; + + private readonly Lazy _getAnnotations; + public global::LionWeb.Core.M3.Concept GetAnnotations_ => _getAnnotations.Value; + + private readonly Lazy _getAnnotationsRaw; + public global::LionWeb.Core.M3.Concept GetAnnotationsRaw_ => _getAnnotationsRaw.Value; + + private readonly Lazy _getClassifier; + public global::LionWeb.Core.M3.Concept GetClassifier_ => _getClassifier.Value; + + private readonly Lazy _getConcept; + public global::LionWeb.Core.M3.Concept GetConcept_ => _getConcept.Value; + + private readonly Lazy _getContainmentOf; + public global::LionWeb.Core.M3.Concept GetContainmentOf => _getContainmentOf.Value; + + private readonly Lazy _getHashCode; + public global::LionWeb.Core.M3.Concept GetHashCode_ => _getHashCode.Value; + + private readonly Lazy _getId; + public global::LionWeb.Core.M3.Concept GetId_ => _getId.Value; + + private readonly Lazy _getInternal; + public global::LionWeb.Core.M3.Concept GetInternal => _getInternal.Value; + + private readonly Lazy _getParent; + public global::LionWeb.Core.M3.Concept GetParent_ => _getParent.Value; + + private readonly Lazy _getPartitionNotificationProducer; + public global::LionWeb.Core.M3.Concept GetPartitionNotificationProducer => _getPartitionNotificationProducer.Value; + + private readonly Lazy _getRequiredNonNullReferences; + public global::LionWeb.Core.M3.Concept GetRequiredNonNullReferences => _getRequiredNonNullReferences.Value; + + private readonly Lazy _getRequiredNullableReferences; + public global::LionWeb.Core.M3.Concept GetRequiredNullableReferences => _getRequiredNullableReferences.Value; + + private readonly Lazy _getRequiredReference; + public global::LionWeb.Core.M3.Concept GetRequiredReference => _getRequiredReference.Value; + + private readonly Lazy _getType; + public global::LionWeb.Core.M3.Concept GetType_ => _getType.Value; + + private readonly Lazy _iEnumerable; + public global::LionWeb.Core.M3.Concept IEnumerable => _iEnumerable.Value; + + private readonly Lazy _iFieldValues; + public global::LionWeb.Core.M3.Concept IFieldValues => _iFieldValues.Value; + + private readonly Lazy _implementsLazy; + public global::LionWeb.Core.M3.Concept ImplementsLazy => _implementsLazy.Value; + + private readonly Lazy _iNamed; + public global::LionWeb.Core.M3.Concept INamed => _iNamed.Value; + + private readonly Lazy _iNamedWritable; + public global::LionWeb.Core.M3.Concept INamedWritable => _iNamedWritable.Value; + + private readonly Lazy _iNode; + public global::LionWeb.Core.M3.Concept INode => _iNode.Value; + + private readonly Lazy _iNodeFactory; + public global::LionWeb.Core.M3.Concept INodeFactory => _iNodeFactory.Value; + + private readonly Lazy _insert; + public global::LionWeb.Core.M3.Concept Insert => _insert.Value; + + private readonly Lazy _insertAnnotations; + public global::LionWeb.Core.M3.Concept InsertAnnotations => _insertAnnotations.Value; + + private readonly Lazy _insertAnnotationsRaw; + public global::LionWeb.Core.M3.Concept InsertAnnotationsRaw => _insertAnnotationsRaw.Value; + + private readonly Lazy _insertChildRaw; + public global::LionWeb.Core.M3.Concept InsertChildRaw => _insertChildRaw.Value; + + private readonly Lazy _insertContainmentsRaw; + public global::LionWeb.Core.M3.Concept InsertContainmentsRaw => _insertContainmentsRaw.Value; + + private readonly Lazy _insertInternal; + public global::LionWeb.Core.M3.Concept InsertInternal => _insertInternal.Value; + + private readonly Lazy _insertOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept InsertOptionalMultipleContainment => _insertOptionalMultipleContainment.Value; + + private readonly Lazy _insertOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept InsertOptionalMultipleReference => _insertOptionalMultipleReference.Value; + + private readonly Lazy _insertReferencesRaw; + public global::LionWeb.Core.M3.Concept InsertReferencesRaw => _insertReferencesRaw.Value; + + private readonly Lazy _insertRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept InsertRequiredMultipleContainment => _insertRequiredMultipleContainment.Value; + + private readonly Lazy _insertRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept InsertRequiredMultipleReference => _insertRequiredMultipleReference.Value; + + private readonly Lazy _instance; + public global::LionWeb.Core.M3.Concept Instance_ => _instance.Value; + + private readonly Lazy _integer; + public global::LionWeb.Core.M3.Concept Integer => _integer.Value; + + private readonly Lazy _interface; + public global::LionWeb.Core.M3.Concept Interface => _interface.Value; + + private readonly Lazy _interfaceBase; + public global::LionWeb.Core.M3.Concept InterfaceBase => _interfaceBase.Value; + + private readonly Lazy _invalidValueException; + public global::LionWeb.Core.M3.Concept InvalidValueException => _invalidValueException.Value; + + private readonly Lazy _iPartitionInstance; + public global::LionWeb.Core.M3.Concept IPartitionInstance => _iPartitionInstance.Value; + + private readonly Lazy _iReadableNode; + public global::LionWeb.Core.M3.Concept IReadableNode => _iReadableNode.Value; + + private readonly Lazy _iReadOnlyList; + public global::LionWeb.Core.M3.Concept IReadOnlyList => _iReadOnlyList.Value; + + private readonly Lazy _isInRange; + public global::LionWeb.Core.M3.Concept IsInRange => _isInRange.Value; + + private readonly Lazy _iStructuredDataTypeInstance; + public global::LionWeb.Core.M3.Concept IStructuredDataTypeInstance => _iStructuredDataTypeInstance.Value; + + private readonly Lazy _iWritableNode; + public global::LionWeb.Core.M3.Concept IWritableNode => _iWritableNode.Value; + + private readonly Lazy _key_; + public global::LionWeb.Core.M3.Concept Key_ => _key_.Value; + + private readonly Lazy _language; + public global::LionWeb.Core.M3.Concept Language => _language.Value; + + private readonly Lazy _languageBase; + public global::LionWeb.Core.M3.Concept LanguageBase => _languageBase.Value; + + private readonly Lazy _languageEntity; + public global::LionWeb.Core.M3.Concept LanguageEntity => _languageEntity.Value; + + private readonly Lazy _lazy; + public global::LionWeb.Core.M3.Concept Lazy => _lazy.Value; + + private readonly Lazy _link; + public global::LionWeb.Core.M3.Concept Link => _link.Value; + + private readonly Lazy _lionCoreFeature; + public global::LionWeb.Core.M3.Concept LionCoreFeature => _lionCoreFeature.Value; + + private readonly Lazy _lionCoreFeatureKind; + public global::LionWeb.Core.M3.Concept LionCoreFeatureKind => _lionCoreFeatureKind.Value; + + private readonly Lazy _lionCoreLanguage; + public global::LionWeb.Core.M3.Concept LionCoreLanguage => _lionCoreLanguage.Value; + + private readonly Lazy _lionCoreMetaPointer; + public global::LionWeb.Core.M3.Concept LionCoreMetaPointer => _lionCoreMetaPointer.Value; + + private readonly Lazy _lionWeb; + public global::LionWeb.Core.M3.Concept LionWeb => _lionWeb.Value; + + private readonly Lazy _lionWebVersions; + public global::LionWeb.Core.M3.Concept LionWebVersions => _lionWebVersions.Value; + + private readonly Lazy _list; + public global::LionWeb.Core.M3.Concept List => _list.Value; + + private readonly Lazy _literalsLazy; + public global::LionWeb.Core.M3.Concept LiteralsLazy => _literalsLazy.Value; + + private readonly Lazy _m2; + public global::LionWeb.Core.M3.Concept M2 => _m2.Value; + + private readonly Lazy _m3_; + public global::LionWeb.Core.M3.Concept M3 => _m3_.Value; + + private readonly Lazy _memberwiseClone; + public global::LionWeb.Core.M3.Concept MemberwiseClone_ => _memberwiseClone.Value; + + private readonly Lazy _multiple; + public global::LionWeb.Core.M3.Concept Multiple => _multiple.Value; + + private readonly Lazy _name_; + public global::LionWeb.Core.M3.Concept Name_ => _name_.Value; + + private readonly Lazy _notification; + public global::LionWeb.Core.M3.Concept Notification => _notification.Value; + + private readonly Lazy _notNullWhenAttribute; + public global::LionWeb.Core.M3.Concept NotNullWhenAttribute => _notNullWhenAttribute.Value; + + private readonly Lazy _optional; + public global::LionWeb.Core.M3.Concept Optional => _optional.Value; + + private readonly Lazy _partition; + public global::LionWeb.Core.M3.Concept Partition => _partition.Value; + + private readonly Lazy _pipe; + public global::LionWeb.Core.M3.Concept Pipe => _pipe.Value; + + private readonly Lazy _primitiveType; + public global::LionWeb.Core.M3.Concept PrimitiveType => _primitiveType.Value; + + private readonly Lazy _primitiveTypeBase; + public global::LionWeb.Core.M3.Concept PrimitiveTypeBase => _primitiveTypeBase.Value; + + private readonly Lazy _property; + public global::LionWeb.Core.M3.Concept Property => _property.Value; + + private readonly Lazy _propertyBase; + public global::LionWeb.Core.M3.Concept PropertyBase => _propertyBase.Value; + + private readonly Lazy _reference; + public global::LionWeb.Core.M3.Concept Reference => _reference.Value; + + private readonly Lazy _referenceBase; + public global::LionWeb.Core.M3.Concept ReferenceBase => _referenceBase.Value; + + private readonly Lazy _referenceEquals; + public global::LionWeb.Core.M3.Concept ReferenceEquals_ => _referenceEquals.Value; + + private readonly Lazy _referenceRemover; + public global::LionWeb.Core.M3.Concept ReferenceRemover => _referenceRemover.Value; + + private readonly Lazy _referenceTargetNonNullTarget; + public global::LionWeb.Core.M3.Concept ReferenceTargetNonNullTarget => _referenceTargetNonNullTarget.Value; + + private readonly Lazy _referenceTargetNonNullTargets; + public global::LionWeb.Core.M3.Concept ReferenceTargetNonNullTargets => _referenceTargetNonNullTargets.Value; + + private readonly Lazy _referenceTargetNullableTarget; + public global::LionWeb.Core.M3.Concept ReferenceTargetNullableTarget => _referenceTargetNullableTarget.Value; + + private readonly Lazy _referenceTargetNullableTargets; + public global::LionWeb.Core.M3.Concept ReferenceTargetNullableTargets => _referenceTargetNullableTargets.Value; + + private readonly Lazy _remove; + public global::LionWeb.Core.M3.Concept Remove => _remove.Value; + + private readonly Lazy _removeAll; + public global::LionWeb.Core.M3.Concept RemoveAll => _removeAll.Value; + + private readonly Lazy _removeAnnotations; + public global::LionWeb.Core.M3.Concept RemoveAnnotations => _removeAnnotations.Value; + + private readonly Lazy _removeAnnotationsRaw; + public global::LionWeb.Core.M3.Concept RemoveAnnotationsRaw => _removeAnnotationsRaw.Value; + + private readonly Lazy _removeChildRaw; + public global::LionWeb.Core.M3.Concept RemoveChildRaw => _removeChildRaw.Value; + + private readonly Lazy _removeContainmentsRaw; + public global::LionWeb.Core.M3.Concept RemoveContainmentsRaw => _removeContainmentsRaw.Value; + + private readonly Lazy _removeInternal; + public global::LionWeb.Core.M3.Concept RemoveInternal => _removeInternal.Value; + + private readonly Lazy _removeOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept RemoveOptionalMultipleContainment => _removeOptionalMultipleContainment.Value; + + private readonly Lazy _removeOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept RemoveOptionalMultipleReference => _removeOptionalMultipleReference.Value; + + private readonly Lazy _removeReferencesRaw; + public global::LionWeb.Core.M3.Concept RemoveReferencesRaw => _removeReferencesRaw.Value; + + private readonly Lazy _removeRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept RemoveRequiredMultipleContainment => _removeRequiredMultipleContainment.Value; + + private readonly Lazy _removeRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept RemoveRequiredMultipleReference => _removeRequiredMultipleReference.Value; + + private readonly Lazy _removeSelfParent; + public global::LionWeb.Core.M3.Concept RemoveSelfParent => _removeSelfParent.Value; + + private readonly Lazy _removeSelfParentRaw; + public global::LionWeb.Core.M3.Concept RemoveSelfParentRaw => _removeSelfParentRaw.Value; + + private readonly Lazy _result; + public global::LionWeb.Core.M3.Concept result => _result.Value; + + private readonly Lazy _set; + public global::LionWeb.Core.M3.Concept Set => _set.Value; + + private readonly Lazy _setContainmentRaw; + public global::LionWeb.Core.M3.Concept SetContainmentRaw => _setContainmentRaw.Value; + + private readonly Lazy _setInternal; + public global::LionWeb.Core.M3.Concept SetInternal => _setInternal.Value; + + private readonly Lazy _setInternalAnnotation; + public global::LionWeb.Core.M3.Concept SetInternalAnnotation => _setInternalAnnotation.Value; + + private readonly Lazy _setName; + public global::LionWeb.Core.M3.Concept SetName => _setName.Value; + + private readonly Lazy _setNameRaw; + public global::LionWeb.Core.M3.Concept SetNameRaw => _setNameRaw.Value; + + private readonly Lazy _setOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept SetOptionalMultipleContainment => _setOptionalMultipleContainment.Value; + + private readonly Lazy _setOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept SetOptionalMultipleReference => _setOptionalMultipleReference.Value; + + private readonly Lazy _setOptionalReferenceTypeProperty; + public global::LionWeb.Core.M3.Concept SetOptionalReferenceTypeProperty => _setOptionalReferenceTypeProperty.Value; + + private readonly Lazy _setOptionalSingleContainment; + public global::LionWeb.Core.M3.Concept SetOptionalSingleContainment => _setOptionalSingleContainment.Value; + + private readonly Lazy _setOptionalSingleReference; + public global::LionWeb.Core.M3.Concept SetOptionalSingleReference => _setOptionalSingleReference.Value; + + private readonly Lazy _setOptionalValueTypeProperty; + public global::LionWeb.Core.M3.Concept SetOptionalValueTypeProperty => _setOptionalValueTypeProperty.Value; + + private readonly Lazy _setParentInternal; + public global::LionWeb.Core.M3.Concept SetParentInternal => _setParentInternal.Value; + + private readonly Lazy _setParentNull; + public global::LionWeb.Core.M3.Concept SetParentNull => _setParentNull.Value; + + private readonly Lazy _setPropertyRaw; + public global::LionWeb.Core.M3.Concept SetPropertyRaw => _setPropertyRaw.Value; + + private readonly Lazy _setRaw; + public global::LionWeb.Core.M3.Concept SetRaw => _setRaw.Value; + + private readonly Lazy _setReferenceRaw; + public global::LionWeb.Core.M3.Concept SetReferenceRaw => _setReferenceRaw.Value; + + private readonly Lazy _setReferencesRaw; + public global::LionWeb.Core.M3.Concept SetReferencesRaw => _setReferencesRaw.Value; + + private readonly Lazy _setRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept SetRequiredMultipleContainment => _setRequiredMultipleContainment.Value; + + private readonly Lazy _setRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept SetRequiredMultipleReference => _setRequiredMultipleReference.Value; + + private readonly Lazy _setRequiredReferenceTypeProperty; + public global::LionWeb.Core.M3.Concept SetRequiredReferenceTypeProperty => _setRequiredReferenceTypeProperty.Value; + + private readonly Lazy _setRequiredSingleContainment; + public global::LionWeb.Core.M3.Concept SetRequiredSingleContainment => _setRequiredSingleContainment.Value; + + private readonly Lazy _setRequiredSingleReference; + public global::LionWeb.Core.M3.Concept SetRequiredSingleReference => _setRequiredSingleReference.Value; + + private readonly Lazy _setRequiredValueTypeProperty; + public global::LionWeb.Core.M3.Concept SetRequiredValueTypeProperty => _setRequiredValueTypeProperty.Value; + + private readonly Lazy _setSelfParent; + public global::LionWeb.Core.M3.Concept SetSelfParent => _setSelfParent.Value; + + private readonly Lazy _setSelfParentRaw; + public global::LionWeb.Core.M3.Concept SetSelfParentRaw => _setSelfParentRaw.Value; + + private readonly Lazy _string; + public global::LionWeb.Core.M3.Concept String => _string.Value; + + private readonly Lazy _structuredDataType; + public global::LionWeb.Core.M3.Concept StructuredDataType => _structuredDataType.Value; + + private readonly Lazy _structuredDataTypeBase; + public global::LionWeb.Core.M3.Concept StructuredDataTypeBase => _structuredDataTypeBase.Value; + + private readonly Lazy _system; + public global::LionWeb.Core.M3.Concept System => _system.Value; + + private readonly Lazy _toString; + public global::LionWeb.Core.M3.Concept ToString_ => _toString.Value; + + private readonly Lazy _tryGet; + public global::LionWeb.Core.M3.Concept TryGet_ => _tryGet.Value; + + private readonly Lazy _tryGetContainmentRaw; + public global::LionWeb.Core.M3.Concept TryGetContainmentRaw_ => _tryGetContainmentRaw.Value; + + private readonly Lazy _tryGetContainmentsRaw; + public global::LionWeb.Core.M3.Concept TryGetContainmentsRaw_ => _tryGetContainmentsRaw.Value; + + private readonly Lazy _tryGetName; + public global::LionWeb.Core.M3.Concept TryGetName_ => _tryGetName.Value; + + private readonly Lazy _tryGetPropertyRaw; + public global::LionWeb.Core.M3.Concept TryGetPropertyRaw_ => _tryGetPropertyRaw.Value; + + private readonly Lazy _tryGetReference; + public global::LionWeb.Core.M3.Concept TryGetReference => _tryGetReference.Value; + + private readonly Lazy _tryGetReferenceRaw; + public global::LionWeb.Core.M3.Concept TryGetReferenceRaw_ => _tryGetReferenceRaw.Value; + + private readonly Lazy _tryGetReferencesRaw; + public global::LionWeb.Core.M3.Concept TryGetReferencesRaw_ => _tryGetReferencesRaw.Value; + + private readonly Lazy _type; + public global::LionWeb.Core.M3.Concept Type => _type.Value; + + private readonly Lazy _unsetFeatureException; + public global::LionWeb.Core.M3.Concept UnsetFeatureException => _unsetFeatureException.Value; + + private readonly Lazy _unsetFieldException; + public global::LionWeb.Core.M3.Concept UnsetFieldException => _unsetFieldException.Value; + + private readonly Lazy _unsupportedClassifierException; + public global::LionWeb.Core.M3.Concept UnsupportedClassifierException => _unsupportedClassifierException.Value; + + private readonly Lazy _unsupportedEnumerationLiteralException; + public global::LionWeb.Core.M3.Concept UnsupportedEnumerationLiteralException => _unsupportedEnumerationLiteralException.Value; + + private readonly Lazy _unsupportedStructuredDataTypeException; + public global::LionWeb.Core.M3.Concept UnsupportedStructuredDataTypeException => _unsupportedStructuredDataTypeException.Value; + + private readonly Lazy _utilities; + public global::LionWeb.Core.M3.Concept Utilities => _utilities.Value; + + private readonly Lazy _v2023_1; + public global::LionWeb.Core.M3.Concept V2023_1 => _v2023_1.Value; + + private readonly Lazy _v2024_1; + public global::LionWeb.Core.M3.Concept V2024_1 => _v2024_1.Value; + + private readonly Lazy _v2024_1_Compatible; + public global::LionWeb.Core.M3.Concept V2024_1_Compatible => _v2024_1_Compatible.Value; + + private readonly Lazy _v2025_1; + public global::LionWeb.Core.M3.Concept V2025_1 => _v2025_1.Value; + + private readonly Lazy _v2025_1_Compatible; + public global::LionWeb.Core.M3.Concept V2025_1_Compatible => _v2025_1_Compatible.Value; + + private readonly Lazy _versionSpecific; + public global::LionWeb.Core.M3.Concept VersionSpecific => _versionSpecific.Value; +} + +public partial interface ILanguageWithLionWebNamedConceptsFactory : global::LionWeb.Core.M2.INodeFactory +{ + public _builtIns New_builtIns(string id); + public _builtIns Create_builtIns(); + public Abstract NewAbstract(string id); + public Abstract CreateAbstract(); + public AbstractBaseNodeFactory NewAbstractBaseNodeFactory(string id); + public AbstractBaseNodeFactory CreateAbstractBaseNodeFactory(); + public Add NewAdd(string id); + public Add CreateAdd(); + public AddAnnotations NewAddAnnotations(string id); + public AddAnnotations CreateAddAnnotations(); + public AddAnnotationsRaw NewAddAnnotationsRaw(string id); + public AddAnnotationsRaw CreateAddAnnotationsRaw(); + public AddChildRaw NewAddChildRaw(string id); + public AddChildRaw CreateAddChildRaw(); + public AddContainmentsRaw_ NewAddContainmentsRaw(string id); + public AddContainmentsRaw_ CreateAddContainmentsRaw(); + public AddInternal_ NewAddInternal(string id); + public AddInternal_ CreateAddInternal(); + public AddOptionalMultipleContainment NewAddOptionalMultipleContainment(string id); + public AddOptionalMultipleContainment CreateAddOptionalMultipleContainment(); + public AddOptionalMultipleReference NewAddOptionalMultipleReference(string id); + public AddOptionalMultipleReference CreateAddOptionalMultipleReference(); + public AddReferencesRaw_ NewAddReferencesRaw(string id); + public AddReferencesRaw_ CreateAddReferencesRaw(); + public AddRequiredMultipleContainment NewAddRequiredMultipleContainment(string id); + public AddRequiredMultipleContainment CreateAddRequiredMultipleContainment(); + public AddRequiredMultipleReference NewAddRequiredMultipleReference(string id); + public AddRequiredMultipleReference CreateAddRequiredMultipleReference(); + public AnnotatesLazy NewAnnotatesLazy(string id); + public AnnotatesLazy CreateAnnotatesLazy(); + public Annotation NewAnnotation(string id); + public Annotation CreateAnnotation(); + public AnnotationBase NewAnnotationBase(string id); + public AnnotationBase CreateAnnotationBase(); + public AnnotationInstanceBase NewAnnotationInstanceBase(string id); + public AnnotationInstanceBase CreateAnnotationInstanceBase(); + public AnnotationRemover NewAnnotationRemover(string id); + public AnnotationRemover CreateAnnotationRemover(); + public ArgumentOutOfRangeException NewArgumentOutOfRangeException(string id); + public ArgumentOutOfRangeException CreateArgumentOutOfRangeException(); + public AsList NewAsList(string id); + public AsList CreateAsList(); + public AsNonEmptyReadOnly NewAsNonEmptyReadOnly(string id); + public AsNonEmptyReadOnly CreateAsNonEmptyReadOnly(); + public AssureAnnotations NewAssureAnnotations(string id); + public AssureAnnotations CreateAssureAnnotations(); + public AssureInRange NewAssureInRange(string id); + public AssureInRange CreateAssureInRange(); + public AssureNonEmpty NewAssureNonEmpty(string id); + public AssureNonEmpty CreateAssureNonEmpty(); + public AssureNoSelfMove NewAssureNoSelfMove(string id); + public AssureNoSelfMove CreateAssureNoSelfMove(); + public AssureNotClearing NewAssureNotClearing(string id); + public AssureNotClearing CreateAssureNotClearing(); + public AssureNotNull NewAssureNotNull(string id); + public AssureNotNull CreateAssureNotNull(); + public AssureNotNullInstance NewAssureNotNullInstance(string id); + public AssureNotNullInstance CreateAssureNotNullInstance(); + public AssureNotNullMembers NewAssureNotNullMembers(string id); + public AssureNotNullMembers CreateAssureNotNullMembers(); + public AssureNullableInstance NewAssureNullableInstance(string id); + public AssureNullableInstance CreateAssureNullableInstance(); + public AttachChild NewAttachChild(string id); + public AttachChild CreateAttachChild(); + public Bool NewBool(string id); + public Bool CreateBool(); + public Boolean NewBoolean(string id); + public Boolean CreateBoolean(); + public Char NewChar(string id); + public Char CreateChar(); + public Character NewCharacter(string id); + public Character CreateCharacter(); + public Classifier NewClassifier(string id); + public Classifier CreateClassifier(); + public CodeAnalysis NewCodeAnalysis(string id); + public CodeAnalysis CreateCodeAnalysis(); + public CollectAllSetFeatures_ NewCollectAllSetFeatures(string id); + public CollectAllSetFeatures_ CreateCollectAllSetFeatures(); + public Collections NewCollections(string id); + public Collections CreateCollections(); + public Concept NewConcept(string id); + public Concept CreateConcept(); + public ConceptBase NewConceptBase(string id); + public ConceptBase CreateConceptBase(); + public ConceptInstanceBase NewConceptInstanceBase(string id); + public ConceptInstanceBase CreateConceptInstanceBase(); + public Containment NewContainment(string id); + public Containment CreateContainment(); + public ContainmentBase NewContainmentBase(string id); + public ContainmentBase CreateContainmentBase(); + public ContainmentRemover NewContainmentRemover(string id); + public ContainmentRemover CreateContainmentRemover(); + public Core NewCore(string id); + public Core CreateCore(); + public Datatype NewDatatype(string id); + public Datatype CreateDatatype(); + public DatatypeBase NewDatatypeBase(string id); + public DatatypeBase CreateDatatypeBase(); + public Decimal NewDecimal(string id); + public Decimal CreateDecimal(); + public DetachChild_ NewDetachChild(string id); + public DetachChild_ CreateDetachChild(); + public DetachChildInternal NewDetachChildInternal(string id); + public DetachChildInternal CreateDetachChildInternal(); + public DetachFromParent_ NewDetachFromParent(string id); + public DetachFromParent_ CreateDetachFromParent(); + public Diagnostics NewDiagnostics(string id); + public Diagnostics CreateDiagnostics(); + public Enum NewEnum(string id); + public Enum CreateEnum(); + public Enumeration NewEnumeration(string id); + public Enumeration CreateEnumeration(); + public EnumerationBase NewEnumerationBase(string id); + public EnumerationBase CreateEnumerationBase(); + public EnumerationLiteral NewEnumerationLiteral(string id); + public EnumerationLiteral CreateEnumerationLiteral(); + public EnumerationLiteralBase NewEnumerationLiteralBase(string id); + public EnumerationLiteralBase CreateEnumerationLiteralBase(); + public Equals NewEquals(string id); + public Equals CreateEquals(); + public ExchangeChildRaw NewExchangeChildRaw(string id); + public ExchangeChildRaw CreateExchangeChildRaw(); + public ExchangeChildrenRaw NewExchangeChildrenRaw(string id); + public ExchangeChildrenRaw CreateExchangeChildrenRaw(); + public FeaturesLazy NewFeaturesLazy(string id); + public FeaturesLazy CreateFeaturesLazy(); + public Field NewField(string id); + public Field CreateField(); + public FieldBase NewFieldBase(string id); + public FieldBase CreateFieldBase(); + public FieldsLazy NewFieldsLazy(string id); + public FieldsLazy CreateFieldsLazy(); + public Finalize NewFinalize(string id); + public Finalize CreateFinalize(); + public Generic NewGeneric(string id); + public Generic CreateGeneric(); + public Get NewGet(string id); + public Get CreateGet(); + public get__builtIns Newget__builtIns(string id); + public get__builtIns Createget__builtIns(); + public get__m3 Newget__m3(string id); + public get__m3 Createget__m3(); + public GetAnnotation NewGetAnnotation(string id); + public GetAnnotation CreateGetAnnotation(); + public GetAnnotations NewGetAnnotations(string id); + public GetAnnotations CreateGetAnnotations(); + public GetAnnotationsRaw NewGetAnnotationsRaw(string id); + public GetAnnotationsRaw CreateGetAnnotationsRaw(); + public GetClassifier_ NewGetClassifier(string id); + public GetClassifier_ CreateGetClassifier(); + public GetConcept_ NewGetConcept(string id); + public GetConcept_ CreateGetConcept(); + public GetContainmentOf_ NewGetContainmentOf(string id); + public GetContainmentOf_ CreateGetContainmentOf(); + public GetHashCode NewGetHashCode(string id); + public GetHashCode CreateGetHashCode(); + public GetId NewGetId(string id); + public GetId CreateGetId(); + public GetInternal_ NewGetInternal(string id); + public GetInternal_ CreateGetInternal(); + public GetParent NewGetParent(string id); + public GetParent CreateGetParent(); + public GetPartitionNotificationProducer_ NewGetPartitionNotificationProducer(string id); + public GetPartitionNotificationProducer_ CreateGetPartitionNotificationProducer(); + public GetRequiredNonNullReferences NewGetRequiredNonNullReferences(string id); + public GetRequiredNonNullReferences CreateGetRequiredNonNullReferences(); + public GetRequiredNullableReferences NewGetRequiredNullableReferences(string id); + public GetRequiredNullableReferences CreateGetRequiredNullableReferences(); + public GetRequiredReference NewGetRequiredReference(string id); + public GetRequiredReference CreateGetRequiredReference(); + public GetType NewGetType(string id); + public GetType CreateGetType(); + public IEnumerable NewIEnumerable(string id); + public IEnumerable CreateIEnumerable(); + public IFieldValues NewIFieldValues(string id); + public IFieldValues CreateIFieldValues(); + public ImplementsLazy NewImplementsLazy(string id); + public ImplementsLazy CreateImplementsLazy(); + public INamed NewINamed(string id); + public INamed CreateINamed(); + public INamedWritable NewINamedWritable(string id); + public INamedWritable CreateINamedWritable(); + public INode NewINode(string id); + public INode CreateINode(); + public INodeFactory NewINodeFactory(string id); + public INodeFactory CreateINodeFactory(); + public Insert NewInsert(string id); + public Insert CreateInsert(); + public InsertAnnotations NewInsertAnnotations(string id); + public InsertAnnotations CreateInsertAnnotations(); + public InsertAnnotationsRaw NewInsertAnnotationsRaw(string id); + public InsertAnnotationsRaw CreateInsertAnnotationsRaw(); + public InsertChildRaw NewInsertChildRaw(string id); + public InsertChildRaw CreateInsertChildRaw(); + public InsertContainmentsRaw_ NewInsertContainmentsRaw(string id); + public InsertContainmentsRaw_ CreateInsertContainmentsRaw(); + public InsertInternal_ NewInsertInternal(string id); + public InsertInternal_ CreateInsertInternal(); + public InsertOptionalMultipleContainment NewInsertOptionalMultipleContainment(string id); + public InsertOptionalMultipleContainment CreateInsertOptionalMultipleContainment(); + public InsertOptionalMultipleReference NewInsertOptionalMultipleReference(string id); + public InsertOptionalMultipleReference CreateInsertOptionalMultipleReference(); + public InsertReferencesRaw_ NewInsertReferencesRaw(string id); + public InsertReferencesRaw_ CreateInsertReferencesRaw(); + public InsertRequiredMultipleContainment NewInsertRequiredMultipleContainment(string id); + public InsertRequiredMultipleContainment CreateInsertRequiredMultipleContainment(); + public InsertRequiredMultipleReference NewInsertRequiredMultipleReference(string id); + public InsertRequiredMultipleReference CreateInsertRequiredMultipleReference(); + public Instance NewInstance(string id); + public Instance CreateInstance(); + public Integer NewInteger(string id); + public Integer CreateInteger(); + public Interface NewInterface(string id); + public Interface CreateInterface(); + public InterfaceBase NewInterfaceBase(string id); + public InterfaceBase CreateInterfaceBase(); + public InvalidValueException NewInvalidValueException(string id); + public InvalidValueException CreateInvalidValueException(); + public IPartitionInstance NewIPartitionInstance(string id); + public IPartitionInstance CreateIPartitionInstance(); + public IReadableNode NewIReadableNode(string id); + public IReadableNode CreateIReadableNode(); + public IReadOnlyList NewIReadOnlyList(string id); + public IReadOnlyList CreateIReadOnlyList(); + public IsInRange NewIsInRange(string id); + public IsInRange CreateIsInRange(); + public IStructuredDataTypeInstance NewIStructuredDataTypeInstance(string id); + public IStructuredDataTypeInstance CreateIStructuredDataTypeInstance(); + public IWritableNode NewIWritableNode(string id); + public IWritableNode CreateIWritableNode(); + public Key NewKey(string id); + public Key CreateKey(); + public Language NewLanguage(string id); + public Language CreateLanguage(); + public LanguageBase NewLanguageBase(string id); + public LanguageBase CreateLanguageBase(); + public LanguageEntity NewLanguageEntity(string id); + public LanguageEntity CreateLanguageEntity(); + public Lazy NewLazy(string id); + public Lazy CreateLazy(); + public Link NewLink(string id); + public Link CreateLink(); + public LionCoreFeature NewLionCoreFeature(string id); + public LionCoreFeature CreateLionCoreFeature(); + public LionCoreFeatureKind NewLionCoreFeatureKind(string id); + public LionCoreFeatureKind CreateLionCoreFeatureKind(); + public LionCoreLanguage NewLionCoreLanguage(string id); + public LionCoreLanguage CreateLionCoreLanguage(); + public LionCoreMetaPointer NewLionCoreMetaPointer(string id); + public LionCoreMetaPointer CreateLionCoreMetaPointer(); + public LionWeb NewLionWeb(string id); + public LionWeb CreateLionWeb(); + public LionWebVersions NewLionWebVersions(string id); + public LionWebVersions CreateLionWebVersions(); + public List NewList(string id); + public List CreateList(); + public LiteralsLazy NewLiteralsLazy(string id); + public LiteralsLazy CreateLiteralsLazy(); + public M2 NewM2(string id); + public M2 CreateM2(); + public M3 NewM3(string id); + public M3 CreateM3(); + public MemberwiseClone NewMemberwiseClone(string id); + public MemberwiseClone CreateMemberwiseClone(); + public Multiple NewMultiple(string id); + public Multiple CreateMultiple(); + public Name NewName(string id); + public Name CreateName(); + public Notification NewNotification(string id); + public Notification CreateNotification(); + public NotNullWhenAttribute NewNotNullWhenAttribute(string id); + public NotNullWhenAttribute CreateNotNullWhenAttribute(); + public Optional NewOptional(string id); + public Optional CreateOptional(); + public Partition NewPartition(string id); + public Partition CreatePartition(); + public Pipe NewPipe(string id); + public Pipe CreatePipe(); + public PrimitiveType NewPrimitiveType(string id); + public PrimitiveType CreatePrimitiveType(); + public PrimitiveTypeBase NewPrimitiveTypeBase(string id); + public PrimitiveTypeBase CreatePrimitiveTypeBase(); + public Property NewProperty(string id); + public Property CreateProperty(); + public PropertyBase NewPropertyBase(string id); + public PropertyBase CreatePropertyBase(); + public Reference NewReference(string id); + public Reference CreateReference(); + public ReferenceBase NewReferenceBase(string id); + public ReferenceBase CreateReferenceBase(); + public ReferenceEquals NewReferenceEquals(string id); + public ReferenceEquals CreateReferenceEquals(); + public ReferenceRemover NewReferenceRemover(string id); + public ReferenceRemover CreateReferenceRemover(); + public ReferenceTargetNonNullTarget NewReferenceTargetNonNullTarget(string id); + public ReferenceTargetNonNullTarget CreateReferenceTargetNonNullTarget(); + public ReferenceTargetNonNullTargets NewReferenceTargetNonNullTargets(string id); + public ReferenceTargetNonNullTargets CreateReferenceTargetNonNullTargets(); + public ReferenceTargetNullableTarget NewReferenceTargetNullableTarget(string id); + public ReferenceTargetNullableTarget CreateReferenceTargetNullableTarget(); + public ReferenceTargetNullableTargets NewReferenceTargetNullableTargets(string id); + public ReferenceTargetNullableTargets CreateReferenceTargetNullableTargets(); + public Remove NewRemove(string id); + public Remove CreateRemove(); + public RemoveAll NewRemoveAll(string id); + public RemoveAll CreateRemoveAll(); + public RemoveAnnotations NewRemoveAnnotations(string id); + public RemoveAnnotations CreateRemoveAnnotations(); + public RemoveAnnotationsRaw NewRemoveAnnotationsRaw(string id); + public RemoveAnnotationsRaw CreateRemoveAnnotationsRaw(); + public RemoveChildRaw NewRemoveChildRaw(string id); + public RemoveChildRaw CreateRemoveChildRaw(); + public RemoveContainmentsRaw_ NewRemoveContainmentsRaw(string id); + public RemoveContainmentsRaw_ CreateRemoveContainmentsRaw(); + public RemoveInternal_ NewRemoveInternal(string id); + public RemoveInternal_ CreateRemoveInternal(); + public RemoveOptionalMultipleContainment NewRemoveOptionalMultipleContainment(string id); + public RemoveOptionalMultipleContainment CreateRemoveOptionalMultipleContainment(); + public RemoveOptionalMultipleReference NewRemoveOptionalMultipleReference(string id); + public RemoveOptionalMultipleReference CreateRemoveOptionalMultipleReference(); + public RemoveReferencesRaw_ NewRemoveReferencesRaw(string id); + public RemoveReferencesRaw_ CreateRemoveReferencesRaw(); + public RemoveRequiredMultipleContainment NewRemoveRequiredMultipleContainment(string id); + public RemoveRequiredMultipleContainment CreateRemoveRequiredMultipleContainment(); + public RemoveRequiredMultipleReference NewRemoveRequiredMultipleReference(string id); + public RemoveRequiredMultipleReference CreateRemoveRequiredMultipleReference(); + public RemoveSelfParent NewRemoveSelfParent(string id); + public RemoveSelfParent CreateRemoveSelfParent(); + public RemoveSelfParentRaw NewRemoveSelfParentRaw(string id); + public RemoveSelfParentRaw CreateRemoveSelfParentRaw(); + public result Newresult(string id); + public result Createresult(); + public Set NewSet(string id); + public Set CreateSet(); + public SetContainmentRaw_ NewSetContainmentRaw(string id); + public SetContainmentRaw_ CreateSetContainmentRaw(); + public SetInternal_ NewSetInternal(string id); + public SetInternal_ CreateSetInternal(); + public SetInternalAnnotation NewSetInternalAnnotation(string id); + public SetInternalAnnotation CreateSetInternalAnnotation(); + public SetName NewSetName(string id); + public SetName CreateSetName(); + public SetNameRaw NewSetNameRaw(string id); + public SetNameRaw CreateSetNameRaw(); + public SetOptionalMultipleContainment NewSetOptionalMultipleContainment(string id); + public SetOptionalMultipleContainment CreateSetOptionalMultipleContainment(); + public SetOptionalMultipleReference NewSetOptionalMultipleReference(string id); + public SetOptionalMultipleReference CreateSetOptionalMultipleReference(); + public SetOptionalReferenceTypeProperty NewSetOptionalReferenceTypeProperty(string id); + public SetOptionalReferenceTypeProperty CreateSetOptionalReferenceTypeProperty(); + public SetOptionalSingleContainment NewSetOptionalSingleContainment(string id); + public SetOptionalSingleContainment CreateSetOptionalSingleContainment(); + public SetOptionalSingleReference NewSetOptionalSingleReference(string id); + public SetOptionalSingleReference CreateSetOptionalSingleReference(); + public SetOptionalValueTypeProperty NewSetOptionalValueTypeProperty(string id); + public SetOptionalValueTypeProperty CreateSetOptionalValueTypeProperty(); + public SetParentInternal NewSetParentInternal(string id); + public SetParentInternal CreateSetParentInternal(); + public SetParentNull NewSetParentNull(string id); + public SetParentNull CreateSetParentNull(); + public SetPropertyRaw_ NewSetPropertyRaw(string id); + public SetPropertyRaw_ CreateSetPropertyRaw(); + public SetRaw_ NewSetRaw(string id); + public SetRaw_ CreateSetRaw(); + public SetReferenceRaw_ NewSetReferenceRaw(string id); + public SetReferenceRaw_ CreateSetReferenceRaw(); + public SetReferencesRaw NewSetReferencesRaw(string id); + public SetReferencesRaw CreateSetReferencesRaw(); + public SetRequiredMultipleContainment NewSetRequiredMultipleContainment(string id); + public SetRequiredMultipleContainment CreateSetRequiredMultipleContainment(); + public SetRequiredMultipleReference NewSetRequiredMultipleReference(string id); + public SetRequiredMultipleReference CreateSetRequiredMultipleReference(); + public SetRequiredReferenceTypeProperty NewSetRequiredReferenceTypeProperty(string id); + public SetRequiredReferenceTypeProperty CreateSetRequiredReferenceTypeProperty(); + public SetRequiredSingleContainment NewSetRequiredSingleContainment(string id); + public SetRequiredSingleContainment CreateSetRequiredSingleContainment(); + public SetRequiredSingleReference NewSetRequiredSingleReference(string id); + public SetRequiredSingleReference CreateSetRequiredSingleReference(); + public SetRequiredValueTypeProperty NewSetRequiredValueTypeProperty(string id); + public SetRequiredValueTypeProperty CreateSetRequiredValueTypeProperty(); + public SetSelfParent NewSetSelfParent(string id); + public SetSelfParent CreateSetSelfParent(); + public SetSelfParentRaw NewSetSelfParentRaw(string id); + public SetSelfParentRaw CreateSetSelfParentRaw(); + public String NewString(string id); + public String CreateString(); + public StructuredDataType NewStructuredDataType(string id); + public StructuredDataType CreateStructuredDataType(); + public StructuredDataTypeBase NewStructuredDataTypeBase(string id); + public StructuredDataTypeBase CreateStructuredDataTypeBase(); + public System NewSystem(string id); + public System CreateSystem(); + public ToString NewToString(string id); + public ToString CreateToString(); + public TryGet_ NewTryGet(string id); + public TryGet_ CreateTryGet(); + public TryGetContainmentRaw_ NewTryGetContainmentRaw(string id); + public TryGetContainmentRaw_ CreateTryGetContainmentRaw(); + public TryGetContainmentsRaw_ NewTryGetContainmentsRaw(string id); + public TryGetContainmentsRaw_ CreateTryGetContainmentsRaw(); + public TryGetName NewTryGetName(string id); + public TryGetName CreateTryGetName(); + public TryGetPropertyRaw_ NewTryGetPropertyRaw(string id); + public TryGetPropertyRaw_ CreateTryGetPropertyRaw(); + public TryGetReference NewTryGetReference(string id); + public TryGetReference CreateTryGetReference(); + public TryGetReferenceRaw_ NewTryGetReferenceRaw(string id); + public TryGetReferenceRaw_ CreateTryGetReferenceRaw(); + public TryGetReferencesRaw_ NewTryGetReferencesRaw(string id); + public TryGetReferencesRaw_ CreateTryGetReferencesRaw(); + public Type NewType(string id); + public Type CreateType(); + public UnsetFeatureException NewUnsetFeatureException(string id); + public UnsetFeatureException CreateUnsetFeatureException(); + public UnsetFieldException NewUnsetFieldException(string id); + public UnsetFieldException CreateUnsetFieldException(); + public UnsupportedClassifierException NewUnsupportedClassifierException(string id); + public UnsupportedClassifierException CreateUnsupportedClassifierException(); + public UnsupportedEnumerationLiteralException NewUnsupportedEnumerationLiteralException(string id); + public UnsupportedEnumerationLiteralException CreateUnsupportedEnumerationLiteralException(); + public UnsupportedStructuredDataTypeException NewUnsupportedStructuredDataTypeException(string id); + public UnsupportedStructuredDataTypeException CreateUnsupportedStructuredDataTypeException(); + public Utilities NewUtilities(string id); + public Utilities CreateUtilities(); + public V2023_1 NewV2023_1(string id); + public V2023_1 CreateV2023_1(); + public V2024_1 NewV2024_1(string id); + public V2024_1 CreateV2024_1(); + public V2024_1_Compatible NewV2024_1_Compatible(string id); + public V2024_1_Compatible CreateV2024_1_Compatible(); + public V2025_1 NewV2025_1(string id); + public V2025_1 CreateV2025_1(); + public V2025_1_Compatible NewV2025_1_Compatible(string id); + public V2025_1_Compatible CreateV2025_1_Compatible(); + public VersionSpecific NewVersionSpecific(string id); + public VersionSpecific CreateVersionSpecific(); +} + +public class LanguageWithLionWebNamedConceptsFactory : global::LionWeb.Core.M2.AbstractBaseNodeFactory, ILanguageWithLionWebNamedConceptsFactory +{ + private readonly LanguageWithLionWebNamedConceptsLanguage _language; + public LanguageWithLionWebNamedConceptsFactory(LanguageWithLionWebNamedConceptsLanguage language) : base(language) + { + _language = language; + } + + /// + public override global::LionWeb.Core.INode CreateNode(string id, global::LionWeb.Core.M3.Classifier classifier) + { + if (_language._builtIns_.EqualsIdentity(classifier)) + return New_builtIns(id); + if (_language.Abstract.EqualsIdentity(classifier)) + return NewAbstract(id); + if (_language.AbstractBaseNodeFactory.EqualsIdentity(classifier)) + return NewAbstractBaseNodeFactory(id); + if (_language.Add.EqualsIdentity(classifier)) + return NewAdd(id); + if (_language.AddAnnotations.EqualsIdentity(classifier)) + return NewAddAnnotations(id); + if (_language.AddAnnotationsRaw.EqualsIdentity(classifier)) + return NewAddAnnotationsRaw(id); + if (_language.AddChildRaw.EqualsIdentity(classifier)) + return NewAddChildRaw(id); + if (_language.AddContainmentsRaw.EqualsIdentity(classifier)) + return NewAddContainmentsRaw(id); + if (_language.AddInternal.EqualsIdentity(classifier)) + return NewAddInternal(id); + if (_language.AddOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewAddOptionalMultipleContainment(id); + if (_language.AddOptionalMultipleReference.EqualsIdentity(classifier)) + return NewAddOptionalMultipleReference(id); + if (_language.AddReferencesRaw.EqualsIdentity(classifier)) + return NewAddReferencesRaw(id); + if (_language.AddRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewAddRequiredMultipleContainment(id); + if (_language.AddRequiredMultipleReference.EqualsIdentity(classifier)) + return NewAddRequiredMultipleReference(id); + if (_language.AnnotatesLazy.EqualsIdentity(classifier)) + return NewAnnotatesLazy(id); + if (_language.Annotation.EqualsIdentity(classifier)) + return NewAnnotation(id); + if (_language.AnnotationBase.EqualsIdentity(classifier)) + return NewAnnotationBase(id); + if (_language.AnnotationInstanceBase.EqualsIdentity(classifier)) + return NewAnnotationInstanceBase(id); + if (_language.AnnotationRemover.EqualsIdentity(classifier)) + return NewAnnotationRemover(id); + if (_language.ArgumentOutOfRangeException.EqualsIdentity(classifier)) + return NewArgumentOutOfRangeException(id); + if (_language.AsList.EqualsIdentity(classifier)) + return NewAsList(id); + if (_language.AsNonEmptyReadOnly.EqualsIdentity(classifier)) + return NewAsNonEmptyReadOnly(id); + if (_language.AssureAnnotations.EqualsIdentity(classifier)) + return NewAssureAnnotations(id); + if (_language.AssureInRange.EqualsIdentity(classifier)) + return NewAssureInRange(id); + if (_language.AssureNonEmpty.EqualsIdentity(classifier)) + return NewAssureNonEmpty(id); + if (_language.AssureNoSelfMove.EqualsIdentity(classifier)) + return NewAssureNoSelfMove(id); + if (_language.AssureNotClearing.EqualsIdentity(classifier)) + return NewAssureNotClearing(id); + if (_language.AssureNotNull.EqualsIdentity(classifier)) + return NewAssureNotNull(id); + if (_language.AssureNotNullInstance.EqualsIdentity(classifier)) + return NewAssureNotNullInstance(id); + if (_language.AssureNotNullMembers.EqualsIdentity(classifier)) + return NewAssureNotNullMembers(id); + if (_language.AssureNullableInstance.EqualsIdentity(classifier)) + return NewAssureNullableInstance(id); + if (_language.AttachChild.EqualsIdentity(classifier)) + return NewAttachChild(id); + if (_language.Bool.EqualsIdentity(classifier)) + return NewBool(id); + if (_language.Boolean.EqualsIdentity(classifier)) + return NewBoolean(id); + if (_language.Char.EqualsIdentity(classifier)) + return NewChar(id); + if (_language.Character.EqualsIdentity(classifier)) + return NewCharacter(id); + if (_language.Classifier.EqualsIdentity(classifier)) + return NewClassifier(id); + if (_language.CodeAnalysis.EqualsIdentity(classifier)) + return NewCodeAnalysis(id); + if (_language.CollectAllSetFeatures_.EqualsIdentity(classifier)) + return NewCollectAllSetFeatures(id); + if (_language.Collections.EqualsIdentity(classifier)) + return NewCollections(id); + if (_language.Concept.EqualsIdentity(classifier)) + return NewConcept(id); + if (_language.ConceptBase.EqualsIdentity(classifier)) + return NewConceptBase(id); + if (_language.ConceptInstanceBase.EqualsIdentity(classifier)) + return NewConceptInstanceBase(id); + if (_language.Containment.EqualsIdentity(classifier)) + return NewContainment(id); + if (_language.ContainmentBase.EqualsIdentity(classifier)) + return NewContainmentBase(id); + if (_language.ContainmentRemover.EqualsIdentity(classifier)) + return NewContainmentRemover(id); + if (_language.Core.EqualsIdentity(classifier)) + return NewCore(id); + if (_language.Datatype.EqualsIdentity(classifier)) + return NewDatatype(id); + if (_language.DatatypeBase.EqualsIdentity(classifier)) + return NewDatatypeBase(id); + if (_language.Decimal.EqualsIdentity(classifier)) + return NewDecimal(id); + if (_language.DetachChild.EqualsIdentity(classifier)) + return NewDetachChild(id); + if (_language.DetachChildInternal.EqualsIdentity(classifier)) + return NewDetachChildInternal(id); + if (_language.DetachFromParent.EqualsIdentity(classifier)) + return NewDetachFromParent(id); + if (_language.Diagnostics.EqualsIdentity(classifier)) + return NewDiagnostics(id); + if (_language.Enum.EqualsIdentity(classifier)) + return NewEnum(id); + if (_language.Enumeration.EqualsIdentity(classifier)) + return NewEnumeration(id); + if (_language.EnumerationBase.EqualsIdentity(classifier)) + return NewEnumerationBase(id); + if (_language.EnumerationLiteral.EqualsIdentity(classifier)) + return NewEnumerationLiteral(id); + if (_language.EnumerationLiteralBase.EqualsIdentity(classifier)) + return NewEnumerationLiteralBase(id); + if (_language.Equals_.EqualsIdentity(classifier)) + return NewEquals(id); + if (_language.ExchangeChildRaw.EqualsIdentity(classifier)) + return NewExchangeChildRaw(id); + if (_language.ExchangeChildrenRaw.EqualsIdentity(classifier)) + return NewExchangeChildrenRaw(id); + if (_language.FeaturesLazy.EqualsIdentity(classifier)) + return NewFeaturesLazy(id); + if (_language.Field.EqualsIdentity(classifier)) + return NewField(id); + if (_language.FieldBase.EqualsIdentity(classifier)) + return NewFieldBase(id); + if (_language.FieldsLazy.EqualsIdentity(classifier)) + return NewFieldsLazy(id); + if (_language.Finalize.EqualsIdentity(classifier)) + return NewFinalize(id); + if (_language.Generic.EqualsIdentity(classifier)) + return NewGeneric(id); + if (_language.Get_.EqualsIdentity(classifier)) + return NewGet(id); + if (_language.get__builtIns.EqualsIdentity(classifier)) + return Newget__builtIns(id); + if (_language.get__m3.EqualsIdentity(classifier)) + return Newget__m3(id); + if (_language.GetAnnotation.EqualsIdentity(classifier)) + return NewGetAnnotation(id); + if (_language.GetAnnotations_.EqualsIdentity(classifier)) + return NewGetAnnotations(id); + if (_language.GetAnnotationsRaw_.EqualsIdentity(classifier)) + return NewGetAnnotationsRaw(id); + if (_language.GetClassifier_.EqualsIdentity(classifier)) + return NewGetClassifier(id); + if (_language.GetConcept_.EqualsIdentity(classifier)) + return NewGetConcept(id); + if (_language.GetContainmentOf.EqualsIdentity(classifier)) + return NewGetContainmentOf(id); + if (_language.GetHashCode_.EqualsIdentity(classifier)) + return NewGetHashCode(id); + if (_language.GetId_.EqualsIdentity(classifier)) + return NewGetId(id); + if (_language.GetInternal.EqualsIdentity(classifier)) + return NewGetInternal(id); + if (_language.GetParent_.EqualsIdentity(classifier)) + return NewGetParent(id); + if (_language.GetPartitionNotificationProducer.EqualsIdentity(classifier)) + return NewGetPartitionNotificationProducer(id); + if (_language.GetRequiredNonNullReferences.EqualsIdentity(classifier)) + return NewGetRequiredNonNullReferences(id); + if (_language.GetRequiredNullableReferences.EqualsIdentity(classifier)) + return NewGetRequiredNullableReferences(id); + if (_language.GetRequiredReference.EqualsIdentity(classifier)) + return NewGetRequiredReference(id); + if (_language.GetType_.EqualsIdentity(classifier)) + return NewGetType(id); + if (_language.IEnumerable.EqualsIdentity(classifier)) + return NewIEnumerable(id); + if (_language.IFieldValues.EqualsIdentity(classifier)) + return NewIFieldValues(id); + if (_language.ImplementsLazy.EqualsIdentity(classifier)) + return NewImplementsLazy(id); + if (_language.INamed.EqualsIdentity(classifier)) + return NewINamed(id); + if (_language.INamedWritable.EqualsIdentity(classifier)) + return NewINamedWritable(id); + if (_language.INode.EqualsIdentity(classifier)) + return NewINode(id); + if (_language.INodeFactory.EqualsIdentity(classifier)) + return NewINodeFactory(id); + if (_language.Insert.EqualsIdentity(classifier)) + return NewInsert(id); + if (_language.InsertAnnotations.EqualsIdentity(classifier)) + return NewInsertAnnotations(id); + if (_language.InsertAnnotationsRaw.EqualsIdentity(classifier)) + return NewInsertAnnotationsRaw(id); + if (_language.InsertChildRaw.EqualsIdentity(classifier)) + return NewInsertChildRaw(id); + if (_language.InsertContainmentsRaw.EqualsIdentity(classifier)) + return NewInsertContainmentsRaw(id); + if (_language.InsertInternal.EqualsIdentity(classifier)) + return NewInsertInternal(id); + if (_language.InsertOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewInsertOptionalMultipleContainment(id); + if (_language.InsertOptionalMultipleReference.EqualsIdentity(classifier)) + return NewInsertOptionalMultipleReference(id); + if (_language.InsertReferencesRaw.EqualsIdentity(classifier)) + return NewInsertReferencesRaw(id); + if (_language.InsertRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewInsertRequiredMultipleContainment(id); + if (_language.InsertRequiredMultipleReference.EqualsIdentity(classifier)) + return NewInsertRequiredMultipleReference(id); + if (_language.Instance_.EqualsIdentity(classifier)) + return NewInstance(id); + if (_language.Integer.EqualsIdentity(classifier)) + return NewInteger(id); + if (_language.Interface.EqualsIdentity(classifier)) + return NewInterface(id); + if (_language.InterfaceBase.EqualsIdentity(classifier)) + return NewInterfaceBase(id); + if (_language.InvalidValueException.EqualsIdentity(classifier)) + return NewInvalidValueException(id); + if (_language.IPartitionInstance.EqualsIdentity(classifier)) + return NewIPartitionInstance(id); + if (_language.IReadableNode.EqualsIdentity(classifier)) + return NewIReadableNode(id); + if (_language.IReadOnlyList.EqualsIdentity(classifier)) + return NewIReadOnlyList(id); + if (_language.IsInRange.EqualsIdentity(classifier)) + return NewIsInRange(id); + if (_language.IStructuredDataTypeInstance.EqualsIdentity(classifier)) + return NewIStructuredDataTypeInstance(id); + if (_language.IWritableNode.EqualsIdentity(classifier)) + return NewIWritableNode(id); + if (_language.Key_.EqualsIdentity(classifier)) + return NewKey(id); + if (_language.Language.EqualsIdentity(classifier)) + return NewLanguage(id); + if (_language.LanguageBase.EqualsIdentity(classifier)) + return NewLanguageBase(id); + if (_language.LanguageEntity.EqualsIdentity(classifier)) + return NewLanguageEntity(id); + if (_language.Lazy.EqualsIdentity(classifier)) + return NewLazy(id); + if (_language.Link.EqualsIdentity(classifier)) + return NewLink(id); + if (_language.LionCoreFeature.EqualsIdentity(classifier)) + return NewLionCoreFeature(id); + if (_language.LionCoreFeatureKind.EqualsIdentity(classifier)) + return NewLionCoreFeatureKind(id); + if (_language.LionCoreLanguage.EqualsIdentity(classifier)) + return NewLionCoreLanguage(id); + if (_language.LionCoreMetaPointer.EqualsIdentity(classifier)) + return NewLionCoreMetaPointer(id); + if (_language.LionWeb.EqualsIdentity(classifier)) + return NewLionWeb(id); + if (_language.LionWebVersions.EqualsIdentity(classifier)) + return NewLionWebVersions(id); + if (_language.List.EqualsIdentity(classifier)) + return NewList(id); + if (_language.LiteralsLazy.EqualsIdentity(classifier)) + return NewLiteralsLazy(id); + if (_language.M2.EqualsIdentity(classifier)) + return NewM2(id); + if (_language.M3.EqualsIdentity(classifier)) + return NewM3(id); + if (_language.MemberwiseClone_.EqualsIdentity(classifier)) + return NewMemberwiseClone(id); + if (_language.Multiple.EqualsIdentity(classifier)) + return NewMultiple(id); + if (_language.Name_.EqualsIdentity(classifier)) + return NewName(id); + if (_language.Notification.EqualsIdentity(classifier)) + return NewNotification(id); + if (_language.NotNullWhenAttribute.EqualsIdentity(classifier)) + return NewNotNullWhenAttribute(id); + if (_language.Optional.EqualsIdentity(classifier)) + return NewOptional(id); + if (_language.Partition.EqualsIdentity(classifier)) + return NewPartition(id); + if (_language.Pipe.EqualsIdentity(classifier)) + return NewPipe(id); + if (_language.PrimitiveType.EqualsIdentity(classifier)) + return NewPrimitiveType(id); + if (_language.PrimitiveTypeBase.EqualsIdentity(classifier)) + return NewPrimitiveTypeBase(id); + if (_language.Property.EqualsIdentity(classifier)) + return NewProperty(id); + if (_language.PropertyBase.EqualsIdentity(classifier)) + return NewPropertyBase(id); + if (_language.Reference.EqualsIdentity(classifier)) + return NewReference(id); + if (_language.ReferenceBase.EqualsIdentity(classifier)) + return NewReferenceBase(id); + if (_language.ReferenceEquals_.EqualsIdentity(classifier)) + return NewReferenceEquals(id); + if (_language.ReferenceRemover.EqualsIdentity(classifier)) + return NewReferenceRemover(id); + if (_language.ReferenceTargetNonNullTarget.EqualsIdentity(classifier)) + return NewReferenceTargetNonNullTarget(id); + if (_language.ReferenceTargetNonNullTargets.EqualsIdentity(classifier)) + return NewReferenceTargetNonNullTargets(id); + if (_language.ReferenceTargetNullableTarget.EqualsIdentity(classifier)) + return NewReferenceTargetNullableTarget(id); + if (_language.ReferenceTargetNullableTargets.EqualsIdentity(classifier)) + return NewReferenceTargetNullableTargets(id); + if (_language.Remove.EqualsIdentity(classifier)) + return NewRemove(id); + if (_language.RemoveAll.EqualsIdentity(classifier)) + return NewRemoveAll(id); + if (_language.RemoveAnnotations.EqualsIdentity(classifier)) + return NewRemoveAnnotations(id); + if (_language.RemoveAnnotationsRaw.EqualsIdentity(classifier)) + return NewRemoveAnnotationsRaw(id); + if (_language.RemoveChildRaw.EqualsIdentity(classifier)) + return NewRemoveChildRaw(id); + if (_language.RemoveContainmentsRaw.EqualsIdentity(classifier)) + return NewRemoveContainmentsRaw(id); + if (_language.RemoveInternal.EqualsIdentity(classifier)) + return NewRemoveInternal(id); + if (_language.RemoveOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewRemoveOptionalMultipleContainment(id); + if (_language.RemoveOptionalMultipleReference.EqualsIdentity(classifier)) + return NewRemoveOptionalMultipleReference(id); + if (_language.RemoveReferencesRaw.EqualsIdentity(classifier)) + return NewRemoveReferencesRaw(id); + if (_language.RemoveRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewRemoveRequiredMultipleContainment(id); + if (_language.RemoveRequiredMultipleReference.EqualsIdentity(classifier)) + return NewRemoveRequiredMultipleReference(id); + if (_language.RemoveSelfParent.EqualsIdentity(classifier)) + return NewRemoveSelfParent(id); + if (_language.RemoveSelfParentRaw.EqualsIdentity(classifier)) + return NewRemoveSelfParentRaw(id); + if (_language.result.EqualsIdentity(classifier)) + return Newresult(id); + if (_language.Set.EqualsIdentity(classifier)) + return NewSet(id); + if (_language.SetContainmentRaw.EqualsIdentity(classifier)) + return NewSetContainmentRaw(id); + if (_language.SetInternal.EqualsIdentity(classifier)) + return NewSetInternal(id); + if (_language.SetInternalAnnotation.EqualsIdentity(classifier)) + return NewSetInternalAnnotation(id); + if (_language.SetName.EqualsIdentity(classifier)) + return NewSetName(id); + if (_language.SetNameRaw.EqualsIdentity(classifier)) + return NewSetNameRaw(id); + if (_language.SetOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewSetOptionalMultipleContainment(id); + if (_language.SetOptionalMultipleReference.EqualsIdentity(classifier)) + return NewSetOptionalMultipleReference(id); + if (_language.SetOptionalReferenceTypeProperty.EqualsIdentity(classifier)) + return NewSetOptionalReferenceTypeProperty(id); + if (_language.SetOptionalSingleContainment.EqualsIdentity(classifier)) + return NewSetOptionalSingleContainment(id); + if (_language.SetOptionalSingleReference.EqualsIdentity(classifier)) + return NewSetOptionalSingleReference(id); + if (_language.SetOptionalValueTypeProperty.EqualsIdentity(classifier)) + return NewSetOptionalValueTypeProperty(id); + if (_language.SetParentInternal.EqualsIdentity(classifier)) + return NewSetParentInternal(id); + if (_language.SetParentNull.EqualsIdentity(classifier)) + return NewSetParentNull(id); + if (_language.SetPropertyRaw.EqualsIdentity(classifier)) + return NewSetPropertyRaw(id); + if (_language.SetRaw.EqualsIdentity(classifier)) + return NewSetRaw(id); + if (_language.SetReferenceRaw.EqualsIdentity(classifier)) + return NewSetReferenceRaw(id); + if (_language.SetReferencesRaw.EqualsIdentity(classifier)) + return NewSetReferencesRaw(id); + if (_language.SetRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewSetRequiredMultipleContainment(id); + if (_language.SetRequiredMultipleReference.EqualsIdentity(classifier)) + return NewSetRequiredMultipleReference(id); + if (_language.SetRequiredReferenceTypeProperty.EqualsIdentity(classifier)) + return NewSetRequiredReferenceTypeProperty(id); + if (_language.SetRequiredSingleContainment.EqualsIdentity(classifier)) + return NewSetRequiredSingleContainment(id); + if (_language.SetRequiredSingleReference.EqualsIdentity(classifier)) + return NewSetRequiredSingleReference(id); + if (_language.SetRequiredValueTypeProperty.EqualsIdentity(classifier)) + return NewSetRequiredValueTypeProperty(id); + if (_language.SetSelfParent.EqualsIdentity(classifier)) + return NewSetSelfParent(id); + if (_language.SetSelfParentRaw.EqualsIdentity(classifier)) + return NewSetSelfParentRaw(id); + if (_language.String.EqualsIdentity(classifier)) + return NewString(id); + if (_language.StructuredDataType.EqualsIdentity(classifier)) + return NewStructuredDataType(id); + if (_language.StructuredDataTypeBase.EqualsIdentity(classifier)) + return NewStructuredDataTypeBase(id); + if (_language.System.EqualsIdentity(classifier)) + return NewSystem(id); + if (_language.ToString_.EqualsIdentity(classifier)) + return NewToString(id); + if (_language.TryGet_.EqualsIdentity(classifier)) + return NewTryGet(id); + if (_language.TryGetContainmentRaw_.EqualsIdentity(classifier)) + return NewTryGetContainmentRaw(id); + if (_language.TryGetContainmentsRaw_.EqualsIdentity(classifier)) + return NewTryGetContainmentsRaw(id); + if (_language.TryGetName_.EqualsIdentity(classifier)) + return NewTryGetName(id); + if (_language.TryGetPropertyRaw_.EqualsIdentity(classifier)) + return NewTryGetPropertyRaw(id); + if (_language.TryGetReference.EqualsIdentity(classifier)) + return NewTryGetReference(id); + if (_language.TryGetReferenceRaw_.EqualsIdentity(classifier)) + return NewTryGetReferenceRaw(id); + if (_language.TryGetReferencesRaw_.EqualsIdentity(classifier)) + return NewTryGetReferencesRaw(id); + if (_language.Type.EqualsIdentity(classifier)) + return NewType(id); + if (_language.UnsetFeatureException.EqualsIdentity(classifier)) + return NewUnsetFeatureException(id); + if (_language.UnsetFieldException.EqualsIdentity(classifier)) + return NewUnsetFieldException(id); + if (_language.UnsupportedClassifierException.EqualsIdentity(classifier)) + return NewUnsupportedClassifierException(id); + if (_language.UnsupportedEnumerationLiteralException.EqualsIdentity(classifier)) + return NewUnsupportedEnumerationLiteralException(id); + if (_language.UnsupportedStructuredDataTypeException.EqualsIdentity(classifier)) + return NewUnsupportedStructuredDataTypeException(id); + if (_language.Utilities.EqualsIdentity(classifier)) + return NewUtilities(id); + if (_language.V2023_1.EqualsIdentity(classifier)) + return NewV2023_1(id); + if (_language.V2024_1.EqualsIdentity(classifier)) + return NewV2024_1(id); + if (_language.V2024_1_Compatible.EqualsIdentity(classifier)) + return NewV2024_1_Compatible(id); + if (_language.V2025_1.EqualsIdentity(classifier)) + return NewV2025_1(id); + if (_language.V2025_1_Compatible.EqualsIdentity(classifier)) + return NewV2025_1_Compatible(id); + if (_language.VersionSpecific.EqualsIdentity(classifier)) + return NewVersionSpecific(id); + throw new global::LionWeb.Core.UnsupportedClassifierException(classifier); + } + + /// + public override global::System.Enum GetEnumerationLiteral(global::LionWeb.Core.M3.EnumerationLiteral literal) + { + throw new global::LionWeb.Core.UnsupportedEnumerationLiteralException(literal); + } + + /// + public override global::LionWeb.Core.IStructuredDataTypeInstance CreateStructuredDataTypeInstance(global::LionWeb.Core.M3.StructuredDataType structuredDataType, global::LionWeb.Core.M2.IFieldValues fieldValues) + { + throw new global::LionWeb.Core.UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual _builtIns New_builtIns(string id) => new(id); + public virtual _builtIns Create_builtIns() => New_builtIns(GetNewId()); + public virtual Abstract NewAbstract(string id) => new(id); + public virtual Abstract CreateAbstract() => NewAbstract(GetNewId()); + public virtual AbstractBaseNodeFactory NewAbstractBaseNodeFactory(string id) => new(id); + public virtual AbstractBaseNodeFactory CreateAbstractBaseNodeFactory() => NewAbstractBaseNodeFactory(GetNewId()); + public virtual Add NewAdd(string id) => new(id); + public virtual Add CreateAdd() => NewAdd(GetNewId()); + public virtual AddAnnotations NewAddAnnotations(string id) => new(id); + public virtual AddAnnotations CreateAddAnnotations() => NewAddAnnotations(GetNewId()); + public virtual AddAnnotationsRaw NewAddAnnotationsRaw(string id) => new(id); + public virtual AddAnnotationsRaw CreateAddAnnotationsRaw() => NewAddAnnotationsRaw(GetNewId()); + public virtual AddChildRaw NewAddChildRaw(string id) => new(id); + public virtual AddChildRaw CreateAddChildRaw() => NewAddChildRaw(GetNewId()); + public virtual AddContainmentsRaw_ NewAddContainmentsRaw(string id) => new(id); + public virtual AddContainmentsRaw_ CreateAddContainmentsRaw() => NewAddContainmentsRaw(GetNewId()); + public virtual AddInternal_ NewAddInternal(string id) => new(id); + public virtual AddInternal_ CreateAddInternal() => NewAddInternal(GetNewId()); + public virtual AddOptionalMultipleContainment NewAddOptionalMultipleContainment(string id) => new(id); + public virtual AddOptionalMultipleContainment CreateAddOptionalMultipleContainment() => NewAddOptionalMultipleContainment(GetNewId()); + public virtual AddOptionalMultipleReference NewAddOptionalMultipleReference(string id) => new(id); + public virtual AddOptionalMultipleReference CreateAddOptionalMultipleReference() => NewAddOptionalMultipleReference(GetNewId()); + public virtual AddReferencesRaw_ NewAddReferencesRaw(string id) => new(id); + public virtual AddReferencesRaw_ CreateAddReferencesRaw() => NewAddReferencesRaw(GetNewId()); + public virtual AddRequiredMultipleContainment NewAddRequiredMultipleContainment(string id) => new(id); + public virtual AddRequiredMultipleContainment CreateAddRequiredMultipleContainment() => NewAddRequiredMultipleContainment(GetNewId()); + public virtual AddRequiredMultipleReference NewAddRequiredMultipleReference(string id) => new(id); + public virtual AddRequiredMultipleReference CreateAddRequiredMultipleReference() => NewAddRequiredMultipleReference(GetNewId()); + public virtual AnnotatesLazy NewAnnotatesLazy(string id) => new(id); + public virtual AnnotatesLazy CreateAnnotatesLazy() => NewAnnotatesLazy(GetNewId()); + public virtual Annotation NewAnnotation(string id) => new(id); + public virtual Annotation CreateAnnotation() => NewAnnotation(GetNewId()); + public virtual AnnotationBase NewAnnotationBase(string id) => new(id); + public virtual AnnotationBase CreateAnnotationBase() => NewAnnotationBase(GetNewId()); + public virtual AnnotationInstanceBase NewAnnotationInstanceBase(string id) => new(id); + public virtual AnnotationInstanceBase CreateAnnotationInstanceBase() => NewAnnotationInstanceBase(GetNewId()); + public virtual AnnotationRemover NewAnnotationRemover(string id) => new(id); + public virtual AnnotationRemover CreateAnnotationRemover() => NewAnnotationRemover(GetNewId()); + public virtual ArgumentOutOfRangeException NewArgumentOutOfRangeException(string id) => new(id); + public virtual ArgumentOutOfRangeException CreateArgumentOutOfRangeException() => NewArgumentOutOfRangeException(GetNewId()); + public virtual AsList NewAsList(string id) => new(id); + public virtual AsList CreateAsList() => NewAsList(GetNewId()); + public virtual AsNonEmptyReadOnly NewAsNonEmptyReadOnly(string id) => new(id); + public virtual AsNonEmptyReadOnly CreateAsNonEmptyReadOnly() => NewAsNonEmptyReadOnly(GetNewId()); + public virtual AssureAnnotations NewAssureAnnotations(string id) => new(id); + public virtual AssureAnnotations CreateAssureAnnotations() => NewAssureAnnotations(GetNewId()); + public virtual AssureInRange NewAssureInRange(string id) => new(id); + public virtual AssureInRange CreateAssureInRange() => NewAssureInRange(GetNewId()); + public virtual AssureNonEmpty NewAssureNonEmpty(string id) => new(id); + public virtual AssureNonEmpty CreateAssureNonEmpty() => NewAssureNonEmpty(GetNewId()); + public virtual AssureNoSelfMove NewAssureNoSelfMove(string id) => new(id); + public virtual AssureNoSelfMove CreateAssureNoSelfMove() => NewAssureNoSelfMove(GetNewId()); + public virtual AssureNotClearing NewAssureNotClearing(string id) => new(id); + public virtual AssureNotClearing CreateAssureNotClearing() => NewAssureNotClearing(GetNewId()); + public virtual AssureNotNull NewAssureNotNull(string id) => new(id); + public virtual AssureNotNull CreateAssureNotNull() => NewAssureNotNull(GetNewId()); + public virtual AssureNotNullInstance NewAssureNotNullInstance(string id) => new(id); + public virtual AssureNotNullInstance CreateAssureNotNullInstance() => NewAssureNotNullInstance(GetNewId()); + public virtual AssureNotNullMembers NewAssureNotNullMembers(string id) => new(id); + public virtual AssureNotNullMembers CreateAssureNotNullMembers() => NewAssureNotNullMembers(GetNewId()); + public virtual AssureNullableInstance NewAssureNullableInstance(string id) => new(id); + public virtual AssureNullableInstance CreateAssureNullableInstance() => NewAssureNullableInstance(GetNewId()); + public virtual AttachChild NewAttachChild(string id) => new(id); + public virtual AttachChild CreateAttachChild() => NewAttachChild(GetNewId()); + public virtual Bool NewBool(string id) => new(id); + public virtual Bool CreateBool() => NewBool(GetNewId()); + public virtual Boolean NewBoolean(string id) => new(id); + public virtual Boolean CreateBoolean() => NewBoolean(GetNewId()); + public virtual Char NewChar(string id) => new(id); + public virtual Char CreateChar() => NewChar(GetNewId()); + public virtual Character NewCharacter(string id) => new(id); + public virtual Character CreateCharacter() => NewCharacter(GetNewId()); + public virtual Classifier NewClassifier(string id) => new(id); + public virtual Classifier CreateClassifier() => NewClassifier(GetNewId()); + public virtual CodeAnalysis NewCodeAnalysis(string id) => new(id); + public virtual CodeAnalysis CreateCodeAnalysis() => NewCodeAnalysis(GetNewId()); + public virtual CollectAllSetFeatures_ NewCollectAllSetFeatures(string id) => new(id); + public virtual CollectAllSetFeatures_ CreateCollectAllSetFeatures() => NewCollectAllSetFeatures(GetNewId()); + public virtual Collections NewCollections(string id) => new(id); + public virtual Collections CreateCollections() => NewCollections(GetNewId()); + public virtual Concept NewConcept(string id) => new(id); + public virtual Concept CreateConcept() => NewConcept(GetNewId()); + public virtual ConceptBase NewConceptBase(string id) => new(id); + public virtual ConceptBase CreateConceptBase() => NewConceptBase(GetNewId()); + public virtual ConceptInstanceBase NewConceptInstanceBase(string id) => new(id); + public virtual ConceptInstanceBase CreateConceptInstanceBase() => NewConceptInstanceBase(GetNewId()); + public virtual Containment NewContainment(string id) => new(id); + public virtual Containment CreateContainment() => NewContainment(GetNewId()); + public virtual ContainmentBase NewContainmentBase(string id) => new(id); + public virtual ContainmentBase CreateContainmentBase() => NewContainmentBase(GetNewId()); + public virtual ContainmentRemover NewContainmentRemover(string id) => new(id); + public virtual ContainmentRemover CreateContainmentRemover() => NewContainmentRemover(GetNewId()); + public virtual Core NewCore(string id) => new(id); + public virtual Core CreateCore() => NewCore(GetNewId()); + public virtual Datatype NewDatatype(string id) => new(id); + public virtual Datatype CreateDatatype() => NewDatatype(GetNewId()); + public virtual DatatypeBase NewDatatypeBase(string id) => new(id); + public virtual DatatypeBase CreateDatatypeBase() => NewDatatypeBase(GetNewId()); + public virtual Decimal NewDecimal(string id) => new(id); + public virtual Decimal CreateDecimal() => NewDecimal(GetNewId()); + public virtual DetachChild_ NewDetachChild(string id) => new(id); + public virtual DetachChild_ CreateDetachChild() => NewDetachChild(GetNewId()); + public virtual DetachChildInternal NewDetachChildInternal(string id) => new(id); + public virtual DetachChildInternal CreateDetachChildInternal() => NewDetachChildInternal(GetNewId()); + public virtual DetachFromParent_ NewDetachFromParent(string id) => new(id); + public virtual DetachFromParent_ CreateDetachFromParent() => NewDetachFromParent(GetNewId()); + public virtual Diagnostics NewDiagnostics(string id) => new(id); + public virtual Diagnostics CreateDiagnostics() => NewDiagnostics(GetNewId()); + public virtual Enum NewEnum(string id) => new(id); + public virtual Enum CreateEnum() => NewEnum(GetNewId()); + public virtual Enumeration NewEnumeration(string id) => new(id); + public virtual Enumeration CreateEnumeration() => NewEnumeration(GetNewId()); + public virtual EnumerationBase NewEnumerationBase(string id) => new(id); + public virtual EnumerationBase CreateEnumerationBase() => NewEnumerationBase(GetNewId()); + public virtual EnumerationLiteral NewEnumerationLiteral(string id) => new(id); + public virtual EnumerationLiteral CreateEnumerationLiteral() => NewEnumerationLiteral(GetNewId()); + public virtual EnumerationLiteralBase NewEnumerationLiteralBase(string id) => new(id); + public virtual EnumerationLiteralBase CreateEnumerationLiteralBase() => NewEnumerationLiteralBase(GetNewId()); + public virtual Equals NewEquals(string id) => new(id); + public virtual Equals CreateEquals() => NewEquals(GetNewId()); + public virtual ExchangeChildRaw NewExchangeChildRaw(string id) => new(id); + public virtual ExchangeChildRaw CreateExchangeChildRaw() => NewExchangeChildRaw(GetNewId()); + public virtual ExchangeChildrenRaw NewExchangeChildrenRaw(string id) => new(id); + public virtual ExchangeChildrenRaw CreateExchangeChildrenRaw() => NewExchangeChildrenRaw(GetNewId()); + public virtual FeaturesLazy NewFeaturesLazy(string id) => new(id); + public virtual FeaturesLazy CreateFeaturesLazy() => NewFeaturesLazy(GetNewId()); + public virtual Field NewField(string id) => new(id); + public virtual Field CreateField() => NewField(GetNewId()); + public virtual FieldBase NewFieldBase(string id) => new(id); + public virtual FieldBase CreateFieldBase() => NewFieldBase(GetNewId()); + public virtual FieldsLazy NewFieldsLazy(string id) => new(id); + public virtual FieldsLazy CreateFieldsLazy() => NewFieldsLazy(GetNewId()); + public virtual Finalize NewFinalize(string id) => new(id); + public virtual Finalize CreateFinalize() => NewFinalize(GetNewId()); + public virtual Generic NewGeneric(string id) => new(id); + public virtual Generic CreateGeneric() => NewGeneric(GetNewId()); + public virtual Get NewGet(string id) => new(id); + public virtual Get CreateGet() => NewGet(GetNewId()); + public virtual get__builtIns Newget__builtIns(string id) => new(id); + public virtual get__builtIns Createget__builtIns() => Newget__builtIns(GetNewId()); + public virtual get__m3 Newget__m3(string id) => new(id); + public virtual get__m3 Createget__m3() => Newget__m3(GetNewId()); + public virtual GetAnnotation NewGetAnnotation(string id) => new(id); + public virtual GetAnnotation CreateGetAnnotation() => NewGetAnnotation(GetNewId()); + public virtual GetAnnotations NewGetAnnotations(string id) => new(id); + public virtual GetAnnotations CreateGetAnnotations() => NewGetAnnotations(GetNewId()); + public virtual GetAnnotationsRaw NewGetAnnotationsRaw(string id) => new(id); + public virtual GetAnnotationsRaw CreateGetAnnotationsRaw() => NewGetAnnotationsRaw(GetNewId()); + public virtual GetClassifier_ NewGetClassifier(string id) => new(id); + public virtual GetClassifier_ CreateGetClassifier() => NewGetClassifier(GetNewId()); + public virtual GetConcept_ NewGetConcept(string id) => new(id); + public virtual GetConcept_ CreateGetConcept() => NewGetConcept(GetNewId()); + public virtual GetContainmentOf_ NewGetContainmentOf(string id) => new(id); + public virtual GetContainmentOf_ CreateGetContainmentOf() => NewGetContainmentOf(GetNewId()); + public virtual GetHashCode NewGetHashCode(string id) => new(id); + public virtual GetHashCode CreateGetHashCode() => NewGetHashCode(GetNewId()); + public virtual GetId NewGetId(string id) => new(id); + public virtual GetId CreateGetId() => NewGetId(GetNewId()); + public virtual GetInternal_ NewGetInternal(string id) => new(id); + public virtual GetInternal_ CreateGetInternal() => NewGetInternal(GetNewId()); + public virtual GetParent NewGetParent(string id) => new(id); + public virtual GetParent CreateGetParent() => NewGetParent(GetNewId()); + public virtual GetPartitionNotificationProducer_ NewGetPartitionNotificationProducer(string id) => new(id); + public virtual GetPartitionNotificationProducer_ CreateGetPartitionNotificationProducer() => NewGetPartitionNotificationProducer(GetNewId()); + public virtual GetRequiredNonNullReferences NewGetRequiredNonNullReferences(string id) => new(id); + public virtual GetRequiredNonNullReferences CreateGetRequiredNonNullReferences() => NewGetRequiredNonNullReferences(GetNewId()); + public virtual GetRequiredNullableReferences NewGetRequiredNullableReferences(string id) => new(id); + public virtual GetRequiredNullableReferences CreateGetRequiredNullableReferences() => NewGetRequiredNullableReferences(GetNewId()); + public virtual GetRequiredReference NewGetRequiredReference(string id) => new(id); + public virtual GetRequiredReference CreateGetRequiredReference() => NewGetRequiredReference(GetNewId()); + public virtual GetType NewGetType(string id) => new(id); + public virtual GetType CreateGetType() => NewGetType(GetNewId()); + public virtual IEnumerable NewIEnumerable(string id) => new(id); + public virtual IEnumerable CreateIEnumerable() => NewIEnumerable(GetNewId()); + public virtual IFieldValues NewIFieldValues(string id) => new(id); + public virtual IFieldValues CreateIFieldValues() => NewIFieldValues(GetNewId()); + public virtual ImplementsLazy NewImplementsLazy(string id) => new(id); + public virtual ImplementsLazy CreateImplementsLazy() => NewImplementsLazy(GetNewId()); + public virtual INamed NewINamed(string id) => new(id); + public virtual INamed CreateINamed() => NewINamed(GetNewId()); + public virtual INamedWritable NewINamedWritable(string id) => new(id); + public virtual INamedWritable CreateINamedWritable() => NewINamedWritable(GetNewId()); + public virtual INode NewINode(string id) => new(id); + public virtual INode CreateINode() => NewINode(GetNewId()); + public virtual INodeFactory NewINodeFactory(string id) => new(id); + public virtual INodeFactory CreateINodeFactory() => NewINodeFactory(GetNewId()); + public virtual Insert NewInsert(string id) => new(id); + public virtual Insert CreateInsert() => NewInsert(GetNewId()); + public virtual InsertAnnotations NewInsertAnnotations(string id) => new(id); + public virtual InsertAnnotations CreateInsertAnnotations() => NewInsertAnnotations(GetNewId()); + public virtual InsertAnnotationsRaw NewInsertAnnotationsRaw(string id) => new(id); + public virtual InsertAnnotationsRaw CreateInsertAnnotationsRaw() => NewInsertAnnotationsRaw(GetNewId()); + public virtual InsertChildRaw NewInsertChildRaw(string id) => new(id); + public virtual InsertChildRaw CreateInsertChildRaw() => NewInsertChildRaw(GetNewId()); + public virtual InsertContainmentsRaw_ NewInsertContainmentsRaw(string id) => new(id); + public virtual InsertContainmentsRaw_ CreateInsertContainmentsRaw() => NewInsertContainmentsRaw(GetNewId()); + public virtual InsertInternal_ NewInsertInternal(string id) => new(id); + public virtual InsertInternal_ CreateInsertInternal() => NewInsertInternal(GetNewId()); + public virtual InsertOptionalMultipleContainment NewInsertOptionalMultipleContainment(string id) => new(id); + public virtual InsertOptionalMultipleContainment CreateInsertOptionalMultipleContainment() => NewInsertOptionalMultipleContainment(GetNewId()); + public virtual InsertOptionalMultipleReference NewInsertOptionalMultipleReference(string id) => new(id); + public virtual InsertOptionalMultipleReference CreateInsertOptionalMultipleReference() => NewInsertOptionalMultipleReference(GetNewId()); + public virtual InsertReferencesRaw_ NewInsertReferencesRaw(string id) => new(id); + public virtual InsertReferencesRaw_ CreateInsertReferencesRaw() => NewInsertReferencesRaw(GetNewId()); + public virtual InsertRequiredMultipleContainment NewInsertRequiredMultipleContainment(string id) => new(id); + public virtual InsertRequiredMultipleContainment CreateInsertRequiredMultipleContainment() => NewInsertRequiredMultipleContainment(GetNewId()); + public virtual InsertRequiredMultipleReference NewInsertRequiredMultipleReference(string id) => new(id); + public virtual InsertRequiredMultipleReference CreateInsertRequiredMultipleReference() => NewInsertRequiredMultipleReference(GetNewId()); + public virtual Instance NewInstance(string id) => new(id); + public virtual Instance CreateInstance() => NewInstance(GetNewId()); + public virtual Integer NewInteger(string id) => new(id); + public virtual Integer CreateInteger() => NewInteger(GetNewId()); + public virtual Interface NewInterface(string id) => new(id); + public virtual Interface CreateInterface() => NewInterface(GetNewId()); + public virtual InterfaceBase NewInterfaceBase(string id) => new(id); + public virtual InterfaceBase CreateInterfaceBase() => NewInterfaceBase(GetNewId()); + public virtual InvalidValueException NewInvalidValueException(string id) => new(id); + public virtual InvalidValueException CreateInvalidValueException() => NewInvalidValueException(GetNewId()); + public virtual IPartitionInstance NewIPartitionInstance(string id) => new(id); + public virtual IPartitionInstance CreateIPartitionInstance() => NewIPartitionInstance(GetNewId()); + public virtual IReadableNode NewIReadableNode(string id) => new(id); + public virtual IReadableNode CreateIReadableNode() => NewIReadableNode(GetNewId()); + public virtual IReadOnlyList NewIReadOnlyList(string id) => new(id); + public virtual IReadOnlyList CreateIReadOnlyList() => NewIReadOnlyList(GetNewId()); + public virtual IsInRange NewIsInRange(string id) => new(id); + public virtual IsInRange CreateIsInRange() => NewIsInRange(GetNewId()); + public virtual IStructuredDataTypeInstance NewIStructuredDataTypeInstance(string id) => new(id); + public virtual IStructuredDataTypeInstance CreateIStructuredDataTypeInstance() => NewIStructuredDataTypeInstance(GetNewId()); + public virtual IWritableNode NewIWritableNode(string id) => new(id); + public virtual IWritableNode CreateIWritableNode() => NewIWritableNode(GetNewId()); + public virtual Key NewKey(string id) => new(id); + public virtual Key CreateKey() => NewKey(GetNewId()); + public virtual Language NewLanguage(string id) => new(id); + public virtual Language CreateLanguage() => NewLanguage(GetNewId()); + public virtual LanguageBase NewLanguageBase(string id) => new(id); + public virtual LanguageBase CreateLanguageBase() => NewLanguageBase(GetNewId()); + public virtual LanguageEntity NewLanguageEntity(string id) => new(id); + public virtual LanguageEntity CreateLanguageEntity() => NewLanguageEntity(GetNewId()); + public virtual Lazy NewLazy(string id) => new(id); + public virtual Lazy CreateLazy() => NewLazy(GetNewId()); + public virtual Link NewLink(string id) => new(id); + public virtual Link CreateLink() => NewLink(GetNewId()); + public virtual LionCoreFeature NewLionCoreFeature(string id) => new(id); + public virtual LionCoreFeature CreateLionCoreFeature() => NewLionCoreFeature(GetNewId()); + public virtual LionCoreFeatureKind NewLionCoreFeatureKind(string id) => new(id); + public virtual LionCoreFeatureKind CreateLionCoreFeatureKind() => NewLionCoreFeatureKind(GetNewId()); + public virtual LionCoreLanguage NewLionCoreLanguage(string id) => new(id); + public virtual LionCoreLanguage CreateLionCoreLanguage() => NewLionCoreLanguage(GetNewId()); + public virtual LionCoreMetaPointer NewLionCoreMetaPointer(string id) => new(id); + public virtual LionCoreMetaPointer CreateLionCoreMetaPointer() => NewLionCoreMetaPointer(GetNewId()); + public virtual LionWeb NewLionWeb(string id) => new(id); + public virtual LionWeb CreateLionWeb() => NewLionWeb(GetNewId()); + public virtual LionWebVersions NewLionWebVersions(string id) => new(id); + public virtual LionWebVersions CreateLionWebVersions() => NewLionWebVersions(GetNewId()); + public virtual List NewList(string id) => new(id); + public virtual List CreateList() => NewList(GetNewId()); + public virtual LiteralsLazy NewLiteralsLazy(string id) => new(id); + public virtual LiteralsLazy CreateLiteralsLazy() => NewLiteralsLazy(GetNewId()); + public virtual M2 NewM2(string id) => new(id); + public virtual M2 CreateM2() => NewM2(GetNewId()); + public virtual M3 NewM3(string id) => new(id); + public virtual M3 CreateM3() => NewM3(GetNewId()); + public virtual MemberwiseClone NewMemberwiseClone(string id) => new(id); + public virtual MemberwiseClone CreateMemberwiseClone() => NewMemberwiseClone(GetNewId()); + public virtual Multiple NewMultiple(string id) => new(id); + public virtual Multiple CreateMultiple() => NewMultiple(GetNewId()); + public virtual Name NewName(string id) => new(id); + public virtual Name CreateName() => NewName(GetNewId()); + public virtual Notification NewNotification(string id) => new(id); + public virtual Notification CreateNotification() => NewNotification(GetNewId()); + public virtual NotNullWhenAttribute NewNotNullWhenAttribute(string id) => new(id); + public virtual NotNullWhenAttribute CreateNotNullWhenAttribute() => NewNotNullWhenAttribute(GetNewId()); + public virtual Optional NewOptional(string id) => new(id); + public virtual Optional CreateOptional() => NewOptional(GetNewId()); + public virtual Partition NewPartition(string id) => new(id); + public virtual Partition CreatePartition() => NewPartition(GetNewId()); + public virtual Pipe NewPipe(string id) => new(id); + public virtual Pipe CreatePipe() => NewPipe(GetNewId()); + public virtual PrimitiveType NewPrimitiveType(string id) => new(id); + public virtual PrimitiveType CreatePrimitiveType() => NewPrimitiveType(GetNewId()); + public virtual PrimitiveTypeBase NewPrimitiveTypeBase(string id) => new(id); + public virtual PrimitiveTypeBase CreatePrimitiveTypeBase() => NewPrimitiveTypeBase(GetNewId()); + public virtual Property NewProperty(string id) => new(id); + public virtual Property CreateProperty() => NewProperty(GetNewId()); + public virtual PropertyBase NewPropertyBase(string id) => new(id); + public virtual PropertyBase CreatePropertyBase() => NewPropertyBase(GetNewId()); + public virtual Reference NewReference(string id) => new(id); + public virtual Reference CreateReference() => NewReference(GetNewId()); + public virtual ReferenceBase NewReferenceBase(string id) => new(id); + public virtual ReferenceBase CreateReferenceBase() => NewReferenceBase(GetNewId()); + public virtual ReferenceEquals NewReferenceEquals(string id) => new(id); + public virtual ReferenceEquals CreateReferenceEquals() => NewReferenceEquals(GetNewId()); + public virtual ReferenceRemover NewReferenceRemover(string id) => new(id); + public virtual ReferenceRemover CreateReferenceRemover() => NewReferenceRemover(GetNewId()); + public virtual ReferenceTargetNonNullTarget NewReferenceTargetNonNullTarget(string id) => new(id); + public virtual ReferenceTargetNonNullTarget CreateReferenceTargetNonNullTarget() => NewReferenceTargetNonNullTarget(GetNewId()); + public virtual ReferenceTargetNonNullTargets NewReferenceTargetNonNullTargets(string id) => new(id); + public virtual ReferenceTargetNonNullTargets CreateReferenceTargetNonNullTargets() => NewReferenceTargetNonNullTargets(GetNewId()); + public virtual ReferenceTargetNullableTarget NewReferenceTargetNullableTarget(string id) => new(id); + public virtual ReferenceTargetNullableTarget CreateReferenceTargetNullableTarget() => NewReferenceTargetNullableTarget(GetNewId()); + public virtual ReferenceTargetNullableTargets NewReferenceTargetNullableTargets(string id) => new(id); + public virtual ReferenceTargetNullableTargets CreateReferenceTargetNullableTargets() => NewReferenceTargetNullableTargets(GetNewId()); + public virtual Remove NewRemove(string id) => new(id); + public virtual Remove CreateRemove() => NewRemove(GetNewId()); + public virtual RemoveAll NewRemoveAll(string id) => new(id); + public virtual RemoveAll CreateRemoveAll() => NewRemoveAll(GetNewId()); + public virtual RemoveAnnotations NewRemoveAnnotations(string id) => new(id); + public virtual RemoveAnnotations CreateRemoveAnnotations() => NewRemoveAnnotations(GetNewId()); + public virtual RemoveAnnotationsRaw NewRemoveAnnotationsRaw(string id) => new(id); + public virtual RemoveAnnotationsRaw CreateRemoveAnnotationsRaw() => NewRemoveAnnotationsRaw(GetNewId()); + public virtual RemoveChildRaw NewRemoveChildRaw(string id) => new(id); + public virtual RemoveChildRaw CreateRemoveChildRaw() => NewRemoveChildRaw(GetNewId()); + public virtual RemoveContainmentsRaw_ NewRemoveContainmentsRaw(string id) => new(id); + public virtual RemoveContainmentsRaw_ CreateRemoveContainmentsRaw() => NewRemoveContainmentsRaw(GetNewId()); + public virtual RemoveInternal_ NewRemoveInternal(string id) => new(id); + public virtual RemoveInternal_ CreateRemoveInternal() => NewRemoveInternal(GetNewId()); + public virtual RemoveOptionalMultipleContainment NewRemoveOptionalMultipleContainment(string id) => new(id); + public virtual RemoveOptionalMultipleContainment CreateRemoveOptionalMultipleContainment() => NewRemoveOptionalMultipleContainment(GetNewId()); + public virtual RemoveOptionalMultipleReference NewRemoveOptionalMultipleReference(string id) => new(id); + public virtual RemoveOptionalMultipleReference CreateRemoveOptionalMultipleReference() => NewRemoveOptionalMultipleReference(GetNewId()); + public virtual RemoveReferencesRaw_ NewRemoveReferencesRaw(string id) => new(id); + public virtual RemoveReferencesRaw_ CreateRemoveReferencesRaw() => NewRemoveReferencesRaw(GetNewId()); + public virtual RemoveRequiredMultipleContainment NewRemoveRequiredMultipleContainment(string id) => new(id); + public virtual RemoveRequiredMultipleContainment CreateRemoveRequiredMultipleContainment() => NewRemoveRequiredMultipleContainment(GetNewId()); + public virtual RemoveRequiredMultipleReference NewRemoveRequiredMultipleReference(string id) => new(id); + public virtual RemoveRequiredMultipleReference CreateRemoveRequiredMultipleReference() => NewRemoveRequiredMultipleReference(GetNewId()); + public virtual RemoveSelfParent NewRemoveSelfParent(string id) => new(id); + public virtual RemoveSelfParent CreateRemoveSelfParent() => NewRemoveSelfParent(GetNewId()); + public virtual RemoveSelfParentRaw NewRemoveSelfParentRaw(string id) => new(id); + public virtual RemoveSelfParentRaw CreateRemoveSelfParentRaw() => NewRemoveSelfParentRaw(GetNewId()); + public virtual result Newresult(string id) => new(id); + public virtual result Createresult() => Newresult(GetNewId()); + public virtual Set NewSet(string id) => new(id); + public virtual Set CreateSet() => NewSet(GetNewId()); + public virtual SetContainmentRaw_ NewSetContainmentRaw(string id) => new(id); + public virtual SetContainmentRaw_ CreateSetContainmentRaw() => NewSetContainmentRaw(GetNewId()); + public virtual SetInternal_ NewSetInternal(string id) => new(id); + public virtual SetInternal_ CreateSetInternal() => NewSetInternal(GetNewId()); + public virtual SetInternalAnnotation NewSetInternalAnnotation(string id) => new(id); + public virtual SetInternalAnnotation CreateSetInternalAnnotation() => NewSetInternalAnnotation(GetNewId()); + public virtual SetName NewSetName(string id) => new(id); + public virtual SetName CreateSetName() => NewSetName(GetNewId()); + public virtual SetNameRaw NewSetNameRaw(string id) => new(id); + public virtual SetNameRaw CreateSetNameRaw() => NewSetNameRaw(GetNewId()); + public virtual SetOptionalMultipleContainment NewSetOptionalMultipleContainment(string id) => new(id); + public virtual SetOptionalMultipleContainment CreateSetOptionalMultipleContainment() => NewSetOptionalMultipleContainment(GetNewId()); + public virtual SetOptionalMultipleReference NewSetOptionalMultipleReference(string id) => new(id); + public virtual SetOptionalMultipleReference CreateSetOptionalMultipleReference() => NewSetOptionalMultipleReference(GetNewId()); + public virtual SetOptionalReferenceTypeProperty NewSetOptionalReferenceTypeProperty(string id) => new(id); + public virtual SetOptionalReferenceTypeProperty CreateSetOptionalReferenceTypeProperty() => NewSetOptionalReferenceTypeProperty(GetNewId()); + public virtual SetOptionalSingleContainment NewSetOptionalSingleContainment(string id) => new(id); + public virtual SetOptionalSingleContainment CreateSetOptionalSingleContainment() => NewSetOptionalSingleContainment(GetNewId()); + public virtual SetOptionalSingleReference NewSetOptionalSingleReference(string id) => new(id); + public virtual SetOptionalSingleReference CreateSetOptionalSingleReference() => NewSetOptionalSingleReference(GetNewId()); + public virtual SetOptionalValueTypeProperty NewSetOptionalValueTypeProperty(string id) => new(id); + public virtual SetOptionalValueTypeProperty CreateSetOptionalValueTypeProperty() => NewSetOptionalValueTypeProperty(GetNewId()); + public virtual SetParentInternal NewSetParentInternal(string id) => new(id); + public virtual SetParentInternal CreateSetParentInternal() => NewSetParentInternal(GetNewId()); + public virtual SetParentNull NewSetParentNull(string id) => new(id); + public virtual SetParentNull CreateSetParentNull() => NewSetParentNull(GetNewId()); + public virtual SetPropertyRaw_ NewSetPropertyRaw(string id) => new(id); + public virtual SetPropertyRaw_ CreateSetPropertyRaw() => NewSetPropertyRaw(GetNewId()); + public virtual SetRaw_ NewSetRaw(string id) => new(id); + public virtual SetRaw_ CreateSetRaw() => NewSetRaw(GetNewId()); + public virtual SetReferenceRaw_ NewSetReferenceRaw(string id) => new(id); + public virtual SetReferenceRaw_ CreateSetReferenceRaw() => NewSetReferenceRaw(GetNewId()); + public virtual SetReferencesRaw NewSetReferencesRaw(string id) => new(id); + public virtual SetReferencesRaw CreateSetReferencesRaw() => NewSetReferencesRaw(GetNewId()); + public virtual SetRequiredMultipleContainment NewSetRequiredMultipleContainment(string id) => new(id); + public virtual SetRequiredMultipleContainment CreateSetRequiredMultipleContainment() => NewSetRequiredMultipleContainment(GetNewId()); + public virtual SetRequiredMultipleReference NewSetRequiredMultipleReference(string id) => new(id); + public virtual SetRequiredMultipleReference CreateSetRequiredMultipleReference() => NewSetRequiredMultipleReference(GetNewId()); + public virtual SetRequiredReferenceTypeProperty NewSetRequiredReferenceTypeProperty(string id) => new(id); + public virtual SetRequiredReferenceTypeProperty CreateSetRequiredReferenceTypeProperty() => NewSetRequiredReferenceTypeProperty(GetNewId()); + public virtual SetRequiredSingleContainment NewSetRequiredSingleContainment(string id) => new(id); + public virtual SetRequiredSingleContainment CreateSetRequiredSingleContainment() => NewSetRequiredSingleContainment(GetNewId()); + public virtual SetRequiredSingleReference NewSetRequiredSingleReference(string id) => new(id); + public virtual SetRequiredSingleReference CreateSetRequiredSingleReference() => NewSetRequiredSingleReference(GetNewId()); + public virtual SetRequiredValueTypeProperty NewSetRequiredValueTypeProperty(string id) => new(id); + public virtual SetRequiredValueTypeProperty CreateSetRequiredValueTypeProperty() => NewSetRequiredValueTypeProperty(GetNewId()); + public virtual SetSelfParent NewSetSelfParent(string id) => new(id); + public virtual SetSelfParent CreateSetSelfParent() => NewSetSelfParent(GetNewId()); + public virtual SetSelfParentRaw NewSetSelfParentRaw(string id) => new(id); + public virtual SetSelfParentRaw CreateSetSelfParentRaw() => NewSetSelfParentRaw(GetNewId()); + public virtual String NewString(string id) => new(id); + public virtual String CreateString() => NewString(GetNewId()); + public virtual StructuredDataType NewStructuredDataType(string id) => new(id); + public virtual StructuredDataType CreateStructuredDataType() => NewStructuredDataType(GetNewId()); + public virtual StructuredDataTypeBase NewStructuredDataTypeBase(string id) => new(id); + public virtual StructuredDataTypeBase CreateStructuredDataTypeBase() => NewStructuredDataTypeBase(GetNewId()); + public virtual System NewSystem(string id) => new(id); + public virtual System CreateSystem() => NewSystem(GetNewId()); + public virtual ToString NewToString(string id) => new(id); + public virtual ToString CreateToString() => NewToString(GetNewId()); + public virtual TryGet_ NewTryGet(string id) => new(id); + public virtual TryGet_ CreateTryGet() => NewTryGet(GetNewId()); + public virtual TryGetContainmentRaw_ NewTryGetContainmentRaw(string id) => new(id); + public virtual TryGetContainmentRaw_ CreateTryGetContainmentRaw() => NewTryGetContainmentRaw(GetNewId()); + public virtual TryGetContainmentsRaw_ NewTryGetContainmentsRaw(string id) => new(id); + public virtual TryGetContainmentsRaw_ CreateTryGetContainmentsRaw() => NewTryGetContainmentsRaw(GetNewId()); + public virtual TryGetName NewTryGetName(string id) => new(id); + public virtual TryGetName CreateTryGetName() => NewTryGetName(GetNewId()); + public virtual TryGetPropertyRaw_ NewTryGetPropertyRaw(string id) => new(id); + public virtual TryGetPropertyRaw_ CreateTryGetPropertyRaw() => NewTryGetPropertyRaw(GetNewId()); + public virtual TryGetReference NewTryGetReference(string id) => new(id); + public virtual TryGetReference CreateTryGetReference() => NewTryGetReference(GetNewId()); + public virtual TryGetReferenceRaw_ NewTryGetReferenceRaw(string id) => new(id); + public virtual TryGetReferenceRaw_ CreateTryGetReferenceRaw() => NewTryGetReferenceRaw(GetNewId()); + public virtual TryGetReferencesRaw_ NewTryGetReferencesRaw(string id) => new(id); + public virtual TryGetReferencesRaw_ CreateTryGetReferencesRaw() => NewTryGetReferencesRaw(GetNewId()); + public virtual Type NewType(string id) => new(id); + public virtual Type CreateType() => NewType(GetNewId()); + public virtual UnsetFeatureException NewUnsetFeatureException(string id) => new(id); + public virtual UnsetFeatureException CreateUnsetFeatureException() => NewUnsetFeatureException(GetNewId()); + public virtual UnsetFieldException NewUnsetFieldException(string id) => new(id); + public virtual UnsetFieldException CreateUnsetFieldException() => NewUnsetFieldException(GetNewId()); + public virtual UnsupportedClassifierException NewUnsupportedClassifierException(string id) => new(id); + public virtual UnsupportedClassifierException CreateUnsupportedClassifierException() => NewUnsupportedClassifierException(GetNewId()); + public virtual UnsupportedEnumerationLiteralException NewUnsupportedEnumerationLiteralException(string id) => new(id); + public virtual UnsupportedEnumerationLiteralException CreateUnsupportedEnumerationLiteralException() => NewUnsupportedEnumerationLiteralException(GetNewId()); + public virtual UnsupportedStructuredDataTypeException NewUnsupportedStructuredDataTypeException(string id) => new(id); + public virtual UnsupportedStructuredDataTypeException CreateUnsupportedStructuredDataTypeException() => NewUnsupportedStructuredDataTypeException(GetNewId()); + public virtual Utilities NewUtilities(string id) => new(id); + public virtual Utilities CreateUtilities() => NewUtilities(GetNewId()); + public virtual V2023_1 NewV2023_1(string id) => new(id); + public virtual V2023_1 CreateV2023_1() => NewV2023_1(GetNewId()); + public virtual V2024_1 NewV2024_1(string id) => new(id); + public virtual V2024_1 CreateV2024_1() => NewV2024_1(GetNewId()); + public virtual V2024_1_Compatible NewV2024_1_Compatible(string id) => new(id); + public virtual V2024_1_Compatible CreateV2024_1_Compatible() => NewV2024_1_Compatible(GetNewId()); + public virtual V2025_1 NewV2025_1(string id) => new(id); + public virtual V2025_1 CreateV2025_1() => NewV2025_1(GetNewId()); + public virtual V2025_1_Compatible NewV2025_1_Compatible(string id) => new(id); + public virtual V2025_1_Compatible CreateV2025_1_Compatible() => NewV2025_1_Compatible(GetNewId()); + public virtual VersionSpecific NewVersionSpecific(string id) => new(id); + public virtual VersionSpecific CreateVersionSpecific() => NewVersionSpecific(GetNewId()); +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-_builtIns")] +public partial class _builtIns : global::LionWeb.Core.ConceptInstanceBase +{ + public _builtIns(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance._builtIns_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Abstract")] +public partial class Abstract : global::LionWeb.Core.ConceptInstanceBase +{ + public Abstract(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Abstract; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AbstractBaseNodeFactory")] +public partial class AbstractBaseNodeFactory : global::LionWeb.Core.ConceptInstanceBase +{ + public AbstractBaseNodeFactory(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AbstractBaseNodeFactory; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Add")] +public partial class Add : global::LionWeb.Core.ConceptInstanceBase +{ + public Add(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Add; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddAnnotations")] +public partial class AddAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public AddAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddAnnotationsRaw")] +public partial class AddAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public AddAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddChildRaw")] +public partial class AddChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public AddChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddContainmentsRaw")] +public partial class AddContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddInternal")] +public partial class AddInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddOptionalMultipleContainment")] +public partial class AddOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public AddOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddOptionalMultipleReference")] +public partial class AddOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public AddOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddReferencesRaw")] +public partial class AddReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddRequiredMultipleContainment")] +public partial class AddRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public AddRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddRequiredMultipleReference")] +public partial class AddRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public AddRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotatesLazy")] +public partial class AnnotatesLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotatesLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotatesLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Annotation")] +public partial class Annotation : global::LionWeb.Core.ConceptInstanceBase +{ + public Annotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Annotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationBase")] +public partial class AnnotationBase : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationInstanceBase")] +public partial class AnnotationInstanceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationInstanceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationInstanceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationRemover")] +public partial class AnnotationRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ArgumentOutOfRangeException")] +public partial class ArgumentOutOfRangeException : global::LionWeb.Core.ConceptInstanceBase +{ + public ArgumentOutOfRangeException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ArgumentOutOfRangeException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AsList")] +public partial class AsList : global::LionWeb.Core.ConceptInstanceBase +{ + public AsList(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AsList; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AsNonEmptyReadOnly")] +public partial class AsNonEmptyReadOnly : global::LionWeb.Core.ConceptInstanceBase +{ + public AsNonEmptyReadOnly(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AsNonEmptyReadOnly; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureAnnotations")] +public partial class AssureAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureInRange")] +public partial class AssureInRange : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureInRange(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureInRange; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNonEmpty")] +public partial class AssureNonEmpty : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNonEmpty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNonEmpty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNoSelfMove")] +public partial class AssureNoSelfMove : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNoSelfMove(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNoSelfMove; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotClearing")] +public partial class AssureNotClearing : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotClearing(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotClearing; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNull")] +public partial class AssureNotNull : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNull(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNull; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNullInstance")] +public partial class AssureNotNullInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNullInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNullInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNullMembers")] +public partial class AssureNotNullMembers : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNullMembers(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNullMembers; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNullableInstance")] +public partial class AssureNullableInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNullableInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNullableInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AttachChild")] +public partial class AttachChild : global::LionWeb.Core.ConceptInstanceBase +{ + public AttachChild(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AttachChild; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Bool")] +public partial class Bool : global::LionWeb.Core.ConceptInstanceBase +{ + public Bool(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Bool; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Boolean")] +public partial class Boolean : global::LionWeb.Core.ConceptInstanceBase +{ + public Boolean(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Boolean; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Char")] +public partial class Char : global::LionWeb.Core.ConceptInstanceBase +{ + public Char(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Char; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Character")] +public partial class Character : global::LionWeb.Core.ConceptInstanceBase +{ + public Character(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Character; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Classifier")] +public partial class Classifier : global::LionWeb.Core.ConceptInstanceBase +{ + public Classifier(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Classifier; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-CodeAnalysis")] +public partial class CodeAnalysis : global::LionWeb.Core.ConceptInstanceBase +{ + public CodeAnalysis(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.CodeAnalysis; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-CollectAllSetFeatures")] +public partial class CollectAllSetFeatures_ : global::LionWeb.Core.ConceptInstanceBase +{ + public CollectAllSetFeatures_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.CollectAllSetFeatures_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Collections")] +public partial class Collections : global::LionWeb.Core.ConceptInstanceBase +{ + public Collections(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Collections; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Concept")] +public partial class Concept : global::LionWeb.Core.ConceptInstanceBase +{ + public Concept(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Concept; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ConceptBase")] +public partial class ConceptBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ConceptBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ConceptBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ConceptInstanceBase")] +public partial class ConceptInstanceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ConceptInstanceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ConceptInstanceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Containment")] +public partial class Containment : global::LionWeb.Core.ConceptInstanceBase +{ + public Containment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Containment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ContainmentBase")] +public partial class ContainmentBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ContainmentBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ContainmentBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ContainmentRemover")] +public partial class ContainmentRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public ContainmentRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ContainmentRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Core")] +public partial class Core : global::LionWeb.Core.ConceptInstanceBase +{ + public Core(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Core; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Datatype")] +public partial class Datatype : global::LionWeb.Core.ConceptInstanceBase +{ + public Datatype(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Datatype; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DatatypeBase")] +public partial class DatatypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public DatatypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DatatypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Decimal")] +public partial class Decimal : global::LionWeb.Core.ConceptInstanceBase +{ + public Decimal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Decimal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachChild")] +public partial class DetachChild_ : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachChild_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachChild; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachChildInternal")] +public partial class DetachChildInternal : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachChildInternal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachChildInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachFromParent")] +public partial class DetachFromParent_ : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachFromParent_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachFromParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Diagnostics")] +public partial class Diagnostics : global::LionWeb.Core.ConceptInstanceBase +{ + public Diagnostics(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Diagnostics; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Enum")] +public partial class Enum : global::LionWeb.Core.ConceptInstanceBase +{ + public Enum(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Enum; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Enumeration")] +public partial class Enumeration : global::LionWeb.Core.ConceptInstanceBase +{ + public Enumeration(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Enumeration; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationBase")] +public partial class EnumerationBase : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationLiteral")] +public partial class EnumerationLiteral : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationLiteral(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationLiteral; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationLiteralBase")] +public partial class EnumerationLiteralBase : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationLiteralBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationLiteralBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Equals")] +public partial class Equals : global::LionWeb.Core.ConceptInstanceBase +{ + public Equals(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Equals_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ExchangeChildRaw")] +public partial class ExchangeChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public ExchangeChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ExchangeChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ExchangeChildrenRaw")] +public partial class ExchangeChildrenRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public ExchangeChildrenRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ExchangeChildrenRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FeaturesLazy")] +public partial class FeaturesLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public FeaturesLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FeaturesLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Field")] +public partial class Field : global::LionWeb.Core.ConceptInstanceBase +{ + public Field(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Field; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FieldBase")] +public partial class FieldBase : global::LionWeb.Core.ConceptInstanceBase +{ + public FieldBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FieldBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FieldsLazy")] +public partial class FieldsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public FieldsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FieldsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Finalize")] +public partial class Finalize : global::LionWeb.Core.ConceptInstanceBase +{ + public Finalize(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Finalize; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Generic")] +public partial class Generic : global::LionWeb.Core.ConceptInstanceBase +{ + public Generic(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Generic; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Get")] +public partial class Get : global::LionWeb.Core.ConceptInstanceBase +{ + public Get(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Get_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-get__builtIns")] +public partial class get__builtIns : global::LionWeb.Core.ConceptInstanceBase +{ + public get__builtIns(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.get__builtIns; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-get__m3")] +public partial class get__m3 : global::LionWeb.Core.ConceptInstanceBase +{ + public get__m3(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.get__m3; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotation")] +public partial class GetAnnotation : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotations")] +public partial class GetAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotations_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotationsRaw")] +public partial class GetAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotationsRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetClassifier")] +public partial class GetClassifier_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetClassifier_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetClassifier_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetConcept")] +public partial class GetConcept_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetConcept_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetConcept_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetContainmentOf")] +public partial class GetContainmentOf_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetContainmentOf_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetContainmentOf; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetHashCode")] +public partial class GetHashCode : global::LionWeb.Core.ConceptInstanceBase +{ + public GetHashCode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetHashCode_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetId")] +public partial class GetId : global::LionWeb.Core.ConceptInstanceBase +{ + public GetId(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetId_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetInternal")] +public partial class GetInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetParent")] +public partial class GetParent : global::LionWeb.Core.ConceptInstanceBase +{ + public GetParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetParent_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetPartitionNotificationProducer")] +public partial class GetPartitionNotificationProducer_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetPartitionNotificationProducer_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetPartitionNotificationProducer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredNonNullReferences")] +public partial class GetRequiredNonNullReferences : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredNonNullReferences(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredNonNullReferences; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredNullableReferences")] +public partial class GetRequiredNullableReferences : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredNullableReferences(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredNullableReferences; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredReference")] +public partial class GetRequiredReference : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetType")] +public partial class GetType : global::LionWeb.Core.ConceptInstanceBase +{ + public GetType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetType_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IEnumerable")] +public partial class IEnumerable : global::LionWeb.Core.ConceptInstanceBase +{ + public IEnumerable(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IEnumerable; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IFieldValues")] +public partial class IFieldValues : global::LionWeb.Core.ConceptInstanceBase +{ + public IFieldValues(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IFieldValues; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ImplementsLazy")] +public partial class ImplementsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public ImplementsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ImplementsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INamed")] +public partial class INamed : global::LionWeb.Core.ConceptInstanceBase +{ + public INamed(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INamed; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INamedWritable")] +public partial class INamedWritable : global::LionWeb.Core.ConceptInstanceBase +{ + public INamedWritable(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INamedWritable; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INode")] +public partial class INode : global::LionWeb.Core.ConceptInstanceBase +{ + public INode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INodeFactory")] +public partial class INodeFactory : global::LionWeb.Core.ConceptInstanceBase +{ + public INodeFactory(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INodeFactory; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Insert")] +public partial class Insert : global::LionWeb.Core.ConceptInstanceBase +{ + public Insert(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Insert; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertAnnotations")] +public partial class InsertAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertAnnotationsRaw")] +public partial class InsertAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertChildRaw")] +public partial class InsertChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertContainmentsRaw")] +public partial class InsertContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertInternal")] +public partial class InsertInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertOptionalMultipleContainment")] +public partial class InsertOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertOptionalMultipleReference")] +public partial class InsertOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertReferencesRaw")] +public partial class InsertReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertRequiredMultipleContainment")] +public partial class InsertRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertRequiredMultipleReference")] +public partial class InsertRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Instance")] +public partial class Instance : global::LionWeb.Core.ConceptInstanceBase +{ + public Instance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Instance_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Integer")] +public partial class Integer : global::LionWeb.Core.ConceptInstanceBase +{ + public Integer(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Integer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Interface")] +public partial class Interface : global::LionWeb.Core.ConceptInstanceBase +{ + public Interface(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Interface; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InterfaceBase")] +public partial class InterfaceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public InterfaceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InterfaceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InvalidValueException")] +public partial class InvalidValueException : global::LionWeb.Core.ConceptInstanceBase +{ + public InvalidValueException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InvalidValueException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IPartitionInstance")] +public partial class IPartitionInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public IPartitionInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IPartitionInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IReadableNode")] +public partial class IReadableNode : global::LionWeb.Core.ConceptInstanceBase +{ + public IReadableNode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IReadableNode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IReadOnlyList")] +public partial class IReadOnlyList : global::LionWeb.Core.ConceptInstanceBase +{ + public IReadOnlyList(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IReadOnlyList; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IsInRange")] +public partial class IsInRange : global::LionWeb.Core.ConceptInstanceBase +{ + public IsInRange(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IsInRange; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IStructuredDataTypeInstance")] +public partial class IStructuredDataTypeInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public IStructuredDataTypeInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IStructuredDataTypeInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IWritableNode")] +public partial class IWritableNode : global::LionWeb.Core.ConceptInstanceBase +{ + public IWritableNode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IWritableNode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Key")] +public partial class Key : global::LionWeb.Core.ConceptInstanceBase +{ + public Key(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Key_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Language")] +public partial class Language : global::LionWeb.Core.ConceptInstanceBase +{ + public Language(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Language; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LanguageBase")] +public partial class LanguageBase : global::LionWeb.Core.ConceptInstanceBase +{ + public LanguageBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LanguageBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LanguageEntity")] +public partial class LanguageEntity : global::LionWeb.Core.ConceptInstanceBase +{ + public LanguageEntity(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LanguageEntity; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Lazy")] +public partial class Lazy : global::LionWeb.Core.ConceptInstanceBase +{ + public Lazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Lazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Link")] +public partial class Link : global::LionWeb.Core.ConceptInstanceBase +{ + public Link(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Link; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreFeature")] +public partial class LionCoreFeature : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreFeature(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreFeature; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreFeatureKind")] +public partial class LionCoreFeatureKind : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreFeatureKind(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreFeatureKind; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreLanguage")] +public partial class LionCoreLanguage : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreLanguage(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreLanguage; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreMetaPointer")] +public partial class LionCoreMetaPointer : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreMetaPointer(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreMetaPointer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionWeb")] +public partial class LionWeb : global::LionWeb.Core.ConceptInstanceBase +{ + public LionWeb(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionWeb; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionWebVersions")] +public partial class LionWebVersions : global::LionWeb.Core.ConceptInstanceBase +{ + public LionWebVersions(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionWebVersions; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-List")] +public partial class List : global::LionWeb.Core.ConceptInstanceBase +{ + public List(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.List; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LiteralsLazy")] +public partial class LiteralsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public LiteralsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LiteralsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-M2")] +public partial class M2 : global::LionWeb.Core.ConceptInstanceBase +{ + public M2(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.M2; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-M3")] +public partial class M3 : global::LionWeb.Core.ConceptInstanceBase +{ + public M3(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.M3; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-MemberwiseClone")] +public partial class MemberwiseClone : global::LionWeb.Core.ConceptInstanceBase +{ + public MemberwiseClone(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.MemberwiseClone_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Multiple")] +public partial class Multiple : global::LionWeb.Core.ConceptInstanceBase +{ + public Multiple(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Multiple; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Name")] +public partial class Name : global::LionWeb.Core.ConceptInstanceBase +{ + public Name(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Name_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Notification")] +public partial class Notification : global::LionWeb.Core.ConceptInstanceBase +{ + public Notification(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Notification; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-NotNullWhenAttribute")] +public partial class NotNullWhenAttribute : global::LionWeb.Core.ConceptInstanceBase +{ + public NotNullWhenAttribute(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.NotNullWhenAttribute; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Optional")] +public partial class Optional : global::LionWeb.Core.ConceptInstanceBase +{ + public Optional(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Optional; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Partition")] +public partial class Partition : global::LionWeb.Core.ConceptInstanceBase +{ + public Partition(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Partition; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Pipe")] +public partial class Pipe : global::LionWeb.Core.ConceptInstanceBase +{ + public Pipe(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Pipe; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PrimitiveType")] +public partial class PrimitiveType : global::LionWeb.Core.ConceptInstanceBase +{ + public PrimitiveType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PrimitiveType; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PrimitiveTypeBase")] +public partial class PrimitiveTypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public PrimitiveTypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PrimitiveTypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Property")] +public partial class Property : global::LionWeb.Core.ConceptInstanceBase +{ + public Property(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Property; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PropertyBase")] +public partial class PropertyBase : global::LionWeb.Core.ConceptInstanceBase +{ + public PropertyBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PropertyBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Reference")] +public partial class Reference : global::LionWeb.Core.ConceptInstanceBase +{ + public Reference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Reference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceBase")] +public partial class ReferenceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceEquals")] +public partial class ReferenceEquals : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceEquals(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceEquals_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceRemover")] +public partial class ReferenceRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNonNullTarget")] +public partial class ReferenceTargetNonNullTarget : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNonNullTarget(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNonNullTarget; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNonNullTargets")] +public partial class ReferenceTargetNonNullTargets : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNonNullTargets(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNonNullTargets; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNullableTarget")] +public partial class ReferenceTargetNullableTarget : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNullableTarget(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNullableTarget; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNullableTargets")] +public partial class ReferenceTargetNullableTargets : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNullableTargets(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNullableTargets; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Remove")] +public partial class Remove : global::LionWeb.Core.ConceptInstanceBase +{ + public Remove(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Remove; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAll")] +public partial class RemoveAll : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAll(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAll; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAnnotations")] +public partial class RemoveAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAnnotationsRaw")] +public partial class RemoveAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveChildRaw")] +public partial class RemoveChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveContainmentsRaw")] +public partial class RemoveContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveInternal")] +public partial class RemoveInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveOptionalMultipleContainment")] +public partial class RemoveOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveOptionalMultipleReference")] +public partial class RemoveOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveReferencesRaw")] +public partial class RemoveReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveRequiredMultipleContainment")] +public partial class RemoveRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveRequiredMultipleReference")] +public partial class RemoveRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveSelfParent")] +public partial class RemoveSelfParent : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveSelfParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveSelfParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveSelfParentRaw")] +public partial class RemoveSelfParentRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveSelfParentRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveSelfParentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-result")] +public partial class result : global::LionWeb.Core.ConceptInstanceBase +{ + public result(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.result; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Set")] +public partial class Set : global::LionWeb.Core.ConceptInstanceBase +{ + public Set(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Set; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetContainmentRaw")] +public partial class SetContainmentRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetContainmentRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetContainmentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetInternal")] +public partial class SetInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetInternalAnnotation")] +public partial class SetInternalAnnotation : global::LionWeb.Core.ConceptInstanceBase +{ + public SetInternalAnnotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetInternalAnnotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetName")] +public partial class SetName : global::LionWeb.Core.ConceptInstanceBase +{ + public SetName(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetName; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetNameRaw")] +public partial class SetNameRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetNameRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetNameRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalMultipleContainment")] +public partial class SetOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalMultipleReference")] +public partial class SetOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalReferenceTypeProperty")] +public partial class SetOptionalReferenceTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalReferenceTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalReferenceTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalSingleContainment")] +public partial class SetOptionalSingleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalSingleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalSingleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalSingleReference")] +public partial class SetOptionalSingleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalSingleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalSingleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalValueTypeProperty")] +public partial class SetOptionalValueTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalValueTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalValueTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetParentInternal")] +public partial class SetParentInternal : global::LionWeb.Core.ConceptInstanceBase +{ + public SetParentInternal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetParentInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetParentNull")] +public partial class SetParentNull : global::LionWeb.Core.ConceptInstanceBase +{ + public SetParentNull(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetParentNull; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetPropertyRaw")] +public partial class SetPropertyRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetPropertyRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetPropertyRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRaw")] +public partial class SetRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetReferenceRaw")] +public partial class SetReferenceRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetReferenceRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetReferenceRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetReferencesRaw")] +public partial class SetReferencesRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetReferencesRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredMultipleContainment")] +public partial class SetRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredMultipleReference")] +public partial class SetRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredReferenceTypeProperty")] +public partial class SetRequiredReferenceTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredReferenceTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredReferenceTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredSingleContainment")] +public partial class SetRequiredSingleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredSingleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredSingleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredSingleReference")] +public partial class SetRequiredSingleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredSingleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredSingleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredValueTypeProperty")] +public partial class SetRequiredValueTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredValueTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredValueTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetSelfParent")] +public partial class SetSelfParent : global::LionWeb.Core.ConceptInstanceBase +{ + public SetSelfParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetSelfParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetSelfParentRaw")] +public partial class SetSelfParentRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetSelfParentRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetSelfParentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-String")] +public partial class String : global::LionWeb.Core.ConceptInstanceBase +{ + public String(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.String; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-StructuredDataType")] +public partial class StructuredDataType : global::LionWeb.Core.ConceptInstanceBase +{ + public StructuredDataType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.StructuredDataType; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-StructuredDataTypeBase")] +public partial class StructuredDataTypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public StructuredDataTypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.StructuredDataTypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-System")] +public partial class System : global::LionWeb.Core.ConceptInstanceBase +{ + public System(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.System; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ToString")] +public partial class ToString : global::LionWeb.Core.ConceptInstanceBase +{ + public ToString(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ToString_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGet")] +public partial class TryGet_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGet_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGet_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetContainmentRaw")] +public partial class TryGetContainmentRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetContainmentRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetContainmentRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetContainmentsRaw")] +public partial class TryGetContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetContainmentsRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetName")] +public partial class TryGetName : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetName(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetName_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetPropertyRaw")] +public partial class TryGetPropertyRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetPropertyRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetPropertyRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReference")] +public partial class TryGetReference : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReferenceRaw")] +public partial class TryGetReferenceRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReferenceRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReferenceRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReferencesRaw")] +public partial class TryGetReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReferencesRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Type")] +public partial class Type : global::LionWeb.Core.ConceptInstanceBase +{ + public Type(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Type; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsetFeatureException")] +public partial class UnsetFeatureException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsetFeatureException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsetFeatureException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsetFieldException")] +public partial class UnsetFieldException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsetFieldException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsetFieldException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedClassifierException")] +public partial class UnsupportedClassifierException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedClassifierException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedClassifierException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedEnumerationLiteralException")] +public partial class UnsupportedEnumerationLiteralException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedEnumerationLiteralException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedEnumerationLiteralException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedStructuredDataTypeException")] +public partial class UnsupportedStructuredDataTypeException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedStructuredDataTypeException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedStructuredDataTypeException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Utilities")] +public partial class Utilities : global::LionWeb.Core.ConceptInstanceBase +{ + public Utilities(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Utilities; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2023_1")] +public partial class V2023_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2023_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2023_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2024_1")] +public partial class V2024_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2024_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2024_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2024_1_Compatible")] +public partial class V2024_1_Compatible : global::LionWeb.Core.ConceptInstanceBase +{ + public V2024_1_Compatible(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2024_1_Compatible; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2025_1")] +public partial class V2025_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2025_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2025_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2025_1_Compatible")] +public partial class V2025_1_Compatible : global::LionWeb.Core.ConceptInstanceBase +{ + public V2025_1_Compatible(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2025_1_Compatible; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-VersionSpecific")] +public partial class VersionSpecific : global::LionWeb.Core.ConceptInstanceBase +{ + public VersionSpecific(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.VersionSpecific; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/LanguageWithLionWebNamedConcepts.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/LanguageWithLionWebNamedConcepts.g.cs new file mode 100644 index 000000000..378d4cf6f --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/LanguageWithLionWebNamedConcepts.g.cs @@ -0,0 +1,4649 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Core.Test.Languages.Generated.V2024_1.LanguageWithLionWebNamedConcepts; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; + +[global::LionWeb.Core.M2.LionCoreLanguage(Key = "key-LanguageWithLionWebNamedConcepts", Version = "1")] +public partial class LanguageWithLionWebNamedConceptsLanguage : LanguageBase +{ + public static readonly LanguageWithLionWebNamedConceptsLanguage Instance = new Lazy(() => new("id-LanguageWithLionWebNamedConcepts-lang")).Value; + public LanguageWithLionWebNamedConceptsLanguage(string id) : base(id, global::LionWeb.Core.LionWebVersions.v2024_1) + { + __builtIns = new(() => new ConceptBase("id-_builtIns", this) { Key = "key-_builtIns", Name = "_builtIns", Abstract = false, Partition = false }); + _abstract = new(() => new ConceptBase("id-Abstract", this) { Key = "key-Abstract", Name = "Abstract", Abstract = false, Partition = false }); + _abstractBaseNodeFactory = new(() => new ConceptBase("id-AbstractBaseNodeFactory", this) { Key = "key-AbstractBaseNodeFactory", Name = "AbstractBaseNodeFactory", Abstract = false, Partition = false }); + _add = new(() => new ConceptBase("id-Add", this) { Key = "key-Add", Name = "Add", Abstract = false, Partition = false }); + _addAnnotations = new(() => new ConceptBase("id-AddAnnotations", this) { Key = "key-AddAnnotations", Name = "AddAnnotations", Abstract = false, Partition = false }); + _addAnnotationsRaw = new(() => new ConceptBase("id-AddAnnotationsRaw", this) { Key = "key-AddAnnotationsRaw", Name = "AddAnnotationsRaw", Abstract = false, Partition = false }); + _addChildRaw = new(() => new ConceptBase("id-AddChildRaw", this) { Key = "key-AddChildRaw", Name = "AddChildRaw", Abstract = false, Partition = false }); + _addContainmentsRaw = new(() => new ConceptBase("id-AddContainmentsRaw", this) { Key = "key-AddContainmentsRaw", Name = "AddContainmentsRaw", Abstract = false, Partition = false }); + _addInternal = new(() => new ConceptBase("id-AddInternal", this) { Key = "key-AddInternal", Name = "AddInternal", Abstract = false, Partition = false }); + _addOptionalMultipleContainment = new(() => new ConceptBase("id-AddOptionalMultipleContainment", this) { Key = "key-AddOptionalMultipleContainment", Name = "AddOptionalMultipleContainment", Abstract = false, Partition = false }); + _addOptionalMultipleReference = new(() => new ConceptBase("id-AddOptionalMultipleReference", this) { Key = "key-AddOptionalMultipleReference", Name = "AddOptionalMultipleReference", Abstract = false, Partition = false }); + _addReferencesRaw = new(() => new ConceptBase("id-AddReferencesRaw", this) { Key = "key-AddReferencesRaw", Name = "AddReferencesRaw", Abstract = false, Partition = false }); + _addRequiredMultipleContainment = new(() => new ConceptBase("id-AddRequiredMultipleContainment", this) { Key = "key-AddRequiredMultipleContainment", Name = "AddRequiredMultipleContainment", Abstract = false, Partition = false }); + _addRequiredMultipleReference = new(() => new ConceptBase("id-AddRequiredMultipleReference", this) { Key = "key-AddRequiredMultipleReference", Name = "AddRequiredMultipleReference", Abstract = false, Partition = false }); + _annotatesLazy = new(() => new ConceptBase("id-AnnotatesLazy", this) { Key = "key-AnnotatesLazy", Name = "AnnotatesLazy", Abstract = false, Partition = false }); + _annotation = new(() => new ConceptBase("id-Annotation", this) { Key = "key-Annotation", Name = "Annotation", Abstract = false, Partition = false }); + _annotationBase = new(() => new ConceptBase("id-AnnotationBase", this) { Key = "key-AnnotationBase", Name = "AnnotationBase", Abstract = false, Partition = false }); + _annotationInstanceBase = new(() => new ConceptBase("id-AnnotationInstanceBase", this) { Key = "key-AnnotationInstanceBase", Name = "AnnotationInstanceBase", Abstract = false, Partition = false }); + _annotationRemover = new(() => new ConceptBase("id-AnnotationRemover", this) { Key = "key-AnnotationRemover", Name = "AnnotationRemover", Abstract = false, Partition = false }); + _argumentOutOfRangeException = new(() => new ConceptBase("id-ArgumentOutOfRangeException", this) { Key = "key-ArgumentOutOfRangeException", Name = "ArgumentOutOfRangeException", Abstract = false, Partition = false }); + _asList = new(() => new ConceptBase("id-AsList", this) { Key = "key-AsList", Name = "AsList", Abstract = false, Partition = false }); + _asNonEmptyReadOnly = new(() => new ConceptBase("id-AsNonEmptyReadOnly", this) { Key = "key-AsNonEmptyReadOnly", Name = "AsNonEmptyReadOnly", Abstract = false, Partition = false }); + _assureAnnotations = new(() => new ConceptBase("id-AssureAnnotations", this) { Key = "key-AssureAnnotations", Name = "AssureAnnotations", Abstract = false, Partition = false }); + _assureInRange = new(() => new ConceptBase("id-AssureInRange", this) { Key = "key-AssureInRange", Name = "AssureInRange", Abstract = false, Partition = false }); + _assureNonEmpty = new(() => new ConceptBase("id-AssureNonEmpty", this) { Key = "key-AssureNonEmpty", Name = "AssureNonEmpty", Abstract = false, Partition = false }); + _assureNoSelfMove = new(() => new ConceptBase("id-AssureNoSelfMove", this) { Key = "key-AssureNoSelfMove", Name = "AssureNoSelfMove", Abstract = false, Partition = false }); + _assureNotClearing = new(() => new ConceptBase("id-AssureNotClearing", this) { Key = "key-AssureNotClearing", Name = "AssureNotClearing", Abstract = false, Partition = false }); + _assureNotNull = new(() => new ConceptBase("id-AssureNotNull", this) { Key = "key-AssureNotNull", Name = "AssureNotNull", Abstract = false, Partition = false }); + _assureNotNullInstance = new(() => new ConceptBase("id-AssureNotNullInstance", this) { Key = "key-AssureNotNullInstance", Name = "AssureNotNullInstance", Abstract = false, Partition = false }); + _assureNotNullMembers = new(() => new ConceptBase("id-AssureNotNullMembers", this) { Key = "key-AssureNotNullMembers", Name = "AssureNotNullMembers", Abstract = false, Partition = false }); + _assureNullableInstance = new(() => new ConceptBase("id-AssureNullableInstance", this) { Key = "key-AssureNullableInstance", Name = "AssureNullableInstance", Abstract = false, Partition = false }); + _attachChild = new(() => new ConceptBase("id-AttachChild", this) { Key = "key-AttachChild", Name = "AttachChild", Abstract = false, Partition = false }); + _bool = new(() => new ConceptBase("id-Bool", this) { Key = "key-Bool", Name = "Bool", Abstract = false, Partition = false }); + _boolean = new(() => new ConceptBase("id-Boolean", this) { Key = "key-Boolean", Name = "Boolean", Abstract = false, Partition = false }); + _char = new(() => new ConceptBase("id-Char", this) { Key = "key-Char", Name = "Char", Abstract = false, Partition = false }); + _character = new(() => new ConceptBase("id-Character", this) { Key = "key-Character", Name = "Character", Abstract = false, Partition = false }); + _classifier = new(() => new ConceptBase("id-Classifier", this) { Key = "key-Classifier", Name = "Classifier", Abstract = false, Partition = false }); + _codeAnalysis = new(() => new ConceptBase("id-CodeAnalysis", this) { Key = "key-CodeAnalysis", Name = "CodeAnalysis", Abstract = false, Partition = false }); + _collectAllSetFeatures = new(() => new ConceptBase("id-CollectAllSetFeatures", this) { Key = "key-CollectAllSetFeatures", Name = "CollectAllSetFeatures", Abstract = false, Partition = false }); + _collections = new(() => new ConceptBase("id-Collections", this) { Key = "key-Collections", Name = "Collections", Abstract = false, Partition = false }); + _concept = new(() => new ConceptBase("id-Concept", this) { Key = "key-Concept", Name = "Concept", Abstract = false, Partition = false }); + _conceptBase = new(() => new ConceptBase("id-ConceptBase", this) { Key = "key-ConceptBase", Name = "ConceptBase", Abstract = false, Partition = false }); + _conceptInstanceBase = new(() => new ConceptBase("id-ConceptInstanceBase", this) { Key = "key-ConceptInstanceBase", Name = "ConceptInstanceBase", Abstract = false, Partition = false }); + _containment = new(() => new ConceptBase("id-Containment", this) { Key = "key-Containment", Name = "Containment", Abstract = false, Partition = false }); + _containmentBase = new(() => new ConceptBase("id-ContainmentBase", this) { Key = "key-ContainmentBase", Name = "ContainmentBase", Abstract = false, Partition = false }); + _containmentRemover = new(() => new ConceptBase("id-ContainmentRemover", this) { Key = "key-ContainmentRemover", Name = "ContainmentRemover", Abstract = false, Partition = false }); + _core = new(() => new ConceptBase("id-Core", this) { Key = "key-Core", Name = "Core", Abstract = false, Partition = false }); + _datatype = new(() => new ConceptBase("id-Datatype", this) { Key = "key-Datatype", Name = "Datatype", Abstract = false, Partition = false }); + _datatypeBase = new(() => new ConceptBase("id-DatatypeBase", this) { Key = "key-DatatypeBase", Name = "DatatypeBase", Abstract = false, Partition = false }); + _decimal = new(() => new ConceptBase("id-Decimal", this) { Key = "key-Decimal", Name = "Decimal", Abstract = false, Partition = false }); + _detachChild = new(() => new ConceptBase("id-DetachChild", this) { Key = "key-DetachChild", Name = "DetachChild", Abstract = false, Partition = false }); + _detachChildInternal = new(() => new ConceptBase("id-DetachChildInternal", this) { Key = "key-DetachChildInternal", Name = "DetachChildInternal", Abstract = false, Partition = false }); + _detachFromParent = new(() => new ConceptBase("id-DetachFromParent", this) { Key = "key-DetachFromParent", Name = "DetachFromParent", Abstract = false, Partition = false }); + _diagnostics = new(() => new ConceptBase("id-Diagnostics", this) { Key = "key-Diagnostics", Name = "Diagnostics", Abstract = false, Partition = false }); + _enum = new(() => new ConceptBase("id-Enum", this) { Key = "key-Enum", Name = "Enum", Abstract = false, Partition = false }); + _enumeration = new(() => new ConceptBase("id-Enumeration", this) { Key = "key-Enumeration", Name = "Enumeration", Abstract = false, Partition = false }); + _enumerationBase = new(() => new ConceptBase("id-EnumerationBase", this) { Key = "key-EnumerationBase", Name = "EnumerationBase", Abstract = false, Partition = false }); + _enumerationLiteral = new(() => new ConceptBase("id-EnumerationLiteral", this) { Key = "key-EnumerationLiteral", Name = "EnumerationLiteral", Abstract = false, Partition = false }); + _enumerationLiteralBase = new(() => new ConceptBase("id-EnumerationLiteralBase", this) { Key = "key-EnumerationLiteralBase", Name = "EnumerationLiteralBase", Abstract = false, Partition = false }); + _equals = new(() => new ConceptBase("id-Equals", this) { Key = "key-Equals", Name = "Equals", Abstract = false, Partition = false }); + _exchangeChildRaw = new(() => new ConceptBase("id-ExchangeChildRaw", this) { Key = "key-ExchangeChildRaw", Name = "ExchangeChildRaw", Abstract = false, Partition = false }); + _exchangeChildrenRaw = new(() => new ConceptBase("id-ExchangeChildrenRaw", this) { Key = "key-ExchangeChildrenRaw", Name = "ExchangeChildrenRaw", Abstract = false, Partition = false }); + _featuresLazy = new(() => new ConceptBase("id-FeaturesLazy", this) { Key = "key-FeaturesLazy", Name = "FeaturesLazy", Abstract = false, Partition = false }); + _field = new(() => new ConceptBase("id-Field", this) { Key = "key-Field", Name = "Field", Abstract = false, Partition = false }); + _fieldBase = new(() => new ConceptBase("id-FieldBase", this) { Key = "key-FieldBase", Name = "FieldBase", Abstract = false, Partition = false }); + _fieldsLazy = new(() => new ConceptBase("id-FieldsLazy", this) { Key = "key-FieldsLazy", Name = "FieldsLazy", Abstract = false, Partition = false }); + _finalize = new(() => new ConceptBase("id-Finalize", this) { Key = "key-Finalize", Name = "Finalize", Abstract = false, Partition = false }); + _generic = new(() => new ConceptBase("id-Generic", this) { Key = "key-Generic", Name = "Generic", Abstract = false, Partition = false }); + _get = new(() => new ConceptBase("id-Get", this) { Key = "key-Get", Name = "Get", Abstract = false, Partition = false }); + _get__builtIns = new(() => new ConceptBase("id-get__builtIns", this) { Key = "key-get__builtIns", Name = "get__builtIns", Abstract = false, Partition = false }); + _get__m3 = new(() => new ConceptBase("id-get__m3", this) { Key = "key-get__m3", Name = "get__m3", Abstract = false, Partition = false }); + _getAnnotation = new(() => new ConceptBase("id-GetAnnotation", this) { Key = "key-GetAnnotation", Name = "GetAnnotation", Abstract = false, Partition = false }); + _getAnnotations = new(() => new ConceptBase("id-GetAnnotations", this) { Key = "key-GetAnnotations", Name = "GetAnnotations", Abstract = false, Partition = false }); + _getAnnotationsRaw = new(() => new ConceptBase("id-GetAnnotationsRaw", this) { Key = "key-GetAnnotationsRaw", Name = "GetAnnotationsRaw", Abstract = false, Partition = false }); + _getClassifier = new(() => new ConceptBase("id-GetClassifier", this) { Key = "key-GetClassifier", Name = "GetClassifier", Abstract = false, Partition = false }); + _getConcept = new(() => new ConceptBase("id-GetConcept", this) { Key = "key-GetConcept", Name = "GetConcept", Abstract = false, Partition = false }); + _getContainmentOf = new(() => new ConceptBase("id-GetContainmentOf", this) { Key = "key-GetContainmentOf", Name = "GetContainmentOf", Abstract = false, Partition = false }); + _getHashCode = new(() => new ConceptBase("id-GetHashCode", this) { Key = "key-GetHashCode", Name = "GetHashCode", Abstract = false, Partition = false }); + _getId = new(() => new ConceptBase("id-GetId", this) { Key = "key-GetId", Name = "GetId", Abstract = false, Partition = false }); + _getInternal = new(() => new ConceptBase("id-GetInternal", this) { Key = "key-GetInternal", Name = "GetInternal", Abstract = false, Partition = false }); + _getParent = new(() => new ConceptBase("id-GetParent", this) { Key = "key-GetParent", Name = "GetParent", Abstract = false, Partition = false }); + _getPartitionNotificationProducer = new(() => new ConceptBase("id-GetPartitionNotificationProducer", this) { Key = "key-GetPartitionNotificationProducer", Name = "GetPartitionNotificationProducer", Abstract = false, Partition = false }); + _getRequiredNonNullReferences = new(() => new ConceptBase("id-GetRequiredNonNullReferences", this) { Key = "key-GetRequiredNonNullReferences", Name = "GetRequiredNonNullReferences", Abstract = false, Partition = false }); + _getRequiredNullableReferences = new(() => new ConceptBase("id-GetRequiredNullableReferences", this) { Key = "key-GetRequiredNullableReferences", Name = "GetRequiredNullableReferences", Abstract = false, Partition = false }); + _getRequiredReference = new(() => new ConceptBase("id-GetRequiredReference", this) { Key = "key-GetRequiredReference", Name = "GetRequiredReference", Abstract = false, Partition = false }); + _getType = new(() => new ConceptBase("id-GetType", this) { Key = "key-GetType", Name = "GetType", Abstract = false, Partition = false }); + _iEnumerable = new(() => new ConceptBase("id-IEnumerable", this) { Key = "key-IEnumerable", Name = "IEnumerable", Abstract = false, Partition = false }); + _iFieldValues = new(() => new ConceptBase("id-IFieldValues", this) { Key = "key-IFieldValues", Name = "IFieldValues", Abstract = false, Partition = false }); + _implementsLazy = new(() => new ConceptBase("id-ImplementsLazy", this) { Key = "key-ImplementsLazy", Name = "ImplementsLazy", Abstract = false, Partition = false }); + _iNamed = new(() => new ConceptBase("id-INamed", this) { Key = "key-INamed", Name = "INamed", Abstract = false, Partition = false }); + _iNamedWritable = new(() => new ConceptBase("id-INamedWritable", this) { Key = "key-INamedWritable", Name = "INamedWritable", Abstract = false, Partition = false }); + _iNode = new(() => new ConceptBase("id-INode", this) { Key = "key-INode", Name = "INode", Abstract = false, Partition = false }); + _iNodeFactory = new(() => new ConceptBase("id-INodeFactory", this) { Key = "key-INodeFactory", Name = "INodeFactory", Abstract = false, Partition = false }); + _insert = new(() => new ConceptBase("id-Insert", this) { Key = "key-Insert", Name = "Insert", Abstract = false, Partition = false }); + _insertAnnotations = new(() => new ConceptBase("id-InsertAnnotations", this) { Key = "key-InsertAnnotations", Name = "InsertAnnotations", Abstract = false, Partition = false }); + _insertAnnotationsRaw = new(() => new ConceptBase("id-InsertAnnotationsRaw", this) { Key = "key-InsertAnnotationsRaw", Name = "InsertAnnotationsRaw", Abstract = false, Partition = false }); + _insertChildRaw = new(() => new ConceptBase("id-InsertChildRaw", this) { Key = "key-InsertChildRaw", Name = "InsertChildRaw", Abstract = false, Partition = false }); + _insertContainmentsRaw = new(() => new ConceptBase("id-InsertContainmentsRaw", this) { Key = "key-InsertContainmentsRaw", Name = "InsertContainmentsRaw", Abstract = false, Partition = false }); + _insertInternal = new(() => new ConceptBase("id-InsertInternal", this) { Key = "key-InsertInternal", Name = "InsertInternal", Abstract = false, Partition = false }); + _insertOptionalMultipleContainment = new(() => new ConceptBase("id-InsertOptionalMultipleContainment", this) { Key = "key-InsertOptionalMultipleContainment", Name = "InsertOptionalMultipleContainment", Abstract = false, Partition = false }); + _insertOptionalMultipleReference = new(() => new ConceptBase("id-InsertOptionalMultipleReference", this) { Key = "key-InsertOptionalMultipleReference", Name = "InsertOptionalMultipleReference", Abstract = false, Partition = false }); + _insertReferencesRaw = new(() => new ConceptBase("id-InsertReferencesRaw", this) { Key = "key-InsertReferencesRaw", Name = "InsertReferencesRaw", Abstract = false, Partition = false }); + _insertRequiredMultipleContainment = new(() => new ConceptBase("id-InsertRequiredMultipleContainment", this) { Key = "key-InsertRequiredMultipleContainment", Name = "InsertRequiredMultipleContainment", Abstract = false, Partition = false }); + _insertRequiredMultipleReference = new(() => new ConceptBase("id-InsertRequiredMultipleReference", this) { Key = "key-InsertRequiredMultipleReference", Name = "InsertRequiredMultipleReference", Abstract = false, Partition = false }); + _instance = new(() => new ConceptBase("id-Instance", this) { Key = "key-Instance", Name = "Instance", Abstract = false, Partition = false }); + _integer = new(() => new ConceptBase("id-Integer", this) { Key = "key-Integer", Name = "Integer", Abstract = false, Partition = false }); + _interface = new(() => new ConceptBase("id-Interface", this) { Key = "key-Interface", Name = "Interface", Abstract = false, Partition = false }); + _interfaceBase = new(() => new ConceptBase("id-InterfaceBase", this) { Key = "key-InterfaceBase", Name = "InterfaceBase", Abstract = false, Partition = false }); + _invalidValueException = new(() => new ConceptBase("id-InvalidValueException", this) { Key = "key-InvalidValueException", Name = "InvalidValueException", Abstract = false, Partition = false }); + _iPartitionInstance = new(() => new ConceptBase("id-IPartitionInstance", this) { Key = "key-IPartitionInstance", Name = "IPartitionInstance", Abstract = false, Partition = false }); + _iReadableNode = new(() => new ConceptBase("id-IReadableNode", this) { Key = "key-IReadableNode", Name = "IReadableNode", Abstract = false, Partition = false }); + _iReadOnlyList = new(() => new ConceptBase("id-IReadOnlyList", this) { Key = "key-IReadOnlyList", Name = "IReadOnlyList", Abstract = false, Partition = false }); + _isInRange = new(() => new ConceptBase("id-IsInRange", this) { Key = "key-IsInRange", Name = "IsInRange", Abstract = false, Partition = false }); + _iStructuredDataTypeInstance = new(() => new ConceptBase("id-IStructuredDataTypeInstance", this) { Key = "key-IStructuredDataTypeInstance", Name = "IStructuredDataTypeInstance", Abstract = false, Partition = false }); + _iWritableNode = new(() => new ConceptBase("id-IWritableNode", this) { Key = "key-IWritableNode", Name = "IWritableNode", Abstract = false, Partition = false }); + _key_ = new(() => new ConceptBase("id-Key", this) { Key = "key-Key", Name = "Key", Abstract = false, Partition = false }); + _language = new(() => new ConceptBase("id-Language", this) { Key = "key-Language", Name = "Language", Abstract = false, Partition = false }); + _languageBase = new(() => new ConceptBase("id-LanguageBase", this) { Key = "key-LanguageBase", Name = "LanguageBase", Abstract = false, Partition = false }); + _languageEntity = new(() => new ConceptBase("id-LanguageEntity", this) { Key = "key-LanguageEntity", Name = "LanguageEntity", Abstract = false, Partition = false }); + _lazy = new(() => new ConceptBase("id-Lazy", this) { Key = "key-Lazy", Name = "Lazy", Abstract = false, Partition = false }); + _link = new(() => new ConceptBase("id-Link", this) { Key = "key-Link", Name = "Link", Abstract = false, Partition = false }); + _lionCoreFeature = new(() => new ConceptBase("id-LionCoreFeature", this) { Key = "key-LionCoreFeature", Name = "LionCoreFeature", Abstract = false, Partition = false }); + _lionCoreFeatureKind = new(() => new ConceptBase("id-LionCoreFeatureKind", this) { Key = "key-LionCoreFeatureKind", Name = "LionCoreFeatureKind", Abstract = false, Partition = false }); + _lionCoreLanguage = new(() => new ConceptBase("id-LionCoreLanguage", this) { Key = "key-LionCoreLanguage", Name = "LionCoreLanguage", Abstract = false, Partition = false }); + _lionCoreMetaPointer = new(() => new ConceptBase("id-LionCoreMetaPointer", this) { Key = "key-LionCoreMetaPointer", Name = "LionCoreMetaPointer", Abstract = false, Partition = false }); + _lionWeb = new(() => new ConceptBase("id-LionWeb", this) { Key = "key-LionWeb", Name = "LionWeb", Abstract = false, Partition = false }); + _lionWebVersions = new(() => new ConceptBase("id-LionWebVersions", this) { Key = "key-LionWebVersions", Name = "LionWebVersions", Abstract = false, Partition = false }); + _list = new(() => new ConceptBase("id-List", this) { Key = "key-List", Name = "List", Abstract = false, Partition = false }); + _literalsLazy = new(() => new ConceptBase("id-LiteralsLazy", this) { Key = "key-LiteralsLazy", Name = "LiteralsLazy", Abstract = false, Partition = false }); + _m2 = new(() => new ConceptBase("id-M2", this) { Key = "key-M2", Name = "M2", Abstract = false, Partition = false }); + _m3_ = new(() => new ConceptBase("id-M3", this) { Key = "key-M3", Name = "M3", Abstract = false, Partition = false }); + _memberwiseClone = new(() => new ConceptBase("id-MemberwiseClone", this) { Key = "key-MemberwiseClone", Name = "MemberwiseClone", Abstract = false, Partition = false }); + _multiple = new(() => new ConceptBase("id-Multiple", this) { Key = "key-Multiple", Name = "Multiple", Abstract = false, Partition = false }); + _name_ = new(() => new ConceptBase("id-Name", this) { Key = "key-Name", Name = "Name", Abstract = false, Partition = false }); + _notification = new(() => new ConceptBase("id-Notification", this) { Key = "key-Notification", Name = "Notification", Abstract = false, Partition = false }); + _notNullWhenAttribute = new(() => new ConceptBase("id-NotNullWhenAttribute", this) { Key = "key-NotNullWhenAttribute", Name = "NotNullWhenAttribute", Abstract = false, Partition = false }); + _optional = new(() => new ConceptBase("id-Optional", this) { Key = "key-Optional", Name = "Optional", Abstract = false, Partition = false }); + _partition = new(() => new ConceptBase("id-Partition", this) { Key = "key-Partition", Name = "Partition", Abstract = false, Partition = false }); + _pipe = new(() => new ConceptBase("id-Pipe", this) { Key = "key-Pipe", Name = "Pipe", Abstract = false, Partition = false }); + _primitiveType = new(() => new ConceptBase("id-PrimitiveType", this) { Key = "key-PrimitiveType", Name = "PrimitiveType", Abstract = false, Partition = false }); + _primitiveTypeBase = new(() => new ConceptBase("id-PrimitiveTypeBase", this) { Key = "key-PrimitiveTypeBase", Name = "PrimitiveTypeBase", Abstract = false, Partition = false }); + _property = new(() => new ConceptBase("id-Property", this) { Key = "key-Property", Name = "Property", Abstract = false, Partition = false }); + _propertyBase = new(() => new ConceptBase("id-PropertyBase", this) { Key = "key-PropertyBase", Name = "PropertyBase", Abstract = false, Partition = false }); + _reference = new(() => new ConceptBase("id-Reference", this) { Key = "key-Reference", Name = "Reference", Abstract = false, Partition = false }); + _referenceBase = new(() => new ConceptBase("id-ReferenceBase", this) { Key = "key-ReferenceBase", Name = "ReferenceBase", Abstract = false, Partition = false }); + _referenceEquals = new(() => new ConceptBase("id-ReferenceEquals", this) { Key = "key-ReferenceEquals", Name = "ReferenceEquals", Abstract = false, Partition = false }); + _referenceRemover = new(() => new ConceptBase("id-ReferenceRemover", this) { Key = "key-ReferenceRemover", Name = "ReferenceRemover", Abstract = false, Partition = false }); + _referenceTargetNonNullTarget = new(() => new ConceptBase("id-ReferenceTargetNonNullTarget", this) { Key = "key-ReferenceTargetNonNullTarget", Name = "ReferenceTargetNonNullTarget", Abstract = false, Partition = false }); + _referenceTargetNonNullTargets = new(() => new ConceptBase("id-ReferenceTargetNonNullTargets", this) { Key = "key-ReferenceTargetNonNullTargets", Name = "ReferenceTargetNonNullTargets", Abstract = false, Partition = false }); + _referenceTargetNullableTarget = new(() => new ConceptBase("id-ReferenceTargetNullableTarget", this) { Key = "key-ReferenceTargetNullableTarget", Name = "ReferenceTargetNullableTarget", Abstract = false, Partition = false }); + _referenceTargetNullableTargets = new(() => new ConceptBase("id-ReferenceTargetNullableTargets", this) { Key = "key-ReferenceTargetNullableTargets", Name = "ReferenceTargetNullableTargets", Abstract = false, Partition = false }); + _remove = new(() => new ConceptBase("id-Remove", this) { Key = "key-Remove", Name = "Remove", Abstract = false, Partition = false }); + _removeAll = new(() => new ConceptBase("id-RemoveAll", this) { Key = "key-RemoveAll", Name = "RemoveAll", Abstract = false, Partition = false }); + _removeAnnotations = new(() => new ConceptBase("id-RemoveAnnotations", this) { Key = "key-RemoveAnnotations", Name = "RemoveAnnotations", Abstract = false, Partition = false }); + _removeAnnotationsRaw = new(() => new ConceptBase("id-RemoveAnnotationsRaw", this) { Key = "key-RemoveAnnotationsRaw", Name = "RemoveAnnotationsRaw", Abstract = false, Partition = false }); + _removeChildRaw = new(() => new ConceptBase("id-RemoveChildRaw", this) { Key = "key-RemoveChildRaw", Name = "RemoveChildRaw", Abstract = false, Partition = false }); + _removeContainmentsRaw = new(() => new ConceptBase("id-RemoveContainmentsRaw", this) { Key = "key-RemoveContainmentsRaw", Name = "RemoveContainmentsRaw", Abstract = false, Partition = false }); + _removeInternal = new(() => new ConceptBase("id-RemoveInternal", this) { Key = "key-RemoveInternal", Name = "RemoveInternal", Abstract = false, Partition = false }); + _removeOptionalMultipleContainment = new(() => new ConceptBase("id-RemoveOptionalMultipleContainment", this) { Key = "key-RemoveOptionalMultipleContainment", Name = "RemoveOptionalMultipleContainment", Abstract = false, Partition = false }); + _removeOptionalMultipleReference = new(() => new ConceptBase("id-RemoveOptionalMultipleReference", this) { Key = "key-RemoveOptionalMultipleReference", Name = "RemoveOptionalMultipleReference", Abstract = false, Partition = false }); + _removeReferencesRaw = new(() => new ConceptBase("id-RemoveReferencesRaw", this) { Key = "key-RemoveReferencesRaw", Name = "RemoveReferencesRaw", Abstract = false, Partition = false }); + _removeRequiredMultipleContainment = new(() => new ConceptBase("id-RemoveRequiredMultipleContainment", this) { Key = "key-RemoveRequiredMultipleContainment", Name = "RemoveRequiredMultipleContainment", Abstract = false, Partition = false }); + _removeRequiredMultipleReference = new(() => new ConceptBase("id-RemoveRequiredMultipleReference", this) { Key = "key-RemoveRequiredMultipleReference", Name = "RemoveRequiredMultipleReference", Abstract = false, Partition = false }); + _removeSelfParent = new(() => new ConceptBase("id-RemoveSelfParent", this) { Key = "key-RemoveSelfParent", Name = "RemoveSelfParent", Abstract = false, Partition = false }); + _removeSelfParentRaw = new(() => new ConceptBase("id-RemoveSelfParentRaw", this) { Key = "key-RemoveSelfParentRaw", Name = "RemoveSelfParentRaw", Abstract = false, Partition = false }); + _result = new(() => new ConceptBase("id-result", this) { Key = "key-result", Name = "result", Abstract = false, Partition = false }); + _set = new(() => new ConceptBase("id-Set", this) { Key = "key-Set", Name = "Set", Abstract = false, Partition = false }); + _setContainmentRaw = new(() => new ConceptBase("id-SetContainmentRaw", this) { Key = "key-SetContainmentRaw", Name = "SetContainmentRaw", Abstract = false, Partition = false }); + _setInternal = new(() => new ConceptBase("id-SetInternal", this) { Key = "key-SetInternal", Name = "SetInternal", Abstract = false, Partition = false }); + _setInternalAnnotation = new(() => new ConceptBase("id-SetInternalAnnotation", this) { Key = "key-SetInternalAnnotation", Name = "SetInternalAnnotation", Abstract = false, Partition = false }); + _setName = new(() => new ConceptBase("id-SetName", this) { Key = "key-SetName", Name = "SetName", Abstract = false, Partition = false }); + _setNameRaw = new(() => new ConceptBase("id-SetNameRaw", this) { Key = "key-SetNameRaw", Name = "SetNameRaw", Abstract = false, Partition = false }); + _setOptionalMultipleContainment = new(() => new ConceptBase("id-SetOptionalMultipleContainment", this) { Key = "key-SetOptionalMultipleContainment", Name = "SetOptionalMultipleContainment", Abstract = false, Partition = false }); + _setOptionalMultipleReference = new(() => new ConceptBase("id-SetOptionalMultipleReference", this) { Key = "key-SetOptionalMultipleReference", Name = "SetOptionalMultipleReference", Abstract = false, Partition = false }); + _setOptionalReferenceTypeProperty = new(() => new ConceptBase("id-SetOptionalReferenceTypeProperty", this) { Key = "key-SetOptionalReferenceTypeProperty", Name = "SetOptionalReferenceTypeProperty", Abstract = false, Partition = false }); + _setOptionalSingleContainment = new(() => new ConceptBase("id-SetOptionalSingleContainment", this) { Key = "key-SetOptionalSingleContainment", Name = "SetOptionalSingleContainment", Abstract = false, Partition = false }); + _setOptionalSingleReference = new(() => new ConceptBase("id-SetOptionalSingleReference", this) { Key = "key-SetOptionalSingleReference", Name = "SetOptionalSingleReference", Abstract = false, Partition = false }); + _setOptionalValueTypeProperty = new(() => new ConceptBase("id-SetOptionalValueTypeProperty", this) { Key = "key-SetOptionalValueTypeProperty", Name = "SetOptionalValueTypeProperty", Abstract = false, Partition = false }); + _setParentInternal = new(() => new ConceptBase("id-SetParentInternal", this) { Key = "key-SetParentInternal", Name = "SetParentInternal", Abstract = false, Partition = false }); + _setParentNull = new(() => new ConceptBase("id-SetParentNull", this) { Key = "key-SetParentNull", Name = "SetParentNull", Abstract = false, Partition = false }); + _setPropertyRaw = new(() => new ConceptBase("id-SetPropertyRaw", this) { Key = "key-SetPropertyRaw", Name = "SetPropertyRaw", Abstract = false, Partition = false }); + _setRaw = new(() => new ConceptBase("id-SetRaw", this) { Key = "key-SetRaw", Name = "SetRaw", Abstract = false, Partition = false }); + _setReferenceRaw = new(() => new ConceptBase("id-SetReferenceRaw", this) { Key = "key-SetReferenceRaw", Name = "SetReferenceRaw", Abstract = false, Partition = false }); + _setReferencesRaw = new(() => new ConceptBase("id-SetReferencesRaw", this) { Key = "key-SetReferencesRaw", Name = "SetReferencesRaw", Abstract = false, Partition = false }); + _setRequiredMultipleContainment = new(() => new ConceptBase("id-SetRequiredMultipleContainment", this) { Key = "key-SetRequiredMultipleContainment", Name = "SetRequiredMultipleContainment", Abstract = false, Partition = false }); + _setRequiredMultipleReference = new(() => new ConceptBase("id-SetRequiredMultipleReference", this) { Key = "key-SetRequiredMultipleReference", Name = "SetRequiredMultipleReference", Abstract = false, Partition = false }); + _setRequiredReferenceTypeProperty = new(() => new ConceptBase("id-SetRequiredReferenceTypeProperty", this) { Key = "key-SetRequiredReferenceTypeProperty", Name = "SetRequiredReferenceTypeProperty", Abstract = false, Partition = false }); + _setRequiredSingleContainment = new(() => new ConceptBase("id-SetRequiredSingleContainment", this) { Key = "key-SetRequiredSingleContainment", Name = "SetRequiredSingleContainment", Abstract = false, Partition = false }); + _setRequiredSingleReference = new(() => new ConceptBase("id-SetRequiredSingleReference", this) { Key = "key-SetRequiredSingleReference", Name = "SetRequiredSingleReference", Abstract = false, Partition = false }); + _setRequiredValueTypeProperty = new(() => new ConceptBase("id-SetRequiredValueTypeProperty", this) { Key = "key-SetRequiredValueTypeProperty", Name = "SetRequiredValueTypeProperty", Abstract = false, Partition = false }); + _setSelfParent = new(() => new ConceptBase("id-SetSelfParent", this) { Key = "key-SetSelfParent", Name = "SetSelfParent", Abstract = false, Partition = false }); + _setSelfParentRaw = new(() => new ConceptBase("id-SetSelfParentRaw", this) { Key = "key-SetSelfParentRaw", Name = "SetSelfParentRaw", Abstract = false, Partition = false }); + _string = new(() => new ConceptBase("id-String", this) { Key = "key-String", Name = "String", Abstract = false, Partition = false }); + _structuredDataType = new(() => new ConceptBase("id-StructuredDataType", this) { Key = "key-StructuredDataType", Name = "StructuredDataType", Abstract = false, Partition = false }); + _structuredDataTypeBase = new(() => new ConceptBase("id-StructuredDataTypeBase", this) { Key = "key-StructuredDataTypeBase", Name = "StructuredDataTypeBase", Abstract = false, Partition = false }); + _system = new(() => new ConceptBase("id-System", this) { Key = "key-System", Name = "System", Abstract = false, Partition = false }); + _toString = new(() => new ConceptBase("id-ToString", this) { Key = "key-ToString", Name = "ToString", Abstract = false, Partition = false }); + _tryGet = new(() => new ConceptBase("id-TryGet", this) { Key = "key-TryGet", Name = "TryGet", Abstract = false, Partition = false }); + _tryGetContainmentRaw = new(() => new ConceptBase("id-TryGetContainmentRaw", this) { Key = "key-TryGetContainmentRaw", Name = "TryGetContainmentRaw", Abstract = false, Partition = false }); + _tryGetContainmentsRaw = new(() => new ConceptBase("id-TryGetContainmentsRaw", this) { Key = "key-TryGetContainmentsRaw", Name = "TryGetContainmentsRaw", Abstract = false, Partition = false }); + _tryGetName = new(() => new ConceptBase("id-TryGetName", this) { Key = "key-TryGetName", Name = "TryGetName", Abstract = false, Partition = false }); + _tryGetPropertyRaw = new(() => new ConceptBase("id-TryGetPropertyRaw", this) { Key = "key-TryGetPropertyRaw", Name = "TryGetPropertyRaw", Abstract = false, Partition = false }); + _tryGetReference = new(() => new ConceptBase("id-TryGetReference", this) { Key = "key-TryGetReference", Name = "TryGetReference", Abstract = false, Partition = false }); + _tryGetReferenceRaw = new(() => new ConceptBase("id-TryGetReferenceRaw", this) { Key = "key-TryGetReferenceRaw", Name = "TryGetReferenceRaw", Abstract = false, Partition = false }); + _tryGetReferencesRaw = new(() => new ConceptBase("id-TryGetReferencesRaw", this) { Key = "key-TryGetReferencesRaw", Name = "TryGetReferencesRaw", Abstract = false, Partition = false }); + _type = new(() => new ConceptBase("id-Type", this) { Key = "key-Type", Name = "Type", Abstract = false, Partition = false }); + _unsetFeatureException = new(() => new ConceptBase("id-UnsetFeatureException", this) { Key = "key-UnsetFeatureException", Name = "UnsetFeatureException", Abstract = false, Partition = false }); + _unsetFieldException = new(() => new ConceptBase("id-UnsetFieldException", this) { Key = "key-UnsetFieldException", Name = "UnsetFieldException", Abstract = false, Partition = false }); + _unsupportedClassifierException = new(() => new ConceptBase("id-UnsupportedClassifierException", this) { Key = "key-UnsupportedClassifierException", Name = "UnsupportedClassifierException", Abstract = false, Partition = false }); + _unsupportedEnumerationLiteralException = new(() => new ConceptBase("id-UnsupportedEnumerationLiteralException", this) { Key = "key-UnsupportedEnumerationLiteralException", Name = "UnsupportedEnumerationLiteralException", Abstract = false, Partition = false }); + _unsupportedStructuredDataTypeException = new(() => new ConceptBase("id-UnsupportedStructuredDataTypeException", this) { Key = "key-UnsupportedStructuredDataTypeException", Name = "UnsupportedStructuredDataTypeException", Abstract = false, Partition = false }); + _utilities = new(() => new ConceptBase("id-Utilities", this) { Key = "key-Utilities", Name = "Utilities", Abstract = false, Partition = false }); + _v2023_1 = new(() => new ConceptBase("id-V2023_1", this) { Key = "key-V2023_1", Name = "V2023_1", Abstract = false, Partition = false }); + _v2024_1 = new(() => new ConceptBase("id-V2024_1", this) { Key = "key-V2024_1", Name = "V2024_1", Abstract = false, Partition = false }); + _v2024_1_Compatible = new(() => new ConceptBase("id-V2024_1_Compatible", this) { Key = "key-V2024_1_Compatible", Name = "V2024_1_Compatible", Abstract = false, Partition = false }); + _v2025_1 = new(() => new ConceptBase("id-V2025_1", this) { Key = "key-V2025_1", Name = "V2025_1", Abstract = false, Partition = false }); + _v2025_1_Compatible = new(() => new ConceptBase("id-V2025_1_Compatible", this) { Key = "key-V2025_1_Compatible", Name = "V2025_1_Compatible", Abstract = false, Partition = false }); + _versionSpecific = new(() => new ConceptBase("id-VersionSpecific", this) { Key = "key-VersionSpecific", Name = "VersionSpecific", Abstract = false, Partition = false }); + _factory = new LanguageWithLionWebNamedConceptsFactory(this); + } + + /// + public override IReadOnlyList Entities => [_builtIns_, Abstract, AbstractBaseNodeFactory, Add, AddAnnotations, AddAnnotationsRaw, AddChildRaw, AddContainmentsRaw, AddInternal, AddOptionalMultipleContainment, AddOptionalMultipleReference, AddReferencesRaw, AddRequiredMultipleContainment, AddRequiredMultipleReference, AnnotatesLazy, Annotation, AnnotationBase, AnnotationInstanceBase, AnnotationRemover, ArgumentOutOfRangeException, AsList, AsNonEmptyReadOnly, AssureAnnotations, AssureInRange, AssureNonEmpty, AssureNoSelfMove, AssureNotClearing, AssureNotNull, AssureNotNullInstance, AssureNotNullMembers, AssureNullableInstance, AttachChild, Bool, Boolean, Char, Character, Classifier, CodeAnalysis, CollectAllSetFeatures_, Collections, Concept, ConceptBase, ConceptInstanceBase, Containment, ContainmentBase, ContainmentRemover, Core, Datatype, DatatypeBase, Decimal, DetachChild, DetachChildInternal, DetachFromParent, Diagnostics, Enum, Enumeration, EnumerationBase, EnumerationLiteral, EnumerationLiteralBase, Equals_, ExchangeChildRaw, ExchangeChildrenRaw, FeaturesLazy, Field, FieldBase, FieldsLazy, Finalize, Generic, Get_, get__builtIns, get__m3, GetAnnotation, GetAnnotations_, GetAnnotationsRaw_, GetClassifier_, GetConcept_, GetContainmentOf, GetHashCode_, GetId_, GetInternal, GetParent_, GetPartitionNotificationProducer, GetRequiredNonNullReferences, GetRequiredNullableReferences, GetRequiredReference, GetType_, IEnumerable, IFieldValues, ImplementsLazy, INamed, INamedWritable, INode, INodeFactory, Insert, InsertAnnotations, InsertAnnotationsRaw, InsertChildRaw, InsertContainmentsRaw, InsertInternal, InsertOptionalMultipleContainment, InsertOptionalMultipleReference, InsertReferencesRaw, InsertRequiredMultipleContainment, InsertRequiredMultipleReference, Instance_, Integer, Interface, InterfaceBase, InvalidValueException, IPartitionInstance, IReadableNode, IReadOnlyList, IsInRange, IStructuredDataTypeInstance, IWritableNode, Key_, Language, LanguageBase, LanguageEntity, Lazy, Link, LionCoreFeature, LionCoreFeatureKind, LionCoreLanguage, LionCoreMetaPointer, LionWeb, LionWebVersions, List, LiteralsLazy, M2, M3, MemberwiseClone_, Multiple, Name_, Notification, NotNullWhenAttribute, Optional, Partition, Pipe, PrimitiveType, PrimitiveTypeBase, Property, PropertyBase, Reference, ReferenceBase, ReferenceEquals_, ReferenceRemover, ReferenceTargetNonNullTarget, ReferenceTargetNonNullTargets, ReferenceTargetNullableTarget, ReferenceTargetNullableTargets, Remove, RemoveAll, RemoveAnnotations, RemoveAnnotationsRaw, RemoveChildRaw, RemoveContainmentsRaw, RemoveInternal, RemoveOptionalMultipleContainment, RemoveOptionalMultipleReference, RemoveReferencesRaw, RemoveRequiredMultipleContainment, RemoveRequiredMultipleReference, RemoveSelfParent, RemoveSelfParentRaw, result, Set, SetContainmentRaw, SetInternal, SetInternalAnnotation, SetName, SetNameRaw, SetOptionalMultipleContainment, SetOptionalMultipleReference, SetOptionalReferenceTypeProperty, SetOptionalSingleContainment, SetOptionalSingleReference, SetOptionalValueTypeProperty, SetParentInternal, SetParentNull, SetPropertyRaw, SetRaw, SetReferenceRaw, SetReferencesRaw, SetRequiredMultipleContainment, SetRequiredMultipleReference, SetRequiredReferenceTypeProperty, SetRequiredSingleContainment, SetRequiredSingleReference, SetRequiredValueTypeProperty, SetSelfParent, SetSelfParentRaw, String, StructuredDataType, StructuredDataTypeBase, System, ToString_, TryGet_, TryGetContainmentRaw_, TryGetContainmentsRaw_, TryGetName_, TryGetPropertyRaw_, TryGetReference, TryGetReferenceRaw_, TryGetReferencesRaw_, Type, UnsetFeatureException, UnsetFieldException, UnsupportedClassifierException, UnsupportedEnumerationLiteralException, UnsupportedStructuredDataTypeException, Utilities, V2023_1, V2024_1, V2024_1_Compatible, V2025_1, V2025_1_Compatible, VersionSpecific]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-LanguageWithLionWebNamedConcepts"; + /// + public override string Key => _key; + + private const string _name = "LanguageWithLionWebNamedConcepts"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy __builtIns; + public global::LionWeb.Core.M3.Concept _builtIns_ => __builtIns.Value; + + private readonly Lazy _abstract; + public global::LionWeb.Core.M3.Concept Abstract => _abstract.Value; + + private readonly Lazy _abstractBaseNodeFactory; + public global::LionWeb.Core.M3.Concept AbstractBaseNodeFactory => _abstractBaseNodeFactory.Value; + + private readonly Lazy _add; + public global::LionWeb.Core.M3.Concept Add => _add.Value; + + private readonly Lazy _addAnnotations; + public global::LionWeb.Core.M3.Concept AddAnnotations => _addAnnotations.Value; + + private readonly Lazy _addAnnotationsRaw; + public global::LionWeb.Core.M3.Concept AddAnnotationsRaw => _addAnnotationsRaw.Value; + + private readonly Lazy _addChildRaw; + public global::LionWeb.Core.M3.Concept AddChildRaw => _addChildRaw.Value; + + private readonly Lazy _addContainmentsRaw; + public global::LionWeb.Core.M3.Concept AddContainmentsRaw => _addContainmentsRaw.Value; + + private readonly Lazy _addInternal; + public global::LionWeb.Core.M3.Concept AddInternal => _addInternal.Value; + + private readonly Lazy _addOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept AddOptionalMultipleContainment => _addOptionalMultipleContainment.Value; + + private readonly Lazy _addOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept AddOptionalMultipleReference => _addOptionalMultipleReference.Value; + + private readonly Lazy _addReferencesRaw; + public global::LionWeb.Core.M3.Concept AddReferencesRaw => _addReferencesRaw.Value; + + private readonly Lazy _addRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept AddRequiredMultipleContainment => _addRequiredMultipleContainment.Value; + + private readonly Lazy _addRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept AddRequiredMultipleReference => _addRequiredMultipleReference.Value; + + private readonly Lazy _annotatesLazy; + public global::LionWeb.Core.M3.Concept AnnotatesLazy => _annotatesLazy.Value; + + private readonly Lazy _annotation; + public global::LionWeb.Core.M3.Concept Annotation => _annotation.Value; + + private readonly Lazy _annotationBase; + public global::LionWeb.Core.M3.Concept AnnotationBase => _annotationBase.Value; + + private readonly Lazy _annotationInstanceBase; + public global::LionWeb.Core.M3.Concept AnnotationInstanceBase => _annotationInstanceBase.Value; + + private readonly Lazy _annotationRemover; + public global::LionWeb.Core.M3.Concept AnnotationRemover => _annotationRemover.Value; + + private readonly Lazy _argumentOutOfRangeException; + public global::LionWeb.Core.M3.Concept ArgumentOutOfRangeException => _argumentOutOfRangeException.Value; + + private readonly Lazy _asList; + public global::LionWeb.Core.M3.Concept AsList => _asList.Value; + + private readonly Lazy _asNonEmptyReadOnly; + public global::LionWeb.Core.M3.Concept AsNonEmptyReadOnly => _asNonEmptyReadOnly.Value; + + private readonly Lazy _assureAnnotations; + public global::LionWeb.Core.M3.Concept AssureAnnotations => _assureAnnotations.Value; + + private readonly Lazy _assureInRange; + public global::LionWeb.Core.M3.Concept AssureInRange => _assureInRange.Value; + + private readonly Lazy _assureNonEmpty; + public global::LionWeb.Core.M3.Concept AssureNonEmpty => _assureNonEmpty.Value; + + private readonly Lazy _assureNoSelfMove; + public global::LionWeb.Core.M3.Concept AssureNoSelfMove => _assureNoSelfMove.Value; + + private readonly Lazy _assureNotClearing; + public global::LionWeb.Core.M3.Concept AssureNotClearing => _assureNotClearing.Value; + + private readonly Lazy _assureNotNull; + public global::LionWeb.Core.M3.Concept AssureNotNull => _assureNotNull.Value; + + private readonly Lazy _assureNotNullInstance; + public global::LionWeb.Core.M3.Concept AssureNotNullInstance => _assureNotNullInstance.Value; + + private readonly Lazy _assureNotNullMembers; + public global::LionWeb.Core.M3.Concept AssureNotNullMembers => _assureNotNullMembers.Value; + + private readonly Lazy _assureNullableInstance; + public global::LionWeb.Core.M3.Concept AssureNullableInstance => _assureNullableInstance.Value; + + private readonly Lazy _attachChild; + public global::LionWeb.Core.M3.Concept AttachChild => _attachChild.Value; + + private readonly Lazy _bool; + public global::LionWeb.Core.M3.Concept Bool => _bool.Value; + + private readonly Lazy _boolean; + public global::LionWeb.Core.M3.Concept Boolean => _boolean.Value; + + private readonly Lazy _char; + public global::LionWeb.Core.M3.Concept Char => _char.Value; + + private readonly Lazy _character; + public global::LionWeb.Core.M3.Concept Character => _character.Value; + + private readonly Lazy _classifier; + public global::LionWeb.Core.M3.Concept Classifier => _classifier.Value; + + private readonly Lazy _codeAnalysis; + public global::LionWeb.Core.M3.Concept CodeAnalysis => _codeAnalysis.Value; + + private readonly Lazy _collectAllSetFeatures; + public global::LionWeb.Core.M3.Concept CollectAllSetFeatures_ => _collectAllSetFeatures.Value; + + private readonly Lazy _collections; + public global::LionWeb.Core.M3.Concept Collections => _collections.Value; + + private readonly Lazy _concept; + public global::LionWeb.Core.M3.Concept Concept => _concept.Value; + + private readonly Lazy _conceptBase; + public global::LionWeb.Core.M3.Concept ConceptBase => _conceptBase.Value; + + private readonly Lazy _conceptInstanceBase; + public global::LionWeb.Core.M3.Concept ConceptInstanceBase => _conceptInstanceBase.Value; + + private readonly Lazy _containment; + public global::LionWeb.Core.M3.Concept Containment => _containment.Value; + + private readonly Lazy _containmentBase; + public global::LionWeb.Core.M3.Concept ContainmentBase => _containmentBase.Value; + + private readonly Lazy _containmentRemover; + public global::LionWeb.Core.M3.Concept ContainmentRemover => _containmentRemover.Value; + + private readonly Lazy _core; + public global::LionWeb.Core.M3.Concept Core => _core.Value; + + private readonly Lazy _datatype; + public global::LionWeb.Core.M3.Concept Datatype => _datatype.Value; + + private readonly Lazy _datatypeBase; + public global::LionWeb.Core.M3.Concept DatatypeBase => _datatypeBase.Value; + + private readonly Lazy _decimal; + public global::LionWeb.Core.M3.Concept Decimal => _decimal.Value; + + private readonly Lazy _detachChild; + public global::LionWeb.Core.M3.Concept DetachChild => _detachChild.Value; + + private readonly Lazy _detachChildInternal; + public global::LionWeb.Core.M3.Concept DetachChildInternal => _detachChildInternal.Value; + + private readonly Lazy _detachFromParent; + public global::LionWeb.Core.M3.Concept DetachFromParent => _detachFromParent.Value; + + private readonly Lazy _diagnostics; + public global::LionWeb.Core.M3.Concept Diagnostics => _diagnostics.Value; + + private readonly Lazy _enum; + public global::LionWeb.Core.M3.Concept Enum => _enum.Value; + + private readonly Lazy _enumeration; + public global::LionWeb.Core.M3.Concept Enumeration => _enumeration.Value; + + private readonly Lazy _enumerationBase; + public global::LionWeb.Core.M3.Concept EnumerationBase => _enumerationBase.Value; + + private readonly Lazy _enumerationLiteral; + public global::LionWeb.Core.M3.Concept EnumerationLiteral => _enumerationLiteral.Value; + + private readonly Lazy _enumerationLiteralBase; + public global::LionWeb.Core.M3.Concept EnumerationLiteralBase => _enumerationLiteralBase.Value; + + private readonly Lazy _equals; + public global::LionWeb.Core.M3.Concept Equals_ => _equals.Value; + + private readonly Lazy _exchangeChildRaw; + public global::LionWeb.Core.M3.Concept ExchangeChildRaw => _exchangeChildRaw.Value; + + private readonly Lazy _exchangeChildrenRaw; + public global::LionWeb.Core.M3.Concept ExchangeChildrenRaw => _exchangeChildrenRaw.Value; + + private readonly Lazy _featuresLazy; + public global::LionWeb.Core.M3.Concept FeaturesLazy => _featuresLazy.Value; + + private readonly Lazy _field; + public global::LionWeb.Core.M3.Concept Field => _field.Value; + + private readonly Lazy _fieldBase; + public global::LionWeb.Core.M3.Concept FieldBase => _fieldBase.Value; + + private readonly Lazy _fieldsLazy; + public global::LionWeb.Core.M3.Concept FieldsLazy => _fieldsLazy.Value; + + private readonly Lazy _finalize; + public global::LionWeb.Core.M3.Concept Finalize => _finalize.Value; + + private readonly Lazy _generic; + public global::LionWeb.Core.M3.Concept Generic => _generic.Value; + + private readonly Lazy _get; + public global::LionWeb.Core.M3.Concept Get_ => _get.Value; + + private readonly Lazy _get__builtIns; + public global::LionWeb.Core.M3.Concept get__builtIns => _get__builtIns.Value; + + private readonly Lazy _get__m3; + public global::LionWeb.Core.M3.Concept get__m3 => _get__m3.Value; + + private readonly Lazy _getAnnotation; + public global::LionWeb.Core.M3.Concept GetAnnotation => _getAnnotation.Value; + + private readonly Lazy _getAnnotations; + public global::LionWeb.Core.M3.Concept GetAnnotations_ => _getAnnotations.Value; + + private readonly Lazy _getAnnotationsRaw; + public global::LionWeb.Core.M3.Concept GetAnnotationsRaw_ => _getAnnotationsRaw.Value; + + private readonly Lazy _getClassifier; + public global::LionWeb.Core.M3.Concept GetClassifier_ => _getClassifier.Value; + + private readonly Lazy _getConcept; + public global::LionWeb.Core.M3.Concept GetConcept_ => _getConcept.Value; + + private readonly Lazy _getContainmentOf; + public global::LionWeb.Core.M3.Concept GetContainmentOf => _getContainmentOf.Value; + + private readonly Lazy _getHashCode; + public global::LionWeb.Core.M3.Concept GetHashCode_ => _getHashCode.Value; + + private readonly Lazy _getId; + public global::LionWeb.Core.M3.Concept GetId_ => _getId.Value; + + private readonly Lazy _getInternal; + public global::LionWeb.Core.M3.Concept GetInternal => _getInternal.Value; + + private readonly Lazy _getParent; + public global::LionWeb.Core.M3.Concept GetParent_ => _getParent.Value; + + private readonly Lazy _getPartitionNotificationProducer; + public global::LionWeb.Core.M3.Concept GetPartitionNotificationProducer => _getPartitionNotificationProducer.Value; + + private readonly Lazy _getRequiredNonNullReferences; + public global::LionWeb.Core.M3.Concept GetRequiredNonNullReferences => _getRequiredNonNullReferences.Value; + + private readonly Lazy _getRequiredNullableReferences; + public global::LionWeb.Core.M3.Concept GetRequiredNullableReferences => _getRequiredNullableReferences.Value; + + private readonly Lazy _getRequiredReference; + public global::LionWeb.Core.M3.Concept GetRequiredReference => _getRequiredReference.Value; + + private readonly Lazy _getType; + public global::LionWeb.Core.M3.Concept GetType_ => _getType.Value; + + private readonly Lazy _iEnumerable; + public global::LionWeb.Core.M3.Concept IEnumerable => _iEnumerable.Value; + + private readonly Lazy _iFieldValues; + public global::LionWeb.Core.M3.Concept IFieldValues => _iFieldValues.Value; + + private readonly Lazy _implementsLazy; + public global::LionWeb.Core.M3.Concept ImplementsLazy => _implementsLazy.Value; + + private readonly Lazy _iNamed; + public global::LionWeb.Core.M3.Concept INamed => _iNamed.Value; + + private readonly Lazy _iNamedWritable; + public global::LionWeb.Core.M3.Concept INamedWritable => _iNamedWritable.Value; + + private readonly Lazy _iNode; + public global::LionWeb.Core.M3.Concept INode => _iNode.Value; + + private readonly Lazy _iNodeFactory; + public global::LionWeb.Core.M3.Concept INodeFactory => _iNodeFactory.Value; + + private readonly Lazy _insert; + public global::LionWeb.Core.M3.Concept Insert => _insert.Value; + + private readonly Lazy _insertAnnotations; + public global::LionWeb.Core.M3.Concept InsertAnnotations => _insertAnnotations.Value; + + private readonly Lazy _insertAnnotationsRaw; + public global::LionWeb.Core.M3.Concept InsertAnnotationsRaw => _insertAnnotationsRaw.Value; + + private readonly Lazy _insertChildRaw; + public global::LionWeb.Core.M3.Concept InsertChildRaw => _insertChildRaw.Value; + + private readonly Lazy _insertContainmentsRaw; + public global::LionWeb.Core.M3.Concept InsertContainmentsRaw => _insertContainmentsRaw.Value; + + private readonly Lazy _insertInternal; + public global::LionWeb.Core.M3.Concept InsertInternal => _insertInternal.Value; + + private readonly Lazy _insertOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept InsertOptionalMultipleContainment => _insertOptionalMultipleContainment.Value; + + private readonly Lazy _insertOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept InsertOptionalMultipleReference => _insertOptionalMultipleReference.Value; + + private readonly Lazy _insertReferencesRaw; + public global::LionWeb.Core.M3.Concept InsertReferencesRaw => _insertReferencesRaw.Value; + + private readonly Lazy _insertRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept InsertRequiredMultipleContainment => _insertRequiredMultipleContainment.Value; + + private readonly Lazy _insertRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept InsertRequiredMultipleReference => _insertRequiredMultipleReference.Value; + + private readonly Lazy _instance; + public global::LionWeb.Core.M3.Concept Instance_ => _instance.Value; + + private readonly Lazy _integer; + public global::LionWeb.Core.M3.Concept Integer => _integer.Value; + + private readonly Lazy _interface; + public global::LionWeb.Core.M3.Concept Interface => _interface.Value; + + private readonly Lazy _interfaceBase; + public global::LionWeb.Core.M3.Concept InterfaceBase => _interfaceBase.Value; + + private readonly Lazy _invalidValueException; + public global::LionWeb.Core.M3.Concept InvalidValueException => _invalidValueException.Value; + + private readonly Lazy _iPartitionInstance; + public global::LionWeb.Core.M3.Concept IPartitionInstance => _iPartitionInstance.Value; + + private readonly Lazy _iReadableNode; + public global::LionWeb.Core.M3.Concept IReadableNode => _iReadableNode.Value; + + private readonly Lazy _iReadOnlyList; + public global::LionWeb.Core.M3.Concept IReadOnlyList => _iReadOnlyList.Value; + + private readonly Lazy _isInRange; + public global::LionWeb.Core.M3.Concept IsInRange => _isInRange.Value; + + private readonly Lazy _iStructuredDataTypeInstance; + public global::LionWeb.Core.M3.Concept IStructuredDataTypeInstance => _iStructuredDataTypeInstance.Value; + + private readonly Lazy _iWritableNode; + public global::LionWeb.Core.M3.Concept IWritableNode => _iWritableNode.Value; + + private readonly Lazy _key_; + public global::LionWeb.Core.M3.Concept Key_ => _key_.Value; + + private readonly Lazy _language; + public global::LionWeb.Core.M3.Concept Language => _language.Value; + + private readonly Lazy _languageBase; + public global::LionWeb.Core.M3.Concept LanguageBase => _languageBase.Value; + + private readonly Lazy _languageEntity; + public global::LionWeb.Core.M3.Concept LanguageEntity => _languageEntity.Value; + + private readonly Lazy _lazy; + public global::LionWeb.Core.M3.Concept Lazy => _lazy.Value; + + private readonly Lazy _link; + public global::LionWeb.Core.M3.Concept Link => _link.Value; + + private readonly Lazy _lionCoreFeature; + public global::LionWeb.Core.M3.Concept LionCoreFeature => _lionCoreFeature.Value; + + private readonly Lazy _lionCoreFeatureKind; + public global::LionWeb.Core.M3.Concept LionCoreFeatureKind => _lionCoreFeatureKind.Value; + + private readonly Lazy _lionCoreLanguage; + public global::LionWeb.Core.M3.Concept LionCoreLanguage => _lionCoreLanguage.Value; + + private readonly Lazy _lionCoreMetaPointer; + public global::LionWeb.Core.M3.Concept LionCoreMetaPointer => _lionCoreMetaPointer.Value; + + private readonly Lazy _lionWeb; + public global::LionWeb.Core.M3.Concept LionWeb => _lionWeb.Value; + + private readonly Lazy _lionWebVersions; + public global::LionWeb.Core.M3.Concept LionWebVersions => _lionWebVersions.Value; + + private readonly Lazy _list; + public global::LionWeb.Core.M3.Concept List => _list.Value; + + private readonly Lazy _literalsLazy; + public global::LionWeb.Core.M3.Concept LiteralsLazy => _literalsLazy.Value; + + private readonly Lazy _m2; + public global::LionWeb.Core.M3.Concept M2 => _m2.Value; + + private readonly Lazy _m3_; + public global::LionWeb.Core.M3.Concept M3 => _m3_.Value; + + private readonly Lazy _memberwiseClone; + public global::LionWeb.Core.M3.Concept MemberwiseClone_ => _memberwiseClone.Value; + + private readonly Lazy _multiple; + public global::LionWeb.Core.M3.Concept Multiple => _multiple.Value; + + private readonly Lazy _name_; + public global::LionWeb.Core.M3.Concept Name_ => _name_.Value; + + private readonly Lazy _notification; + public global::LionWeb.Core.M3.Concept Notification => _notification.Value; + + private readonly Lazy _notNullWhenAttribute; + public global::LionWeb.Core.M3.Concept NotNullWhenAttribute => _notNullWhenAttribute.Value; + + private readonly Lazy _optional; + public global::LionWeb.Core.M3.Concept Optional => _optional.Value; + + private readonly Lazy _partition; + public global::LionWeb.Core.M3.Concept Partition => _partition.Value; + + private readonly Lazy _pipe; + public global::LionWeb.Core.M3.Concept Pipe => _pipe.Value; + + private readonly Lazy _primitiveType; + public global::LionWeb.Core.M3.Concept PrimitiveType => _primitiveType.Value; + + private readonly Lazy _primitiveTypeBase; + public global::LionWeb.Core.M3.Concept PrimitiveTypeBase => _primitiveTypeBase.Value; + + private readonly Lazy _property; + public global::LionWeb.Core.M3.Concept Property => _property.Value; + + private readonly Lazy _propertyBase; + public global::LionWeb.Core.M3.Concept PropertyBase => _propertyBase.Value; + + private readonly Lazy _reference; + public global::LionWeb.Core.M3.Concept Reference => _reference.Value; + + private readonly Lazy _referenceBase; + public global::LionWeb.Core.M3.Concept ReferenceBase => _referenceBase.Value; + + private readonly Lazy _referenceEquals; + public global::LionWeb.Core.M3.Concept ReferenceEquals_ => _referenceEquals.Value; + + private readonly Lazy _referenceRemover; + public global::LionWeb.Core.M3.Concept ReferenceRemover => _referenceRemover.Value; + + private readonly Lazy _referenceTargetNonNullTarget; + public global::LionWeb.Core.M3.Concept ReferenceTargetNonNullTarget => _referenceTargetNonNullTarget.Value; + + private readonly Lazy _referenceTargetNonNullTargets; + public global::LionWeb.Core.M3.Concept ReferenceTargetNonNullTargets => _referenceTargetNonNullTargets.Value; + + private readonly Lazy _referenceTargetNullableTarget; + public global::LionWeb.Core.M3.Concept ReferenceTargetNullableTarget => _referenceTargetNullableTarget.Value; + + private readonly Lazy _referenceTargetNullableTargets; + public global::LionWeb.Core.M3.Concept ReferenceTargetNullableTargets => _referenceTargetNullableTargets.Value; + + private readonly Lazy _remove; + public global::LionWeb.Core.M3.Concept Remove => _remove.Value; + + private readonly Lazy _removeAll; + public global::LionWeb.Core.M3.Concept RemoveAll => _removeAll.Value; + + private readonly Lazy _removeAnnotations; + public global::LionWeb.Core.M3.Concept RemoveAnnotations => _removeAnnotations.Value; + + private readonly Lazy _removeAnnotationsRaw; + public global::LionWeb.Core.M3.Concept RemoveAnnotationsRaw => _removeAnnotationsRaw.Value; + + private readonly Lazy _removeChildRaw; + public global::LionWeb.Core.M3.Concept RemoveChildRaw => _removeChildRaw.Value; + + private readonly Lazy _removeContainmentsRaw; + public global::LionWeb.Core.M3.Concept RemoveContainmentsRaw => _removeContainmentsRaw.Value; + + private readonly Lazy _removeInternal; + public global::LionWeb.Core.M3.Concept RemoveInternal => _removeInternal.Value; + + private readonly Lazy _removeOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept RemoveOptionalMultipleContainment => _removeOptionalMultipleContainment.Value; + + private readonly Lazy _removeOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept RemoveOptionalMultipleReference => _removeOptionalMultipleReference.Value; + + private readonly Lazy _removeReferencesRaw; + public global::LionWeb.Core.M3.Concept RemoveReferencesRaw => _removeReferencesRaw.Value; + + private readonly Lazy _removeRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept RemoveRequiredMultipleContainment => _removeRequiredMultipleContainment.Value; + + private readonly Lazy _removeRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept RemoveRequiredMultipleReference => _removeRequiredMultipleReference.Value; + + private readonly Lazy _removeSelfParent; + public global::LionWeb.Core.M3.Concept RemoveSelfParent => _removeSelfParent.Value; + + private readonly Lazy _removeSelfParentRaw; + public global::LionWeb.Core.M3.Concept RemoveSelfParentRaw => _removeSelfParentRaw.Value; + + private readonly Lazy _result; + public global::LionWeb.Core.M3.Concept result => _result.Value; + + private readonly Lazy _set; + public global::LionWeb.Core.M3.Concept Set => _set.Value; + + private readonly Lazy _setContainmentRaw; + public global::LionWeb.Core.M3.Concept SetContainmentRaw => _setContainmentRaw.Value; + + private readonly Lazy _setInternal; + public global::LionWeb.Core.M3.Concept SetInternal => _setInternal.Value; + + private readonly Lazy _setInternalAnnotation; + public global::LionWeb.Core.M3.Concept SetInternalAnnotation => _setInternalAnnotation.Value; + + private readonly Lazy _setName; + public global::LionWeb.Core.M3.Concept SetName => _setName.Value; + + private readonly Lazy _setNameRaw; + public global::LionWeb.Core.M3.Concept SetNameRaw => _setNameRaw.Value; + + private readonly Lazy _setOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept SetOptionalMultipleContainment => _setOptionalMultipleContainment.Value; + + private readonly Lazy _setOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept SetOptionalMultipleReference => _setOptionalMultipleReference.Value; + + private readonly Lazy _setOptionalReferenceTypeProperty; + public global::LionWeb.Core.M3.Concept SetOptionalReferenceTypeProperty => _setOptionalReferenceTypeProperty.Value; + + private readonly Lazy _setOptionalSingleContainment; + public global::LionWeb.Core.M3.Concept SetOptionalSingleContainment => _setOptionalSingleContainment.Value; + + private readonly Lazy _setOptionalSingleReference; + public global::LionWeb.Core.M3.Concept SetOptionalSingleReference => _setOptionalSingleReference.Value; + + private readonly Lazy _setOptionalValueTypeProperty; + public global::LionWeb.Core.M3.Concept SetOptionalValueTypeProperty => _setOptionalValueTypeProperty.Value; + + private readonly Lazy _setParentInternal; + public global::LionWeb.Core.M3.Concept SetParentInternal => _setParentInternal.Value; + + private readonly Lazy _setParentNull; + public global::LionWeb.Core.M3.Concept SetParentNull => _setParentNull.Value; + + private readonly Lazy _setPropertyRaw; + public global::LionWeb.Core.M3.Concept SetPropertyRaw => _setPropertyRaw.Value; + + private readonly Lazy _setRaw; + public global::LionWeb.Core.M3.Concept SetRaw => _setRaw.Value; + + private readonly Lazy _setReferenceRaw; + public global::LionWeb.Core.M3.Concept SetReferenceRaw => _setReferenceRaw.Value; + + private readonly Lazy _setReferencesRaw; + public global::LionWeb.Core.M3.Concept SetReferencesRaw => _setReferencesRaw.Value; + + private readonly Lazy _setRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept SetRequiredMultipleContainment => _setRequiredMultipleContainment.Value; + + private readonly Lazy _setRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept SetRequiredMultipleReference => _setRequiredMultipleReference.Value; + + private readonly Lazy _setRequiredReferenceTypeProperty; + public global::LionWeb.Core.M3.Concept SetRequiredReferenceTypeProperty => _setRequiredReferenceTypeProperty.Value; + + private readonly Lazy _setRequiredSingleContainment; + public global::LionWeb.Core.M3.Concept SetRequiredSingleContainment => _setRequiredSingleContainment.Value; + + private readonly Lazy _setRequiredSingleReference; + public global::LionWeb.Core.M3.Concept SetRequiredSingleReference => _setRequiredSingleReference.Value; + + private readonly Lazy _setRequiredValueTypeProperty; + public global::LionWeb.Core.M3.Concept SetRequiredValueTypeProperty => _setRequiredValueTypeProperty.Value; + + private readonly Lazy _setSelfParent; + public global::LionWeb.Core.M3.Concept SetSelfParent => _setSelfParent.Value; + + private readonly Lazy _setSelfParentRaw; + public global::LionWeb.Core.M3.Concept SetSelfParentRaw => _setSelfParentRaw.Value; + + private readonly Lazy _string; + public global::LionWeb.Core.M3.Concept String => _string.Value; + + private readonly Lazy _structuredDataType; + public global::LionWeb.Core.M3.Concept StructuredDataType => _structuredDataType.Value; + + private readonly Lazy _structuredDataTypeBase; + public global::LionWeb.Core.M3.Concept StructuredDataTypeBase => _structuredDataTypeBase.Value; + + private readonly Lazy _system; + public global::LionWeb.Core.M3.Concept System => _system.Value; + + private readonly Lazy _toString; + public global::LionWeb.Core.M3.Concept ToString_ => _toString.Value; + + private readonly Lazy _tryGet; + public global::LionWeb.Core.M3.Concept TryGet_ => _tryGet.Value; + + private readonly Lazy _tryGetContainmentRaw; + public global::LionWeb.Core.M3.Concept TryGetContainmentRaw_ => _tryGetContainmentRaw.Value; + + private readonly Lazy _tryGetContainmentsRaw; + public global::LionWeb.Core.M3.Concept TryGetContainmentsRaw_ => _tryGetContainmentsRaw.Value; + + private readonly Lazy _tryGetName; + public global::LionWeb.Core.M3.Concept TryGetName_ => _tryGetName.Value; + + private readonly Lazy _tryGetPropertyRaw; + public global::LionWeb.Core.M3.Concept TryGetPropertyRaw_ => _tryGetPropertyRaw.Value; + + private readonly Lazy _tryGetReference; + public global::LionWeb.Core.M3.Concept TryGetReference => _tryGetReference.Value; + + private readonly Lazy _tryGetReferenceRaw; + public global::LionWeb.Core.M3.Concept TryGetReferenceRaw_ => _tryGetReferenceRaw.Value; + + private readonly Lazy _tryGetReferencesRaw; + public global::LionWeb.Core.M3.Concept TryGetReferencesRaw_ => _tryGetReferencesRaw.Value; + + private readonly Lazy _type; + public global::LionWeb.Core.M3.Concept Type => _type.Value; + + private readonly Lazy _unsetFeatureException; + public global::LionWeb.Core.M3.Concept UnsetFeatureException => _unsetFeatureException.Value; + + private readonly Lazy _unsetFieldException; + public global::LionWeb.Core.M3.Concept UnsetFieldException => _unsetFieldException.Value; + + private readonly Lazy _unsupportedClassifierException; + public global::LionWeb.Core.M3.Concept UnsupportedClassifierException => _unsupportedClassifierException.Value; + + private readonly Lazy _unsupportedEnumerationLiteralException; + public global::LionWeb.Core.M3.Concept UnsupportedEnumerationLiteralException => _unsupportedEnumerationLiteralException.Value; + + private readonly Lazy _unsupportedStructuredDataTypeException; + public global::LionWeb.Core.M3.Concept UnsupportedStructuredDataTypeException => _unsupportedStructuredDataTypeException.Value; + + private readonly Lazy _utilities; + public global::LionWeb.Core.M3.Concept Utilities => _utilities.Value; + + private readonly Lazy _v2023_1; + public global::LionWeb.Core.M3.Concept V2023_1 => _v2023_1.Value; + + private readonly Lazy _v2024_1; + public global::LionWeb.Core.M3.Concept V2024_1 => _v2024_1.Value; + + private readonly Lazy _v2024_1_Compatible; + public global::LionWeb.Core.M3.Concept V2024_1_Compatible => _v2024_1_Compatible.Value; + + private readonly Lazy _v2025_1; + public global::LionWeb.Core.M3.Concept V2025_1 => _v2025_1.Value; + + private readonly Lazy _v2025_1_Compatible; + public global::LionWeb.Core.M3.Concept V2025_1_Compatible => _v2025_1_Compatible.Value; + + private readonly Lazy _versionSpecific; + public global::LionWeb.Core.M3.Concept VersionSpecific => _versionSpecific.Value; +} + +public partial interface ILanguageWithLionWebNamedConceptsFactory : global::LionWeb.Core.M2.INodeFactory +{ + public _builtIns New_builtIns(string id); + public _builtIns Create_builtIns(); + public Abstract NewAbstract(string id); + public Abstract CreateAbstract(); + public AbstractBaseNodeFactory NewAbstractBaseNodeFactory(string id); + public AbstractBaseNodeFactory CreateAbstractBaseNodeFactory(); + public Add NewAdd(string id); + public Add CreateAdd(); + public AddAnnotations NewAddAnnotations(string id); + public AddAnnotations CreateAddAnnotations(); + public AddAnnotationsRaw NewAddAnnotationsRaw(string id); + public AddAnnotationsRaw CreateAddAnnotationsRaw(); + public AddChildRaw NewAddChildRaw(string id); + public AddChildRaw CreateAddChildRaw(); + public AddContainmentsRaw_ NewAddContainmentsRaw(string id); + public AddContainmentsRaw_ CreateAddContainmentsRaw(); + public AddInternal_ NewAddInternal(string id); + public AddInternal_ CreateAddInternal(); + public AddOptionalMultipleContainment NewAddOptionalMultipleContainment(string id); + public AddOptionalMultipleContainment CreateAddOptionalMultipleContainment(); + public AddOptionalMultipleReference NewAddOptionalMultipleReference(string id); + public AddOptionalMultipleReference CreateAddOptionalMultipleReference(); + public AddReferencesRaw_ NewAddReferencesRaw(string id); + public AddReferencesRaw_ CreateAddReferencesRaw(); + public AddRequiredMultipleContainment NewAddRequiredMultipleContainment(string id); + public AddRequiredMultipleContainment CreateAddRequiredMultipleContainment(); + public AddRequiredMultipleReference NewAddRequiredMultipleReference(string id); + public AddRequiredMultipleReference CreateAddRequiredMultipleReference(); + public AnnotatesLazy NewAnnotatesLazy(string id); + public AnnotatesLazy CreateAnnotatesLazy(); + public Annotation NewAnnotation(string id); + public Annotation CreateAnnotation(); + public AnnotationBase NewAnnotationBase(string id); + public AnnotationBase CreateAnnotationBase(); + public AnnotationInstanceBase NewAnnotationInstanceBase(string id); + public AnnotationInstanceBase CreateAnnotationInstanceBase(); + public AnnotationRemover NewAnnotationRemover(string id); + public AnnotationRemover CreateAnnotationRemover(); + public ArgumentOutOfRangeException NewArgumentOutOfRangeException(string id); + public ArgumentOutOfRangeException CreateArgumentOutOfRangeException(); + public AsList NewAsList(string id); + public AsList CreateAsList(); + public AsNonEmptyReadOnly NewAsNonEmptyReadOnly(string id); + public AsNonEmptyReadOnly CreateAsNonEmptyReadOnly(); + public AssureAnnotations NewAssureAnnotations(string id); + public AssureAnnotations CreateAssureAnnotations(); + public AssureInRange NewAssureInRange(string id); + public AssureInRange CreateAssureInRange(); + public AssureNonEmpty NewAssureNonEmpty(string id); + public AssureNonEmpty CreateAssureNonEmpty(); + public AssureNoSelfMove NewAssureNoSelfMove(string id); + public AssureNoSelfMove CreateAssureNoSelfMove(); + public AssureNotClearing NewAssureNotClearing(string id); + public AssureNotClearing CreateAssureNotClearing(); + public AssureNotNull NewAssureNotNull(string id); + public AssureNotNull CreateAssureNotNull(); + public AssureNotNullInstance NewAssureNotNullInstance(string id); + public AssureNotNullInstance CreateAssureNotNullInstance(); + public AssureNotNullMembers NewAssureNotNullMembers(string id); + public AssureNotNullMembers CreateAssureNotNullMembers(); + public AssureNullableInstance NewAssureNullableInstance(string id); + public AssureNullableInstance CreateAssureNullableInstance(); + public AttachChild NewAttachChild(string id); + public AttachChild CreateAttachChild(); + public Bool NewBool(string id); + public Bool CreateBool(); + public Boolean NewBoolean(string id); + public Boolean CreateBoolean(); + public Char NewChar(string id); + public Char CreateChar(); + public Character NewCharacter(string id); + public Character CreateCharacter(); + public Classifier NewClassifier(string id); + public Classifier CreateClassifier(); + public CodeAnalysis NewCodeAnalysis(string id); + public CodeAnalysis CreateCodeAnalysis(); + public CollectAllSetFeatures_ NewCollectAllSetFeatures(string id); + public CollectAllSetFeatures_ CreateCollectAllSetFeatures(); + public Collections NewCollections(string id); + public Collections CreateCollections(); + public Concept NewConcept(string id); + public Concept CreateConcept(); + public ConceptBase NewConceptBase(string id); + public ConceptBase CreateConceptBase(); + public ConceptInstanceBase NewConceptInstanceBase(string id); + public ConceptInstanceBase CreateConceptInstanceBase(); + public Containment NewContainment(string id); + public Containment CreateContainment(); + public ContainmentBase NewContainmentBase(string id); + public ContainmentBase CreateContainmentBase(); + public ContainmentRemover NewContainmentRemover(string id); + public ContainmentRemover CreateContainmentRemover(); + public Core NewCore(string id); + public Core CreateCore(); + public Datatype NewDatatype(string id); + public Datatype CreateDatatype(); + public DatatypeBase NewDatatypeBase(string id); + public DatatypeBase CreateDatatypeBase(); + public Decimal NewDecimal(string id); + public Decimal CreateDecimal(); + public DetachChild_ NewDetachChild(string id); + public DetachChild_ CreateDetachChild(); + public DetachChildInternal NewDetachChildInternal(string id); + public DetachChildInternal CreateDetachChildInternal(); + public DetachFromParent_ NewDetachFromParent(string id); + public DetachFromParent_ CreateDetachFromParent(); + public Diagnostics NewDiagnostics(string id); + public Diagnostics CreateDiagnostics(); + public Enum NewEnum(string id); + public Enum CreateEnum(); + public Enumeration NewEnumeration(string id); + public Enumeration CreateEnumeration(); + public EnumerationBase NewEnumerationBase(string id); + public EnumerationBase CreateEnumerationBase(); + public EnumerationLiteral NewEnumerationLiteral(string id); + public EnumerationLiteral CreateEnumerationLiteral(); + public EnumerationLiteralBase NewEnumerationLiteralBase(string id); + public EnumerationLiteralBase CreateEnumerationLiteralBase(); + public Equals NewEquals(string id); + public Equals CreateEquals(); + public ExchangeChildRaw NewExchangeChildRaw(string id); + public ExchangeChildRaw CreateExchangeChildRaw(); + public ExchangeChildrenRaw NewExchangeChildrenRaw(string id); + public ExchangeChildrenRaw CreateExchangeChildrenRaw(); + public FeaturesLazy NewFeaturesLazy(string id); + public FeaturesLazy CreateFeaturesLazy(); + public Field NewField(string id); + public Field CreateField(); + public FieldBase NewFieldBase(string id); + public FieldBase CreateFieldBase(); + public FieldsLazy NewFieldsLazy(string id); + public FieldsLazy CreateFieldsLazy(); + public Finalize NewFinalize(string id); + public Finalize CreateFinalize(); + public Generic NewGeneric(string id); + public Generic CreateGeneric(); + public Get NewGet(string id); + public Get CreateGet(); + public get__builtIns Newget__builtIns(string id); + public get__builtIns Createget__builtIns(); + public get__m3 Newget__m3(string id); + public get__m3 Createget__m3(); + public GetAnnotation NewGetAnnotation(string id); + public GetAnnotation CreateGetAnnotation(); + public GetAnnotations NewGetAnnotations(string id); + public GetAnnotations CreateGetAnnotations(); + public GetAnnotationsRaw NewGetAnnotationsRaw(string id); + public GetAnnotationsRaw CreateGetAnnotationsRaw(); + public GetClassifier_ NewGetClassifier(string id); + public GetClassifier_ CreateGetClassifier(); + public GetConcept_ NewGetConcept(string id); + public GetConcept_ CreateGetConcept(); + public GetContainmentOf_ NewGetContainmentOf(string id); + public GetContainmentOf_ CreateGetContainmentOf(); + public GetHashCode NewGetHashCode(string id); + public GetHashCode CreateGetHashCode(); + public GetId NewGetId(string id); + public GetId CreateGetId(); + public GetInternal_ NewGetInternal(string id); + public GetInternal_ CreateGetInternal(); + public GetParent NewGetParent(string id); + public GetParent CreateGetParent(); + public GetPartitionNotificationProducer_ NewGetPartitionNotificationProducer(string id); + public GetPartitionNotificationProducer_ CreateGetPartitionNotificationProducer(); + public GetRequiredNonNullReferences NewGetRequiredNonNullReferences(string id); + public GetRequiredNonNullReferences CreateGetRequiredNonNullReferences(); + public GetRequiredNullableReferences NewGetRequiredNullableReferences(string id); + public GetRequiredNullableReferences CreateGetRequiredNullableReferences(); + public GetRequiredReference NewGetRequiredReference(string id); + public GetRequiredReference CreateGetRequiredReference(); + public GetType NewGetType(string id); + public GetType CreateGetType(); + public IEnumerable NewIEnumerable(string id); + public IEnumerable CreateIEnumerable(); + public IFieldValues NewIFieldValues(string id); + public IFieldValues CreateIFieldValues(); + public ImplementsLazy NewImplementsLazy(string id); + public ImplementsLazy CreateImplementsLazy(); + public INamed NewINamed(string id); + public INamed CreateINamed(); + public INamedWritable NewINamedWritable(string id); + public INamedWritable CreateINamedWritable(); + public INode NewINode(string id); + public INode CreateINode(); + public INodeFactory NewINodeFactory(string id); + public INodeFactory CreateINodeFactory(); + public Insert NewInsert(string id); + public Insert CreateInsert(); + public InsertAnnotations NewInsertAnnotations(string id); + public InsertAnnotations CreateInsertAnnotations(); + public InsertAnnotationsRaw NewInsertAnnotationsRaw(string id); + public InsertAnnotationsRaw CreateInsertAnnotationsRaw(); + public InsertChildRaw NewInsertChildRaw(string id); + public InsertChildRaw CreateInsertChildRaw(); + public InsertContainmentsRaw_ NewInsertContainmentsRaw(string id); + public InsertContainmentsRaw_ CreateInsertContainmentsRaw(); + public InsertInternal_ NewInsertInternal(string id); + public InsertInternal_ CreateInsertInternal(); + public InsertOptionalMultipleContainment NewInsertOptionalMultipleContainment(string id); + public InsertOptionalMultipleContainment CreateInsertOptionalMultipleContainment(); + public InsertOptionalMultipleReference NewInsertOptionalMultipleReference(string id); + public InsertOptionalMultipleReference CreateInsertOptionalMultipleReference(); + public InsertReferencesRaw_ NewInsertReferencesRaw(string id); + public InsertReferencesRaw_ CreateInsertReferencesRaw(); + public InsertRequiredMultipleContainment NewInsertRequiredMultipleContainment(string id); + public InsertRequiredMultipleContainment CreateInsertRequiredMultipleContainment(); + public InsertRequiredMultipleReference NewInsertRequiredMultipleReference(string id); + public InsertRequiredMultipleReference CreateInsertRequiredMultipleReference(); + public Instance NewInstance(string id); + public Instance CreateInstance(); + public Integer NewInteger(string id); + public Integer CreateInteger(); + public Interface NewInterface(string id); + public Interface CreateInterface(); + public InterfaceBase NewInterfaceBase(string id); + public InterfaceBase CreateInterfaceBase(); + public InvalidValueException NewInvalidValueException(string id); + public InvalidValueException CreateInvalidValueException(); + public IPartitionInstance NewIPartitionInstance(string id); + public IPartitionInstance CreateIPartitionInstance(); + public IReadableNode NewIReadableNode(string id); + public IReadableNode CreateIReadableNode(); + public IReadOnlyList NewIReadOnlyList(string id); + public IReadOnlyList CreateIReadOnlyList(); + public IsInRange NewIsInRange(string id); + public IsInRange CreateIsInRange(); + public IStructuredDataTypeInstance NewIStructuredDataTypeInstance(string id); + public IStructuredDataTypeInstance CreateIStructuredDataTypeInstance(); + public IWritableNode NewIWritableNode(string id); + public IWritableNode CreateIWritableNode(); + public Key NewKey(string id); + public Key CreateKey(); + public Language NewLanguage(string id); + public Language CreateLanguage(); + public LanguageBase NewLanguageBase(string id); + public LanguageBase CreateLanguageBase(); + public LanguageEntity NewLanguageEntity(string id); + public LanguageEntity CreateLanguageEntity(); + public Lazy NewLazy(string id); + public Lazy CreateLazy(); + public Link NewLink(string id); + public Link CreateLink(); + public LionCoreFeature NewLionCoreFeature(string id); + public LionCoreFeature CreateLionCoreFeature(); + public LionCoreFeatureKind NewLionCoreFeatureKind(string id); + public LionCoreFeatureKind CreateLionCoreFeatureKind(); + public LionCoreLanguage NewLionCoreLanguage(string id); + public LionCoreLanguage CreateLionCoreLanguage(); + public LionCoreMetaPointer NewLionCoreMetaPointer(string id); + public LionCoreMetaPointer CreateLionCoreMetaPointer(); + public LionWeb NewLionWeb(string id); + public LionWeb CreateLionWeb(); + public LionWebVersions NewLionWebVersions(string id); + public LionWebVersions CreateLionWebVersions(); + public List NewList(string id); + public List CreateList(); + public LiteralsLazy NewLiteralsLazy(string id); + public LiteralsLazy CreateLiteralsLazy(); + public M2 NewM2(string id); + public M2 CreateM2(); + public M3 NewM3(string id); + public M3 CreateM3(); + public MemberwiseClone NewMemberwiseClone(string id); + public MemberwiseClone CreateMemberwiseClone(); + public Multiple NewMultiple(string id); + public Multiple CreateMultiple(); + public Name NewName(string id); + public Name CreateName(); + public Notification NewNotification(string id); + public Notification CreateNotification(); + public NotNullWhenAttribute NewNotNullWhenAttribute(string id); + public NotNullWhenAttribute CreateNotNullWhenAttribute(); + public Optional NewOptional(string id); + public Optional CreateOptional(); + public Partition NewPartition(string id); + public Partition CreatePartition(); + public Pipe NewPipe(string id); + public Pipe CreatePipe(); + public PrimitiveType NewPrimitiveType(string id); + public PrimitiveType CreatePrimitiveType(); + public PrimitiveTypeBase NewPrimitiveTypeBase(string id); + public PrimitiveTypeBase CreatePrimitiveTypeBase(); + public Property NewProperty(string id); + public Property CreateProperty(); + public PropertyBase NewPropertyBase(string id); + public PropertyBase CreatePropertyBase(); + public Reference NewReference(string id); + public Reference CreateReference(); + public ReferenceBase NewReferenceBase(string id); + public ReferenceBase CreateReferenceBase(); + public ReferenceEquals NewReferenceEquals(string id); + public ReferenceEquals CreateReferenceEquals(); + public ReferenceRemover NewReferenceRemover(string id); + public ReferenceRemover CreateReferenceRemover(); + public ReferenceTargetNonNullTarget NewReferenceTargetNonNullTarget(string id); + public ReferenceTargetNonNullTarget CreateReferenceTargetNonNullTarget(); + public ReferenceTargetNonNullTargets NewReferenceTargetNonNullTargets(string id); + public ReferenceTargetNonNullTargets CreateReferenceTargetNonNullTargets(); + public ReferenceTargetNullableTarget NewReferenceTargetNullableTarget(string id); + public ReferenceTargetNullableTarget CreateReferenceTargetNullableTarget(); + public ReferenceTargetNullableTargets NewReferenceTargetNullableTargets(string id); + public ReferenceTargetNullableTargets CreateReferenceTargetNullableTargets(); + public Remove NewRemove(string id); + public Remove CreateRemove(); + public RemoveAll NewRemoveAll(string id); + public RemoveAll CreateRemoveAll(); + public RemoveAnnotations NewRemoveAnnotations(string id); + public RemoveAnnotations CreateRemoveAnnotations(); + public RemoveAnnotationsRaw NewRemoveAnnotationsRaw(string id); + public RemoveAnnotationsRaw CreateRemoveAnnotationsRaw(); + public RemoveChildRaw NewRemoveChildRaw(string id); + public RemoveChildRaw CreateRemoveChildRaw(); + public RemoveContainmentsRaw_ NewRemoveContainmentsRaw(string id); + public RemoveContainmentsRaw_ CreateRemoveContainmentsRaw(); + public RemoveInternal_ NewRemoveInternal(string id); + public RemoveInternal_ CreateRemoveInternal(); + public RemoveOptionalMultipleContainment NewRemoveOptionalMultipleContainment(string id); + public RemoveOptionalMultipleContainment CreateRemoveOptionalMultipleContainment(); + public RemoveOptionalMultipleReference NewRemoveOptionalMultipleReference(string id); + public RemoveOptionalMultipleReference CreateRemoveOptionalMultipleReference(); + public RemoveReferencesRaw_ NewRemoveReferencesRaw(string id); + public RemoveReferencesRaw_ CreateRemoveReferencesRaw(); + public RemoveRequiredMultipleContainment NewRemoveRequiredMultipleContainment(string id); + public RemoveRequiredMultipleContainment CreateRemoveRequiredMultipleContainment(); + public RemoveRequiredMultipleReference NewRemoveRequiredMultipleReference(string id); + public RemoveRequiredMultipleReference CreateRemoveRequiredMultipleReference(); + public RemoveSelfParent NewRemoveSelfParent(string id); + public RemoveSelfParent CreateRemoveSelfParent(); + public RemoveSelfParentRaw NewRemoveSelfParentRaw(string id); + public RemoveSelfParentRaw CreateRemoveSelfParentRaw(); + public result Newresult(string id); + public result Createresult(); + public Set NewSet(string id); + public Set CreateSet(); + public SetContainmentRaw_ NewSetContainmentRaw(string id); + public SetContainmentRaw_ CreateSetContainmentRaw(); + public SetInternal_ NewSetInternal(string id); + public SetInternal_ CreateSetInternal(); + public SetInternalAnnotation NewSetInternalAnnotation(string id); + public SetInternalAnnotation CreateSetInternalAnnotation(); + public SetName NewSetName(string id); + public SetName CreateSetName(); + public SetNameRaw NewSetNameRaw(string id); + public SetNameRaw CreateSetNameRaw(); + public SetOptionalMultipleContainment NewSetOptionalMultipleContainment(string id); + public SetOptionalMultipleContainment CreateSetOptionalMultipleContainment(); + public SetOptionalMultipleReference NewSetOptionalMultipleReference(string id); + public SetOptionalMultipleReference CreateSetOptionalMultipleReference(); + public SetOptionalReferenceTypeProperty NewSetOptionalReferenceTypeProperty(string id); + public SetOptionalReferenceTypeProperty CreateSetOptionalReferenceTypeProperty(); + public SetOptionalSingleContainment NewSetOptionalSingleContainment(string id); + public SetOptionalSingleContainment CreateSetOptionalSingleContainment(); + public SetOptionalSingleReference NewSetOptionalSingleReference(string id); + public SetOptionalSingleReference CreateSetOptionalSingleReference(); + public SetOptionalValueTypeProperty NewSetOptionalValueTypeProperty(string id); + public SetOptionalValueTypeProperty CreateSetOptionalValueTypeProperty(); + public SetParentInternal NewSetParentInternal(string id); + public SetParentInternal CreateSetParentInternal(); + public SetParentNull NewSetParentNull(string id); + public SetParentNull CreateSetParentNull(); + public SetPropertyRaw_ NewSetPropertyRaw(string id); + public SetPropertyRaw_ CreateSetPropertyRaw(); + public SetRaw_ NewSetRaw(string id); + public SetRaw_ CreateSetRaw(); + public SetReferenceRaw_ NewSetReferenceRaw(string id); + public SetReferenceRaw_ CreateSetReferenceRaw(); + public SetReferencesRaw NewSetReferencesRaw(string id); + public SetReferencesRaw CreateSetReferencesRaw(); + public SetRequiredMultipleContainment NewSetRequiredMultipleContainment(string id); + public SetRequiredMultipleContainment CreateSetRequiredMultipleContainment(); + public SetRequiredMultipleReference NewSetRequiredMultipleReference(string id); + public SetRequiredMultipleReference CreateSetRequiredMultipleReference(); + public SetRequiredReferenceTypeProperty NewSetRequiredReferenceTypeProperty(string id); + public SetRequiredReferenceTypeProperty CreateSetRequiredReferenceTypeProperty(); + public SetRequiredSingleContainment NewSetRequiredSingleContainment(string id); + public SetRequiredSingleContainment CreateSetRequiredSingleContainment(); + public SetRequiredSingleReference NewSetRequiredSingleReference(string id); + public SetRequiredSingleReference CreateSetRequiredSingleReference(); + public SetRequiredValueTypeProperty NewSetRequiredValueTypeProperty(string id); + public SetRequiredValueTypeProperty CreateSetRequiredValueTypeProperty(); + public SetSelfParent NewSetSelfParent(string id); + public SetSelfParent CreateSetSelfParent(); + public SetSelfParentRaw NewSetSelfParentRaw(string id); + public SetSelfParentRaw CreateSetSelfParentRaw(); + public String NewString(string id); + public String CreateString(); + public StructuredDataType NewStructuredDataType(string id); + public StructuredDataType CreateStructuredDataType(); + public StructuredDataTypeBase NewStructuredDataTypeBase(string id); + public StructuredDataTypeBase CreateStructuredDataTypeBase(); + public System NewSystem(string id); + public System CreateSystem(); + public ToString NewToString(string id); + public ToString CreateToString(); + public TryGet_ NewTryGet(string id); + public TryGet_ CreateTryGet(); + public TryGetContainmentRaw_ NewTryGetContainmentRaw(string id); + public TryGetContainmentRaw_ CreateTryGetContainmentRaw(); + public TryGetContainmentsRaw_ NewTryGetContainmentsRaw(string id); + public TryGetContainmentsRaw_ CreateTryGetContainmentsRaw(); + public TryGetName NewTryGetName(string id); + public TryGetName CreateTryGetName(); + public TryGetPropertyRaw_ NewTryGetPropertyRaw(string id); + public TryGetPropertyRaw_ CreateTryGetPropertyRaw(); + public TryGetReference NewTryGetReference(string id); + public TryGetReference CreateTryGetReference(); + public TryGetReferenceRaw_ NewTryGetReferenceRaw(string id); + public TryGetReferenceRaw_ CreateTryGetReferenceRaw(); + public TryGetReferencesRaw_ NewTryGetReferencesRaw(string id); + public TryGetReferencesRaw_ CreateTryGetReferencesRaw(); + public Type NewType(string id); + public Type CreateType(); + public UnsetFeatureException NewUnsetFeatureException(string id); + public UnsetFeatureException CreateUnsetFeatureException(); + public UnsetFieldException NewUnsetFieldException(string id); + public UnsetFieldException CreateUnsetFieldException(); + public UnsupportedClassifierException NewUnsupportedClassifierException(string id); + public UnsupportedClassifierException CreateUnsupportedClassifierException(); + public UnsupportedEnumerationLiteralException NewUnsupportedEnumerationLiteralException(string id); + public UnsupportedEnumerationLiteralException CreateUnsupportedEnumerationLiteralException(); + public UnsupportedStructuredDataTypeException NewUnsupportedStructuredDataTypeException(string id); + public UnsupportedStructuredDataTypeException CreateUnsupportedStructuredDataTypeException(); + public Utilities NewUtilities(string id); + public Utilities CreateUtilities(); + public V2023_1 NewV2023_1(string id); + public V2023_1 CreateV2023_1(); + public V2024_1 NewV2024_1(string id); + public V2024_1 CreateV2024_1(); + public V2024_1_Compatible NewV2024_1_Compatible(string id); + public V2024_1_Compatible CreateV2024_1_Compatible(); + public V2025_1 NewV2025_1(string id); + public V2025_1 CreateV2025_1(); + public V2025_1_Compatible NewV2025_1_Compatible(string id); + public V2025_1_Compatible CreateV2025_1_Compatible(); + public VersionSpecific NewVersionSpecific(string id); + public VersionSpecific CreateVersionSpecific(); +} + +public class LanguageWithLionWebNamedConceptsFactory : global::LionWeb.Core.M2.AbstractBaseNodeFactory, ILanguageWithLionWebNamedConceptsFactory +{ + private readonly LanguageWithLionWebNamedConceptsLanguage _language; + public LanguageWithLionWebNamedConceptsFactory(LanguageWithLionWebNamedConceptsLanguage language) : base(language) + { + _language = language; + } + + /// + public override global::LionWeb.Core.INode CreateNode(string id, global::LionWeb.Core.M3.Classifier classifier) + { + if (_language._builtIns_.EqualsIdentity(classifier)) + return New_builtIns(id); + if (_language.Abstract.EqualsIdentity(classifier)) + return NewAbstract(id); + if (_language.AbstractBaseNodeFactory.EqualsIdentity(classifier)) + return NewAbstractBaseNodeFactory(id); + if (_language.Add.EqualsIdentity(classifier)) + return NewAdd(id); + if (_language.AddAnnotations.EqualsIdentity(classifier)) + return NewAddAnnotations(id); + if (_language.AddAnnotationsRaw.EqualsIdentity(classifier)) + return NewAddAnnotationsRaw(id); + if (_language.AddChildRaw.EqualsIdentity(classifier)) + return NewAddChildRaw(id); + if (_language.AddContainmentsRaw.EqualsIdentity(classifier)) + return NewAddContainmentsRaw(id); + if (_language.AddInternal.EqualsIdentity(classifier)) + return NewAddInternal(id); + if (_language.AddOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewAddOptionalMultipleContainment(id); + if (_language.AddOptionalMultipleReference.EqualsIdentity(classifier)) + return NewAddOptionalMultipleReference(id); + if (_language.AddReferencesRaw.EqualsIdentity(classifier)) + return NewAddReferencesRaw(id); + if (_language.AddRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewAddRequiredMultipleContainment(id); + if (_language.AddRequiredMultipleReference.EqualsIdentity(classifier)) + return NewAddRequiredMultipleReference(id); + if (_language.AnnotatesLazy.EqualsIdentity(classifier)) + return NewAnnotatesLazy(id); + if (_language.Annotation.EqualsIdentity(classifier)) + return NewAnnotation(id); + if (_language.AnnotationBase.EqualsIdentity(classifier)) + return NewAnnotationBase(id); + if (_language.AnnotationInstanceBase.EqualsIdentity(classifier)) + return NewAnnotationInstanceBase(id); + if (_language.AnnotationRemover.EqualsIdentity(classifier)) + return NewAnnotationRemover(id); + if (_language.ArgumentOutOfRangeException.EqualsIdentity(classifier)) + return NewArgumentOutOfRangeException(id); + if (_language.AsList.EqualsIdentity(classifier)) + return NewAsList(id); + if (_language.AsNonEmptyReadOnly.EqualsIdentity(classifier)) + return NewAsNonEmptyReadOnly(id); + if (_language.AssureAnnotations.EqualsIdentity(classifier)) + return NewAssureAnnotations(id); + if (_language.AssureInRange.EqualsIdentity(classifier)) + return NewAssureInRange(id); + if (_language.AssureNonEmpty.EqualsIdentity(classifier)) + return NewAssureNonEmpty(id); + if (_language.AssureNoSelfMove.EqualsIdentity(classifier)) + return NewAssureNoSelfMove(id); + if (_language.AssureNotClearing.EqualsIdentity(classifier)) + return NewAssureNotClearing(id); + if (_language.AssureNotNull.EqualsIdentity(classifier)) + return NewAssureNotNull(id); + if (_language.AssureNotNullInstance.EqualsIdentity(classifier)) + return NewAssureNotNullInstance(id); + if (_language.AssureNotNullMembers.EqualsIdentity(classifier)) + return NewAssureNotNullMembers(id); + if (_language.AssureNullableInstance.EqualsIdentity(classifier)) + return NewAssureNullableInstance(id); + if (_language.AttachChild.EqualsIdentity(classifier)) + return NewAttachChild(id); + if (_language.Bool.EqualsIdentity(classifier)) + return NewBool(id); + if (_language.Boolean.EqualsIdentity(classifier)) + return NewBoolean(id); + if (_language.Char.EqualsIdentity(classifier)) + return NewChar(id); + if (_language.Character.EqualsIdentity(classifier)) + return NewCharacter(id); + if (_language.Classifier.EqualsIdentity(classifier)) + return NewClassifier(id); + if (_language.CodeAnalysis.EqualsIdentity(classifier)) + return NewCodeAnalysis(id); + if (_language.CollectAllSetFeatures_.EqualsIdentity(classifier)) + return NewCollectAllSetFeatures(id); + if (_language.Collections.EqualsIdentity(classifier)) + return NewCollections(id); + if (_language.Concept.EqualsIdentity(classifier)) + return NewConcept(id); + if (_language.ConceptBase.EqualsIdentity(classifier)) + return NewConceptBase(id); + if (_language.ConceptInstanceBase.EqualsIdentity(classifier)) + return NewConceptInstanceBase(id); + if (_language.Containment.EqualsIdentity(classifier)) + return NewContainment(id); + if (_language.ContainmentBase.EqualsIdentity(classifier)) + return NewContainmentBase(id); + if (_language.ContainmentRemover.EqualsIdentity(classifier)) + return NewContainmentRemover(id); + if (_language.Core.EqualsIdentity(classifier)) + return NewCore(id); + if (_language.Datatype.EqualsIdentity(classifier)) + return NewDatatype(id); + if (_language.DatatypeBase.EqualsIdentity(classifier)) + return NewDatatypeBase(id); + if (_language.Decimal.EqualsIdentity(classifier)) + return NewDecimal(id); + if (_language.DetachChild.EqualsIdentity(classifier)) + return NewDetachChild(id); + if (_language.DetachChildInternal.EqualsIdentity(classifier)) + return NewDetachChildInternal(id); + if (_language.DetachFromParent.EqualsIdentity(classifier)) + return NewDetachFromParent(id); + if (_language.Diagnostics.EqualsIdentity(classifier)) + return NewDiagnostics(id); + if (_language.Enum.EqualsIdentity(classifier)) + return NewEnum(id); + if (_language.Enumeration.EqualsIdentity(classifier)) + return NewEnumeration(id); + if (_language.EnumerationBase.EqualsIdentity(classifier)) + return NewEnumerationBase(id); + if (_language.EnumerationLiteral.EqualsIdentity(classifier)) + return NewEnumerationLiteral(id); + if (_language.EnumerationLiteralBase.EqualsIdentity(classifier)) + return NewEnumerationLiteralBase(id); + if (_language.Equals_.EqualsIdentity(classifier)) + return NewEquals(id); + if (_language.ExchangeChildRaw.EqualsIdentity(classifier)) + return NewExchangeChildRaw(id); + if (_language.ExchangeChildrenRaw.EqualsIdentity(classifier)) + return NewExchangeChildrenRaw(id); + if (_language.FeaturesLazy.EqualsIdentity(classifier)) + return NewFeaturesLazy(id); + if (_language.Field.EqualsIdentity(classifier)) + return NewField(id); + if (_language.FieldBase.EqualsIdentity(classifier)) + return NewFieldBase(id); + if (_language.FieldsLazy.EqualsIdentity(classifier)) + return NewFieldsLazy(id); + if (_language.Finalize.EqualsIdentity(classifier)) + return NewFinalize(id); + if (_language.Generic.EqualsIdentity(classifier)) + return NewGeneric(id); + if (_language.Get_.EqualsIdentity(classifier)) + return NewGet(id); + if (_language.get__builtIns.EqualsIdentity(classifier)) + return Newget__builtIns(id); + if (_language.get__m3.EqualsIdentity(classifier)) + return Newget__m3(id); + if (_language.GetAnnotation.EqualsIdentity(classifier)) + return NewGetAnnotation(id); + if (_language.GetAnnotations_.EqualsIdentity(classifier)) + return NewGetAnnotations(id); + if (_language.GetAnnotationsRaw_.EqualsIdentity(classifier)) + return NewGetAnnotationsRaw(id); + if (_language.GetClassifier_.EqualsIdentity(classifier)) + return NewGetClassifier(id); + if (_language.GetConcept_.EqualsIdentity(classifier)) + return NewGetConcept(id); + if (_language.GetContainmentOf.EqualsIdentity(classifier)) + return NewGetContainmentOf(id); + if (_language.GetHashCode_.EqualsIdentity(classifier)) + return NewGetHashCode(id); + if (_language.GetId_.EqualsIdentity(classifier)) + return NewGetId(id); + if (_language.GetInternal.EqualsIdentity(classifier)) + return NewGetInternal(id); + if (_language.GetParent_.EqualsIdentity(classifier)) + return NewGetParent(id); + if (_language.GetPartitionNotificationProducer.EqualsIdentity(classifier)) + return NewGetPartitionNotificationProducer(id); + if (_language.GetRequiredNonNullReferences.EqualsIdentity(classifier)) + return NewGetRequiredNonNullReferences(id); + if (_language.GetRequiredNullableReferences.EqualsIdentity(classifier)) + return NewGetRequiredNullableReferences(id); + if (_language.GetRequiredReference.EqualsIdentity(classifier)) + return NewGetRequiredReference(id); + if (_language.GetType_.EqualsIdentity(classifier)) + return NewGetType(id); + if (_language.IEnumerable.EqualsIdentity(classifier)) + return NewIEnumerable(id); + if (_language.IFieldValues.EqualsIdentity(classifier)) + return NewIFieldValues(id); + if (_language.ImplementsLazy.EqualsIdentity(classifier)) + return NewImplementsLazy(id); + if (_language.INamed.EqualsIdentity(classifier)) + return NewINamed(id); + if (_language.INamedWritable.EqualsIdentity(classifier)) + return NewINamedWritable(id); + if (_language.INode.EqualsIdentity(classifier)) + return NewINode(id); + if (_language.INodeFactory.EqualsIdentity(classifier)) + return NewINodeFactory(id); + if (_language.Insert.EqualsIdentity(classifier)) + return NewInsert(id); + if (_language.InsertAnnotations.EqualsIdentity(classifier)) + return NewInsertAnnotations(id); + if (_language.InsertAnnotationsRaw.EqualsIdentity(classifier)) + return NewInsertAnnotationsRaw(id); + if (_language.InsertChildRaw.EqualsIdentity(classifier)) + return NewInsertChildRaw(id); + if (_language.InsertContainmentsRaw.EqualsIdentity(classifier)) + return NewInsertContainmentsRaw(id); + if (_language.InsertInternal.EqualsIdentity(classifier)) + return NewInsertInternal(id); + if (_language.InsertOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewInsertOptionalMultipleContainment(id); + if (_language.InsertOptionalMultipleReference.EqualsIdentity(classifier)) + return NewInsertOptionalMultipleReference(id); + if (_language.InsertReferencesRaw.EqualsIdentity(classifier)) + return NewInsertReferencesRaw(id); + if (_language.InsertRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewInsertRequiredMultipleContainment(id); + if (_language.InsertRequiredMultipleReference.EqualsIdentity(classifier)) + return NewInsertRequiredMultipleReference(id); + if (_language.Instance_.EqualsIdentity(classifier)) + return NewInstance(id); + if (_language.Integer.EqualsIdentity(classifier)) + return NewInteger(id); + if (_language.Interface.EqualsIdentity(classifier)) + return NewInterface(id); + if (_language.InterfaceBase.EqualsIdentity(classifier)) + return NewInterfaceBase(id); + if (_language.InvalidValueException.EqualsIdentity(classifier)) + return NewInvalidValueException(id); + if (_language.IPartitionInstance.EqualsIdentity(classifier)) + return NewIPartitionInstance(id); + if (_language.IReadableNode.EqualsIdentity(classifier)) + return NewIReadableNode(id); + if (_language.IReadOnlyList.EqualsIdentity(classifier)) + return NewIReadOnlyList(id); + if (_language.IsInRange.EqualsIdentity(classifier)) + return NewIsInRange(id); + if (_language.IStructuredDataTypeInstance.EqualsIdentity(classifier)) + return NewIStructuredDataTypeInstance(id); + if (_language.IWritableNode.EqualsIdentity(classifier)) + return NewIWritableNode(id); + if (_language.Key_.EqualsIdentity(classifier)) + return NewKey(id); + if (_language.Language.EqualsIdentity(classifier)) + return NewLanguage(id); + if (_language.LanguageBase.EqualsIdentity(classifier)) + return NewLanguageBase(id); + if (_language.LanguageEntity.EqualsIdentity(classifier)) + return NewLanguageEntity(id); + if (_language.Lazy.EqualsIdentity(classifier)) + return NewLazy(id); + if (_language.Link.EqualsIdentity(classifier)) + return NewLink(id); + if (_language.LionCoreFeature.EqualsIdentity(classifier)) + return NewLionCoreFeature(id); + if (_language.LionCoreFeatureKind.EqualsIdentity(classifier)) + return NewLionCoreFeatureKind(id); + if (_language.LionCoreLanguage.EqualsIdentity(classifier)) + return NewLionCoreLanguage(id); + if (_language.LionCoreMetaPointer.EqualsIdentity(classifier)) + return NewLionCoreMetaPointer(id); + if (_language.LionWeb.EqualsIdentity(classifier)) + return NewLionWeb(id); + if (_language.LionWebVersions.EqualsIdentity(classifier)) + return NewLionWebVersions(id); + if (_language.List.EqualsIdentity(classifier)) + return NewList(id); + if (_language.LiteralsLazy.EqualsIdentity(classifier)) + return NewLiteralsLazy(id); + if (_language.M2.EqualsIdentity(classifier)) + return NewM2(id); + if (_language.M3.EqualsIdentity(classifier)) + return NewM3(id); + if (_language.MemberwiseClone_.EqualsIdentity(classifier)) + return NewMemberwiseClone(id); + if (_language.Multiple.EqualsIdentity(classifier)) + return NewMultiple(id); + if (_language.Name_.EqualsIdentity(classifier)) + return NewName(id); + if (_language.Notification.EqualsIdentity(classifier)) + return NewNotification(id); + if (_language.NotNullWhenAttribute.EqualsIdentity(classifier)) + return NewNotNullWhenAttribute(id); + if (_language.Optional.EqualsIdentity(classifier)) + return NewOptional(id); + if (_language.Partition.EqualsIdentity(classifier)) + return NewPartition(id); + if (_language.Pipe.EqualsIdentity(classifier)) + return NewPipe(id); + if (_language.PrimitiveType.EqualsIdentity(classifier)) + return NewPrimitiveType(id); + if (_language.PrimitiveTypeBase.EqualsIdentity(classifier)) + return NewPrimitiveTypeBase(id); + if (_language.Property.EqualsIdentity(classifier)) + return NewProperty(id); + if (_language.PropertyBase.EqualsIdentity(classifier)) + return NewPropertyBase(id); + if (_language.Reference.EqualsIdentity(classifier)) + return NewReference(id); + if (_language.ReferenceBase.EqualsIdentity(classifier)) + return NewReferenceBase(id); + if (_language.ReferenceEquals_.EqualsIdentity(classifier)) + return NewReferenceEquals(id); + if (_language.ReferenceRemover.EqualsIdentity(classifier)) + return NewReferenceRemover(id); + if (_language.ReferenceTargetNonNullTarget.EqualsIdentity(classifier)) + return NewReferenceTargetNonNullTarget(id); + if (_language.ReferenceTargetNonNullTargets.EqualsIdentity(classifier)) + return NewReferenceTargetNonNullTargets(id); + if (_language.ReferenceTargetNullableTarget.EqualsIdentity(classifier)) + return NewReferenceTargetNullableTarget(id); + if (_language.ReferenceTargetNullableTargets.EqualsIdentity(classifier)) + return NewReferenceTargetNullableTargets(id); + if (_language.Remove.EqualsIdentity(classifier)) + return NewRemove(id); + if (_language.RemoveAll.EqualsIdentity(classifier)) + return NewRemoveAll(id); + if (_language.RemoveAnnotations.EqualsIdentity(classifier)) + return NewRemoveAnnotations(id); + if (_language.RemoveAnnotationsRaw.EqualsIdentity(classifier)) + return NewRemoveAnnotationsRaw(id); + if (_language.RemoveChildRaw.EqualsIdentity(classifier)) + return NewRemoveChildRaw(id); + if (_language.RemoveContainmentsRaw.EqualsIdentity(classifier)) + return NewRemoveContainmentsRaw(id); + if (_language.RemoveInternal.EqualsIdentity(classifier)) + return NewRemoveInternal(id); + if (_language.RemoveOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewRemoveOptionalMultipleContainment(id); + if (_language.RemoveOptionalMultipleReference.EqualsIdentity(classifier)) + return NewRemoveOptionalMultipleReference(id); + if (_language.RemoveReferencesRaw.EqualsIdentity(classifier)) + return NewRemoveReferencesRaw(id); + if (_language.RemoveRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewRemoveRequiredMultipleContainment(id); + if (_language.RemoveRequiredMultipleReference.EqualsIdentity(classifier)) + return NewRemoveRequiredMultipleReference(id); + if (_language.RemoveSelfParent.EqualsIdentity(classifier)) + return NewRemoveSelfParent(id); + if (_language.RemoveSelfParentRaw.EqualsIdentity(classifier)) + return NewRemoveSelfParentRaw(id); + if (_language.result.EqualsIdentity(classifier)) + return Newresult(id); + if (_language.Set.EqualsIdentity(classifier)) + return NewSet(id); + if (_language.SetContainmentRaw.EqualsIdentity(classifier)) + return NewSetContainmentRaw(id); + if (_language.SetInternal.EqualsIdentity(classifier)) + return NewSetInternal(id); + if (_language.SetInternalAnnotation.EqualsIdentity(classifier)) + return NewSetInternalAnnotation(id); + if (_language.SetName.EqualsIdentity(classifier)) + return NewSetName(id); + if (_language.SetNameRaw.EqualsIdentity(classifier)) + return NewSetNameRaw(id); + if (_language.SetOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewSetOptionalMultipleContainment(id); + if (_language.SetOptionalMultipleReference.EqualsIdentity(classifier)) + return NewSetOptionalMultipleReference(id); + if (_language.SetOptionalReferenceTypeProperty.EqualsIdentity(classifier)) + return NewSetOptionalReferenceTypeProperty(id); + if (_language.SetOptionalSingleContainment.EqualsIdentity(classifier)) + return NewSetOptionalSingleContainment(id); + if (_language.SetOptionalSingleReference.EqualsIdentity(classifier)) + return NewSetOptionalSingleReference(id); + if (_language.SetOptionalValueTypeProperty.EqualsIdentity(classifier)) + return NewSetOptionalValueTypeProperty(id); + if (_language.SetParentInternal.EqualsIdentity(classifier)) + return NewSetParentInternal(id); + if (_language.SetParentNull.EqualsIdentity(classifier)) + return NewSetParentNull(id); + if (_language.SetPropertyRaw.EqualsIdentity(classifier)) + return NewSetPropertyRaw(id); + if (_language.SetRaw.EqualsIdentity(classifier)) + return NewSetRaw(id); + if (_language.SetReferenceRaw.EqualsIdentity(classifier)) + return NewSetReferenceRaw(id); + if (_language.SetReferencesRaw.EqualsIdentity(classifier)) + return NewSetReferencesRaw(id); + if (_language.SetRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewSetRequiredMultipleContainment(id); + if (_language.SetRequiredMultipleReference.EqualsIdentity(classifier)) + return NewSetRequiredMultipleReference(id); + if (_language.SetRequiredReferenceTypeProperty.EqualsIdentity(classifier)) + return NewSetRequiredReferenceTypeProperty(id); + if (_language.SetRequiredSingleContainment.EqualsIdentity(classifier)) + return NewSetRequiredSingleContainment(id); + if (_language.SetRequiredSingleReference.EqualsIdentity(classifier)) + return NewSetRequiredSingleReference(id); + if (_language.SetRequiredValueTypeProperty.EqualsIdentity(classifier)) + return NewSetRequiredValueTypeProperty(id); + if (_language.SetSelfParent.EqualsIdentity(classifier)) + return NewSetSelfParent(id); + if (_language.SetSelfParentRaw.EqualsIdentity(classifier)) + return NewSetSelfParentRaw(id); + if (_language.String.EqualsIdentity(classifier)) + return NewString(id); + if (_language.StructuredDataType.EqualsIdentity(classifier)) + return NewStructuredDataType(id); + if (_language.StructuredDataTypeBase.EqualsIdentity(classifier)) + return NewStructuredDataTypeBase(id); + if (_language.System.EqualsIdentity(classifier)) + return NewSystem(id); + if (_language.ToString_.EqualsIdentity(classifier)) + return NewToString(id); + if (_language.TryGet_.EqualsIdentity(classifier)) + return NewTryGet(id); + if (_language.TryGetContainmentRaw_.EqualsIdentity(classifier)) + return NewTryGetContainmentRaw(id); + if (_language.TryGetContainmentsRaw_.EqualsIdentity(classifier)) + return NewTryGetContainmentsRaw(id); + if (_language.TryGetName_.EqualsIdentity(classifier)) + return NewTryGetName(id); + if (_language.TryGetPropertyRaw_.EqualsIdentity(classifier)) + return NewTryGetPropertyRaw(id); + if (_language.TryGetReference.EqualsIdentity(classifier)) + return NewTryGetReference(id); + if (_language.TryGetReferenceRaw_.EqualsIdentity(classifier)) + return NewTryGetReferenceRaw(id); + if (_language.TryGetReferencesRaw_.EqualsIdentity(classifier)) + return NewTryGetReferencesRaw(id); + if (_language.Type.EqualsIdentity(classifier)) + return NewType(id); + if (_language.UnsetFeatureException.EqualsIdentity(classifier)) + return NewUnsetFeatureException(id); + if (_language.UnsetFieldException.EqualsIdentity(classifier)) + return NewUnsetFieldException(id); + if (_language.UnsupportedClassifierException.EqualsIdentity(classifier)) + return NewUnsupportedClassifierException(id); + if (_language.UnsupportedEnumerationLiteralException.EqualsIdentity(classifier)) + return NewUnsupportedEnumerationLiteralException(id); + if (_language.UnsupportedStructuredDataTypeException.EqualsIdentity(classifier)) + return NewUnsupportedStructuredDataTypeException(id); + if (_language.Utilities.EqualsIdentity(classifier)) + return NewUtilities(id); + if (_language.V2023_1.EqualsIdentity(classifier)) + return NewV2023_1(id); + if (_language.V2024_1.EqualsIdentity(classifier)) + return NewV2024_1(id); + if (_language.V2024_1_Compatible.EqualsIdentity(classifier)) + return NewV2024_1_Compatible(id); + if (_language.V2025_1.EqualsIdentity(classifier)) + return NewV2025_1(id); + if (_language.V2025_1_Compatible.EqualsIdentity(classifier)) + return NewV2025_1_Compatible(id); + if (_language.VersionSpecific.EqualsIdentity(classifier)) + return NewVersionSpecific(id); + throw new global::LionWeb.Core.UnsupportedClassifierException(classifier); + } + + /// + public override global::System.Enum GetEnumerationLiteral(global::LionWeb.Core.M3.EnumerationLiteral literal) + { + throw new global::LionWeb.Core.UnsupportedEnumerationLiteralException(literal); + } + + /// + public override global::LionWeb.Core.IStructuredDataTypeInstance CreateStructuredDataTypeInstance(global::LionWeb.Core.M3.StructuredDataType structuredDataType, global::LionWeb.Core.M2.IFieldValues fieldValues) + { + throw new global::LionWeb.Core.UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual _builtIns New_builtIns(string id) => new(id); + public virtual _builtIns Create_builtIns() => New_builtIns(GetNewId()); + public virtual Abstract NewAbstract(string id) => new(id); + public virtual Abstract CreateAbstract() => NewAbstract(GetNewId()); + public virtual AbstractBaseNodeFactory NewAbstractBaseNodeFactory(string id) => new(id); + public virtual AbstractBaseNodeFactory CreateAbstractBaseNodeFactory() => NewAbstractBaseNodeFactory(GetNewId()); + public virtual Add NewAdd(string id) => new(id); + public virtual Add CreateAdd() => NewAdd(GetNewId()); + public virtual AddAnnotations NewAddAnnotations(string id) => new(id); + public virtual AddAnnotations CreateAddAnnotations() => NewAddAnnotations(GetNewId()); + public virtual AddAnnotationsRaw NewAddAnnotationsRaw(string id) => new(id); + public virtual AddAnnotationsRaw CreateAddAnnotationsRaw() => NewAddAnnotationsRaw(GetNewId()); + public virtual AddChildRaw NewAddChildRaw(string id) => new(id); + public virtual AddChildRaw CreateAddChildRaw() => NewAddChildRaw(GetNewId()); + public virtual AddContainmentsRaw_ NewAddContainmentsRaw(string id) => new(id); + public virtual AddContainmentsRaw_ CreateAddContainmentsRaw() => NewAddContainmentsRaw(GetNewId()); + public virtual AddInternal_ NewAddInternal(string id) => new(id); + public virtual AddInternal_ CreateAddInternal() => NewAddInternal(GetNewId()); + public virtual AddOptionalMultipleContainment NewAddOptionalMultipleContainment(string id) => new(id); + public virtual AddOptionalMultipleContainment CreateAddOptionalMultipleContainment() => NewAddOptionalMultipleContainment(GetNewId()); + public virtual AddOptionalMultipleReference NewAddOptionalMultipleReference(string id) => new(id); + public virtual AddOptionalMultipleReference CreateAddOptionalMultipleReference() => NewAddOptionalMultipleReference(GetNewId()); + public virtual AddReferencesRaw_ NewAddReferencesRaw(string id) => new(id); + public virtual AddReferencesRaw_ CreateAddReferencesRaw() => NewAddReferencesRaw(GetNewId()); + public virtual AddRequiredMultipleContainment NewAddRequiredMultipleContainment(string id) => new(id); + public virtual AddRequiredMultipleContainment CreateAddRequiredMultipleContainment() => NewAddRequiredMultipleContainment(GetNewId()); + public virtual AddRequiredMultipleReference NewAddRequiredMultipleReference(string id) => new(id); + public virtual AddRequiredMultipleReference CreateAddRequiredMultipleReference() => NewAddRequiredMultipleReference(GetNewId()); + public virtual AnnotatesLazy NewAnnotatesLazy(string id) => new(id); + public virtual AnnotatesLazy CreateAnnotatesLazy() => NewAnnotatesLazy(GetNewId()); + public virtual Annotation NewAnnotation(string id) => new(id); + public virtual Annotation CreateAnnotation() => NewAnnotation(GetNewId()); + public virtual AnnotationBase NewAnnotationBase(string id) => new(id); + public virtual AnnotationBase CreateAnnotationBase() => NewAnnotationBase(GetNewId()); + public virtual AnnotationInstanceBase NewAnnotationInstanceBase(string id) => new(id); + public virtual AnnotationInstanceBase CreateAnnotationInstanceBase() => NewAnnotationInstanceBase(GetNewId()); + public virtual AnnotationRemover NewAnnotationRemover(string id) => new(id); + public virtual AnnotationRemover CreateAnnotationRemover() => NewAnnotationRemover(GetNewId()); + public virtual ArgumentOutOfRangeException NewArgumentOutOfRangeException(string id) => new(id); + public virtual ArgumentOutOfRangeException CreateArgumentOutOfRangeException() => NewArgumentOutOfRangeException(GetNewId()); + public virtual AsList NewAsList(string id) => new(id); + public virtual AsList CreateAsList() => NewAsList(GetNewId()); + public virtual AsNonEmptyReadOnly NewAsNonEmptyReadOnly(string id) => new(id); + public virtual AsNonEmptyReadOnly CreateAsNonEmptyReadOnly() => NewAsNonEmptyReadOnly(GetNewId()); + public virtual AssureAnnotations NewAssureAnnotations(string id) => new(id); + public virtual AssureAnnotations CreateAssureAnnotations() => NewAssureAnnotations(GetNewId()); + public virtual AssureInRange NewAssureInRange(string id) => new(id); + public virtual AssureInRange CreateAssureInRange() => NewAssureInRange(GetNewId()); + public virtual AssureNonEmpty NewAssureNonEmpty(string id) => new(id); + public virtual AssureNonEmpty CreateAssureNonEmpty() => NewAssureNonEmpty(GetNewId()); + public virtual AssureNoSelfMove NewAssureNoSelfMove(string id) => new(id); + public virtual AssureNoSelfMove CreateAssureNoSelfMove() => NewAssureNoSelfMove(GetNewId()); + public virtual AssureNotClearing NewAssureNotClearing(string id) => new(id); + public virtual AssureNotClearing CreateAssureNotClearing() => NewAssureNotClearing(GetNewId()); + public virtual AssureNotNull NewAssureNotNull(string id) => new(id); + public virtual AssureNotNull CreateAssureNotNull() => NewAssureNotNull(GetNewId()); + public virtual AssureNotNullInstance NewAssureNotNullInstance(string id) => new(id); + public virtual AssureNotNullInstance CreateAssureNotNullInstance() => NewAssureNotNullInstance(GetNewId()); + public virtual AssureNotNullMembers NewAssureNotNullMembers(string id) => new(id); + public virtual AssureNotNullMembers CreateAssureNotNullMembers() => NewAssureNotNullMembers(GetNewId()); + public virtual AssureNullableInstance NewAssureNullableInstance(string id) => new(id); + public virtual AssureNullableInstance CreateAssureNullableInstance() => NewAssureNullableInstance(GetNewId()); + public virtual AttachChild NewAttachChild(string id) => new(id); + public virtual AttachChild CreateAttachChild() => NewAttachChild(GetNewId()); + public virtual Bool NewBool(string id) => new(id); + public virtual Bool CreateBool() => NewBool(GetNewId()); + public virtual Boolean NewBoolean(string id) => new(id); + public virtual Boolean CreateBoolean() => NewBoolean(GetNewId()); + public virtual Char NewChar(string id) => new(id); + public virtual Char CreateChar() => NewChar(GetNewId()); + public virtual Character NewCharacter(string id) => new(id); + public virtual Character CreateCharacter() => NewCharacter(GetNewId()); + public virtual Classifier NewClassifier(string id) => new(id); + public virtual Classifier CreateClassifier() => NewClassifier(GetNewId()); + public virtual CodeAnalysis NewCodeAnalysis(string id) => new(id); + public virtual CodeAnalysis CreateCodeAnalysis() => NewCodeAnalysis(GetNewId()); + public virtual CollectAllSetFeatures_ NewCollectAllSetFeatures(string id) => new(id); + public virtual CollectAllSetFeatures_ CreateCollectAllSetFeatures() => NewCollectAllSetFeatures(GetNewId()); + public virtual Collections NewCollections(string id) => new(id); + public virtual Collections CreateCollections() => NewCollections(GetNewId()); + public virtual Concept NewConcept(string id) => new(id); + public virtual Concept CreateConcept() => NewConcept(GetNewId()); + public virtual ConceptBase NewConceptBase(string id) => new(id); + public virtual ConceptBase CreateConceptBase() => NewConceptBase(GetNewId()); + public virtual ConceptInstanceBase NewConceptInstanceBase(string id) => new(id); + public virtual ConceptInstanceBase CreateConceptInstanceBase() => NewConceptInstanceBase(GetNewId()); + public virtual Containment NewContainment(string id) => new(id); + public virtual Containment CreateContainment() => NewContainment(GetNewId()); + public virtual ContainmentBase NewContainmentBase(string id) => new(id); + public virtual ContainmentBase CreateContainmentBase() => NewContainmentBase(GetNewId()); + public virtual ContainmentRemover NewContainmentRemover(string id) => new(id); + public virtual ContainmentRemover CreateContainmentRemover() => NewContainmentRemover(GetNewId()); + public virtual Core NewCore(string id) => new(id); + public virtual Core CreateCore() => NewCore(GetNewId()); + public virtual Datatype NewDatatype(string id) => new(id); + public virtual Datatype CreateDatatype() => NewDatatype(GetNewId()); + public virtual DatatypeBase NewDatatypeBase(string id) => new(id); + public virtual DatatypeBase CreateDatatypeBase() => NewDatatypeBase(GetNewId()); + public virtual Decimal NewDecimal(string id) => new(id); + public virtual Decimal CreateDecimal() => NewDecimal(GetNewId()); + public virtual DetachChild_ NewDetachChild(string id) => new(id); + public virtual DetachChild_ CreateDetachChild() => NewDetachChild(GetNewId()); + public virtual DetachChildInternal NewDetachChildInternal(string id) => new(id); + public virtual DetachChildInternal CreateDetachChildInternal() => NewDetachChildInternal(GetNewId()); + public virtual DetachFromParent_ NewDetachFromParent(string id) => new(id); + public virtual DetachFromParent_ CreateDetachFromParent() => NewDetachFromParent(GetNewId()); + public virtual Diagnostics NewDiagnostics(string id) => new(id); + public virtual Diagnostics CreateDiagnostics() => NewDiagnostics(GetNewId()); + public virtual Enum NewEnum(string id) => new(id); + public virtual Enum CreateEnum() => NewEnum(GetNewId()); + public virtual Enumeration NewEnumeration(string id) => new(id); + public virtual Enumeration CreateEnumeration() => NewEnumeration(GetNewId()); + public virtual EnumerationBase NewEnumerationBase(string id) => new(id); + public virtual EnumerationBase CreateEnumerationBase() => NewEnumerationBase(GetNewId()); + public virtual EnumerationLiteral NewEnumerationLiteral(string id) => new(id); + public virtual EnumerationLiteral CreateEnumerationLiteral() => NewEnumerationLiteral(GetNewId()); + public virtual EnumerationLiteralBase NewEnumerationLiteralBase(string id) => new(id); + public virtual EnumerationLiteralBase CreateEnumerationLiteralBase() => NewEnumerationLiteralBase(GetNewId()); + public virtual Equals NewEquals(string id) => new(id); + public virtual Equals CreateEquals() => NewEquals(GetNewId()); + public virtual ExchangeChildRaw NewExchangeChildRaw(string id) => new(id); + public virtual ExchangeChildRaw CreateExchangeChildRaw() => NewExchangeChildRaw(GetNewId()); + public virtual ExchangeChildrenRaw NewExchangeChildrenRaw(string id) => new(id); + public virtual ExchangeChildrenRaw CreateExchangeChildrenRaw() => NewExchangeChildrenRaw(GetNewId()); + public virtual FeaturesLazy NewFeaturesLazy(string id) => new(id); + public virtual FeaturesLazy CreateFeaturesLazy() => NewFeaturesLazy(GetNewId()); + public virtual Field NewField(string id) => new(id); + public virtual Field CreateField() => NewField(GetNewId()); + public virtual FieldBase NewFieldBase(string id) => new(id); + public virtual FieldBase CreateFieldBase() => NewFieldBase(GetNewId()); + public virtual FieldsLazy NewFieldsLazy(string id) => new(id); + public virtual FieldsLazy CreateFieldsLazy() => NewFieldsLazy(GetNewId()); + public virtual Finalize NewFinalize(string id) => new(id); + public virtual Finalize CreateFinalize() => NewFinalize(GetNewId()); + public virtual Generic NewGeneric(string id) => new(id); + public virtual Generic CreateGeneric() => NewGeneric(GetNewId()); + public virtual Get NewGet(string id) => new(id); + public virtual Get CreateGet() => NewGet(GetNewId()); + public virtual get__builtIns Newget__builtIns(string id) => new(id); + public virtual get__builtIns Createget__builtIns() => Newget__builtIns(GetNewId()); + public virtual get__m3 Newget__m3(string id) => new(id); + public virtual get__m3 Createget__m3() => Newget__m3(GetNewId()); + public virtual GetAnnotation NewGetAnnotation(string id) => new(id); + public virtual GetAnnotation CreateGetAnnotation() => NewGetAnnotation(GetNewId()); + public virtual GetAnnotations NewGetAnnotations(string id) => new(id); + public virtual GetAnnotations CreateGetAnnotations() => NewGetAnnotations(GetNewId()); + public virtual GetAnnotationsRaw NewGetAnnotationsRaw(string id) => new(id); + public virtual GetAnnotationsRaw CreateGetAnnotationsRaw() => NewGetAnnotationsRaw(GetNewId()); + public virtual GetClassifier_ NewGetClassifier(string id) => new(id); + public virtual GetClassifier_ CreateGetClassifier() => NewGetClassifier(GetNewId()); + public virtual GetConcept_ NewGetConcept(string id) => new(id); + public virtual GetConcept_ CreateGetConcept() => NewGetConcept(GetNewId()); + public virtual GetContainmentOf_ NewGetContainmentOf(string id) => new(id); + public virtual GetContainmentOf_ CreateGetContainmentOf() => NewGetContainmentOf(GetNewId()); + public virtual GetHashCode NewGetHashCode(string id) => new(id); + public virtual GetHashCode CreateGetHashCode() => NewGetHashCode(GetNewId()); + public virtual GetId NewGetId(string id) => new(id); + public virtual GetId CreateGetId() => NewGetId(GetNewId()); + public virtual GetInternal_ NewGetInternal(string id) => new(id); + public virtual GetInternal_ CreateGetInternal() => NewGetInternal(GetNewId()); + public virtual GetParent NewGetParent(string id) => new(id); + public virtual GetParent CreateGetParent() => NewGetParent(GetNewId()); + public virtual GetPartitionNotificationProducer_ NewGetPartitionNotificationProducer(string id) => new(id); + public virtual GetPartitionNotificationProducer_ CreateGetPartitionNotificationProducer() => NewGetPartitionNotificationProducer(GetNewId()); + public virtual GetRequiredNonNullReferences NewGetRequiredNonNullReferences(string id) => new(id); + public virtual GetRequiredNonNullReferences CreateGetRequiredNonNullReferences() => NewGetRequiredNonNullReferences(GetNewId()); + public virtual GetRequiredNullableReferences NewGetRequiredNullableReferences(string id) => new(id); + public virtual GetRequiredNullableReferences CreateGetRequiredNullableReferences() => NewGetRequiredNullableReferences(GetNewId()); + public virtual GetRequiredReference NewGetRequiredReference(string id) => new(id); + public virtual GetRequiredReference CreateGetRequiredReference() => NewGetRequiredReference(GetNewId()); + public virtual GetType NewGetType(string id) => new(id); + public virtual GetType CreateGetType() => NewGetType(GetNewId()); + public virtual IEnumerable NewIEnumerable(string id) => new(id); + public virtual IEnumerable CreateIEnumerable() => NewIEnumerable(GetNewId()); + public virtual IFieldValues NewIFieldValues(string id) => new(id); + public virtual IFieldValues CreateIFieldValues() => NewIFieldValues(GetNewId()); + public virtual ImplementsLazy NewImplementsLazy(string id) => new(id); + public virtual ImplementsLazy CreateImplementsLazy() => NewImplementsLazy(GetNewId()); + public virtual INamed NewINamed(string id) => new(id); + public virtual INamed CreateINamed() => NewINamed(GetNewId()); + public virtual INamedWritable NewINamedWritable(string id) => new(id); + public virtual INamedWritable CreateINamedWritable() => NewINamedWritable(GetNewId()); + public virtual INode NewINode(string id) => new(id); + public virtual INode CreateINode() => NewINode(GetNewId()); + public virtual INodeFactory NewINodeFactory(string id) => new(id); + public virtual INodeFactory CreateINodeFactory() => NewINodeFactory(GetNewId()); + public virtual Insert NewInsert(string id) => new(id); + public virtual Insert CreateInsert() => NewInsert(GetNewId()); + public virtual InsertAnnotations NewInsertAnnotations(string id) => new(id); + public virtual InsertAnnotations CreateInsertAnnotations() => NewInsertAnnotations(GetNewId()); + public virtual InsertAnnotationsRaw NewInsertAnnotationsRaw(string id) => new(id); + public virtual InsertAnnotationsRaw CreateInsertAnnotationsRaw() => NewInsertAnnotationsRaw(GetNewId()); + public virtual InsertChildRaw NewInsertChildRaw(string id) => new(id); + public virtual InsertChildRaw CreateInsertChildRaw() => NewInsertChildRaw(GetNewId()); + public virtual InsertContainmentsRaw_ NewInsertContainmentsRaw(string id) => new(id); + public virtual InsertContainmentsRaw_ CreateInsertContainmentsRaw() => NewInsertContainmentsRaw(GetNewId()); + public virtual InsertInternal_ NewInsertInternal(string id) => new(id); + public virtual InsertInternal_ CreateInsertInternal() => NewInsertInternal(GetNewId()); + public virtual InsertOptionalMultipleContainment NewInsertOptionalMultipleContainment(string id) => new(id); + public virtual InsertOptionalMultipleContainment CreateInsertOptionalMultipleContainment() => NewInsertOptionalMultipleContainment(GetNewId()); + public virtual InsertOptionalMultipleReference NewInsertOptionalMultipleReference(string id) => new(id); + public virtual InsertOptionalMultipleReference CreateInsertOptionalMultipleReference() => NewInsertOptionalMultipleReference(GetNewId()); + public virtual InsertReferencesRaw_ NewInsertReferencesRaw(string id) => new(id); + public virtual InsertReferencesRaw_ CreateInsertReferencesRaw() => NewInsertReferencesRaw(GetNewId()); + public virtual InsertRequiredMultipleContainment NewInsertRequiredMultipleContainment(string id) => new(id); + public virtual InsertRequiredMultipleContainment CreateInsertRequiredMultipleContainment() => NewInsertRequiredMultipleContainment(GetNewId()); + public virtual InsertRequiredMultipleReference NewInsertRequiredMultipleReference(string id) => new(id); + public virtual InsertRequiredMultipleReference CreateInsertRequiredMultipleReference() => NewInsertRequiredMultipleReference(GetNewId()); + public virtual Instance NewInstance(string id) => new(id); + public virtual Instance CreateInstance() => NewInstance(GetNewId()); + public virtual Integer NewInteger(string id) => new(id); + public virtual Integer CreateInteger() => NewInteger(GetNewId()); + public virtual Interface NewInterface(string id) => new(id); + public virtual Interface CreateInterface() => NewInterface(GetNewId()); + public virtual InterfaceBase NewInterfaceBase(string id) => new(id); + public virtual InterfaceBase CreateInterfaceBase() => NewInterfaceBase(GetNewId()); + public virtual InvalidValueException NewInvalidValueException(string id) => new(id); + public virtual InvalidValueException CreateInvalidValueException() => NewInvalidValueException(GetNewId()); + public virtual IPartitionInstance NewIPartitionInstance(string id) => new(id); + public virtual IPartitionInstance CreateIPartitionInstance() => NewIPartitionInstance(GetNewId()); + public virtual IReadableNode NewIReadableNode(string id) => new(id); + public virtual IReadableNode CreateIReadableNode() => NewIReadableNode(GetNewId()); + public virtual IReadOnlyList NewIReadOnlyList(string id) => new(id); + public virtual IReadOnlyList CreateIReadOnlyList() => NewIReadOnlyList(GetNewId()); + public virtual IsInRange NewIsInRange(string id) => new(id); + public virtual IsInRange CreateIsInRange() => NewIsInRange(GetNewId()); + public virtual IStructuredDataTypeInstance NewIStructuredDataTypeInstance(string id) => new(id); + public virtual IStructuredDataTypeInstance CreateIStructuredDataTypeInstance() => NewIStructuredDataTypeInstance(GetNewId()); + public virtual IWritableNode NewIWritableNode(string id) => new(id); + public virtual IWritableNode CreateIWritableNode() => NewIWritableNode(GetNewId()); + public virtual Key NewKey(string id) => new(id); + public virtual Key CreateKey() => NewKey(GetNewId()); + public virtual Language NewLanguage(string id) => new(id); + public virtual Language CreateLanguage() => NewLanguage(GetNewId()); + public virtual LanguageBase NewLanguageBase(string id) => new(id); + public virtual LanguageBase CreateLanguageBase() => NewLanguageBase(GetNewId()); + public virtual LanguageEntity NewLanguageEntity(string id) => new(id); + public virtual LanguageEntity CreateLanguageEntity() => NewLanguageEntity(GetNewId()); + public virtual Lazy NewLazy(string id) => new(id); + public virtual Lazy CreateLazy() => NewLazy(GetNewId()); + public virtual Link NewLink(string id) => new(id); + public virtual Link CreateLink() => NewLink(GetNewId()); + public virtual LionCoreFeature NewLionCoreFeature(string id) => new(id); + public virtual LionCoreFeature CreateLionCoreFeature() => NewLionCoreFeature(GetNewId()); + public virtual LionCoreFeatureKind NewLionCoreFeatureKind(string id) => new(id); + public virtual LionCoreFeatureKind CreateLionCoreFeatureKind() => NewLionCoreFeatureKind(GetNewId()); + public virtual LionCoreLanguage NewLionCoreLanguage(string id) => new(id); + public virtual LionCoreLanguage CreateLionCoreLanguage() => NewLionCoreLanguage(GetNewId()); + public virtual LionCoreMetaPointer NewLionCoreMetaPointer(string id) => new(id); + public virtual LionCoreMetaPointer CreateLionCoreMetaPointer() => NewLionCoreMetaPointer(GetNewId()); + public virtual LionWeb NewLionWeb(string id) => new(id); + public virtual LionWeb CreateLionWeb() => NewLionWeb(GetNewId()); + public virtual LionWebVersions NewLionWebVersions(string id) => new(id); + public virtual LionWebVersions CreateLionWebVersions() => NewLionWebVersions(GetNewId()); + public virtual List NewList(string id) => new(id); + public virtual List CreateList() => NewList(GetNewId()); + public virtual LiteralsLazy NewLiteralsLazy(string id) => new(id); + public virtual LiteralsLazy CreateLiteralsLazy() => NewLiteralsLazy(GetNewId()); + public virtual M2 NewM2(string id) => new(id); + public virtual M2 CreateM2() => NewM2(GetNewId()); + public virtual M3 NewM3(string id) => new(id); + public virtual M3 CreateM3() => NewM3(GetNewId()); + public virtual MemberwiseClone NewMemberwiseClone(string id) => new(id); + public virtual MemberwiseClone CreateMemberwiseClone() => NewMemberwiseClone(GetNewId()); + public virtual Multiple NewMultiple(string id) => new(id); + public virtual Multiple CreateMultiple() => NewMultiple(GetNewId()); + public virtual Name NewName(string id) => new(id); + public virtual Name CreateName() => NewName(GetNewId()); + public virtual Notification NewNotification(string id) => new(id); + public virtual Notification CreateNotification() => NewNotification(GetNewId()); + public virtual NotNullWhenAttribute NewNotNullWhenAttribute(string id) => new(id); + public virtual NotNullWhenAttribute CreateNotNullWhenAttribute() => NewNotNullWhenAttribute(GetNewId()); + public virtual Optional NewOptional(string id) => new(id); + public virtual Optional CreateOptional() => NewOptional(GetNewId()); + public virtual Partition NewPartition(string id) => new(id); + public virtual Partition CreatePartition() => NewPartition(GetNewId()); + public virtual Pipe NewPipe(string id) => new(id); + public virtual Pipe CreatePipe() => NewPipe(GetNewId()); + public virtual PrimitiveType NewPrimitiveType(string id) => new(id); + public virtual PrimitiveType CreatePrimitiveType() => NewPrimitiveType(GetNewId()); + public virtual PrimitiveTypeBase NewPrimitiveTypeBase(string id) => new(id); + public virtual PrimitiveTypeBase CreatePrimitiveTypeBase() => NewPrimitiveTypeBase(GetNewId()); + public virtual Property NewProperty(string id) => new(id); + public virtual Property CreateProperty() => NewProperty(GetNewId()); + public virtual PropertyBase NewPropertyBase(string id) => new(id); + public virtual PropertyBase CreatePropertyBase() => NewPropertyBase(GetNewId()); + public virtual Reference NewReference(string id) => new(id); + public virtual Reference CreateReference() => NewReference(GetNewId()); + public virtual ReferenceBase NewReferenceBase(string id) => new(id); + public virtual ReferenceBase CreateReferenceBase() => NewReferenceBase(GetNewId()); + public virtual ReferenceEquals NewReferenceEquals(string id) => new(id); + public virtual ReferenceEquals CreateReferenceEquals() => NewReferenceEquals(GetNewId()); + public virtual ReferenceRemover NewReferenceRemover(string id) => new(id); + public virtual ReferenceRemover CreateReferenceRemover() => NewReferenceRemover(GetNewId()); + public virtual ReferenceTargetNonNullTarget NewReferenceTargetNonNullTarget(string id) => new(id); + public virtual ReferenceTargetNonNullTarget CreateReferenceTargetNonNullTarget() => NewReferenceTargetNonNullTarget(GetNewId()); + public virtual ReferenceTargetNonNullTargets NewReferenceTargetNonNullTargets(string id) => new(id); + public virtual ReferenceTargetNonNullTargets CreateReferenceTargetNonNullTargets() => NewReferenceTargetNonNullTargets(GetNewId()); + public virtual ReferenceTargetNullableTarget NewReferenceTargetNullableTarget(string id) => new(id); + public virtual ReferenceTargetNullableTarget CreateReferenceTargetNullableTarget() => NewReferenceTargetNullableTarget(GetNewId()); + public virtual ReferenceTargetNullableTargets NewReferenceTargetNullableTargets(string id) => new(id); + public virtual ReferenceTargetNullableTargets CreateReferenceTargetNullableTargets() => NewReferenceTargetNullableTargets(GetNewId()); + public virtual Remove NewRemove(string id) => new(id); + public virtual Remove CreateRemove() => NewRemove(GetNewId()); + public virtual RemoveAll NewRemoveAll(string id) => new(id); + public virtual RemoveAll CreateRemoveAll() => NewRemoveAll(GetNewId()); + public virtual RemoveAnnotations NewRemoveAnnotations(string id) => new(id); + public virtual RemoveAnnotations CreateRemoveAnnotations() => NewRemoveAnnotations(GetNewId()); + public virtual RemoveAnnotationsRaw NewRemoveAnnotationsRaw(string id) => new(id); + public virtual RemoveAnnotationsRaw CreateRemoveAnnotationsRaw() => NewRemoveAnnotationsRaw(GetNewId()); + public virtual RemoveChildRaw NewRemoveChildRaw(string id) => new(id); + public virtual RemoveChildRaw CreateRemoveChildRaw() => NewRemoveChildRaw(GetNewId()); + public virtual RemoveContainmentsRaw_ NewRemoveContainmentsRaw(string id) => new(id); + public virtual RemoveContainmentsRaw_ CreateRemoveContainmentsRaw() => NewRemoveContainmentsRaw(GetNewId()); + public virtual RemoveInternal_ NewRemoveInternal(string id) => new(id); + public virtual RemoveInternal_ CreateRemoveInternal() => NewRemoveInternal(GetNewId()); + public virtual RemoveOptionalMultipleContainment NewRemoveOptionalMultipleContainment(string id) => new(id); + public virtual RemoveOptionalMultipleContainment CreateRemoveOptionalMultipleContainment() => NewRemoveOptionalMultipleContainment(GetNewId()); + public virtual RemoveOptionalMultipleReference NewRemoveOptionalMultipleReference(string id) => new(id); + public virtual RemoveOptionalMultipleReference CreateRemoveOptionalMultipleReference() => NewRemoveOptionalMultipleReference(GetNewId()); + public virtual RemoveReferencesRaw_ NewRemoveReferencesRaw(string id) => new(id); + public virtual RemoveReferencesRaw_ CreateRemoveReferencesRaw() => NewRemoveReferencesRaw(GetNewId()); + public virtual RemoveRequiredMultipleContainment NewRemoveRequiredMultipleContainment(string id) => new(id); + public virtual RemoveRequiredMultipleContainment CreateRemoveRequiredMultipleContainment() => NewRemoveRequiredMultipleContainment(GetNewId()); + public virtual RemoveRequiredMultipleReference NewRemoveRequiredMultipleReference(string id) => new(id); + public virtual RemoveRequiredMultipleReference CreateRemoveRequiredMultipleReference() => NewRemoveRequiredMultipleReference(GetNewId()); + public virtual RemoveSelfParent NewRemoveSelfParent(string id) => new(id); + public virtual RemoveSelfParent CreateRemoveSelfParent() => NewRemoveSelfParent(GetNewId()); + public virtual RemoveSelfParentRaw NewRemoveSelfParentRaw(string id) => new(id); + public virtual RemoveSelfParentRaw CreateRemoveSelfParentRaw() => NewRemoveSelfParentRaw(GetNewId()); + public virtual result Newresult(string id) => new(id); + public virtual result Createresult() => Newresult(GetNewId()); + public virtual Set NewSet(string id) => new(id); + public virtual Set CreateSet() => NewSet(GetNewId()); + public virtual SetContainmentRaw_ NewSetContainmentRaw(string id) => new(id); + public virtual SetContainmentRaw_ CreateSetContainmentRaw() => NewSetContainmentRaw(GetNewId()); + public virtual SetInternal_ NewSetInternal(string id) => new(id); + public virtual SetInternal_ CreateSetInternal() => NewSetInternal(GetNewId()); + public virtual SetInternalAnnotation NewSetInternalAnnotation(string id) => new(id); + public virtual SetInternalAnnotation CreateSetInternalAnnotation() => NewSetInternalAnnotation(GetNewId()); + public virtual SetName NewSetName(string id) => new(id); + public virtual SetName CreateSetName() => NewSetName(GetNewId()); + public virtual SetNameRaw NewSetNameRaw(string id) => new(id); + public virtual SetNameRaw CreateSetNameRaw() => NewSetNameRaw(GetNewId()); + public virtual SetOptionalMultipleContainment NewSetOptionalMultipleContainment(string id) => new(id); + public virtual SetOptionalMultipleContainment CreateSetOptionalMultipleContainment() => NewSetOptionalMultipleContainment(GetNewId()); + public virtual SetOptionalMultipleReference NewSetOptionalMultipleReference(string id) => new(id); + public virtual SetOptionalMultipleReference CreateSetOptionalMultipleReference() => NewSetOptionalMultipleReference(GetNewId()); + public virtual SetOptionalReferenceTypeProperty NewSetOptionalReferenceTypeProperty(string id) => new(id); + public virtual SetOptionalReferenceTypeProperty CreateSetOptionalReferenceTypeProperty() => NewSetOptionalReferenceTypeProperty(GetNewId()); + public virtual SetOptionalSingleContainment NewSetOptionalSingleContainment(string id) => new(id); + public virtual SetOptionalSingleContainment CreateSetOptionalSingleContainment() => NewSetOptionalSingleContainment(GetNewId()); + public virtual SetOptionalSingleReference NewSetOptionalSingleReference(string id) => new(id); + public virtual SetOptionalSingleReference CreateSetOptionalSingleReference() => NewSetOptionalSingleReference(GetNewId()); + public virtual SetOptionalValueTypeProperty NewSetOptionalValueTypeProperty(string id) => new(id); + public virtual SetOptionalValueTypeProperty CreateSetOptionalValueTypeProperty() => NewSetOptionalValueTypeProperty(GetNewId()); + public virtual SetParentInternal NewSetParentInternal(string id) => new(id); + public virtual SetParentInternal CreateSetParentInternal() => NewSetParentInternal(GetNewId()); + public virtual SetParentNull NewSetParentNull(string id) => new(id); + public virtual SetParentNull CreateSetParentNull() => NewSetParentNull(GetNewId()); + public virtual SetPropertyRaw_ NewSetPropertyRaw(string id) => new(id); + public virtual SetPropertyRaw_ CreateSetPropertyRaw() => NewSetPropertyRaw(GetNewId()); + public virtual SetRaw_ NewSetRaw(string id) => new(id); + public virtual SetRaw_ CreateSetRaw() => NewSetRaw(GetNewId()); + public virtual SetReferenceRaw_ NewSetReferenceRaw(string id) => new(id); + public virtual SetReferenceRaw_ CreateSetReferenceRaw() => NewSetReferenceRaw(GetNewId()); + public virtual SetReferencesRaw NewSetReferencesRaw(string id) => new(id); + public virtual SetReferencesRaw CreateSetReferencesRaw() => NewSetReferencesRaw(GetNewId()); + public virtual SetRequiredMultipleContainment NewSetRequiredMultipleContainment(string id) => new(id); + public virtual SetRequiredMultipleContainment CreateSetRequiredMultipleContainment() => NewSetRequiredMultipleContainment(GetNewId()); + public virtual SetRequiredMultipleReference NewSetRequiredMultipleReference(string id) => new(id); + public virtual SetRequiredMultipleReference CreateSetRequiredMultipleReference() => NewSetRequiredMultipleReference(GetNewId()); + public virtual SetRequiredReferenceTypeProperty NewSetRequiredReferenceTypeProperty(string id) => new(id); + public virtual SetRequiredReferenceTypeProperty CreateSetRequiredReferenceTypeProperty() => NewSetRequiredReferenceTypeProperty(GetNewId()); + public virtual SetRequiredSingleContainment NewSetRequiredSingleContainment(string id) => new(id); + public virtual SetRequiredSingleContainment CreateSetRequiredSingleContainment() => NewSetRequiredSingleContainment(GetNewId()); + public virtual SetRequiredSingleReference NewSetRequiredSingleReference(string id) => new(id); + public virtual SetRequiredSingleReference CreateSetRequiredSingleReference() => NewSetRequiredSingleReference(GetNewId()); + public virtual SetRequiredValueTypeProperty NewSetRequiredValueTypeProperty(string id) => new(id); + public virtual SetRequiredValueTypeProperty CreateSetRequiredValueTypeProperty() => NewSetRequiredValueTypeProperty(GetNewId()); + public virtual SetSelfParent NewSetSelfParent(string id) => new(id); + public virtual SetSelfParent CreateSetSelfParent() => NewSetSelfParent(GetNewId()); + public virtual SetSelfParentRaw NewSetSelfParentRaw(string id) => new(id); + public virtual SetSelfParentRaw CreateSetSelfParentRaw() => NewSetSelfParentRaw(GetNewId()); + public virtual String NewString(string id) => new(id); + public virtual String CreateString() => NewString(GetNewId()); + public virtual StructuredDataType NewStructuredDataType(string id) => new(id); + public virtual StructuredDataType CreateStructuredDataType() => NewStructuredDataType(GetNewId()); + public virtual StructuredDataTypeBase NewStructuredDataTypeBase(string id) => new(id); + public virtual StructuredDataTypeBase CreateStructuredDataTypeBase() => NewStructuredDataTypeBase(GetNewId()); + public virtual System NewSystem(string id) => new(id); + public virtual System CreateSystem() => NewSystem(GetNewId()); + public virtual ToString NewToString(string id) => new(id); + public virtual ToString CreateToString() => NewToString(GetNewId()); + public virtual TryGet_ NewTryGet(string id) => new(id); + public virtual TryGet_ CreateTryGet() => NewTryGet(GetNewId()); + public virtual TryGetContainmentRaw_ NewTryGetContainmentRaw(string id) => new(id); + public virtual TryGetContainmentRaw_ CreateTryGetContainmentRaw() => NewTryGetContainmentRaw(GetNewId()); + public virtual TryGetContainmentsRaw_ NewTryGetContainmentsRaw(string id) => new(id); + public virtual TryGetContainmentsRaw_ CreateTryGetContainmentsRaw() => NewTryGetContainmentsRaw(GetNewId()); + public virtual TryGetName NewTryGetName(string id) => new(id); + public virtual TryGetName CreateTryGetName() => NewTryGetName(GetNewId()); + public virtual TryGetPropertyRaw_ NewTryGetPropertyRaw(string id) => new(id); + public virtual TryGetPropertyRaw_ CreateTryGetPropertyRaw() => NewTryGetPropertyRaw(GetNewId()); + public virtual TryGetReference NewTryGetReference(string id) => new(id); + public virtual TryGetReference CreateTryGetReference() => NewTryGetReference(GetNewId()); + public virtual TryGetReferenceRaw_ NewTryGetReferenceRaw(string id) => new(id); + public virtual TryGetReferenceRaw_ CreateTryGetReferenceRaw() => NewTryGetReferenceRaw(GetNewId()); + public virtual TryGetReferencesRaw_ NewTryGetReferencesRaw(string id) => new(id); + public virtual TryGetReferencesRaw_ CreateTryGetReferencesRaw() => NewTryGetReferencesRaw(GetNewId()); + public virtual Type NewType(string id) => new(id); + public virtual Type CreateType() => NewType(GetNewId()); + public virtual UnsetFeatureException NewUnsetFeatureException(string id) => new(id); + public virtual UnsetFeatureException CreateUnsetFeatureException() => NewUnsetFeatureException(GetNewId()); + public virtual UnsetFieldException NewUnsetFieldException(string id) => new(id); + public virtual UnsetFieldException CreateUnsetFieldException() => NewUnsetFieldException(GetNewId()); + public virtual UnsupportedClassifierException NewUnsupportedClassifierException(string id) => new(id); + public virtual UnsupportedClassifierException CreateUnsupportedClassifierException() => NewUnsupportedClassifierException(GetNewId()); + public virtual UnsupportedEnumerationLiteralException NewUnsupportedEnumerationLiteralException(string id) => new(id); + public virtual UnsupportedEnumerationLiteralException CreateUnsupportedEnumerationLiteralException() => NewUnsupportedEnumerationLiteralException(GetNewId()); + public virtual UnsupportedStructuredDataTypeException NewUnsupportedStructuredDataTypeException(string id) => new(id); + public virtual UnsupportedStructuredDataTypeException CreateUnsupportedStructuredDataTypeException() => NewUnsupportedStructuredDataTypeException(GetNewId()); + public virtual Utilities NewUtilities(string id) => new(id); + public virtual Utilities CreateUtilities() => NewUtilities(GetNewId()); + public virtual V2023_1 NewV2023_1(string id) => new(id); + public virtual V2023_1 CreateV2023_1() => NewV2023_1(GetNewId()); + public virtual V2024_1 NewV2024_1(string id) => new(id); + public virtual V2024_1 CreateV2024_1() => NewV2024_1(GetNewId()); + public virtual V2024_1_Compatible NewV2024_1_Compatible(string id) => new(id); + public virtual V2024_1_Compatible CreateV2024_1_Compatible() => NewV2024_1_Compatible(GetNewId()); + public virtual V2025_1 NewV2025_1(string id) => new(id); + public virtual V2025_1 CreateV2025_1() => NewV2025_1(GetNewId()); + public virtual V2025_1_Compatible NewV2025_1_Compatible(string id) => new(id); + public virtual V2025_1_Compatible CreateV2025_1_Compatible() => NewV2025_1_Compatible(GetNewId()); + public virtual VersionSpecific NewVersionSpecific(string id) => new(id); + public virtual VersionSpecific CreateVersionSpecific() => NewVersionSpecific(GetNewId()); +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-_builtIns")] +public partial class _builtIns : global::LionWeb.Core.ConceptInstanceBase +{ + public _builtIns(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance._builtIns_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Abstract")] +public partial class Abstract : global::LionWeb.Core.ConceptInstanceBase +{ + public Abstract(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Abstract; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AbstractBaseNodeFactory")] +public partial class AbstractBaseNodeFactory : global::LionWeb.Core.ConceptInstanceBase +{ + public AbstractBaseNodeFactory(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AbstractBaseNodeFactory; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Add")] +public partial class Add : global::LionWeb.Core.ConceptInstanceBase +{ + public Add(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Add; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddAnnotations")] +public partial class AddAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public AddAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddAnnotationsRaw")] +public partial class AddAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public AddAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddChildRaw")] +public partial class AddChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public AddChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddContainmentsRaw")] +public partial class AddContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddInternal")] +public partial class AddInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddOptionalMultipleContainment")] +public partial class AddOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public AddOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddOptionalMultipleReference")] +public partial class AddOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public AddOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddReferencesRaw")] +public partial class AddReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddRequiredMultipleContainment")] +public partial class AddRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public AddRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddRequiredMultipleReference")] +public partial class AddRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public AddRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotatesLazy")] +public partial class AnnotatesLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotatesLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotatesLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Annotation")] +public partial class Annotation : global::LionWeb.Core.ConceptInstanceBase +{ + public Annotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Annotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationBase")] +public partial class AnnotationBase : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationInstanceBase")] +public partial class AnnotationInstanceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationInstanceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationInstanceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationRemover")] +public partial class AnnotationRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ArgumentOutOfRangeException")] +public partial class ArgumentOutOfRangeException : global::LionWeb.Core.ConceptInstanceBase +{ + public ArgumentOutOfRangeException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ArgumentOutOfRangeException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AsList")] +public partial class AsList : global::LionWeb.Core.ConceptInstanceBase +{ + public AsList(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AsList; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AsNonEmptyReadOnly")] +public partial class AsNonEmptyReadOnly : global::LionWeb.Core.ConceptInstanceBase +{ + public AsNonEmptyReadOnly(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AsNonEmptyReadOnly; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureAnnotations")] +public partial class AssureAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureInRange")] +public partial class AssureInRange : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureInRange(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureInRange; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNonEmpty")] +public partial class AssureNonEmpty : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNonEmpty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNonEmpty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNoSelfMove")] +public partial class AssureNoSelfMove : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNoSelfMove(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNoSelfMove; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotClearing")] +public partial class AssureNotClearing : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotClearing(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotClearing; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNull")] +public partial class AssureNotNull : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNull(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNull; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNullInstance")] +public partial class AssureNotNullInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNullInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNullInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNullMembers")] +public partial class AssureNotNullMembers : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNullMembers(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNullMembers; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNullableInstance")] +public partial class AssureNullableInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNullableInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNullableInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AttachChild")] +public partial class AttachChild : global::LionWeb.Core.ConceptInstanceBase +{ + public AttachChild(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AttachChild; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Bool")] +public partial class Bool : global::LionWeb.Core.ConceptInstanceBase +{ + public Bool(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Bool; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Boolean")] +public partial class Boolean : global::LionWeb.Core.ConceptInstanceBase +{ + public Boolean(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Boolean; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Char")] +public partial class Char : global::LionWeb.Core.ConceptInstanceBase +{ + public Char(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Char; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Character")] +public partial class Character : global::LionWeb.Core.ConceptInstanceBase +{ + public Character(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Character; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Classifier")] +public partial class Classifier : global::LionWeb.Core.ConceptInstanceBase +{ + public Classifier(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Classifier; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-CodeAnalysis")] +public partial class CodeAnalysis : global::LionWeb.Core.ConceptInstanceBase +{ + public CodeAnalysis(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.CodeAnalysis; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-CollectAllSetFeatures")] +public partial class CollectAllSetFeatures_ : global::LionWeb.Core.ConceptInstanceBase +{ + public CollectAllSetFeatures_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.CollectAllSetFeatures_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Collections")] +public partial class Collections : global::LionWeb.Core.ConceptInstanceBase +{ + public Collections(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Collections; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Concept")] +public partial class Concept : global::LionWeb.Core.ConceptInstanceBase +{ + public Concept(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Concept; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ConceptBase")] +public partial class ConceptBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ConceptBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ConceptBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ConceptInstanceBase")] +public partial class ConceptInstanceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ConceptInstanceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ConceptInstanceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Containment")] +public partial class Containment : global::LionWeb.Core.ConceptInstanceBase +{ + public Containment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Containment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ContainmentBase")] +public partial class ContainmentBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ContainmentBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ContainmentBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ContainmentRemover")] +public partial class ContainmentRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public ContainmentRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ContainmentRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Core")] +public partial class Core : global::LionWeb.Core.ConceptInstanceBase +{ + public Core(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Core; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Datatype")] +public partial class Datatype : global::LionWeb.Core.ConceptInstanceBase +{ + public Datatype(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Datatype; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DatatypeBase")] +public partial class DatatypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public DatatypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DatatypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Decimal")] +public partial class Decimal : global::LionWeb.Core.ConceptInstanceBase +{ + public Decimal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Decimal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachChild")] +public partial class DetachChild_ : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachChild_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachChild; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachChildInternal")] +public partial class DetachChildInternal : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachChildInternal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachChildInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachFromParent")] +public partial class DetachFromParent_ : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachFromParent_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachFromParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Diagnostics")] +public partial class Diagnostics : global::LionWeb.Core.ConceptInstanceBase +{ + public Diagnostics(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Diagnostics; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Enum")] +public partial class Enum : global::LionWeb.Core.ConceptInstanceBase +{ + public Enum(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Enum; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Enumeration")] +public partial class Enumeration : global::LionWeb.Core.ConceptInstanceBase +{ + public Enumeration(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Enumeration; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationBase")] +public partial class EnumerationBase : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationLiteral")] +public partial class EnumerationLiteral : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationLiteral(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationLiteral; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationLiteralBase")] +public partial class EnumerationLiteralBase : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationLiteralBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationLiteralBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Equals")] +public partial class Equals : global::LionWeb.Core.ConceptInstanceBase +{ + public Equals(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Equals_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ExchangeChildRaw")] +public partial class ExchangeChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public ExchangeChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ExchangeChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ExchangeChildrenRaw")] +public partial class ExchangeChildrenRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public ExchangeChildrenRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ExchangeChildrenRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FeaturesLazy")] +public partial class FeaturesLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public FeaturesLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FeaturesLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Field")] +public partial class Field : global::LionWeb.Core.ConceptInstanceBase +{ + public Field(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Field; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FieldBase")] +public partial class FieldBase : global::LionWeb.Core.ConceptInstanceBase +{ + public FieldBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FieldBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FieldsLazy")] +public partial class FieldsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public FieldsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FieldsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Finalize")] +public partial class Finalize : global::LionWeb.Core.ConceptInstanceBase +{ + public Finalize(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Finalize; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Generic")] +public partial class Generic : global::LionWeb.Core.ConceptInstanceBase +{ + public Generic(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Generic; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Get")] +public partial class Get : global::LionWeb.Core.ConceptInstanceBase +{ + public Get(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Get_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-get__builtIns")] +public partial class get__builtIns : global::LionWeb.Core.ConceptInstanceBase +{ + public get__builtIns(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.get__builtIns; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-get__m3")] +public partial class get__m3 : global::LionWeb.Core.ConceptInstanceBase +{ + public get__m3(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.get__m3; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotation")] +public partial class GetAnnotation : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotations")] +public partial class GetAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotations_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotationsRaw")] +public partial class GetAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotationsRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetClassifier")] +public partial class GetClassifier_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetClassifier_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetClassifier_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetConcept")] +public partial class GetConcept_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetConcept_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetConcept_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetContainmentOf")] +public partial class GetContainmentOf_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetContainmentOf_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetContainmentOf; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetHashCode")] +public partial class GetHashCode : global::LionWeb.Core.ConceptInstanceBase +{ + public GetHashCode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetHashCode_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetId")] +public partial class GetId : global::LionWeb.Core.ConceptInstanceBase +{ + public GetId(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetId_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetInternal")] +public partial class GetInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetParent")] +public partial class GetParent : global::LionWeb.Core.ConceptInstanceBase +{ + public GetParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetParent_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetPartitionNotificationProducer")] +public partial class GetPartitionNotificationProducer_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetPartitionNotificationProducer_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetPartitionNotificationProducer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredNonNullReferences")] +public partial class GetRequiredNonNullReferences : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredNonNullReferences(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredNonNullReferences; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredNullableReferences")] +public partial class GetRequiredNullableReferences : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredNullableReferences(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredNullableReferences; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredReference")] +public partial class GetRequiredReference : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetType")] +public partial class GetType : global::LionWeb.Core.ConceptInstanceBase +{ + public GetType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetType_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IEnumerable")] +public partial class IEnumerable : global::LionWeb.Core.ConceptInstanceBase +{ + public IEnumerable(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IEnumerable; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IFieldValues")] +public partial class IFieldValues : global::LionWeb.Core.ConceptInstanceBase +{ + public IFieldValues(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IFieldValues; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ImplementsLazy")] +public partial class ImplementsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public ImplementsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ImplementsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INamed")] +public partial class INamed : global::LionWeb.Core.ConceptInstanceBase +{ + public INamed(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INamed; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INamedWritable")] +public partial class INamedWritable : global::LionWeb.Core.ConceptInstanceBase +{ + public INamedWritable(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INamedWritable; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INode")] +public partial class INode : global::LionWeb.Core.ConceptInstanceBase +{ + public INode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INodeFactory")] +public partial class INodeFactory : global::LionWeb.Core.ConceptInstanceBase +{ + public INodeFactory(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INodeFactory; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Insert")] +public partial class Insert : global::LionWeb.Core.ConceptInstanceBase +{ + public Insert(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Insert; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertAnnotations")] +public partial class InsertAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertAnnotationsRaw")] +public partial class InsertAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertChildRaw")] +public partial class InsertChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertContainmentsRaw")] +public partial class InsertContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertInternal")] +public partial class InsertInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertOptionalMultipleContainment")] +public partial class InsertOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertOptionalMultipleReference")] +public partial class InsertOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertReferencesRaw")] +public partial class InsertReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertRequiredMultipleContainment")] +public partial class InsertRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertRequiredMultipleReference")] +public partial class InsertRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Instance")] +public partial class Instance : global::LionWeb.Core.ConceptInstanceBase +{ + public Instance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Instance_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Integer")] +public partial class Integer : global::LionWeb.Core.ConceptInstanceBase +{ + public Integer(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Integer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Interface")] +public partial class Interface : global::LionWeb.Core.ConceptInstanceBase +{ + public Interface(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Interface; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InterfaceBase")] +public partial class InterfaceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public InterfaceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InterfaceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InvalidValueException")] +public partial class InvalidValueException : global::LionWeb.Core.ConceptInstanceBase +{ + public InvalidValueException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InvalidValueException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IPartitionInstance")] +public partial class IPartitionInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public IPartitionInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IPartitionInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IReadableNode")] +public partial class IReadableNode : global::LionWeb.Core.ConceptInstanceBase +{ + public IReadableNode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IReadableNode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IReadOnlyList")] +public partial class IReadOnlyList : global::LionWeb.Core.ConceptInstanceBase +{ + public IReadOnlyList(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IReadOnlyList; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IsInRange")] +public partial class IsInRange : global::LionWeb.Core.ConceptInstanceBase +{ + public IsInRange(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IsInRange; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IStructuredDataTypeInstance")] +public partial class IStructuredDataTypeInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public IStructuredDataTypeInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IStructuredDataTypeInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IWritableNode")] +public partial class IWritableNode : global::LionWeb.Core.ConceptInstanceBase +{ + public IWritableNode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IWritableNode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Key")] +public partial class Key : global::LionWeb.Core.ConceptInstanceBase +{ + public Key(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Key_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Language")] +public partial class Language : global::LionWeb.Core.ConceptInstanceBase +{ + public Language(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Language; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LanguageBase")] +public partial class LanguageBase : global::LionWeb.Core.ConceptInstanceBase +{ + public LanguageBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LanguageBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LanguageEntity")] +public partial class LanguageEntity : global::LionWeb.Core.ConceptInstanceBase +{ + public LanguageEntity(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LanguageEntity; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Lazy")] +public partial class Lazy : global::LionWeb.Core.ConceptInstanceBase +{ + public Lazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Lazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Link")] +public partial class Link : global::LionWeb.Core.ConceptInstanceBase +{ + public Link(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Link; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreFeature")] +public partial class LionCoreFeature : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreFeature(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreFeature; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreFeatureKind")] +public partial class LionCoreFeatureKind : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreFeatureKind(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreFeatureKind; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreLanguage")] +public partial class LionCoreLanguage : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreLanguage(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreLanguage; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreMetaPointer")] +public partial class LionCoreMetaPointer : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreMetaPointer(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreMetaPointer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionWeb")] +public partial class LionWeb : global::LionWeb.Core.ConceptInstanceBase +{ + public LionWeb(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionWeb; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionWebVersions")] +public partial class LionWebVersions : global::LionWeb.Core.ConceptInstanceBase +{ + public LionWebVersions(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionWebVersions; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-List")] +public partial class List : global::LionWeb.Core.ConceptInstanceBase +{ + public List(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.List; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LiteralsLazy")] +public partial class LiteralsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public LiteralsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LiteralsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-M2")] +public partial class M2 : global::LionWeb.Core.ConceptInstanceBase +{ + public M2(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.M2; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-M3")] +public partial class M3 : global::LionWeb.Core.ConceptInstanceBase +{ + public M3(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.M3; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-MemberwiseClone")] +public partial class MemberwiseClone : global::LionWeb.Core.ConceptInstanceBase +{ + public MemberwiseClone(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.MemberwiseClone_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Multiple")] +public partial class Multiple : global::LionWeb.Core.ConceptInstanceBase +{ + public Multiple(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Multiple; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Name")] +public partial class Name : global::LionWeb.Core.ConceptInstanceBase +{ + public Name(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Name_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Notification")] +public partial class Notification : global::LionWeb.Core.ConceptInstanceBase +{ + public Notification(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Notification; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-NotNullWhenAttribute")] +public partial class NotNullWhenAttribute : global::LionWeb.Core.ConceptInstanceBase +{ + public NotNullWhenAttribute(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.NotNullWhenAttribute; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Optional")] +public partial class Optional : global::LionWeb.Core.ConceptInstanceBase +{ + public Optional(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Optional; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Partition")] +public partial class Partition : global::LionWeb.Core.ConceptInstanceBase +{ + public Partition(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Partition; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Pipe")] +public partial class Pipe : global::LionWeb.Core.ConceptInstanceBase +{ + public Pipe(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Pipe; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PrimitiveType")] +public partial class PrimitiveType : global::LionWeb.Core.ConceptInstanceBase +{ + public PrimitiveType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PrimitiveType; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PrimitiveTypeBase")] +public partial class PrimitiveTypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public PrimitiveTypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PrimitiveTypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Property")] +public partial class Property : global::LionWeb.Core.ConceptInstanceBase +{ + public Property(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Property; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PropertyBase")] +public partial class PropertyBase : global::LionWeb.Core.ConceptInstanceBase +{ + public PropertyBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PropertyBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Reference")] +public partial class Reference : global::LionWeb.Core.ConceptInstanceBase +{ + public Reference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Reference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceBase")] +public partial class ReferenceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceEquals")] +public partial class ReferenceEquals : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceEquals(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceEquals_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceRemover")] +public partial class ReferenceRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNonNullTarget")] +public partial class ReferenceTargetNonNullTarget : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNonNullTarget(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNonNullTarget; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNonNullTargets")] +public partial class ReferenceTargetNonNullTargets : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNonNullTargets(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNonNullTargets; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNullableTarget")] +public partial class ReferenceTargetNullableTarget : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNullableTarget(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNullableTarget; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNullableTargets")] +public partial class ReferenceTargetNullableTargets : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNullableTargets(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNullableTargets; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Remove")] +public partial class Remove : global::LionWeb.Core.ConceptInstanceBase +{ + public Remove(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Remove; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAll")] +public partial class RemoveAll : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAll(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAll; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAnnotations")] +public partial class RemoveAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAnnotationsRaw")] +public partial class RemoveAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveChildRaw")] +public partial class RemoveChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveContainmentsRaw")] +public partial class RemoveContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveInternal")] +public partial class RemoveInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveOptionalMultipleContainment")] +public partial class RemoveOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveOptionalMultipleReference")] +public partial class RemoveOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveReferencesRaw")] +public partial class RemoveReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveRequiredMultipleContainment")] +public partial class RemoveRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveRequiredMultipleReference")] +public partial class RemoveRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveSelfParent")] +public partial class RemoveSelfParent : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveSelfParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveSelfParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveSelfParentRaw")] +public partial class RemoveSelfParentRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveSelfParentRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveSelfParentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-result")] +public partial class result : global::LionWeb.Core.ConceptInstanceBase +{ + public result(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.result; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Set")] +public partial class Set : global::LionWeb.Core.ConceptInstanceBase +{ + public Set(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Set; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetContainmentRaw")] +public partial class SetContainmentRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetContainmentRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetContainmentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetInternal")] +public partial class SetInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetInternalAnnotation")] +public partial class SetInternalAnnotation : global::LionWeb.Core.ConceptInstanceBase +{ + public SetInternalAnnotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetInternalAnnotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetName")] +public partial class SetName : global::LionWeb.Core.ConceptInstanceBase +{ + public SetName(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetName; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetNameRaw")] +public partial class SetNameRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetNameRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetNameRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalMultipleContainment")] +public partial class SetOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalMultipleReference")] +public partial class SetOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalReferenceTypeProperty")] +public partial class SetOptionalReferenceTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalReferenceTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalReferenceTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalSingleContainment")] +public partial class SetOptionalSingleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalSingleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalSingleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalSingleReference")] +public partial class SetOptionalSingleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalSingleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalSingleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalValueTypeProperty")] +public partial class SetOptionalValueTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalValueTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalValueTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetParentInternal")] +public partial class SetParentInternal : global::LionWeb.Core.ConceptInstanceBase +{ + public SetParentInternal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetParentInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetParentNull")] +public partial class SetParentNull : global::LionWeb.Core.ConceptInstanceBase +{ + public SetParentNull(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetParentNull; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetPropertyRaw")] +public partial class SetPropertyRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetPropertyRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetPropertyRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRaw")] +public partial class SetRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetReferenceRaw")] +public partial class SetReferenceRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetReferenceRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetReferenceRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetReferencesRaw")] +public partial class SetReferencesRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetReferencesRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredMultipleContainment")] +public partial class SetRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredMultipleReference")] +public partial class SetRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredReferenceTypeProperty")] +public partial class SetRequiredReferenceTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredReferenceTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredReferenceTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredSingleContainment")] +public partial class SetRequiredSingleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredSingleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredSingleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredSingleReference")] +public partial class SetRequiredSingleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredSingleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredSingleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredValueTypeProperty")] +public partial class SetRequiredValueTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredValueTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredValueTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetSelfParent")] +public partial class SetSelfParent : global::LionWeb.Core.ConceptInstanceBase +{ + public SetSelfParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetSelfParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetSelfParentRaw")] +public partial class SetSelfParentRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetSelfParentRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetSelfParentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-String")] +public partial class String : global::LionWeb.Core.ConceptInstanceBase +{ + public String(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.String; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-StructuredDataType")] +public partial class StructuredDataType : global::LionWeb.Core.ConceptInstanceBase +{ + public StructuredDataType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.StructuredDataType; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-StructuredDataTypeBase")] +public partial class StructuredDataTypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public StructuredDataTypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.StructuredDataTypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-System")] +public partial class System : global::LionWeb.Core.ConceptInstanceBase +{ + public System(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.System; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ToString")] +public partial class ToString : global::LionWeb.Core.ConceptInstanceBase +{ + public ToString(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ToString_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGet")] +public partial class TryGet_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGet_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGet_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetContainmentRaw")] +public partial class TryGetContainmentRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetContainmentRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetContainmentRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetContainmentsRaw")] +public partial class TryGetContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetContainmentsRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetName")] +public partial class TryGetName : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetName(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetName_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetPropertyRaw")] +public partial class TryGetPropertyRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetPropertyRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetPropertyRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReference")] +public partial class TryGetReference : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReferenceRaw")] +public partial class TryGetReferenceRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReferenceRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReferenceRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReferencesRaw")] +public partial class TryGetReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReferencesRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Type")] +public partial class Type : global::LionWeb.Core.ConceptInstanceBase +{ + public Type(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Type; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsetFeatureException")] +public partial class UnsetFeatureException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsetFeatureException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsetFeatureException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsetFieldException")] +public partial class UnsetFieldException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsetFieldException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsetFieldException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedClassifierException")] +public partial class UnsupportedClassifierException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedClassifierException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedClassifierException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedEnumerationLiteralException")] +public partial class UnsupportedEnumerationLiteralException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedEnumerationLiteralException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedEnumerationLiteralException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedStructuredDataTypeException")] +public partial class UnsupportedStructuredDataTypeException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedStructuredDataTypeException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedStructuredDataTypeException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Utilities")] +public partial class Utilities : global::LionWeb.Core.ConceptInstanceBase +{ + public Utilities(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Utilities; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2023_1")] +public partial class V2023_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2023_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2023_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2024_1")] +public partial class V2024_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2024_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2024_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2024_1_Compatible")] +public partial class V2024_1_Compatible : global::LionWeb.Core.ConceptInstanceBase +{ + public V2024_1_Compatible(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2024_1_Compatible; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2025_1")] +public partial class V2025_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2025_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2025_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2025_1_Compatible")] +public partial class V2025_1_Compatible : global::LionWeb.Core.ConceptInstanceBase +{ + public V2025_1_Compatible(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2025_1_Compatible; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-VersionSpecific")] +public partial class VersionSpecific : global::LionWeb.Core.ConceptInstanceBase +{ + public VersionSpecific(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.VersionSpecific; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/LanguageWithLionWebNamedConcepts.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/LanguageWithLionWebNamedConcepts.g.cs new file mode 100644 index 000000000..df38e2c8f --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/LanguageWithLionWebNamedConcepts.g.cs @@ -0,0 +1,4649 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Core.Test.Languages.Generated.V2025_1.LanguageWithLionWebNamedConcepts; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; + +[global::LionWeb.Core.M2.LionCoreLanguage(Key = "key-LanguageWithLionWebNamedConcepts", Version = "1")] +public partial class LanguageWithLionWebNamedConceptsLanguage : LanguageBase +{ + public static readonly LanguageWithLionWebNamedConceptsLanguage Instance = new Lazy(() => new("id-LanguageWithLionWebNamedConcepts-lang")).Value; + public LanguageWithLionWebNamedConceptsLanguage(string id) : base(id, global::LionWeb.Core.LionWebVersions.v2025_1) + { + __builtIns = new(() => new ConceptBase("id-_builtIns", this) { Key = "key-_builtIns", Name = "_builtIns", Abstract = false, Partition = false }); + _abstract = new(() => new ConceptBase("id-Abstract", this) { Key = "key-Abstract", Name = "Abstract", Abstract = false, Partition = false }); + _abstractBaseNodeFactory = new(() => new ConceptBase("id-AbstractBaseNodeFactory", this) { Key = "key-AbstractBaseNodeFactory", Name = "AbstractBaseNodeFactory", Abstract = false, Partition = false }); + _add = new(() => new ConceptBase("id-Add", this) { Key = "key-Add", Name = "Add", Abstract = false, Partition = false }); + _addAnnotations = new(() => new ConceptBase("id-AddAnnotations", this) { Key = "key-AddAnnotations", Name = "AddAnnotations", Abstract = false, Partition = false }); + _addAnnotationsRaw = new(() => new ConceptBase("id-AddAnnotationsRaw", this) { Key = "key-AddAnnotationsRaw", Name = "AddAnnotationsRaw", Abstract = false, Partition = false }); + _addChildRaw = new(() => new ConceptBase("id-AddChildRaw", this) { Key = "key-AddChildRaw", Name = "AddChildRaw", Abstract = false, Partition = false }); + _addContainmentsRaw = new(() => new ConceptBase("id-AddContainmentsRaw", this) { Key = "key-AddContainmentsRaw", Name = "AddContainmentsRaw", Abstract = false, Partition = false }); + _addInternal = new(() => new ConceptBase("id-AddInternal", this) { Key = "key-AddInternal", Name = "AddInternal", Abstract = false, Partition = false }); + _addOptionalMultipleContainment = new(() => new ConceptBase("id-AddOptionalMultipleContainment", this) { Key = "key-AddOptionalMultipleContainment", Name = "AddOptionalMultipleContainment", Abstract = false, Partition = false }); + _addOptionalMultipleReference = new(() => new ConceptBase("id-AddOptionalMultipleReference", this) { Key = "key-AddOptionalMultipleReference", Name = "AddOptionalMultipleReference", Abstract = false, Partition = false }); + _addReferencesRaw = new(() => new ConceptBase("id-AddReferencesRaw", this) { Key = "key-AddReferencesRaw", Name = "AddReferencesRaw", Abstract = false, Partition = false }); + _addRequiredMultipleContainment = new(() => new ConceptBase("id-AddRequiredMultipleContainment", this) { Key = "key-AddRequiredMultipleContainment", Name = "AddRequiredMultipleContainment", Abstract = false, Partition = false }); + _addRequiredMultipleReference = new(() => new ConceptBase("id-AddRequiredMultipleReference", this) { Key = "key-AddRequiredMultipleReference", Name = "AddRequiredMultipleReference", Abstract = false, Partition = false }); + _annotatesLazy = new(() => new ConceptBase("id-AnnotatesLazy", this) { Key = "key-AnnotatesLazy", Name = "AnnotatesLazy", Abstract = false, Partition = false }); + _annotation = new(() => new ConceptBase("id-Annotation", this) { Key = "key-Annotation", Name = "Annotation", Abstract = false, Partition = false }); + _annotationBase = new(() => new ConceptBase("id-AnnotationBase", this) { Key = "key-AnnotationBase", Name = "AnnotationBase", Abstract = false, Partition = false }); + _annotationInstanceBase = new(() => new ConceptBase("id-AnnotationInstanceBase", this) { Key = "key-AnnotationInstanceBase", Name = "AnnotationInstanceBase", Abstract = false, Partition = false }); + _annotationRemover = new(() => new ConceptBase("id-AnnotationRemover", this) { Key = "key-AnnotationRemover", Name = "AnnotationRemover", Abstract = false, Partition = false }); + _argumentOutOfRangeException = new(() => new ConceptBase("id-ArgumentOutOfRangeException", this) { Key = "key-ArgumentOutOfRangeException", Name = "ArgumentOutOfRangeException", Abstract = false, Partition = false }); + _asList = new(() => new ConceptBase("id-AsList", this) { Key = "key-AsList", Name = "AsList", Abstract = false, Partition = false }); + _asNonEmptyReadOnly = new(() => new ConceptBase("id-AsNonEmptyReadOnly", this) { Key = "key-AsNonEmptyReadOnly", Name = "AsNonEmptyReadOnly", Abstract = false, Partition = false }); + _assureAnnotations = new(() => new ConceptBase("id-AssureAnnotations", this) { Key = "key-AssureAnnotations", Name = "AssureAnnotations", Abstract = false, Partition = false }); + _assureInRange = new(() => new ConceptBase("id-AssureInRange", this) { Key = "key-AssureInRange", Name = "AssureInRange", Abstract = false, Partition = false }); + _assureNonEmpty = new(() => new ConceptBase("id-AssureNonEmpty", this) { Key = "key-AssureNonEmpty", Name = "AssureNonEmpty", Abstract = false, Partition = false }); + _assureNoSelfMove = new(() => new ConceptBase("id-AssureNoSelfMove", this) { Key = "key-AssureNoSelfMove", Name = "AssureNoSelfMove", Abstract = false, Partition = false }); + _assureNotClearing = new(() => new ConceptBase("id-AssureNotClearing", this) { Key = "key-AssureNotClearing", Name = "AssureNotClearing", Abstract = false, Partition = false }); + _assureNotNull = new(() => new ConceptBase("id-AssureNotNull", this) { Key = "key-AssureNotNull", Name = "AssureNotNull", Abstract = false, Partition = false }); + _assureNotNullInstance = new(() => new ConceptBase("id-AssureNotNullInstance", this) { Key = "key-AssureNotNullInstance", Name = "AssureNotNullInstance", Abstract = false, Partition = false }); + _assureNotNullMembers = new(() => new ConceptBase("id-AssureNotNullMembers", this) { Key = "key-AssureNotNullMembers", Name = "AssureNotNullMembers", Abstract = false, Partition = false }); + _assureNullableInstance = new(() => new ConceptBase("id-AssureNullableInstance", this) { Key = "key-AssureNullableInstance", Name = "AssureNullableInstance", Abstract = false, Partition = false }); + _attachChild = new(() => new ConceptBase("id-AttachChild", this) { Key = "key-AttachChild", Name = "AttachChild", Abstract = false, Partition = false }); + _bool = new(() => new ConceptBase("id-Bool", this) { Key = "key-Bool", Name = "Bool", Abstract = false, Partition = false }); + _boolean = new(() => new ConceptBase("id-Boolean", this) { Key = "key-Boolean", Name = "Boolean", Abstract = false, Partition = false }); + _char = new(() => new ConceptBase("id-Char", this) { Key = "key-Char", Name = "Char", Abstract = false, Partition = false }); + _character = new(() => new ConceptBase("id-Character", this) { Key = "key-Character", Name = "Character", Abstract = false, Partition = false }); + _classifier = new(() => new ConceptBase("id-Classifier", this) { Key = "key-Classifier", Name = "Classifier", Abstract = false, Partition = false }); + _codeAnalysis = new(() => new ConceptBase("id-CodeAnalysis", this) { Key = "key-CodeAnalysis", Name = "CodeAnalysis", Abstract = false, Partition = false }); + _collectAllSetFeatures = new(() => new ConceptBase("id-CollectAllSetFeatures", this) { Key = "key-CollectAllSetFeatures", Name = "CollectAllSetFeatures", Abstract = false, Partition = false }); + _collections = new(() => new ConceptBase("id-Collections", this) { Key = "key-Collections", Name = "Collections", Abstract = false, Partition = false }); + _concept = new(() => new ConceptBase("id-Concept", this) { Key = "key-Concept", Name = "Concept", Abstract = false, Partition = false }); + _conceptBase = new(() => new ConceptBase("id-ConceptBase", this) { Key = "key-ConceptBase", Name = "ConceptBase", Abstract = false, Partition = false }); + _conceptInstanceBase = new(() => new ConceptBase("id-ConceptInstanceBase", this) { Key = "key-ConceptInstanceBase", Name = "ConceptInstanceBase", Abstract = false, Partition = false }); + _containment = new(() => new ConceptBase("id-Containment", this) { Key = "key-Containment", Name = "Containment", Abstract = false, Partition = false }); + _containmentBase = new(() => new ConceptBase("id-ContainmentBase", this) { Key = "key-ContainmentBase", Name = "ContainmentBase", Abstract = false, Partition = false }); + _containmentRemover = new(() => new ConceptBase("id-ContainmentRemover", this) { Key = "key-ContainmentRemover", Name = "ContainmentRemover", Abstract = false, Partition = false }); + _core = new(() => new ConceptBase("id-Core", this) { Key = "key-Core", Name = "Core", Abstract = false, Partition = false }); + _datatype = new(() => new ConceptBase("id-Datatype", this) { Key = "key-Datatype", Name = "Datatype", Abstract = false, Partition = false }); + _datatypeBase = new(() => new ConceptBase("id-DatatypeBase", this) { Key = "key-DatatypeBase", Name = "DatatypeBase", Abstract = false, Partition = false }); + _decimal = new(() => new ConceptBase("id-Decimal", this) { Key = "key-Decimal", Name = "Decimal", Abstract = false, Partition = false }); + _detachChild = new(() => new ConceptBase("id-DetachChild", this) { Key = "key-DetachChild", Name = "DetachChild", Abstract = false, Partition = false }); + _detachChildInternal = new(() => new ConceptBase("id-DetachChildInternal", this) { Key = "key-DetachChildInternal", Name = "DetachChildInternal", Abstract = false, Partition = false }); + _detachFromParent = new(() => new ConceptBase("id-DetachFromParent", this) { Key = "key-DetachFromParent", Name = "DetachFromParent", Abstract = false, Partition = false }); + _diagnostics = new(() => new ConceptBase("id-Diagnostics", this) { Key = "key-Diagnostics", Name = "Diagnostics", Abstract = false, Partition = false }); + _enum = new(() => new ConceptBase("id-Enum", this) { Key = "key-Enum", Name = "Enum", Abstract = false, Partition = false }); + _enumeration = new(() => new ConceptBase("id-Enumeration", this) { Key = "key-Enumeration", Name = "Enumeration", Abstract = false, Partition = false }); + _enumerationBase = new(() => new ConceptBase("id-EnumerationBase", this) { Key = "key-EnumerationBase", Name = "EnumerationBase", Abstract = false, Partition = false }); + _enumerationLiteral = new(() => new ConceptBase("id-EnumerationLiteral", this) { Key = "key-EnumerationLiteral", Name = "EnumerationLiteral", Abstract = false, Partition = false }); + _enumerationLiteralBase = new(() => new ConceptBase("id-EnumerationLiteralBase", this) { Key = "key-EnumerationLiteralBase", Name = "EnumerationLiteralBase", Abstract = false, Partition = false }); + _equals = new(() => new ConceptBase("id-Equals", this) { Key = "key-Equals", Name = "Equals", Abstract = false, Partition = false }); + _exchangeChildRaw = new(() => new ConceptBase("id-ExchangeChildRaw", this) { Key = "key-ExchangeChildRaw", Name = "ExchangeChildRaw", Abstract = false, Partition = false }); + _exchangeChildrenRaw = new(() => new ConceptBase("id-ExchangeChildrenRaw", this) { Key = "key-ExchangeChildrenRaw", Name = "ExchangeChildrenRaw", Abstract = false, Partition = false }); + _featuresLazy = new(() => new ConceptBase("id-FeaturesLazy", this) { Key = "key-FeaturesLazy", Name = "FeaturesLazy", Abstract = false, Partition = false }); + _field = new(() => new ConceptBase("id-Field", this) { Key = "key-Field", Name = "Field", Abstract = false, Partition = false }); + _fieldBase = new(() => new ConceptBase("id-FieldBase", this) { Key = "key-FieldBase", Name = "FieldBase", Abstract = false, Partition = false }); + _fieldsLazy = new(() => new ConceptBase("id-FieldsLazy", this) { Key = "key-FieldsLazy", Name = "FieldsLazy", Abstract = false, Partition = false }); + _finalize = new(() => new ConceptBase("id-Finalize", this) { Key = "key-Finalize", Name = "Finalize", Abstract = false, Partition = false }); + _generic = new(() => new ConceptBase("id-Generic", this) { Key = "key-Generic", Name = "Generic", Abstract = false, Partition = false }); + _get = new(() => new ConceptBase("id-Get", this) { Key = "key-Get", Name = "Get", Abstract = false, Partition = false }); + _get__builtIns = new(() => new ConceptBase("id-get__builtIns", this) { Key = "key-get__builtIns", Name = "get__builtIns", Abstract = false, Partition = false }); + _get__m3 = new(() => new ConceptBase("id-get__m3", this) { Key = "key-get__m3", Name = "get__m3", Abstract = false, Partition = false }); + _getAnnotation = new(() => new ConceptBase("id-GetAnnotation", this) { Key = "key-GetAnnotation", Name = "GetAnnotation", Abstract = false, Partition = false }); + _getAnnotations = new(() => new ConceptBase("id-GetAnnotations", this) { Key = "key-GetAnnotations", Name = "GetAnnotations", Abstract = false, Partition = false }); + _getAnnotationsRaw = new(() => new ConceptBase("id-GetAnnotationsRaw", this) { Key = "key-GetAnnotationsRaw", Name = "GetAnnotationsRaw", Abstract = false, Partition = false }); + _getClassifier = new(() => new ConceptBase("id-GetClassifier", this) { Key = "key-GetClassifier", Name = "GetClassifier", Abstract = false, Partition = false }); + _getConcept = new(() => new ConceptBase("id-GetConcept", this) { Key = "key-GetConcept", Name = "GetConcept", Abstract = false, Partition = false }); + _getContainmentOf = new(() => new ConceptBase("id-GetContainmentOf", this) { Key = "key-GetContainmentOf", Name = "GetContainmentOf", Abstract = false, Partition = false }); + _getHashCode = new(() => new ConceptBase("id-GetHashCode", this) { Key = "key-GetHashCode", Name = "GetHashCode", Abstract = false, Partition = false }); + _getId = new(() => new ConceptBase("id-GetId", this) { Key = "key-GetId", Name = "GetId", Abstract = false, Partition = false }); + _getInternal = new(() => new ConceptBase("id-GetInternal", this) { Key = "key-GetInternal", Name = "GetInternal", Abstract = false, Partition = false }); + _getParent = new(() => new ConceptBase("id-GetParent", this) { Key = "key-GetParent", Name = "GetParent", Abstract = false, Partition = false }); + _getPartitionNotificationProducer = new(() => new ConceptBase("id-GetPartitionNotificationProducer", this) { Key = "key-GetPartitionNotificationProducer", Name = "GetPartitionNotificationProducer", Abstract = false, Partition = false }); + _getRequiredNonNullReferences = new(() => new ConceptBase("id-GetRequiredNonNullReferences", this) { Key = "key-GetRequiredNonNullReferences", Name = "GetRequiredNonNullReferences", Abstract = false, Partition = false }); + _getRequiredNullableReferences = new(() => new ConceptBase("id-GetRequiredNullableReferences", this) { Key = "key-GetRequiredNullableReferences", Name = "GetRequiredNullableReferences", Abstract = false, Partition = false }); + _getRequiredReference = new(() => new ConceptBase("id-GetRequiredReference", this) { Key = "key-GetRequiredReference", Name = "GetRequiredReference", Abstract = false, Partition = false }); + _getType = new(() => new ConceptBase("id-GetType", this) { Key = "key-GetType", Name = "GetType", Abstract = false, Partition = false }); + _iEnumerable = new(() => new ConceptBase("id-IEnumerable", this) { Key = "key-IEnumerable", Name = "IEnumerable", Abstract = false, Partition = false }); + _iFieldValues = new(() => new ConceptBase("id-IFieldValues", this) { Key = "key-IFieldValues", Name = "IFieldValues", Abstract = false, Partition = false }); + _implementsLazy = new(() => new ConceptBase("id-ImplementsLazy", this) { Key = "key-ImplementsLazy", Name = "ImplementsLazy", Abstract = false, Partition = false }); + _iNamed = new(() => new ConceptBase("id-INamed", this) { Key = "key-INamed", Name = "INamed", Abstract = false, Partition = false }); + _iNamedWritable = new(() => new ConceptBase("id-INamedWritable", this) { Key = "key-INamedWritable", Name = "INamedWritable", Abstract = false, Partition = false }); + _iNode = new(() => new ConceptBase("id-INode", this) { Key = "key-INode", Name = "INode", Abstract = false, Partition = false }); + _iNodeFactory = new(() => new ConceptBase("id-INodeFactory", this) { Key = "key-INodeFactory", Name = "INodeFactory", Abstract = false, Partition = false }); + _insert = new(() => new ConceptBase("id-Insert", this) { Key = "key-Insert", Name = "Insert", Abstract = false, Partition = false }); + _insertAnnotations = new(() => new ConceptBase("id-InsertAnnotations", this) { Key = "key-InsertAnnotations", Name = "InsertAnnotations", Abstract = false, Partition = false }); + _insertAnnotationsRaw = new(() => new ConceptBase("id-InsertAnnotationsRaw", this) { Key = "key-InsertAnnotationsRaw", Name = "InsertAnnotationsRaw", Abstract = false, Partition = false }); + _insertChildRaw = new(() => new ConceptBase("id-InsertChildRaw", this) { Key = "key-InsertChildRaw", Name = "InsertChildRaw", Abstract = false, Partition = false }); + _insertContainmentsRaw = new(() => new ConceptBase("id-InsertContainmentsRaw", this) { Key = "key-InsertContainmentsRaw", Name = "InsertContainmentsRaw", Abstract = false, Partition = false }); + _insertInternal = new(() => new ConceptBase("id-InsertInternal", this) { Key = "key-InsertInternal", Name = "InsertInternal", Abstract = false, Partition = false }); + _insertOptionalMultipleContainment = new(() => new ConceptBase("id-InsertOptionalMultipleContainment", this) { Key = "key-InsertOptionalMultipleContainment", Name = "InsertOptionalMultipleContainment", Abstract = false, Partition = false }); + _insertOptionalMultipleReference = new(() => new ConceptBase("id-InsertOptionalMultipleReference", this) { Key = "key-InsertOptionalMultipleReference", Name = "InsertOptionalMultipleReference", Abstract = false, Partition = false }); + _insertReferencesRaw = new(() => new ConceptBase("id-InsertReferencesRaw", this) { Key = "key-InsertReferencesRaw", Name = "InsertReferencesRaw", Abstract = false, Partition = false }); + _insertRequiredMultipleContainment = new(() => new ConceptBase("id-InsertRequiredMultipleContainment", this) { Key = "key-InsertRequiredMultipleContainment", Name = "InsertRequiredMultipleContainment", Abstract = false, Partition = false }); + _insertRequiredMultipleReference = new(() => new ConceptBase("id-InsertRequiredMultipleReference", this) { Key = "key-InsertRequiredMultipleReference", Name = "InsertRequiredMultipleReference", Abstract = false, Partition = false }); + _instance = new(() => new ConceptBase("id-Instance", this) { Key = "key-Instance", Name = "Instance", Abstract = false, Partition = false }); + _integer = new(() => new ConceptBase("id-Integer", this) { Key = "key-Integer", Name = "Integer", Abstract = false, Partition = false }); + _interface = new(() => new ConceptBase("id-Interface", this) { Key = "key-Interface", Name = "Interface", Abstract = false, Partition = false }); + _interfaceBase = new(() => new ConceptBase("id-InterfaceBase", this) { Key = "key-InterfaceBase", Name = "InterfaceBase", Abstract = false, Partition = false }); + _invalidValueException = new(() => new ConceptBase("id-InvalidValueException", this) { Key = "key-InvalidValueException", Name = "InvalidValueException", Abstract = false, Partition = false }); + _iPartitionInstance = new(() => new ConceptBase("id-IPartitionInstance", this) { Key = "key-IPartitionInstance", Name = "IPartitionInstance", Abstract = false, Partition = false }); + _iReadableNode = new(() => new ConceptBase("id-IReadableNode", this) { Key = "key-IReadableNode", Name = "IReadableNode", Abstract = false, Partition = false }); + _iReadOnlyList = new(() => new ConceptBase("id-IReadOnlyList", this) { Key = "key-IReadOnlyList", Name = "IReadOnlyList", Abstract = false, Partition = false }); + _isInRange = new(() => new ConceptBase("id-IsInRange", this) { Key = "key-IsInRange", Name = "IsInRange", Abstract = false, Partition = false }); + _iStructuredDataTypeInstance = new(() => new ConceptBase("id-IStructuredDataTypeInstance", this) { Key = "key-IStructuredDataTypeInstance", Name = "IStructuredDataTypeInstance", Abstract = false, Partition = false }); + _iWritableNode = new(() => new ConceptBase("id-IWritableNode", this) { Key = "key-IWritableNode", Name = "IWritableNode", Abstract = false, Partition = false }); + _key_ = new(() => new ConceptBase("id-Key", this) { Key = "key-Key", Name = "Key", Abstract = false, Partition = false }); + _language = new(() => new ConceptBase("id-Language", this) { Key = "key-Language", Name = "Language", Abstract = false, Partition = false }); + _languageBase = new(() => new ConceptBase("id-LanguageBase", this) { Key = "key-LanguageBase", Name = "LanguageBase", Abstract = false, Partition = false }); + _languageEntity = new(() => new ConceptBase("id-LanguageEntity", this) { Key = "key-LanguageEntity", Name = "LanguageEntity", Abstract = false, Partition = false }); + _lazy = new(() => new ConceptBase("id-Lazy", this) { Key = "key-Lazy", Name = "Lazy", Abstract = false, Partition = false }); + _link = new(() => new ConceptBase("id-Link", this) { Key = "key-Link", Name = "Link", Abstract = false, Partition = false }); + _lionCoreFeature = new(() => new ConceptBase("id-LionCoreFeature", this) { Key = "key-LionCoreFeature", Name = "LionCoreFeature", Abstract = false, Partition = false }); + _lionCoreFeatureKind = new(() => new ConceptBase("id-LionCoreFeatureKind", this) { Key = "key-LionCoreFeatureKind", Name = "LionCoreFeatureKind", Abstract = false, Partition = false }); + _lionCoreLanguage = new(() => new ConceptBase("id-LionCoreLanguage", this) { Key = "key-LionCoreLanguage", Name = "LionCoreLanguage", Abstract = false, Partition = false }); + _lionCoreMetaPointer = new(() => new ConceptBase("id-LionCoreMetaPointer", this) { Key = "key-LionCoreMetaPointer", Name = "LionCoreMetaPointer", Abstract = false, Partition = false }); + _lionWeb = new(() => new ConceptBase("id-LionWeb", this) { Key = "key-LionWeb", Name = "LionWeb", Abstract = false, Partition = false }); + _lionWebVersions = new(() => new ConceptBase("id-LionWebVersions", this) { Key = "key-LionWebVersions", Name = "LionWebVersions", Abstract = false, Partition = false }); + _list = new(() => new ConceptBase("id-List", this) { Key = "key-List", Name = "List", Abstract = false, Partition = false }); + _literalsLazy = new(() => new ConceptBase("id-LiteralsLazy", this) { Key = "key-LiteralsLazy", Name = "LiteralsLazy", Abstract = false, Partition = false }); + _m2 = new(() => new ConceptBase("id-M2", this) { Key = "key-M2", Name = "M2", Abstract = false, Partition = false }); + _m3_ = new(() => new ConceptBase("id-M3", this) { Key = "key-M3", Name = "M3", Abstract = false, Partition = false }); + _memberwiseClone = new(() => new ConceptBase("id-MemberwiseClone", this) { Key = "key-MemberwiseClone", Name = "MemberwiseClone", Abstract = false, Partition = false }); + _multiple = new(() => new ConceptBase("id-Multiple", this) { Key = "key-Multiple", Name = "Multiple", Abstract = false, Partition = false }); + _name_ = new(() => new ConceptBase("id-Name", this) { Key = "key-Name", Name = "Name", Abstract = false, Partition = false }); + _notification = new(() => new ConceptBase("id-Notification", this) { Key = "key-Notification", Name = "Notification", Abstract = false, Partition = false }); + _notNullWhenAttribute = new(() => new ConceptBase("id-NotNullWhenAttribute", this) { Key = "key-NotNullWhenAttribute", Name = "NotNullWhenAttribute", Abstract = false, Partition = false }); + _optional = new(() => new ConceptBase("id-Optional", this) { Key = "key-Optional", Name = "Optional", Abstract = false, Partition = false }); + _partition = new(() => new ConceptBase("id-Partition", this) { Key = "key-Partition", Name = "Partition", Abstract = false, Partition = false }); + _pipe = new(() => new ConceptBase("id-Pipe", this) { Key = "key-Pipe", Name = "Pipe", Abstract = false, Partition = false }); + _primitiveType = new(() => new ConceptBase("id-PrimitiveType", this) { Key = "key-PrimitiveType", Name = "PrimitiveType", Abstract = false, Partition = false }); + _primitiveTypeBase = new(() => new ConceptBase("id-PrimitiveTypeBase", this) { Key = "key-PrimitiveTypeBase", Name = "PrimitiveTypeBase", Abstract = false, Partition = false }); + _property = new(() => new ConceptBase("id-Property", this) { Key = "key-Property", Name = "Property", Abstract = false, Partition = false }); + _propertyBase = new(() => new ConceptBase("id-PropertyBase", this) { Key = "key-PropertyBase", Name = "PropertyBase", Abstract = false, Partition = false }); + _reference = new(() => new ConceptBase("id-Reference", this) { Key = "key-Reference", Name = "Reference", Abstract = false, Partition = false }); + _referenceBase = new(() => new ConceptBase("id-ReferenceBase", this) { Key = "key-ReferenceBase", Name = "ReferenceBase", Abstract = false, Partition = false }); + _referenceEquals = new(() => new ConceptBase("id-ReferenceEquals", this) { Key = "key-ReferenceEquals", Name = "ReferenceEquals", Abstract = false, Partition = false }); + _referenceRemover = new(() => new ConceptBase("id-ReferenceRemover", this) { Key = "key-ReferenceRemover", Name = "ReferenceRemover", Abstract = false, Partition = false }); + _referenceTargetNonNullTarget = new(() => new ConceptBase("id-ReferenceTargetNonNullTarget", this) { Key = "key-ReferenceTargetNonNullTarget", Name = "ReferenceTargetNonNullTarget", Abstract = false, Partition = false }); + _referenceTargetNonNullTargets = new(() => new ConceptBase("id-ReferenceTargetNonNullTargets", this) { Key = "key-ReferenceTargetNonNullTargets", Name = "ReferenceTargetNonNullTargets", Abstract = false, Partition = false }); + _referenceTargetNullableTarget = new(() => new ConceptBase("id-ReferenceTargetNullableTarget", this) { Key = "key-ReferenceTargetNullableTarget", Name = "ReferenceTargetNullableTarget", Abstract = false, Partition = false }); + _referenceTargetNullableTargets = new(() => new ConceptBase("id-ReferenceTargetNullableTargets", this) { Key = "key-ReferenceTargetNullableTargets", Name = "ReferenceTargetNullableTargets", Abstract = false, Partition = false }); + _remove = new(() => new ConceptBase("id-Remove", this) { Key = "key-Remove", Name = "Remove", Abstract = false, Partition = false }); + _removeAll = new(() => new ConceptBase("id-RemoveAll", this) { Key = "key-RemoveAll", Name = "RemoveAll", Abstract = false, Partition = false }); + _removeAnnotations = new(() => new ConceptBase("id-RemoveAnnotations", this) { Key = "key-RemoveAnnotations", Name = "RemoveAnnotations", Abstract = false, Partition = false }); + _removeAnnotationsRaw = new(() => new ConceptBase("id-RemoveAnnotationsRaw", this) { Key = "key-RemoveAnnotationsRaw", Name = "RemoveAnnotationsRaw", Abstract = false, Partition = false }); + _removeChildRaw = new(() => new ConceptBase("id-RemoveChildRaw", this) { Key = "key-RemoveChildRaw", Name = "RemoveChildRaw", Abstract = false, Partition = false }); + _removeContainmentsRaw = new(() => new ConceptBase("id-RemoveContainmentsRaw", this) { Key = "key-RemoveContainmentsRaw", Name = "RemoveContainmentsRaw", Abstract = false, Partition = false }); + _removeInternal = new(() => new ConceptBase("id-RemoveInternal", this) { Key = "key-RemoveInternal", Name = "RemoveInternal", Abstract = false, Partition = false }); + _removeOptionalMultipleContainment = new(() => new ConceptBase("id-RemoveOptionalMultipleContainment", this) { Key = "key-RemoveOptionalMultipleContainment", Name = "RemoveOptionalMultipleContainment", Abstract = false, Partition = false }); + _removeOptionalMultipleReference = new(() => new ConceptBase("id-RemoveOptionalMultipleReference", this) { Key = "key-RemoveOptionalMultipleReference", Name = "RemoveOptionalMultipleReference", Abstract = false, Partition = false }); + _removeReferencesRaw = new(() => new ConceptBase("id-RemoveReferencesRaw", this) { Key = "key-RemoveReferencesRaw", Name = "RemoveReferencesRaw", Abstract = false, Partition = false }); + _removeRequiredMultipleContainment = new(() => new ConceptBase("id-RemoveRequiredMultipleContainment", this) { Key = "key-RemoveRequiredMultipleContainment", Name = "RemoveRequiredMultipleContainment", Abstract = false, Partition = false }); + _removeRequiredMultipleReference = new(() => new ConceptBase("id-RemoveRequiredMultipleReference", this) { Key = "key-RemoveRequiredMultipleReference", Name = "RemoveRequiredMultipleReference", Abstract = false, Partition = false }); + _removeSelfParent = new(() => new ConceptBase("id-RemoveSelfParent", this) { Key = "key-RemoveSelfParent", Name = "RemoveSelfParent", Abstract = false, Partition = false }); + _removeSelfParentRaw = new(() => new ConceptBase("id-RemoveSelfParentRaw", this) { Key = "key-RemoveSelfParentRaw", Name = "RemoveSelfParentRaw", Abstract = false, Partition = false }); + _result = new(() => new ConceptBase("id-result", this) { Key = "key-result", Name = "result", Abstract = false, Partition = false }); + _set = new(() => new ConceptBase("id-Set", this) { Key = "key-Set", Name = "Set", Abstract = false, Partition = false }); + _setContainmentRaw = new(() => new ConceptBase("id-SetContainmentRaw", this) { Key = "key-SetContainmentRaw", Name = "SetContainmentRaw", Abstract = false, Partition = false }); + _setInternal = new(() => new ConceptBase("id-SetInternal", this) { Key = "key-SetInternal", Name = "SetInternal", Abstract = false, Partition = false }); + _setInternalAnnotation = new(() => new ConceptBase("id-SetInternalAnnotation", this) { Key = "key-SetInternalAnnotation", Name = "SetInternalAnnotation", Abstract = false, Partition = false }); + _setName = new(() => new ConceptBase("id-SetName", this) { Key = "key-SetName", Name = "SetName", Abstract = false, Partition = false }); + _setNameRaw = new(() => new ConceptBase("id-SetNameRaw", this) { Key = "key-SetNameRaw", Name = "SetNameRaw", Abstract = false, Partition = false }); + _setOptionalMultipleContainment = new(() => new ConceptBase("id-SetOptionalMultipleContainment", this) { Key = "key-SetOptionalMultipleContainment", Name = "SetOptionalMultipleContainment", Abstract = false, Partition = false }); + _setOptionalMultipleReference = new(() => new ConceptBase("id-SetOptionalMultipleReference", this) { Key = "key-SetOptionalMultipleReference", Name = "SetOptionalMultipleReference", Abstract = false, Partition = false }); + _setOptionalReferenceTypeProperty = new(() => new ConceptBase("id-SetOptionalReferenceTypeProperty", this) { Key = "key-SetOptionalReferenceTypeProperty", Name = "SetOptionalReferenceTypeProperty", Abstract = false, Partition = false }); + _setOptionalSingleContainment = new(() => new ConceptBase("id-SetOptionalSingleContainment", this) { Key = "key-SetOptionalSingleContainment", Name = "SetOptionalSingleContainment", Abstract = false, Partition = false }); + _setOptionalSingleReference = new(() => new ConceptBase("id-SetOptionalSingleReference", this) { Key = "key-SetOptionalSingleReference", Name = "SetOptionalSingleReference", Abstract = false, Partition = false }); + _setOptionalValueTypeProperty = new(() => new ConceptBase("id-SetOptionalValueTypeProperty", this) { Key = "key-SetOptionalValueTypeProperty", Name = "SetOptionalValueTypeProperty", Abstract = false, Partition = false }); + _setParentInternal = new(() => new ConceptBase("id-SetParentInternal", this) { Key = "key-SetParentInternal", Name = "SetParentInternal", Abstract = false, Partition = false }); + _setParentNull = new(() => new ConceptBase("id-SetParentNull", this) { Key = "key-SetParentNull", Name = "SetParentNull", Abstract = false, Partition = false }); + _setPropertyRaw = new(() => new ConceptBase("id-SetPropertyRaw", this) { Key = "key-SetPropertyRaw", Name = "SetPropertyRaw", Abstract = false, Partition = false }); + _setRaw = new(() => new ConceptBase("id-SetRaw", this) { Key = "key-SetRaw", Name = "SetRaw", Abstract = false, Partition = false }); + _setReferenceRaw = new(() => new ConceptBase("id-SetReferenceRaw", this) { Key = "key-SetReferenceRaw", Name = "SetReferenceRaw", Abstract = false, Partition = false }); + _setReferencesRaw = new(() => new ConceptBase("id-SetReferencesRaw", this) { Key = "key-SetReferencesRaw", Name = "SetReferencesRaw", Abstract = false, Partition = false }); + _setRequiredMultipleContainment = new(() => new ConceptBase("id-SetRequiredMultipleContainment", this) { Key = "key-SetRequiredMultipleContainment", Name = "SetRequiredMultipleContainment", Abstract = false, Partition = false }); + _setRequiredMultipleReference = new(() => new ConceptBase("id-SetRequiredMultipleReference", this) { Key = "key-SetRequiredMultipleReference", Name = "SetRequiredMultipleReference", Abstract = false, Partition = false }); + _setRequiredReferenceTypeProperty = new(() => new ConceptBase("id-SetRequiredReferenceTypeProperty", this) { Key = "key-SetRequiredReferenceTypeProperty", Name = "SetRequiredReferenceTypeProperty", Abstract = false, Partition = false }); + _setRequiredSingleContainment = new(() => new ConceptBase("id-SetRequiredSingleContainment", this) { Key = "key-SetRequiredSingleContainment", Name = "SetRequiredSingleContainment", Abstract = false, Partition = false }); + _setRequiredSingleReference = new(() => new ConceptBase("id-SetRequiredSingleReference", this) { Key = "key-SetRequiredSingleReference", Name = "SetRequiredSingleReference", Abstract = false, Partition = false }); + _setRequiredValueTypeProperty = new(() => new ConceptBase("id-SetRequiredValueTypeProperty", this) { Key = "key-SetRequiredValueTypeProperty", Name = "SetRequiredValueTypeProperty", Abstract = false, Partition = false }); + _setSelfParent = new(() => new ConceptBase("id-SetSelfParent", this) { Key = "key-SetSelfParent", Name = "SetSelfParent", Abstract = false, Partition = false }); + _setSelfParentRaw = new(() => new ConceptBase("id-SetSelfParentRaw", this) { Key = "key-SetSelfParentRaw", Name = "SetSelfParentRaw", Abstract = false, Partition = false }); + _string = new(() => new ConceptBase("id-String", this) { Key = "key-String", Name = "String", Abstract = false, Partition = false }); + _structuredDataType = new(() => new ConceptBase("id-StructuredDataType", this) { Key = "key-StructuredDataType", Name = "StructuredDataType", Abstract = false, Partition = false }); + _structuredDataTypeBase = new(() => new ConceptBase("id-StructuredDataTypeBase", this) { Key = "key-StructuredDataTypeBase", Name = "StructuredDataTypeBase", Abstract = false, Partition = false }); + _system = new(() => new ConceptBase("id-System", this) { Key = "key-System", Name = "System", Abstract = false, Partition = false }); + _toString = new(() => new ConceptBase("id-ToString", this) { Key = "key-ToString", Name = "ToString", Abstract = false, Partition = false }); + _tryGet = new(() => new ConceptBase("id-TryGet", this) { Key = "key-TryGet", Name = "TryGet", Abstract = false, Partition = false }); + _tryGetContainmentRaw = new(() => new ConceptBase("id-TryGetContainmentRaw", this) { Key = "key-TryGetContainmentRaw", Name = "TryGetContainmentRaw", Abstract = false, Partition = false }); + _tryGetContainmentsRaw = new(() => new ConceptBase("id-TryGetContainmentsRaw", this) { Key = "key-TryGetContainmentsRaw", Name = "TryGetContainmentsRaw", Abstract = false, Partition = false }); + _tryGetName = new(() => new ConceptBase("id-TryGetName", this) { Key = "key-TryGetName", Name = "TryGetName", Abstract = false, Partition = false }); + _tryGetPropertyRaw = new(() => new ConceptBase("id-TryGetPropertyRaw", this) { Key = "key-TryGetPropertyRaw", Name = "TryGetPropertyRaw", Abstract = false, Partition = false }); + _tryGetReference = new(() => new ConceptBase("id-TryGetReference", this) { Key = "key-TryGetReference", Name = "TryGetReference", Abstract = false, Partition = false }); + _tryGetReferenceRaw = new(() => new ConceptBase("id-TryGetReferenceRaw", this) { Key = "key-TryGetReferenceRaw", Name = "TryGetReferenceRaw", Abstract = false, Partition = false }); + _tryGetReferencesRaw = new(() => new ConceptBase("id-TryGetReferencesRaw", this) { Key = "key-TryGetReferencesRaw", Name = "TryGetReferencesRaw", Abstract = false, Partition = false }); + _type = new(() => new ConceptBase("id-Type", this) { Key = "key-Type", Name = "Type", Abstract = false, Partition = false }); + _unsetFeatureException = new(() => new ConceptBase("id-UnsetFeatureException", this) { Key = "key-UnsetFeatureException", Name = "UnsetFeatureException", Abstract = false, Partition = false }); + _unsetFieldException = new(() => new ConceptBase("id-UnsetFieldException", this) { Key = "key-UnsetFieldException", Name = "UnsetFieldException", Abstract = false, Partition = false }); + _unsupportedClassifierException = new(() => new ConceptBase("id-UnsupportedClassifierException", this) { Key = "key-UnsupportedClassifierException", Name = "UnsupportedClassifierException", Abstract = false, Partition = false }); + _unsupportedEnumerationLiteralException = new(() => new ConceptBase("id-UnsupportedEnumerationLiteralException", this) { Key = "key-UnsupportedEnumerationLiteralException", Name = "UnsupportedEnumerationLiteralException", Abstract = false, Partition = false }); + _unsupportedStructuredDataTypeException = new(() => new ConceptBase("id-UnsupportedStructuredDataTypeException", this) { Key = "key-UnsupportedStructuredDataTypeException", Name = "UnsupportedStructuredDataTypeException", Abstract = false, Partition = false }); + _utilities = new(() => new ConceptBase("id-Utilities", this) { Key = "key-Utilities", Name = "Utilities", Abstract = false, Partition = false }); + _v2023_1 = new(() => new ConceptBase("id-V2023_1", this) { Key = "key-V2023_1", Name = "V2023_1", Abstract = false, Partition = false }); + _v2024_1 = new(() => new ConceptBase("id-V2024_1", this) { Key = "key-V2024_1", Name = "V2024_1", Abstract = false, Partition = false }); + _v2024_1_Compatible = new(() => new ConceptBase("id-V2024_1_Compatible", this) { Key = "key-V2024_1_Compatible", Name = "V2024_1_Compatible", Abstract = false, Partition = false }); + _v2025_1 = new(() => new ConceptBase("id-V2025_1", this) { Key = "key-V2025_1", Name = "V2025_1", Abstract = false, Partition = false }); + _v2025_1_Compatible = new(() => new ConceptBase("id-V2025_1_Compatible", this) { Key = "key-V2025_1_Compatible", Name = "V2025_1_Compatible", Abstract = false, Partition = false }); + _versionSpecific = new(() => new ConceptBase("id-VersionSpecific", this) { Key = "key-VersionSpecific", Name = "VersionSpecific", Abstract = false, Partition = false }); + _factory = new LanguageWithLionWebNamedConceptsFactory(this); + } + + /// + public override IReadOnlyList Entities => [_builtIns_, Abstract, AbstractBaseNodeFactory, Add, AddAnnotations, AddAnnotationsRaw, AddChildRaw, AddContainmentsRaw, AddInternal, AddOptionalMultipleContainment, AddOptionalMultipleReference, AddReferencesRaw, AddRequiredMultipleContainment, AddRequiredMultipleReference, AnnotatesLazy, Annotation, AnnotationBase, AnnotationInstanceBase, AnnotationRemover, ArgumentOutOfRangeException, AsList, AsNonEmptyReadOnly, AssureAnnotations, AssureInRange, AssureNonEmpty, AssureNoSelfMove, AssureNotClearing, AssureNotNull, AssureNotNullInstance, AssureNotNullMembers, AssureNullableInstance, AttachChild, Bool, Boolean, Char, Character, Classifier, CodeAnalysis, CollectAllSetFeatures_, Collections, Concept, ConceptBase, ConceptInstanceBase, Containment, ContainmentBase, ContainmentRemover, Core, Datatype, DatatypeBase, Decimal, DetachChild, DetachChildInternal, DetachFromParent, Diagnostics, Enum, Enumeration, EnumerationBase, EnumerationLiteral, EnumerationLiteralBase, Equals_, ExchangeChildRaw, ExchangeChildrenRaw, FeaturesLazy, Field, FieldBase, FieldsLazy, Finalize, Generic, Get_, get__builtIns, get__m3, GetAnnotation, GetAnnotations_, GetAnnotationsRaw_, GetClassifier_, GetConcept_, GetContainmentOf, GetHashCode_, GetId_, GetInternal, GetParent_, GetPartitionNotificationProducer, GetRequiredNonNullReferences, GetRequiredNullableReferences, GetRequiredReference, GetType_, IEnumerable, IFieldValues, ImplementsLazy, INamed, INamedWritable, INode, INodeFactory, Insert, InsertAnnotations, InsertAnnotationsRaw, InsertChildRaw, InsertContainmentsRaw, InsertInternal, InsertOptionalMultipleContainment, InsertOptionalMultipleReference, InsertReferencesRaw, InsertRequiredMultipleContainment, InsertRequiredMultipleReference, Instance_, Integer, Interface, InterfaceBase, InvalidValueException, IPartitionInstance, IReadableNode, IReadOnlyList, IsInRange, IStructuredDataTypeInstance, IWritableNode, Key_, Language, LanguageBase, LanguageEntity, Lazy, Link, LionCoreFeature, LionCoreFeatureKind, LionCoreLanguage, LionCoreMetaPointer, LionWeb, LionWebVersions, List, LiteralsLazy, M2, M3, MemberwiseClone_, Multiple, Name_, Notification, NotNullWhenAttribute, Optional, Partition, Pipe, PrimitiveType, PrimitiveTypeBase, Property, PropertyBase, Reference, ReferenceBase, ReferenceEquals_, ReferenceRemover, ReferenceTargetNonNullTarget, ReferenceTargetNonNullTargets, ReferenceTargetNullableTarget, ReferenceTargetNullableTargets, Remove, RemoveAll, RemoveAnnotations, RemoveAnnotationsRaw, RemoveChildRaw, RemoveContainmentsRaw, RemoveInternal, RemoveOptionalMultipleContainment, RemoveOptionalMultipleReference, RemoveReferencesRaw, RemoveRequiredMultipleContainment, RemoveRequiredMultipleReference, RemoveSelfParent, RemoveSelfParentRaw, result, Set, SetContainmentRaw, SetInternal, SetInternalAnnotation, SetName, SetNameRaw, SetOptionalMultipleContainment, SetOptionalMultipleReference, SetOptionalReferenceTypeProperty, SetOptionalSingleContainment, SetOptionalSingleReference, SetOptionalValueTypeProperty, SetParentInternal, SetParentNull, SetPropertyRaw, SetRaw, SetReferenceRaw, SetReferencesRaw, SetRequiredMultipleContainment, SetRequiredMultipleReference, SetRequiredReferenceTypeProperty, SetRequiredSingleContainment, SetRequiredSingleReference, SetRequiredValueTypeProperty, SetSelfParent, SetSelfParentRaw, String, StructuredDataType, StructuredDataTypeBase, System, ToString_, TryGet_, TryGetContainmentRaw_, TryGetContainmentsRaw_, TryGetName_, TryGetPropertyRaw_, TryGetReference, TryGetReferenceRaw_, TryGetReferencesRaw_, Type, UnsetFeatureException, UnsetFieldException, UnsupportedClassifierException, UnsupportedEnumerationLiteralException, UnsupportedStructuredDataTypeException, Utilities, V2023_1, V2024_1, V2024_1_Compatible, V2025_1, V2025_1_Compatible, VersionSpecific]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-LanguageWithLionWebNamedConcepts"; + /// + public override string Key => _key; + + private const string _name = "LanguageWithLionWebNamedConcepts"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy __builtIns; + public global::LionWeb.Core.M3.Concept _builtIns_ => __builtIns.Value; + + private readonly Lazy _abstract; + public global::LionWeb.Core.M3.Concept Abstract => _abstract.Value; + + private readonly Lazy _abstractBaseNodeFactory; + public global::LionWeb.Core.M3.Concept AbstractBaseNodeFactory => _abstractBaseNodeFactory.Value; + + private readonly Lazy _add; + public global::LionWeb.Core.M3.Concept Add => _add.Value; + + private readonly Lazy _addAnnotations; + public global::LionWeb.Core.M3.Concept AddAnnotations => _addAnnotations.Value; + + private readonly Lazy _addAnnotationsRaw; + public global::LionWeb.Core.M3.Concept AddAnnotationsRaw => _addAnnotationsRaw.Value; + + private readonly Lazy _addChildRaw; + public global::LionWeb.Core.M3.Concept AddChildRaw => _addChildRaw.Value; + + private readonly Lazy _addContainmentsRaw; + public global::LionWeb.Core.M3.Concept AddContainmentsRaw => _addContainmentsRaw.Value; + + private readonly Lazy _addInternal; + public global::LionWeb.Core.M3.Concept AddInternal => _addInternal.Value; + + private readonly Lazy _addOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept AddOptionalMultipleContainment => _addOptionalMultipleContainment.Value; + + private readonly Lazy _addOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept AddOptionalMultipleReference => _addOptionalMultipleReference.Value; + + private readonly Lazy _addReferencesRaw; + public global::LionWeb.Core.M3.Concept AddReferencesRaw => _addReferencesRaw.Value; + + private readonly Lazy _addRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept AddRequiredMultipleContainment => _addRequiredMultipleContainment.Value; + + private readonly Lazy _addRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept AddRequiredMultipleReference => _addRequiredMultipleReference.Value; + + private readonly Lazy _annotatesLazy; + public global::LionWeb.Core.M3.Concept AnnotatesLazy => _annotatesLazy.Value; + + private readonly Lazy _annotation; + public global::LionWeb.Core.M3.Concept Annotation => _annotation.Value; + + private readonly Lazy _annotationBase; + public global::LionWeb.Core.M3.Concept AnnotationBase => _annotationBase.Value; + + private readonly Lazy _annotationInstanceBase; + public global::LionWeb.Core.M3.Concept AnnotationInstanceBase => _annotationInstanceBase.Value; + + private readonly Lazy _annotationRemover; + public global::LionWeb.Core.M3.Concept AnnotationRemover => _annotationRemover.Value; + + private readonly Lazy _argumentOutOfRangeException; + public global::LionWeb.Core.M3.Concept ArgumentOutOfRangeException => _argumentOutOfRangeException.Value; + + private readonly Lazy _asList; + public global::LionWeb.Core.M3.Concept AsList => _asList.Value; + + private readonly Lazy _asNonEmptyReadOnly; + public global::LionWeb.Core.M3.Concept AsNonEmptyReadOnly => _asNonEmptyReadOnly.Value; + + private readonly Lazy _assureAnnotations; + public global::LionWeb.Core.M3.Concept AssureAnnotations => _assureAnnotations.Value; + + private readonly Lazy _assureInRange; + public global::LionWeb.Core.M3.Concept AssureInRange => _assureInRange.Value; + + private readonly Lazy _assureNonEmpty; + public global::LionWeb.Core.M3.Concept AssureNonEmpty => _assureNonEmpty.Value; + + private readonly Lazy _assureNoSelfMove; + public global::LionWeb.Core.M3.Concept AssureNoSelfMove => _assureNoSelfMove.Value; + + private readonly Lazy _assureNotClearing; + public global::LionWeb.Core.M3.Concept AssureNotClearing => _assureNotClearing.Value; + + private readonly Lazy _assureNotNull; + public global::LionWeb.Core.M3.Concept AssureNotNull => _assureNotNull.Value; + + private readonly Lazy _assureNotNullInstance; + public global::LionWeb.Core.M3.Concept AssureNotNullInstance => _assureNotNullInstance.Value; + + private readonly Lazy _assureNotNullMembers; + public global::LionWeb.Core.M3.Concept AssureNotNullMembers => _assureNotNullMembers.Value; + + private readonly Lazy _assureNullableInstance; + public global::LionWeb.Core.M3.Concept AssureNullableInstance => _assureNullableInstance.Value; + + private readonly Lazy _attachChild; + public global::LionWeb.Core.M3.Concept AttachChild => _attachChild.Value; + + private readonly Lazy _bool; + public global::LionWeb.Core.M3.Concept Bool => _bool.Value; + + private readonly Lazy _boolean; + public global::LionWeb.Core.M3.Concept Boolean => _boolean.Value; + + private readonly Lazy _char; + public global::LionWeb.Core.M3.Concept Char => _char.Value; + + private readonly Lazy _character; + public global::LionWeb.Core.M3.Concept Character => _character.Value; + + private readonly Lazy _classifier; + public global::LionWeb.Core.M3.Concept Classifier => _classifier.Value; + + private readonly Lazy _codeAnalysis; + public global::LionWeb.Core.M3.Concept CodeAnalysis => _codeAnalysis.Value; + + private readonly Lazy _collectAllSetFeatures; + public global::LionWeb.Core.M3.Concept CollectAllSetFeatures_ => _collectAllSetFeatures.Value; + + private readonly Lazy _collections; + public global::LionWeb.Core.M3.Concept Collections => _collections.Value; + + private readonly Lazy _concept; + public global::LionWeb.Core.M3.Concept Concept => _concept.Value; + + private readonly Lazy _conceptBase; + public global::LionWeb.Core.M3.Concept ConceptBase => _conceptBase.Value; + + private readonly Lazy _conceptInstanceBase; + public global::LionWeb.Core.M3.Concept ConceptInstanceBase => _conceptInstanceBase.Value; + + private readonly Lazy _containment; + public global::LionWeb.Core.M3.Concept Containment => _containment.Value; + + private readonly Lazy _containmentBase; + public global::LionWeb.Core.M3.Concept ContainmentBase => _containmentBase.Value; + + private readonly Lazy _containmentRemover; + public global::LionWeb.Core.M3.Concept ContainmentRemover => _containmentRemover.Value; + + private readonly Lazy _core; + public global::LionWeb.Core.M3.Concept Core => _core.Value; + + private readonly Lazy _datatype; + public global::LionWeb.Core.M3.Concept Datatype => _datatype.Value; + + private readonly Lazy _datatypeBase; + public global::LionWeb.Core.M3.Concept DatatypeBase => _datatypeBase.Value; + + private readonly Lazy _decimal; + public global::LionWeb.Core.M3.Concept Decimal => _decimal.Value; + + private readonly Lazy _detachChild; + public global::LionWeb.Core.M3.Concept DetachChild => _detachChild.Value; + + private readonly Lazy _detachChildInternal; + public global::LionWeb.Core.M3.Concept DetachChildInternal => _detachChildInternal.Value; + + private readonly Lazy _detachFromParent; + public global::LionWeb.Core.M3.Concept DetachFromParent => _detachFromParent.Value; + + private readonly Lazy _diagnostics; + public global::LionWeb.Core.M3.Concept Diagnostics => _diagnostics.Value; + + private readonly Lazy _enum; + public global::LionWeb.Core.M3.Concept Enum => _enum.Value; + + private readonly Lazy _enumeration; + public global::LionWeb.Core.M3.Concept Enumeration => _enumeration.Value; + + private readonly Lazy _enumerationBase; + public global::LionWeb.Core.M3.Concept EnumerationBase => _enumerationBase.Value; + + private readonly Lazy _enumerationLiteral; + public global::LionWeb.Core.M3.Concept EnumerationLiteral => _enumerationLiteral.Value; + + private readonly Lazy _enumerationLiteralBase; + public global::LionWeb.Core.M3.Concept EnumerationLiteralBase => _enumerationLiteralBase.Value; + + private readonly Lazy _equals; + public global::LionWeb.Core.M3.Concept Equals_ => _equals.Value; + + private readonly Lazy _exchangeChildRaw; + public global::LionWeb.Core.M3.Concept ExchangeChildRaw => _exchangeChildRaw.Value; + + private readonly Lazy _exchangeChildrenRaw; + public global::LionWeb.Core.M3.Concept ExchangeChildrenRaw => _exchangeChildrenRaw.Value; + + private readonly Lazy _featuresLazy; + public global::LionWeb.Core.M3.Concept FeaturesLazy => _featuresLazy.Value; + + private readonly Lazy _field; + public global::LionWeb.Core.M3.Concept Field => _field.Value; + + private readonly Lazy _fieldBase; + public global::LionWeb.Core.M3.Concept FieldBase => _fieldBase.Value; + + private readonly Lazy _fieldsLazy; + public global::LionWeb.Core.M3.Concept FieldsLazy => _fieldsLazy.Value; + + private readonly Lazy _finalize; + public global::LionWeb.Core.M3.Concept Finalize => _finalize.Value; + + private readonly Lazy _generic; + public global::LionWeb.Core.M3.Concept Generic => _generic.Value; + + private readonly Lazy _get; + public global::LionWeb.Core.M3.Concept Get_ => _get.Value; + + private readonly Lazy _get__builtIns; + public global::LionWeb.Core.M3.Concept get__builtIns => _get__builtIns.Value; + + private readonly Lazy _get__m3; + public global::LionWeb.Core.M3.Concept get__m3 => _get__m3.Value; + + private readonly Lazy _getAnnotation; + public global::LionWeb.Core.M3.Concept GetAnnotation => _getAnnotation.Value; + + private readonly Lazy _getAnnotations; + public global::LionWeb.Core.M3.Concept GetAnnotations_ => _getAnnotations.Value; + + private readonly Lazy _getAnnotationsRaw; + public global::LionWeb.Core.M3.Concept GetAnnotationsRaw_ => _getAnnotationsRaw.Value; + + private readonly Lazy _getClassifier; + public global::LionWeb.Core.M3.Concept GetClassifier_ => _getClassifier.Value; + + private readonly Lazy _getConcept; + public global::LionWeb.Core.M3.Concept GetConcept_ => _getConcept.Value; + + private readonly Lazy _getContainmentOf; + public global::LionWeb.Core.M3.Concept GetContainmentOf => _getContainmentOf.Value; + + private readonly Lazy _getHashCode; + public global::LionWeb.Core.M3.Concept GetHashCode_ => _getHashCode.Value; + + private readonly Lazy _getId; + public global::LionWeb.Core.M3.Concept GetId_ => _getId.Value; + + private readonly Lazy _getInternal; + public global::LionWeb.Core.M3.Concept GetInternal => _getInternal.Value; + + private readonly Lazy _getParent; + public global::LionWeb.Core.M3.Concept GetParent_ => _getParent.Value; + + private readonly Lazy _getPartitionNotificationProducer; + public global::LionWeb.Core.M3.Concept GetPartitionNotificationProducer => _getPartitionNotificationProducer.Value; + + private readonly Lazy _getRequiredNonNullReferences; + public global::LionWeb.Core.M3.Concept GetRequiredNonNullReferences => _getRequiredNonNullReferences.Value; + + private readonly Lazy _getRequiredNullableReferences; + public global::LionWeb.Core.M3.Concept GetRequiredNullableReferences => _getRequiredNullableReferences.Value; + + private readonly Lazy _getRequiredReference; + public global::LionWeb.Core.M3.Concept GetRequiredReference => _getRequiredReference.Value; + + private readonly Lazy _getType; + public global::LionWeb.Core.M3.Concept GetType_ => _getType.Value; + + private readonly Lazy _iEnumerable; + public global::LionWeb.Core.M3.Concept IEnumerable => _iEnumerable.Value; + + private readonly Lazy _iFieldValues; + public global::LionWeb.Core.M3.Concept IFieldValues => _iFieldValues.Value; + + private readonly Lazy _implementsLazy; + public global::LionWeb.Core.M3.Concept ImplementsLazy => _implementsLazy.Value; + + private readonly Lazy _iNamed; + public global::LionWeb.Core.M3.Concept INamed => _iNamed.Value; + + private readonly Lazy _iNamedWritable; + public global::LionWeb.Core.M3.Concept INamedWritable => _iNamedWritable.Value; + + private readonly Lazy _iNode; + public global::LionWeb.Core.M3.Concept INode => _iNode.Value; + + private readonly Lazy _iNodeFactory; + public global::LionWeb.Core.M3.Concept INodeFactory => _iNodeFactory.Value; + + private readonly Lazy _insert; + public global::LionWeb.Core.M3.Concept Insert => _insert.Value; + + private readonly Lazy _insertAnnotations; + public global::LionWeb.Core.M3.Concept InsertAnnotations => _insertAnnotations.Value; + + private readonly Lazy _insertAnnotationsRaw; + public global::LionWeb.Core.M3.Concept InsertAnnotationsRaw => _insertAnnotationsRaw.Value; + + private readonly Lazy _insertChildRaw; + public global::LionWeb.Core.M3.Concept InsertChildRaw => _insertChildRaw.Value; + + private readonly Lazy _insertContainmentsRaw; + public global::LionWeb.Core.M3.Concept InsertContainmentsRaw => _insertContainmentsRaw.Value; + + private readonly Lazy _insertInternal; + public global::LionWeb.Core.M3.Concept InsertInternal => _insertInternal.Value; + + private readonly Lazy _insertOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept InsertOptionalMultipleContainment => _insertOptionalMultipleContainment.Value; + + private readonly Lazy _insertOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept InsertOptionalMultipleReference => _insertOptionalMultipleReference.Value; + + private readonly Lazy _insertReferencesRaw; + public global::LionWeb.Core.M3.Concept InsertReferencesRaw => _insertReferencesRaw.Value; + + private readonly Lazy _insertRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept InsertRequiredMultipleContainment => _insertRequiredMultipleContainment.Value; + + private readonly Lazy _insertRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept InsertRequiredMultipleReference => _insertRequiredMultipleReference.Value; + + private readonly Lazy _instance; + public global::LionWeb.Core.M3.Concept Instance_ => _instance.Value; + + private readonly Lazy _integer; + public global::LionWeb.Core.M3.Concept Integer => _integer.Value; + + private readonly Lazy _interface; + public global::LionWeb.Core.M3.Concept Interface => _interface.Value; + + private readonly Lazy _interfaceBase; + public global::LionWeb.Core.M3.Concept InterfaceBase => _interfaceBase.Value; + + private readonly Lazy _invalidValueException; + public global::LionWeb.Core.M3.Concept InvalidValueException => _invalidValueException.Value; + + private readonly Lazy _iPartitionInstance; + public global::LionWeb.Core.M3.Concept IPartitionInstance => _iPartitionInstance.Value; + + private readonly Lazy _iReadableNode; + public global::LionWeb.Core.M3.Concept IReadableNode => _iReadableNode.Value; + + private readonly Lazy _iReadOnlyList; + public global::LionWeb.Core.M3.Concept IReadOnlyList => _iReadOnlyList.Value; + + private readonly Lazy _isInRange; + public global::LionWeb.Core.M3.Concept IsInRange => _isInRange.Value; + + private readonly Lazy _iStructuredDataTypeInstance; + public global::LionWeb.Core.M3.Concept IStructuredDataTypeInstance => _iStructuredDataTypeInstance.Value; + + private readonly Lazy _iWritableNode; + public global::LionWeb.Core.M3.Concept IWritableNode => _iWritableNode.Value; + + private readonly Lazy _key_; + public global::LionWeb.Core.M3.Concept Key_ => _key_.Value; + + private readonly Lazy _language; + public global::LionWeb.Core.M3.Concept Language => _language.Value; + + private readonly Lazy _languageBase; + public global::LionWeb.Core.M3.Concept LanguageBase => _languageBase.Value; + + private readonly Lazy _languageEntity; + public global::LionWeb.Core.M3.Concept LanguageEntity => _languageEntity.Value; + + private readonly Lazy _lazy; + public global::LionWeb.Core.M3.Concept Lazy => _lazy.Value; + + private readonly Lazy _link; + public global::LionWeb.Core.M3.Concept Link => _link.Value; + + private readonly Lazy _lionCoreFeature; + public global::LionWeb.Core.M3.Concept LionCoreFeature => _lionCoreFeature.Value; + + private readonly Lazy _lionCoreFeatureKind; + public global::LionWeb.Core.M3.Concept LionCoreFeatureKind => _lionCoreFeatureKind.Value; + + private readonly Lazy _lionCoreLanguage; + public global::LionWeb.Core.M3.Concept LionCoreLanguage => _lionCoreLanguage.Value; + + private readonly Lazy _lionCoreMetaPointer; + public global::LionWeb.Core.M3.Concept LionCoreMetaPointer => _lionCoreMetaPointer.Value; + + private readonly Lazy _lionWeb; + public global::LionWeb.Core.M3.Concept LionWeb => _lionWeb.Value; + + private readonly Lazy _lionWebVersions; + public global::LionWeb.Core.M3.Concept LionWebVersions => _lionWebVersions.Value; + + private readonly Lazy _list; + public global::LionWeb.Core.M3.Concept List => _list.Value; + + private readonly Lazy _literalsLazy; + public global::LionWeb.Core.M3.Concept LiteralsLazy => _literalsLazy.Value; + + private readonly Lazy _m2; + public global::LionWeb.Core.M3.Concept M2 => _m2.Value; + + private readonly Lazy _m3_; + public global::LionWeb.Core.M3.Concept M3 => _m3_.Value; + + private readonly Lazy _memberwiseClone; + public global::LionWeb.Core.M3.Concept MemberwiseClone_ => _memberwiseClone.Value; + + private readonly Lazy _multiple; + public global::LionWeb.Core.M3.Concept Multiple => _multiple.Value; + + private readonly Lazy _name_; + public global::LionWeb.Core.M3.Concept Name_ => _name_.Value; + + private readonly Lazy _notification; + public global::LionWeb.Core.M3.Concept Notification => _notification.Value; + + private readonly Lazy _notNullWhenAttribute; + public global::LionWeb.Core.M3.Concept NotNullWhenAttribute => _notNullWhenAttribute.Value; + + private readonly Lazy _optional; + public global::LionWeb.Core.M3.Concept Optional => _optional.Value; + + private readonly Lazy _partition; + public global::LionWeb.Core.M3.Concept Partition => _partition.Value; + + private readonly Lazy _pipe; + public global::LionWeb.Core.M3.Concept Pipe => _pipe.Value; + + private readonly Lazy _primitiveType; + public global::LionWeb.Core.M3.Concept PrimitiveType => _primitiveType.Value; + + private readonly Lazy _primitiveTypeBase; + public global::LionWeb.Core.M3.Concept PrimitiveTypeBase => _primitiveTypeBase.Value; + + private readonly Lazy _property; + public global::LionWeb.Core.M3.Concept Property => _property.Value; + + private readonly Lazy _propertyBase; + public global::LionWeb.Core.M3.Concept PropertyBase => _propertyBase.Value; + + private readonly Lazy _reference; + public global::LionWeb.Core.M3.Concept Reference => _reference.Value; + + private readonly Lazy _referenceBase; + public global::LionWeb.Core.M3.Concept ReferenceBase => _referenceBase.Value; + + private readonly Lazy _referenceEquals; + public global::LionWeb.Core.M3.Concept ReferenceEquals_ => _referenceEquals.Value; + + private readonly Lazy _referenceRemover; + public global::LionWeb.Core.M3.Concept ReferenceRemover => _referenceRemover.Value; + + private readonly Lazy _referenceTargetNonNullTarget; + public global::LionWeb.Core.M3.Concept ReferenceTargetNonNullTarget => _referenceTargetNonNullTarget.Value; + + private readonly Lazy _referenceTargetNonNullTargets; + public global::LionWeb.Core.M3.Concept ReferenceTargetNonNullTargets => _referenceTargetNonNullTargets.Value; + + private readonly Lazy _referenceTargetNullableTarget; + public global::LionWeb.Core.M3.Concept ReferenceTargetNullableTarget => _referenceTargetNullableTarget.Value; + + private readonly Lazy _referenceTargetNullableTargets; + public global::LionWeb.Core.M3.Concept ReferenceTargetNullableTargets => _referenceTargetNullableTargets.Value; + + private readonly Lazy _remove; + public global::LionWeb.Core.M3.Concept Remove => _remove.Value; + + private readonly Lazy _removeAll; + public global::LionWeb.Core.M3.Concept RemoveAll => _removeAll.Value; + + private readonly Lazy _removeAnnotations; + public global::LionWeb.Core.M3.Concept RemoveAnnotations => _removeAnnotations.Value; + + private readonly Lazy _removeAnnotationsRaw; + public global::LionWeb.Core.M3.Concept RemoveAnnotationsRaw => _removeAnnotationsRaw.Value; + + private readonly Lazy _removeChildRaw; + public global::LionWeb.Core.M3.Concept RemoveChildRaw => _removeChildRaw.Value; + + private readonly Lazy _removeContainmentsRaw; + public global::LionWeb.Core.M3.Concept RemoveContainmentsRaw => _removeContainmentsRaw.Value; + + private readonly Lazy _removeInternal; + public global::LionWeb.Core.M3.Concept RemoveInternal => _removeInternal.Value; + + private readonly Lazy _removeOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept RemoveOptionalMultipleContainment => _removeOptionalMultipleContainment.Value; + + private readonly Lazy _removeOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept RemoveOptionalMultipleReference => _removeOptionalMultipleReference.Value; + + private readonly Lazy _removeReferencesRaw; + public global::LionWeb.Core.M3.Concept RemoveReferencesRaw => _removeReferencesRaw.Value; + + private readonly Lazy _removeRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept RemoveRequiredMultipleContainment => _removeRequiredMultipleContainment.Value; + + private readonly Lazy _removeRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept RemoveRequiredMultipleReference => _removeRequiredMultipleReference.Value; + + private readonly Lazy _removeSelfParent; + public global::LionWeb.Core.M3.Concept RemoveSelfParent => _removeSelfParent.Value; + + private readonly Lazy _removeSelfParentRaw; + public global::LionWeb.Core.M3.Concept RemoveSelfParentRaw => _removeSelfParentRaw.Value; + + private readonly Lazy _result; + public global::LionWeb.Core.M3.Concept result => _result.Value; + + private readonly Lazy _set; + public global::LionWeb.Core.M3.Concept Set => _set.Value; + + private readonly Lazy _setContainmentRaw; + public global::LionWeb.Core.M3.Concept SetContainmentRaw => _setContainmentRaw.Value; + + private readonly Lazy _setInternal; + public global::LionWeb.Core.M3.Concept SetInternal => _setInternal.Value; + + private readonly Lazy _setInternalAnnotation; + public global::LionWeb.Core.M3.Concept SetInternalAnnotation => _setInternalAnnotation.Value; + + private readonly Lazy _setName; + public global::LionWeb.Core.M3.Concept SetName => _setName.Value; + + private readonly Lazy _setNameRaw; + public global::LionWeb.Core.M3.Concept SetNameRaw => _setNameRaw.Value; + + private readonly Lazy _setOptionalMultipleContainment; + public global::LionWeb.Core.M3.Concept SetOptionalMultipleContainment => _setOptionalMultipleContainment.Value; + + private readonly Lazy _setOptionalMultipleReference; + public global::LionWeb.Core.M3.Concept SetOptionalMultipleReference => _setOptionalMultipleReference.Value; + + private readonly Lazy _setOptionalReferenceTypeProperty; + public global::LionWeb.Core.M3.Concept SetOptionalReferenceTypeProperty => _setOptionalReferenceTypeProperty.Value; + + private readonly Lazy _setOptionalSingleContainment; + public global::LionWeb.Core.M3.Concept SetOptionalSingleContainment => _setOptionalSingleContainment.Value; + + private readonly Lazy _setOptionalSingleReference; + public global::LionWeb.Core.M3.Concept SetOptionalSingleReference => _setOptionalSingleReference.Value; + + private readonly Lazy _setOptionalValueTypeProperty; + public global::LionWeb.Core.M3.Concept SetOptionalValueTypeProperty => _setOptionalValueTypeProperty.Value; + + private readonly Lazy _setParentInternal; + public global::LionWeb.Core.M3.Concept SetParentInternal => _setParentInternal.Value; + + private readonly Lazy _setParentNull; + public global::LionWeb.Core.M3.Concept SetParentNull => _setParentNull.Value; + + private readonly Lazy _setPropertyRaw; + public global::LionWeb.Core.M3.Concept SetPropertyRaw => _setPropertyRaw.Value; + + private readonly Lazy _setRaw; + public global::LionWeb.Core.M3.Concept SetRaw => _setRaw.Value; + + private readonly Lazy _setReferenceRaw; + public global::LionWeb.Core.M3.Concept SetReferenceRaw => _setReferenceRaw.Value; + + private readonly Lazy _setReferencesRaw; + public global::LionWeb.Core.M3.Concept SetReferencesRaw => _setReferencesRaw.Value; + + private readonly Lazy _setRequiredMultipleContainment; + public global::LionWeb.Core.M3.Concept SetRequiredMultipleContainment => _setRequiredMultipleContainment.Value; + + private readonly Lazy _setRequiredMultipleReference; + public global::LionWeb.Core.M3.Concept SetRequiredMultipleReference => _setRequiredMultipleReference.Value; + + private readonly Lazy _setRequiredReferenceTypeProperty; + public global::LionWeb.Core.M3.Concept SetRequiredReferenceTypeProperty => _setRequiredReferenceTypeProperty.Value; + + private readonly Lazy _setRequiredSingleContainment; + public global::LionWeb.Core.M3.Concept SetRequiredSingleContainment => _setRequiredSingleContainment.Value; + + private readonly Lazy _setRequiredSingleReference; + public global::LionWeb.Core.M3.Concept SetRequiredSingleReference => _setRequiredSingleReference.Value; + + private readonly Lazy _setRequiredValueTypeProperty; + public global::LionWeb.Core.M3.Concept SetRequiredValueTypeProperty => _setRequiredValueTypeProperty.Value; + + private readonly Lazy _setSelfParent; + public global::LionWeb.Core.M3.Concept SetSelfParent => _setSelfParent.Value; + + private readonly Lazy _setSelfParentRaw; + public global::LionWeb.Core.M3.Concept SetSelfParentRaw => _setSelfParentRaw.Value; + + private readonly Lazy _string; + public global::LionWeb.Core.M3.Concept String => _string.Value; + + private readonly Lazy _structuredDataType; + public global::LionWeb.Core.M3.Concept StructuredDataType => _structuredDataType.Value; + + private readonly Lazy _structuredDataTypeBase; + public global::LionWeb.Core.M3.Concept StructuredDataTypeBase => _structuredDataTypeBase.Value; + + private readonly Lazy _system; + public global::LionWeb.Core.M3.Concept System => _system.Value; + + private readonly Lazy _toString; + public global::LionWeb.Core.M3.Concept ToString_ => _toString.Value; + + private readonly Lazy _tryGet; + public global::LionWeb.Core.M3.Concept TryGet_ => _tryGet.Value; + + private readonly Lazy _tryGetContainmentRaw; + public global::LionWeb.Core.M3.Concept TryGetContainmentRaw_ => _tryGetContainmentRaw.Value; + + private readonly Lazy _tryGetContainmentsRaw; + public global::LionWeb.Core.M3.Concept TryGetContainmentsRaw_ => _tryGetContainmentsRaw.Value; + + private readonly Lazy _tryGetName; + public global::LionWeb.Core.M3.Concept TryGetName_ => _tryGetName.Value; + + private readonly Lazy _tryGetPropertyRaw; + public global::LionWeb.Core.M3.Concept TryGetPropertyRaw_ => _tryGetPropertyRaw.Value; + + private readonly Lazy _tryGetReference; + public global::LionWeb.Core.M3.Concept TryGetReference => _tryGetReference.Value; + + private readonly Lazy _tryGetReferenceRaw; + public global::LionWeb.Core.M3.Concept TryGetReferenceRaw_ => _tryGetReferenceRaw.Value; + + private readonly Lazy _tryGetReferencesRaw; + public global::LionWeb.Core.M3.Concept TryGetReferencesRaw_ => _tryGetReferencesRaw.Value; + + private readonly Lazy _type; + public global::LionWeb.Core.M3.Concept Type => _type.Value; + + private readonly Lazy _unsetFeatureException; + public global::LionWeb.Core.M3.Concept UnsetFeatureException => _unsetFeatureException.Value; + + private readonly Lazy _unsetFieldException; + public global::LionWeb.Core.M3.Concept UnsetFieldException => _unsetFieldException.Value; + + private readonly Lazy _unsupportedClassifierException; + public global::LionWeb.Core.M3.Concept UnsupportedClassifierException => _unsupportedClassifierException.Value; + + private readonly Lazy _unsupportedEnumerationLiteralException; + public global::LionWeb.Core.M3.Concept UnsupportedEnumerationLiteralException => _unsupportedEnumerationLiteralException.Value; + + private readonly Lazy _unsupportedStructuredDataTypeException; + public global::LionWeb.Core.M3.Concept UnsupportedStructuredDataTypeException => _unsupportedStructuredDataTypeException.Value; + + private readonly Lazy _utilities; + public global::LionWeb.Core.M3.Concept Utilities => _utilities.Value; + + private readonly Lazy _v2023_1; + public global::LionWeb.Core.M3.Concept V2023_1 => _v2023_1.Value; + + private readonly Lazy _v2024_1; + public global::LionWeb.Core.M3.Concept V2024_1 => _v2024_1.Value; + + private readonly Lazy _v2024_1_Compatible; + public global::LionWeb.Core.M3.Concept V2024_1_Compatible => _v2024_1_Compatible.Value; + + private readonly Lazy _v2025_1; + public global::LionWeb.Core.M3.Concept V2025_1 => _v2025_1.Value; + + private readonly Lazy _v2025_1_Compatible; + public global::LionWeb.Core.M3.Concept V2025_1_Compatible => _v2025_1_Compatible.Value; + + private readonly Lazy _versionSpecific; + public global::LionWeb.Core.M3.Concept VersionSpecific => _versionSpecific.Value; +} + +public partial interface ILanguageWithLionWebNamedConceptsFactory : global::LionWeb.Core.M2.INodeFactory +{ + public _builtIns New_builtIns(string id); + public _builtIns Create_builtIns(); + public Abstract NewAbstract(string id); + public Abstract CreateAbstract(); + public AbstractBaseNodeFactory NewAbstractBaseNodeFactory(string id); + public AbstractBaseNodeFactory CreateAbstractBaseNodeFactory(); + public Add NewAdd(string id); + public Add CreateAdd(); + public AddAnnotations NewAddAnnotations(string id); + public AddAnnotations CreateAddAnnotations(); + public AddAnnotationsRaw NewAddAnnotationsRaw(string id); + public AddAnnotationsRaw CreateAddAnnotationsRaw(); + public AddChildRaw NewAddChildRaw(string id); + public AddChildRaw CreateAddChildRaw(); + public AddContainmentsRaw_ NewAddContainmentsRaw(string id); + public AddContainmentsRaw_ CreateAddContainmentsRaw(); + public AddInternal_ NewAddInternal(string id); + public AddInternal_ CreateAddInternal(); + public AddOptionalMultipleContainment NewAddOptionalMultipleContainment(string id); + public AddOptionalMultipleContainment CreateAddOptionalMultipleContainment(); + public AddOptionalMultipleReference NewAddOptionalMultipleReference(string id); + public AddOptionalMultipleReference CreateAddOptionalMultipleReference(); + public AddReferencesRaw_ NewAddReferencesRaw(string id); + public AddReferencesRaw_ CreateAddReferencesRaw(); + public AddRequiredMultipleContainment NewAddRequiredMultipleContainment(string id); + public AddRequiredMultipleContainment CreateAddRequiredMultipleContainment(); + public AddRequiredMultipleReference NewAddRequiredMultipleReference(string id); + public AddRequiredMultipleReference CreateAddRequiredMultipleReference(); + public AnnotatesLazy NewAnnotatesLazy(string id); + public AnnotatesLazy CreateAnnotatesLazy(); + public Annotation NewAnnotation(string id); + public Annotation CreateAnnotation(); + public AnnotationBase NewAnnotationBase(string id); + public AnnotationBase CreateAnnotationBase(); + public AnnotationInstanceBase NewAnnotationInstanceBase(string id); + public AnnotationInstanceBase CreateAnnotationInstanceBase(); + public AnnotationRemover NewAnnotationRemover(string id); + public AnnotationRemover CreateAnnotationRemover(); + public ArgumentOutOfRangeException NewArgumentOutOfRangeException(string id); + public ArgumentOutOfRangeException CreateArgumentOutOfRangeException(); + public AsList NewAsList(string id); + public AsList CreateAsList(); + public AsNonEmptyReadOnly NewAsNonEmptyReadOnly(string id); + public AsNonEmptyReadOnly CreateAsNonEmptyReadOnly(); + public AssureAnnotations NewAssureAnnotations(string id); + public AssureAnnotations CreateAssureAnnotations(); + public AssureInRange NewAssureInRange(string id); + public AssureInRange CreateAssureInRange(); + public AssureNonEmpty NewAssureNonEmpty(string id); + public AssureNonEmpty CreateAssureNonEmpty(); + public AssureNoSelfMove NewAssureNoSelfMove(string id); + public AssureNoSelfMove CreateAssureNoSelfMove(); + public AssureNotClearing NewAssureNotClearing(string id); + public AssureNotClearing CreateAssureNotClearing(); + public AssureNotNull NewAssureNotNull(string id); + public AssureNotNull CreateAssureNotNull(); + public AssureNotNullInstance NewAssureNotNullInstance(string id); + public AssureNotNullInstance CreateAssureNotNullInstance(); + public AssureNotNullMembers NewAssureNotNullMembers(string id); + public AssureNotNullMembers CreateAssureNotNullMembers(); + public AssureNullableInstance NewAssureNullableInstance(string id); + public AssureNullableInstance CreateAssureNullableInstance(); + public AttachChild NewAttachChild(string id); + public AttachChild CreateAttachChild(); + public Bool NewBool(string id); + public Bool CreateBool(); + public Boolean NewBoolean(string id); + public Boolean CreateBoolean(); + public Char NewChar(string id); + public Char CreateChar(); + public Character NewCharacter(string id); + public Character CreateCharacter(); + public Classifier NewClassifier(string id); + public Classifier CreateClassifier(); + public CodeAnalysis NewCodeAnalysis(string id); + public CodeAnalysis CreateCodeAnalysis(); + public CollectAllSetFeatures_ NewCollectAllSetFeatures(string id); + public CollectAllSetFeatures_ CreateCollectAllSetFeatures(); + public Collections NewCollections(string id); + public Collections CreateCollections(); + public Concept NewConcept(string id); + public Concept CreateConcept(); + public ConceptBase NewConceptBase(string id); + public ConceptBase CreateConceptBase(); + public ConceptInstanceBase NewConceptInstanceBase(string id); + public ConceptInstanceBase CreateConceptInstanceBase(); + public Containment NewContainment(string id); + public Containment CreateContainment(); + public ContainmentBase NewContainmentBase(string id); + public ContainmentBase CreateContainmentBase(); + public ContainmentRemover NewContainmentRemover(string id); + public ContainmentRemover CreateContainmentRemover(); + public Core NewCore(string id); + public Core CreateCore(); + public Datatype NewDatatype(string id); + public Datatype CreateDatatype(); + public DatatypeBase NewDatatypeBase(string id); + public DatatypeBase CreateDatatypeBase(); + public Decimal NewDecimal(string id); + public Decimal CreateDecimal(); + public DetachChild_ NewDetachChild(string id); + public DetachChild_ CreateDetachChild(); + public DetachChildInternal NewDetachChildInternal(string id); + public DetachChildInternal CreateDetachChildInternal(); + public DetachFromParent_ NewDetachFromParent(string id); + public DetachFromParent_ CreateDetachFromParent(); + public Diagnostics NewDiagnostics(string id); + public Diagnostics CreateDiagnostics(); + public Enum NewEnum(string id); + public Enum CreateEnum(); + public Enumeration NewEnumeration(string id); + public Enumeration CreateEnumeration(); + public EnumerationBase NewEnumerationBase(string id); + public EnumerationBase CreateEnumerationBase(); + public EnumerationLiteral NewEnumerationLiteral(string id); + public EnumerationLiteral CreateEnumerationLiteral(); + public EnumerationLiteralBase NewEnumerationLiteralBase(string id); + public EnumerationLiteralBase CreateEnumerationLiteralBase(); + public Equals NewEquals(string id); + public Equals CreateEquals(); + public ExchangeChildRaw NewExchangeChildRaw(string id); + public ExchangeChildRaw CreateExchangeChildRaw(); + public ExchangeChildrenRaw NewExchangeChildrenRaw(string id); + public ExchangeChildrenRaw CreateExchangeChildrenRaw(); + public FeaturesLazy NewFeaturesLazy(string id); + public FeaturesLazy CreateFeaturesLazy(); + public Field NewField(string id); + public Field CreateField(); + public FieldBase NewFieldBase(string id); + public FieldBase CreateFieldBase(); + public FieldsLazy NewFieldsLazy(string id); + public FieldsLazy CreateFieldsLazy(); + public Finalize NewFinalize(string id); + public Finalize CreateFinalize(); + public Generic NewGeneric(string id); + public Generic CreateGeneric(); + public Get NewGet(string id); + public Get CreateGet(); + public get__builtIns Newget__builtIns(string id); + public get__builtIns Createget__builtIns(); + public get__m3 Newget__m3(string id); + public get__m3 Createget__m3(); + public GetAnnotation NewGetAnnotation(string id); + public GetAnnotation CreateGetAnnotation(); + public GetAnnotations NewGetAnnotations(string id); + public GetAnnotations CreateGetAnnotations(); + public GetAnnotationsRaw NewGetAnnotationsRaw(string id); + public GetAnnotationsRaw CreateGetAnnotationsRaw(); + public GetClassifier_ NewGetClassifier(string id); + public GetClassifier_ CreateGetClassifier(); + public GetConcept_ NewGetConcept(string id); + public GetConcept_ CreateGetConcept(); + public GetContainmentOf_ NewGetContainmentOf(string id); + public GetContainmentOf_ CreateGetContainmentOf(); + public GetHashCode NewGetHashCode(string id); + public GetHashCode CreateGetHashCode(); + public GetId NewGetId(string id); + public GetId CreateGetId(); + public GetInternal_ NewGetInternal(string id); + public GetInternal_ CreateGetInternal(); + public GetParent NewGetParent(string id); + public GetParent CreateGetParent(); + public GetPartitionNotificationProducer_ NewGetPartitionNotificationProducer(string id); + public GetPartitionNotificationProducer_ CreateGetPartitionNotificationProducer(); + public GetRequiredNonNullReferences NewGetRequiredNonNullReferences(string id); + public GetRequiredNonNullReferences CreateGetRequiredNonNullReferences(); + public GetRequiredNullableReferences NewGetRequiredNullableReferences(string id); + public GetRequiredNullableReferences CreateGetRequiredNullableReferences(); + public GetRequiredReference NewGetRequiredReference(string id); + public GetRequiredReference CreateGetRequiredReference(); + public GetType NewGetType(string id); + public GetType CreateGetType(); + public IEnumerable NewIEnumerable(string id); + public IEnumerable CreateIEnumerable(); + public IFieldValues NewIFieldValues(string id); + public IFieldValues CreateIFieldValues(); + public ImplementsLazy NewImplementsLazy(string id); + public ImplementsLazy CreateImplementsLazy(); + public INamed NewINamed(string id); + public INamed CreateINamed(); + public INamedWritable NewINamedWritable(string id); + public INamedWritable CreateINamedWritable(); + public INode NewINode(string id); + public INode CreateINode(); + public INodeFactory NewINodeFactory(string id); + public INodeFactory CreateINodeFactory(); + public Insert NewInsert(string id); + public Insert CreateInsert(); + public InsertAnnotations NewInsertAnnotations(string id); + public InsertAnnotations CreateInsertAnnotations(); + public InsertAnnotationsRaw NewInsertAnnotationsRaw(string id); + public InsertAnnotationsRaw CreateInsertAnnotationsRaw(); + public InsertChildRaw NewInsertChildRaw(string id); + public InsertChildRaw CreateInsertChildRaw(); + public InsertContainmentsRaw_ NewInsertContainmentsRaw(string id); + public InsertContainmentsRaw_ CreateInsertContainmentsRaw(); + public InsertInternal_ NewInsertInternal(string id); + public InsertInternal_ CreateInsertInternal(); + public InsertOptionalMultipleContainment NewInsertOptionalMultipleContainment(string id); + public InsertOptionalMultipleContainment CreateInsertOptionalMultipleContainment(); + public InsertOptionalMultipleReference NewInsertOptionalMultipleReference(string id); + public InsertOptionalMultipleReference CreateInsertOptionalMultipleReference(); + public InsertReferencesRaw_ NewInsertReferencesRaw(string id); + public InsertReferencesRaw_ CreateInsertReferencesRaw(); + public InsertRequiredMultipleContainment NewInsertRequiredMultipleContainment(string id); + public InsertRequiredMultipleContainment CreateInsertRequiredMultipleContainment(); + public InsertRequiredMultipleReference NewInsertRequiredMultipleReference(string id); + public InsertRequiredMultipleReference CreateInsertRequiredMultipleReference(); + public Instance NewInstance(string id); + public Instance CreateInstance(); + public Integer NewInteger(string id); + public Integer CreateInteger(); + public Interface NewInterface(string id); + public Interface CreateInterface(); + public InterfaceBase NewInterfaceBase(string id); + public InterfaceBase CreateInterfaceBase(); + public InvalidValueException NewInvalidValueException(string id); + public InvalidValueException CreateInvalidValueException(); + public IPartitionInstance NewIPartitionInstance(string id); + public IPartitionInstance CreateIPartitionInstance(); + public IReadableNode NewIReadableNode(string id); + public IReadableNode CreateIReadableNode(); + public IReadOnlyList NewIReadOnlyList(string id); + public IReadOnlyList CreateIReadOnlyList(); + public IsInRange NewIsInRange(string id); + public IsInRange CreateIsInRange(); + public IStructuredDataTypeInstance NewIStructuredDataTypeInstance(string id); + public IStructuredDataTypeInstance CreateIStructuredDataTypeInstance(); + public IWritableNode NewIWritableNode(string id); + public IWritableNode CreateIWritableNode(); + public Key NewKey(string id); + public Key CreateKey(); + public Language NewLanguage(string id); + public Language CreateLanguage(); + public LanguageBase NewLanguageBase(string id); + public LanguageBase CreateLanguageBase(); + public LanguageEntity NewLanguageEntity(string id); + public LanguageEntity CreateLanguageEntity(); + public Lazy NewLazy(string id); + public Lazy CreateLazy(); + public Link NewLink(string id); + public Link CreateLink(); + public LionCoreFeature NewLionCoreFeature(string id); + public LionCoreFeature CreateLionCoreFeature(); + public LionCoreFeatureKind NewLionCoreFeatureKind(string id); + public LionCoreFeatureKind CreateLionCoreFeatureKind(); + public LionCoreLanguage NewLionCoreLanguage(string id); + public LionCoreLanguage CreateLionCoreLanguage(); + public LionCoreMetaPointer NewLionCoreMetaPointer(string id); + public LionCoreMetaPointer CreateLionCoreMetaPointer(); + public LionWeb NewLionWeb(string id); + public LionWeb CreateLionWeb(); + public LionWebVersions NewLionWebVersions(string id); + public LionWebVersions CreateLionWebVersions(); + public List NewList(string id); + public List CreateList(); + public LiteralsLazy NewLiteralsLazy(string id); + public LiteralsLazy CreateLiteralsLazy(); + public M2 NewM2(string id); + public M2 CreateM2(); + public M3 NewM3(string id); + public M3 CreateM3(); + public MemberwiseClone NewMemberwiseClone(string id); + public MemberwiseClone CreateMemberwiseClone(); + public Multiple NewMultiple(string id); + public Multiple CreateMultiple(); + public Name NewName(string id); + public Name CreateName(); + public Notification NewNotification(string id); + public Notification CreateNotification(); + public NotNullWhenAttribute NewNotNullWhenAttribute(string id); + public NotNullWhenAttribute CreateNotNullWhenAttribute(); + public Optional NewOptional(string id); + public Optional CreateOptional(); + public Partition NewPartition(string id); + public Partition CreatePartition(); + public Pipe NewPipe(string id); + public Pipe CreatePipe(); + public PrimitiveType NewPrimitiveType(string id); + public PrimitiveType CreatePrimitiveType(); + public PrimitiveTypeBase NewPrimitiveTypeBase(string id); + public PrimitiveTypeBase CreatePrimitiveTypeBase(); + public Property NewProperty(string id); + public Property CreateProperty(); + public PropertyBase NewPropertyBase(string id); + public PropertyBase CreatePropertyBase(); + public Reference NewReference(string id); + public Reference CreateReference(); + public ReferenceBase NewReferenceBase(string id); + public ReferenceBase CreateReferenceBase(); + public ReferenceEquals NewReferenceEquals(string id); + public ReferenceEquals CreateReferenceEquals(); + public ReferenceRemover NewReferenceRemover(string id); + public ReferenceRemover CreateReferenceRemover(); + public ReferenceTargetNonNullTarget NewReferenceTargetNonNullTarget(string id); + public ReferenceTargetNonNullTarget CreateReferenceTargetNonNullTarget(); + public ReferenceTargetNonNullTargets NewReferenceTargetNonNullTargets(string id); + public ReferenceTargetNonNullTargets CreateReferenceTargetNonNullTargets(); + public ReferenceTargetNullableTarget NewReferenceTargetNullableTarget(string id); + public ReferenceTargetNullableTarget CreateReferenceTargetNullableTarget(); + public ReferenceTargetNullableTargets NewReferenceTargetNullableTargets(string id); + public ReferenceTargetNullableTargets CreateReferenceTargetNullableTargets(); + public Remove NewRemove(string id); + public Remove CreateRemove(); + public RemoveAll NewRemoveAll(string id); + public RemoveAll CreateRemoveAll(); + public RemoveAnnotations NewRemoveAnnotations(string id); + public RemoveAnnotations CreateRemoveAnnotations(); + public RemoveAnnotationsRaw NewRemoveAnnotationsRaw(string id); + public RemoveAnnotationsRaw CreateRemoveAnnotationsRaw(); + public RemoveChildRaw NewRemoveChildRaw(string id); + public RemoveChildRaw CreateRemoveChildRaw(); + public RemoveContainmentsRaw_ NewRemoveContainmentsRaw(string id); + public RemoveContainmentsRaw_ CreateRemoveContainmentsRaw(); + public RemoveInternal_ NewRemoveInternal(string id); + public RemoveInternal_ CreateRemoveInternal(); + public RemoveOptionalMultipleContainment NewRemoveOptionalMultipleContainment(string id); + public RemoveOptionalMultipleContainment CreateRemoveOptionalMultipleContainment(); + public RemoveOptionalMultipleReference NewRemoveOptionalMultipleReference(string id); + public RemoveOptionalMultipleReference CreateRemoveOptionalMultipleReference(); + public RemoveReferencesRaw_ NewRemoveReferencesRaw(string id); + public RemoveReferencesRaw_ CreateRemoveReferencesRaw(); + public RemoveRequiredMultipleContainment NewRemoveRequiredMultipleContainment(string id); + public RemoveRequiredMultipleContainment CreateRemoveRequiredMultipleContainment(); + public RemoveRequiredMultipleReference NewRemoveRequiredMultipleReference(string id); + public RemoveRequiredMultipleReference CreateRemoveRequiredMultipleReference(); + public RemoveSelfParent NewRemoveSelfParent(string id); + public RemoveSelfParent CreateRemoveSelfParent(); + public RemoveSelfParentRaw NewRemoveSelfParentRaw(string id); + public RemoveSelfParentRaw CreateRemoveSelfParentRaw(); + public result Newresult(string id); + public result Createresult(); + public Set NewSet(string id); + public Set CreateSet(); + public SetContainmentRaw_ NewSetContainmentRaw(string id); + public SetContainmentRaw_ CreateSetContainmentRaw(); + public SetInternal_ NewSetInternal(string id); + public SetInternal_ CreateSetInternal(); + public SetInternalAnnotation NewSetInternalAnnotation(string id); + public SetInternalAnnotation CreateSetInternalAnnotation(); + public SetName NewSetName(string id); + public SetName CreateSetName(); + public SetNameRaw NewSetNameRaw(string id); + public SetNameRaw CreateSetNameRaw(); + public SetOptionalMultipleContainment NewSetOptionalMultipleContainment(string id); + public SetOptionalMultipleContainment CreateSetOptionalMultipleContainment(); + public SetOptionalMultipleReference NewSetOptionalMultipleReference(string id); + public SetOptionalMultipleReference CreateSetOptionalMultipleReference(); + public SetOptionalReferenceTypeProperty NewSetOptionalReferenceTypeProperty(string id); + public SetOptionalReferenceTypeProperty CreateSetOptionalReferenceTypeProperty(); + public SetOptionalSingleContainment NewSetOptionalSingleContainment(string id); + public SetOptionalSingleContainment CreateSetOptionalSingleContainment(); + public SetOptionalSingleReference NewSetOptionalSingleReference(string id); + public SetOptionalSingleReference CreateSetOptionalSingleReference(); + public SetOptionalValueTypeProperty NewSetOptionalValueTypeProperty(string id); + public SetOptionalValueTypeProperty CreateSetOptionalValueTypeProperty(); + public SetParentInternal NewSetParentInternal(string id); + public SetParentInternal CreateSetParentInternal(); + public SetParentNull NewSetParentNull(string id); + public SetParentNull CreateSetParentNull(); + public SetPropertyRaw_ NewSetPropertyRaw(string id); + public SetPropertyRaw_ CreateSetPropertyRaw(); + public SetRaw_ NewSetRaw(string id); + public SetRaw_ CreateSetRaw(); + public SetReferenceRaw_ NewSetReferenceRaw(string id); + public SetReferenceRaw_ CreateSetReferenceRaw(); + public SetReferencesRaw NewSetReferencesRaw(string id); + public SetReferencesRaw CreateSetReferencesRaw(); + public SetRequiredMultipleContainment NewSetRequiredMultipleContainment(string id); + public SetRequiredMultipleContainment CreateSetRequiredMultipleContainment(); + public SetRequiredMultipleReference NewSetRequiredMultipleReference(string id); + public SetRequiredMultipleReference CreateSetRequiredMultipleReference(); + public SetRequiredReferenceTypeProperty NewSetRequiredReferenceTypeProperty(string id); + public SetRequiredReferenceTypeProperty CreateSetRequiredReferenceTypeProperty(); + public SetRequiredSingleContainment NewSetRequiredSingleContainment(string id); + public SetRequiredSingleContainment CreateSetRequiredSingleContainment(); + public SetRequiredSingleReference NewSetRequiredSingleReference(string id); + public SetRequiredSingleReference CreateSetRequiredSingleReference(); + public SetRequiredValueTypeProperty NewSetRequiredValueTypeProperty(string id); + public SetRequiredValueTypeProperty CreateSetRequiredValueTypeProperty(); + public SetSelfParent NewSetSelfParent(string id); + public SetSelfParent CreateSetSelfParent(); + public SetSelfParentRaw NewSetSelfParentRaw(string id); + public SetSelfParentRaw CreateSetSelfParentRaw(); + public String NewString(string id); + public String CreateString(); + public StructuredDataType NewStructuredDataType(string id); + public StructuredDataType CreateStructuredDataType(); + public StructuredDataTypeBase NewStructuredDataTypeBase(string id); + public StructuredDataTypeBase CreateStructuredDataTypeBase(); + public System NewSystem(string id); + public System CreateSystem(); + public ToString NewToString(string id); + public ToString CreateToString(); + public TryGet_ NewTryGet(string id); + public TryGet_ CreateTryGet(); + public TryGetContainmentRaw_ NewTryGetContainmentRaw(string id); + public TryGetContainmentRaw_ CreateTryGetContainmentRaw(); + public TryGetContainmentsRaw_ NewTryGetContainmentsRaw(string id); + public TryGetContainmentsRaw_ CreateTryGetContainmentsRaw(); + public TryGetName NewTryGetName(string id); + public TryGetName CreateTryGetName(); + public TryGetPropertyRaw_ NewTryGetPropertyRaw(string id); + public TryGetPropertyRaw_ CreateTryGetPropertyRaw(); + public TryGetReference NewTryGetReference(string id); + public TryGetReference CreateTryGetReference(); + public TryGetReferenceRaw_ NewTryGetReferenceRaw(string id); + public TryGetReferenceRaw_ CreateTryGetReferenceRaw(); + public TryGetReferencesRaw_ NewTryGetReferencesRaw(string id); + public TryGetReferencesRaw_ CreateTryGetReferencesRaw(); + public Type NewType(string id); + public Type CreateType(); + public UnsetFeatureException NewUnsetFeatureException(string id); + public UnsetFeatureException CreateUnsetFeatureException(); + public UnsetFieldException NewUnsetFieldException(string id); + public UnsetFieldException CreateUnsetFieldException(); + public UnsupportedClassifierException NewUnsupportedClassifierException(string id); + public UnsupportedClassifierException CreateUnsupportedClassifierException(); + public UnsupportedEnumerationLiteralException NewUnsupportedEnumerationLiteralException(string id); + public UnsupportedEnumerationLiteralException CreateUnsupportedEnumerationLiteralException(); + public UnsupportedStructuredDataTypeException NewUnsupportedStructuredDataTypeException(string id); + public UnsupportedStructuredDataTypeException CreateUnsupportedStructuredDataTypeException(); + public Utilities NewUtilities(string id); + public Utilities CreateUtilities(); + public V2023_1 NewV2023_1(string id); + public V2023_1 CreateV2023_1(); + public V2024_1 NewV2024_1(string id); + public V2024_1 CreateV2024_1(); + public V2024_1_Compatible NewV2024_1_Compatible(string id); + public V2024_1_Compatible CreateV2024_1_Compatible(); + public V2025_1 NewV2025_1(string id); + public V2025_1 CreateV2025_1(); + public V2025_1_Compatible NewV2025_1_Compatible(string id); + public V2025_1_Compatible CreateV2025_1_Compatible(); + public VersionSpecific NewVersionSpecific(string id); + public VersionSpecific CreateVersionSpecific(); +} + +public class LanguageWithLionWebNamedConceptsFactory : global::LionWeb.Core.M2.AbstractBaseNodeFactory, ILanguageWithLionWebNamedConceptsFactory +{ + private readonly LanguageWithLionWebNamedConceptsLanguage _language; + public LanguageWithLionWebNamedConceptsFactory(LanguageWithLionWebNamedConceptsLanguage language) : base(language) + { + _language = language; + } + + /// + public override global::LionWeb.Core.INode CreateNode(string id, global::LionWeb.Core.M3.Classifier classifier) + { + if (_language._builtIns_.EqualsIdentity(classifier)) + return New_builtIns(id); + if (_language.Abstract.EqualsIdentity(classifier)) + return NewAbstract(id); + if (_language.AbstractBaseNodeFactory.EqualsIdentity(classifier)) + return NewAbstractBaseNodeFactory(id); + if (_language.Add.EqualsIdentity(classifier)) + return NewAdd(id); + if (_language.AddAnnotations.EqualsIdentity(classifier)) + return NewAddAnnotations(id); + if (_language.AddAnnotationsRaw.EqualsIdentity(classifier)) + return NewAddAnnotationsRaw(id); + if (_language.AddChildRaw.EqualsIdentity(classifier)) + return NewAddChildRaw(id); + if (_language.AddContainmentsRaw.EqualsIdentity(classifier)) + return NewAddContainmentsRaw(id); + if (_language.AddInternal.EqualsIdentity(classifier)) + return NewAddInternal(id); + if (_language.AddOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewAddOptionalMultipleContainment(id); + if (_language.AddOptionalMultipleReference.EqualsIdentity(classifier)) + return NewAddOptionalMultipleReference(id); + if (_language.AddReferencesRaw.EqualsIdentity(classifier)) + return NewAddReferencesRaw(id); + if (_language.AddRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewAddRequiredMultipleContainment(id); + if (_language.AddRequiredMultipleReference.EqualsIdentity(classifier)) + return NewAddRequiredMultipleReference(id); + if (_language.AnnotatesLazy.EqualsIdentity(classifier)) + return NewAnnotatesLazy(id); + if (_language.Annotation.EqualsIdentity(classifier)) + return NewAnnotation(id); + if (_language.AnnotationBase.EqualsIdentity(classifier)) + return NewAnnotationBase(id); + if (_language.AnnotationInstanceBase.EqualsIdentity(classifier)) + return NewAnnotationInstanceBase(id); + if (_language.AnnotationRemover.EqualsIdentity(classifier)) + return NewAnnotationRemover(id); + if (_language.ArgumentOutOfRangeException.EqualsIdentity(classifier)) + return NewArgumentOutOfRangeException(id); + if (_language.AsList.EqualsIdentity(classifier)) + return NewAsList(id); + if (_language.AsNonEmptyReadOnly.EqualsIdentity(classifier)) + return NewAsNonEmptyReadOnly(id); + if (_language.AssureAnnotations.EqualsIdentity(classifier)) + return NewAssureAnnotations(id); + if (_language.AssureInRange.EqualsIdentity(classifier)) + return NewAssureInRange(id); + if (_language.AssureNonEmpty.EqualsIdentity(classifier)) + return NewAssureNonEmpty(id); + if (_language.AssureNoSelfMove.EqualsIdentity(classifier)) + return NewAssureNoSelfMove(id); + if (_language.AssureNotClearing.EqualsIdentity(classifier)) + return NewAssureNotClearing(id); + if (_language.AssureNotNull.EqualsIdentity(classifier)) + return NewAssureNotNull(id); + if (_language.AssureNotNullInstance.EqualsIdentity(classifier)) + return NewAssureNotNullInstance(id); + if (_language.AssureNotNullMembers.EqualsIdentity(classifier)) + return NewAssureNotNullMembers(id); + if (_language.AssureNullableInstance.EqualsIdentity(classifier)) + return NewAssureNullableInstance(id); + if (_language.AttachChild.EqualsIdentity(classifier)) + return NewAttachChild(id); + if (_language.Bool.EqualsIdentity(classifier)) + return NewBool(id); + if (_language.Boolean.EqualsIdentity(classifier)) + return NewBoolean(id); + if (_language.Char.EqualsIdentity(classifier)) + return NewChar(id); + if (_language.Character.EqualsIdentity(classifier)) + return NewCharacter(id); + if (_language.Classifier.EqualsIdentity(classifier)) + return NewClassifier(id); + if (_language.CodeAnalysis.EqualsIdentity(classifier)) + return NewCodeAnalysis(id); + if (_language.CollectAllSetFeatures_.EqualsIdentity(classifier)) + return NewCollectAllSetFeatures(id); + if (_language.Collections.EqualsIdentity(classifier)) + return NewCollections(id); + if (_language.Concept.EqualsIdentity(classifier)) + return NewConcept(id); + if (_language.ConceptBase.EqualsIdentity(classifier)) + return NewConceptBase(id); + if (_language.ConceptInstanceBase.EqualsIdentity(classifier)) + return NewConceptInstanceBase(id); + if (_language.Containment.EqualsIdentity(classifier)) + return NewContainment(id); + if (_language.ContainmentBase.EqualsIdentity(classifier)) + return NewContainmentBase(id); + if (_language.ContainmentRemover.EqualsIdentity(classifier)) + return NewContainmentRemover(id); + if (_language.Core.EqualsIdentity(classifier)) + return NewCore(id); + if (_language.Datatype.EqualsIdentity(classifier)) + return NewDatatype(id); + if (_language.DatatypeBase.EqualsIdentity(classifier)) + return NewDatatypeBase(id); + if (_language.Decimal.EqualsIdentity(classifier)) + return NewDecimal(id); + if (_language.DetachChild.EqualsIdentity(classifier)) + return NewDetachChild(id); + if (_language.DetachChildInternal.EqualsIdentity(classifier)) + return NewDetachChildInternal(id); + if (_language.DetachFromParent.EqualsIdentity(classifier)) + return NewDetachFromParent(id); + if (_language.Diagnostics.EqualsIdentity(classifier)) + return NewDiagnostics(id); + if (_language.Enum.EqualsIdentity(classifier)) + return NewEnum(id); + if (_language.Enumeration.EqualsIdentity(classifier)) + return NewEnumeration(id); + if (_language.EnumerationBase.EqualsIdentity(classifier)) + return NewEnumerationBase(id); + if (_language.EnumerationLiteral.EqualsIdentity(classifier)) + return NewEnumerationLiteral(id); + if (_language.EnumerationLiteralBase.EqualsIdentity(classifier)) + return NewEnumerationLiteralBase(id); + if (_language.Equals_.EqualsIdentity(classifier)) + return NewEquals(id); + if (_language.ExchangeChildRaw.EqualsIdentity(classifier)) + return NewExchangeChildRaw(id); + if (_language.ExchangeChildrenRaw.EqualsIdentity(classifier)) + return NewExchangeChildrenRaw(id); + if (_language.FeaturesLazy.EqualsIdentity(classifier)) + return NewFeaturesLazy(id); + if (_language.Field.EqualsIdentity(classifier)) + return NewField(id); + if (_language.FieldBase.EqualsIdentity(classifier)) + return NewFieldBase(id); + if (_language.FieldsLazy.EqualsIdentity(classifier)) + return NewFieldsLazy(id); + if (_language.Finalize.EqualsIdentity(classifier)) + return NewFinalize(id); + if (_language.Generic.EqualsIdentity(classifier)) + return NewGeneric(id); + if (_language.Get_.EqualsIdentity(classifier)) + return NewGet(id); + if (_language.get__builtIns.EqualsIdentity(classifier)) + return Newget__builtIns(id); + if (_language.get__m3.EqualsIdentity(classifier)) + return Newget__m3(id); + if (_language.GetAnnotation.EqualsIdentity(classifier)) + return NewGetAnnotation(id); + if (_language.GetAnnotations_.EqualsIdentity(classifier)) + return NewGetAnnotations(id); + if (_language.GetAnnotationsRaw_.EqualsIdentity(classifier)) + return NewGetAnnotationsRaw(id); + if (_language.GetClassifier_.EqualsIdentity(classifier)) + return NewGetClassifier(id); + if (_language.GetConcept_.EqualsIdentity(classifier)) + return NewGetConcept(id); + if (_language.GetContainmentOf.EqualsIdentity(classifier)) + return NewGetContainmentOf(id); + if (_language.GetHashCode_.EqualsIdentity(classifier)) + return NewGetHashCode(id); + if (_language.GetId_.EqualsIdentity(classifier)) + return NewGetId(id); + if (_language.GetInternal.EqualsIdentity(classifier)) + return NewGetInternal(id); + if (_language.GetParent_.EqualsIdentity(classifier)) + return NewGetParent(id); + if (_language.GetPartitionNotificationProducer.EqualsIdentity(classifier)) + return NewGetPartitionNotificationProducer(id); + if (_language.GetRequiredNonNullReferences.EqualsIdentity(classifier)) + return NewGetRequiredNonNullReferences(id); + if (_language.GetRequiredNullableReferences.EqualsIdentity(classifier)) + return NewGetRequiredNullableReferences(id); + if (_language.GetRequiredReference.EqualsIdentity(classifier)) + return NewGetRequiredReference(id); + if (_language.GetType_.EqualsIdentity(classifier)) + return NewGetType(id); + if (_language.IEnumerable.EqualsIdentity(classifier)) + return NewIEnumerable(id); + if (_language.IFieldValues.EqualsIdentity(classifier)) + return NewIFieldValues(id); + if (_language.ImplementsLazy.EqualsIdentity(classifier)) + return NewImplementsLazy(id); + if (_language.INamed.EqualsIdentity(classifier)) + return NewINamed(id); + if (_language.INamedWritable.EqualsIdentity(classifier)) + return NewINamedWritable(id); + if (_language.INode.EqualsIdentity(classifier)) + return NewINode(id); + if (_language.INodeFactory.EqualsIdentity(classifier)) + return NewINodeFactory(id); + if (_language.Insert.EqualsIdentity(classifier)) + return NewInsert(id); + if (_language.InsertAnnotations.EqualsIdentity(classifier)) + return NewInsertAnnotations(id); + if (_language.InsertAnnotationsRaw.EqualsIdentity(classifier)) + return NewInsertAnnotationsRaw(id); + if (_language.InsertChildRaw.EqualsIdentity(classifier)) + return NewInsertChildRaw(id); + if (_language.InsertContainmentsRaw.EqualsIdentity(classifier)) + return NewInsertContainmentsRaw(id); + if (_language.InsertInternal.EqualsIdentity(classifier)) + return NewInsertInternal(id); + if (_language.InsertOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewInsertOptionalMultipleContainment(id); + if (_language.InsertOptionalMultipleReference.EqualsIdentity(classifier)) + return NewInsertOptionalMultipleReference(id); + if (_language.InsertReferencesRaw.EqualsIdentity(classifier)) + return NewInsertReferencesRaw(id); + if (_language.InsertRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewInsertRequiredMultipleContainment(id); + if (_language.InsertRequiredMultipleReference.EqualsIdentity(classifier)) + return NewInsertRequiredMultipleReference(id); + if (_language.Instance_.EqualsIdentity(classifier)) + return NewInstance(id); + if (_language.Integer.EqualsIdentity(classifier)) + return NewInteger(id); + if (_language.Interface.EqualsIdentity(classifier)) + return NewInterface(id); + if (_language.InterfaceBase.EqualsIdentity(classifier)) + return NewInterfaceBase(id); + if (_language.InvalidValueException.EqualsIdentity(classifier)) + return NewInvalidValueException(id); + if (_language.IPartitionInstance.EqualsIdentity(classifier)) + return NewIPartitionInstance(id); + if (_language.IReadableNode.EqualsIdentity(classifier)) + return NewIReadableNode(id); + if (_language.IReadOnlyList.EqualsIdentity(classifier)) + return NewIReadOnlyList(id); + if (_language.IsInRange.EqualsIdentity(classifier)) + return NewIsInRange(id); + if (_language.IStructuredDataTypeInstance.EqualsIdentity(classifier)) + return NewIStructuredDataTypeInstance(id); + if (_language.IWritableNode.EqualsIdentity(classifier)) + return NewIWritableNode(id); + if (_language.Key_.EqualsIdentity(classifier)) + return NewKey(id); + if (_language.Language.EqualsIdentity(classifier)) + return NewLanguage(id); + if (_language.LanguageBase.EqualsIdentity(classifier)) + return NewLanguageBase(id); + if (_language.LanguageEntity.EqualsIdentity(classifier)) + return NewLanguageEntity(id); + if (_language.Lazy.EqualsIdentity(classifier)) + return NewLazy(id); + if (_language.Link.EqualsIdentity(classifier)) + return NewLink(id); + if (_language.LionCoreFeature.EqualsIdentity(classifier)) + return NewLionCoreFeature(id); + if (_language.LionCoreFeatureKind.EqualsIdentity(classifier)) + return NewLionCoreFeatureKind(id); + if (_language.LionCoreLanguage.EqualsIdentity(classifier)) + return NewLionCoreLanguage(id); + if (_language.LionCoreMetaPointer.EqualsIdentity(classifier)) + return NewLionCoreMetaPointer(id); + if (_language.LionWeb.EqualsIdentity(classifier)) + return NewLionWeb(id); + if (_language.LionWebVersions.EqualsIdentity(classifier)) + return NewLionWebVersions(id); + if (_language.List.EqualsIdentity(classifier)) + return NewList(id); + if (_language.LiteralsLazy.EqualsIdentity(classifier)) + return NewLiteralsLazy(id); + if (_language.M2.EqualsIdentity(classifier)) + return NewM2(id); + if (_language.M3.EqualsIdentity(classifier)) + return NewM3(id); + if (_language.MemberwiseClone_.EqualsIdentity(classifier)) + return NewMemberwiseClone(id); + if (_language.Multiple.EqualsIdentity(classifier)) + return NewMultiple(id); + if (_language.Name_.EqualsIdentity(classifier)) + return NewName(id); + if (_language.Notification.EqualsIdentity(classifier)) + return NewNotification(id); + if (_language.NotNullWhenAttribute.EqualsIdentity(classifier)) + return NewNotNullWhenAttribute(id); + if (_language.Optional.EqualsIdentity(classifier)) + return NewOptional(id); + if (_language.Partition.EqualsIdentity(classifier)) + return NewPartition(id); + if (_language.Pipe.EqualsIdentity(classifier)) + return NewPipe(id); + if (_language.PrimitiveType.EqualsIdentity(classifier)) + return NewPrimitiveType(id); + if (_language.PrimitiveTypeBase.EqualsIdentity(classifier)) + return NewPrimitiveTypeBase(id); + if (_language.Property.EqualsIdentity(classifier)) + return NewProperty(id); + if (_language.PropertyBase.EqualsIdentity(classifier)) + return NewPropertyBase(id); + if (_language.Reference.EqualsIdentity(classifier)) + return NewReference(id); + if (_language.ReferenceBase.EqualsIdentity(classifier)) + return NewReferenceBase(id); + if (_language.ReferenceEquals_.EqualsIdentity(classifier)) + return NewReferenceEquals(id); + if (_language.ReferenceRemover.EqualsIdentity(classifier)) + return NewReferenceRemover(id); + if (_language.ReferenceTargetNonNullTarget.EqualsIdentity(classifier)) + return NewReferenceTargetNonNullTarget(id); + if (_language.ReferenceTargetNonNullTargets.EqualsIdentity(classifier)) + return NewReferenceTargetNonNullTargets(id); + if (_language.ReferenceTargetNullableTarget.EqualsIdentity(classifier)) + return NewReferenceTargetNullableTarget(id); + if (_language.ReferenceTargetNullableTargets.EqualsIdentity(classifier)) + return NewReferenceTargetNullableTargets(id); + if (_language.Remove.EqualsIdentity(classifier)) + return NewRemove(id); + if (_language.RemoveAll.EqualsIdentity(classifier)) + return NewRemoveAll(id); + if (_language.RemoveAnnotations.EqualsIdentity(classifier)) + return NewRemoveAnnotations(id); + if (_language.RemoveAnnotationsRaw.EqualsIdentity(classifier)) + return NewRemoveAnnotationsRaw(id); + if (_language.RemoveChildRaw.EqualsIdentity(classifier)) + return NewRemoveChildRaw(id); + if (_language.RemoveContainmentsRaw.EqualsIdentity(classifier)) + return NewRemoveContainmentsRaw(id); + if (_language.RemoveInternal.EqualsIdentity(classifier)) + return NewRemoveInternal(id); + if (_language.RemoveOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewRemoveOptionalMultipleContainment(id); + if (_language.RemoveOptionalMultipleReference.EqualsIdentity(classifier)) + return NewRemoveOptionalMultipleReference(id); + if (_language.RemoveReferencesRaw.EqualsIdentity(classifier)) + return NewRemoveReferencesRaw(id); + if (_language.RemoveRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewRemoveRequiredMultipleContainment(id); + if (_language.RemoveRequiredMultipleReference.EqualsIdentity(classifier)) + return NewRemoveRequiredMultipleReference(id); + if (_language.RemoveSelfParent.EqualsIdentity(classifier)) + return NewRemoveSelfParent(id); + if (_language.RemoveSelfParentRaw.EqualsIdentity(classifier)) + return NewRemoveSelfParentRaw(id); + if (_language.result.EqualsIdentity(classifier)) + return Newresult(id); + if (_language.Set.EqualsIdentity(classifier)) + return NewSet(id); + if (_language.SetContainmentRaw.EqualsIdentity(classifier)) + return NewSetContainmentRaw(id); + if (_language.SetInternal.EqualsIdentity(classifier)) + return NewSetInternal(id); + if (_language.SetInternalAnnotation.EqualsIdentity(classifier)) + return NewSetInternalAnnotation(id); + if (_language.SetName.EqualsIdentity(classifier)) + return NewSetName(id); + if (_language.SetNameRaw.EqualsIdentity(classifier)) + return NewSetNameRaw(id); + if (_language.SetOptionalMultipleContainment.EqualsIdentity(classifier)) + return NewSetOptionalMultipleContainment(id); + if (_language.SetOptionalMultipleReference.EqualsIdentity(classifier)) + return NewSetOptionalMultipleReference(id); + if (_language.SetOptionalReferenceTypeProperty.EqualsIdentity(classifier)) + return NewSetOptionalReferenceTypeProperty(id); + if (_language.SetOptionalSingleContainment.EqualsIdentity(classifier)) + return NewSetOptionalSingleContainment(id); + if (_language.SetOptionalSingleReference.EqualsIdentity(classifier)) + return NewSetOptionalSingleReference(id); + if (_language.SetOptionalValueTypeProperty.EqualsIdentity(classifier)) + return NewSetOptionalValueTypeProperty(id); + if (_language.SetParentInternal.EqualsIdentity(classifier)) + return NewSetParentInternal(id); + if (_language.SetParentNull.EqualsIdentity(classifier)) + return NewSetParentNull(id); + if (_language.SetPropertyRaw.EqualsIdentity(classifier)) + return NewSetPropertyRaw(id); + if (_language.SetRaw.EqualsIdentity(classifier)) + return NewSetRaw(id); + if (_language.SetReferenceRaw.EqualsIdentity(classifier)) + return NewSetReferenceRaw(id); + if (_language.SetReferencesRaw.EqualsIdentity(classifier)) + return NewSetReferencesRaw(id); + if (_language.SetRequiredMultipleContainment.EqualsIdentity(classifier)) + return NewSetRequiredMultipleContainment(id); + if (_language.SetRequiredMultipleReference.EqualsIdentity(classifier)) + return NewSetRequiredMultipleReference(id); + if (_language.SetRequiredReferenceTypeProperty.EqualsIdentity(classifier)) + return NewSetRequiredReferenceTypeProperty(id); + if (_language.SetRequiredSingleContainment.EqualsIdentity(classifier)) + return NewSetRequiredSingleContainment(id); + if (_language.SetRequiredSingleReference.EqualsIdentity(classifier)) + return NewSetRequiredSingleReference(id); + if (_language.SetRequiredValueTypeProperty.EqualsIdentity(classifier)) + return NewSetRequiredValueTypeProperty(id); + if (_language.SetSelfParent.EqualsIdentity(classifier)) + return NewSetSelfParent(id); + if (_language.SetSelfParentRaw.EqualsIdentity(classifier)) + return NewSetSelfParentRaw(id); + if (_language.String.EqualsIdentity(classifier)) + return NewString(id); + if (_language.StructuredDataType.EqualsIdentity(classifier)) + return NewStructuredDataType(id); + if (_language.StructuredDataTypeBase.EqualsIdentity(classifier)) + return NewStructuredDataTypeBase(id); + if (_language.System.EqualsIdentity(classifier)) + return NewSystem(id); + if (_language.ToString_.EqualsIdentity(classifier)) + return NewToString(id); + if (_language.TryGet_.EqualsIdentity(classifier)) + return NewTryGet(id); + if (_language.TryGetContainmentRaw_.EqualsIdentity(classifier)) + return NewTryGetContainmentRaw(id); + if (_language.TryGetContainmentsRaw_.EqualsIdentity(classifier)) + return NewTryGetContainmentsRaw(id); + if (_language.TryGetName_.EqualsIdentity(classifier)) + return NewTryGetName(id); + if (_language.TryGetPropertyRaw_.EqualsIdentity(classifier)) + return NewTryGetPropertyRaw(id); + if (_language.TryGetReference.EqualsIdentity(classifier)) + return NewTryGetReference(id); + if (_language.TryGetReferenceRaw_.EqualsIdentity(classifier)) + return NewTryGetReferenceRaw(id); + if (_language.TryGetReferencesRaw_.EqualsIdentity(classifier)) + return NewTryGetReferencesRaw(id); + if (_language.Type.EqualsIdentity(classifier)) + return NewType(id); + if (_language.UnsetFeatureException.EqualsIdentity(classifier)) + return NewUnsetFeatureException(id); + if (_language.UnsetFieldException.EqualsIdentity(classifier)) + return NewUnsetFieldException(id); + if (_language.UnsupportedClassifierException.EqualsIdentity(classifier)) + return NewUnsupportedClassifierException(id); + if (_language.UnsupportedEnumerationLiteralException.EqualsIdentity(classifier)) + return NewUnsupportedEnumerationLiteralException(id); + if (_language.UnsupportedStructuredDataTypeException.EqualsIdentity(classifier)) + return NewUnsupportedStructuredDataTypeException(id); + if (_language.Utilities.EqualsIdentity(classifier)) + return NewUtilities(id); + if (_language.V2023_1.EqualsIdentity(classifier)) + return NewV2023_1(id); + if (_language.V2024_1.EqualsIdentity(classifier)) + return NewV2024_1(id); + if (_language.V2024_1_Compatible.EqualsIdentity(classifier)) + return NewV2024_1_Compatible(id); + if (_language.V2025_1.EqualsIdentity(classifier)) + return NewV2025_1(id); + if (_language.V2025_1_Compatible.EqualsIdentity(classifier)) + return NewV2025_1_Compatible(id); + if (_language.VersionSpecific.EqualsIdentity(classifier)) + return NewVersionSpecific(id); + throw new global::LionWeb.Core.UnsupportedClassifierException(classifier); + } + + /// + public override global::System.Enum GetEnumerationLiteral(global::LionWeb.Core.M3.EnumerationLiteral literal) + { + throw new global::LionWeb.Core.UnsupportedEnumerationLiteralException(literal); + } + + /// + public override global::LionWeb.Core.IStructuredDataTypeInstance CreateStructuredDataTypeInstance(global::LionWeb.Core.M3.StructuredDataType structuredDataType, global::LionWeb.Core.M2.IFieldValues fieldValues) + { + throw new global::LionWeb.Core.UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual _builtIns New_builtIns(string id) => new(id); + public virtual _builtIns Create_builtIns() => New_builtIns(GetNewId()); + public virtual Abstract NewAbstract(string id) => new(id); + public virtual Abstract CreateAbstract() => NewAbstract(GetNewId()); + public virtual AbstractBaseNodeFactory NewAbstractBaseNodeFactory(string id) => new(id); + public virtual AbstractBaseNodeFactory CreateAbstractBaseNodeFactory() => NewAbstractBaseNodeFactory(GetNewId()); + public virtual Add NewAdd(string id) => new(id); + public virtual Add CreateAdd() => NewAdd(GetNewId()); + public virtual AddAnnotations NewAddAnnotations(string id) => new(id); + public virtual AddAnnotations CreateAddAnnotations() => NewAddAnnotations(GetNewId()); + public virtual AddAnnotationsRaw NewAddAnnotationsRaw(string id) => new(id); + public virtual AddAnnotationsRaw CreateAddAnnotationsRaw() => NewAddAnnotationsRaw(GetNewId()); + public virtual AddChildRaw NewAddChildRaw(string id) => new(id); + public virtual AddChildRaw CreateAddChildRaw() => NewAddChildRaw(GetNewId()); + public virtual AddContainmentsRaw_ NewAddContainmentsRaw(string id) => new(id); + public virtual AddContainmentsRaw_ CreateAddContainmentsRaw() => NewAddContainmentsRaw(GetNewId()); + public virtual AddInternal_ NewAddInternal(string id) => new(id); + public virtual AddInternal_ CreateAddInternal() => NewAddInternal(GetNewId()); + public virtual AddOptionalMultipleContainment NewAddOptionalMultipleContainment(string id) => new(id); + public virtual AddOptionalMultipleContainment CreateAddOptionalMultipleContainment() => NewAddOptionalMultipleContainment(GetNewId()); + public virtual AddOptionalMultipleReference NewAddOptionalMultipleReference(string id) => new(id); + public virtual AddOptionalMultipleReference CreateAddOptionalMultipleReference() => NewAddOptionalMultipleReference(GetNewId()); + public virtual AddReferencesRaw_ NewAddReferencesRaw(string id) => new(id); + public virtual AddReferencesRaw_ CreateAddReferencesRaw() => NewAddReferencesRaw(GetNewId()); + public virtual AddRequiredMultipleContainment NewAddRequiredMultipleContainment(string id) => new(id); + public virtual AddRequiredMultipleContainment CreateAddRequiredMultipleContainment() => NewAddRequiredMultipleContainment(GetNewId()); + public virtual AddRequiredMultipleReference NewAddRequiredMultipleReference(string id) => new(id); + public virtual AddRequiredMultipleReference CreateAddRequiredMultipleReference() => NewAddRequiredMultipleReference(GetNewId()); + public virtual AnnotatesLazy NewAnnotatesLazy(string id) => new(id); + public virtual AnnotatesLazy CreateAnnotatesLazy() => NewAnnotatesLazy(GetNewId()); + public virtual Annotation NewAnnotation(string id) => new(id); + public virtual Annotation CreateAnnotation() => NewAnnotation(GetNewId()); + public virtual AnnotationBase NewAnnotationBase(string id) => new(id); + public virtual AnnotationBase CreateAnnotationBase() => NewAnnotationBase(GetNewId()); + public virtual AnnotationInstanceBase NewAnnotationInstanceBase(string id) => new(id); + public virtual AnnotationInstanceBase CreateAnnotationInstanceBase() => NewAnnotationInstanceBase(GetNewId()); + public virtual AnnotationRemover NewAnnotationRemover(string id) => new(id); + public virtual AnnotationRemover CreateAnnotationRemover() => NewAnnotationRemover(GetNewId()); + public virtual ArgumentOutOfRangeException NewArgumentOutOfRangeException(string id) => new(id); + public virtual ArgumentOutOfRangeException CreateArgumentOutOfRangeException() => NewArgumentOutOfRangeException(GetNewId()); + public virtual AsList NewAsList(string id) => new(id); + public virtual AsList CreateAsList() => NewAsList(GetNewId()); + public virtual AsNonEmptyReadOnly NewAsNonEmptyReadOnly(string id) => new(id); + public virtual AsNonEmptyReadOnly CreateAsNonEmptyReadOnly() => NewAsNonEmptyReadOnly(GetNewId()); + public virtual AssureAnnotations NewAssureAnnotations(string id) => new(id); + public virtual AssureAnnotations CreateAssureAnnotations() => NewAssureAnnotations(GetNewId()); + public virtual AssureInRange NewAssureInRange(string id) => new(id); + public virtual AssureInRange CreateAssureInRange() => NewAssureInRange(GetNewId()); + public virtual AssureNonEmpty NewAssureNonEmpty(string id) => new(id); + public virtual AssureNonEmpty CreateAssureNonEmpty() => NewAssureNonEmpty(GetNewId()); + public virtual AssureNoSelfMove NewAssureNoSelfMove(string id) => new(id); + public virtual AssureNoSelfMove CreateAssureNoSelfMove() => NewAssureNoSelfMove(GetNewId()); + public virtual AssureNotClearing NewAssureNotClearing(string id) => new(id); + public virtual AssureNotClearing CreateAssureNotClearing() => NewAssureNotClearing(GetNewId()); + public virtual AssureNotNull NewAssureNotNull(string id) => new(id); + public virtual AssureNotNull CreateAssureNotNull() => NewAssureNotNull(GetNewId()); + public virtual AssureNotNullInstance NewAssureNotNullInstance(string id) => new(id); + public virtual AssureNotNullInstance CreateAssureNotNullInstance() => NewAssureNotNullInstance(GetNewId()); + public virtual AssureNotNullMembers NewAssureNotNullMembers(string id) => new(id); + public virtual AssureNotNullMembers CreateAssureNotNullMembers() => NewAssureNotNullMembers(GetNewId()); + public virtual AssureNullableInstance NewAssureNullableInstance(string id) => new(id); + public virtual AssureNullableInstance CreateAssureNullableInstance() => NewAssureNullableInstance(GetNewId()); + public virtual AttachChild NewAttachChild(string id) => new(id); + public virtual AttachChild CreateAttachChild() => NewAttachChild(GetNewId()); + public virtual Bool NewBool(string id) => new(id); + public virtual Bool CreateBool() => NewBool(GetNewId()); + public virtual Boolean NewBoolean(string id) => new(id); + public virtual Boolean CreateBoolean() => NewBoolean(GetNewId()); + public virtual Char NewChar(string id) => new(id); + public virtual Char CreateChar() => NewChar(GetNewId()); + public virtual Character NewCharacter(string id) => new(id); + public virtual Character CreateCharacter() => NewCharacter(GetNewId()); + public virtual Classifier NewClassifier(string id) => new(id); + public virtual Classifier CreateClassifier() => NewClassifier(GetNewId()); + public virtual CodeAnalysis NewCodeAnalysis(string id) => new(id); + public virtual CodeAnalysis CreateCodeAnalysis() => NewCodeAnalysis(GetNewId()); + public virtual CollectAllSetFeatures_ NewCollectAllSetFeatures(string id) => new(id); + public virtual CollectAllSetFeatures_ CreateCollectAllSetFeatures() => NewCollectAllSetFeatures(GetNewId()); + public virtual Collections NewCollections(string id) => new(id); + public virtual Collections CreateCollections() => NewCollections(GetNewId()); + public virtual Concept NewConcept(string id) => new(id); + public virtual Concept CreateConcept() => NewConcept(GetNewId()); + public virtual ConceptBase NewConceptBase(string id) => new(id); + public virtual ConceptBase CreateConceptBase() => NewConceptBase(GetNewId()); + public virtual ConceptInstanceBase NewConceptInstanceBase(string id) => new(id); + public virtual ConceptInstanceBase CreateConceptInstanceBase() => NewConceptInstanceBase(GetNewId()); + public virtual Containment NewContainment(string id) => new(id); + public virtual Containment CreateContainment() => NewContainment(GetNewId()); + public virtual ContainmentBase NewContainmentBase(string id) => new(id); + public virtual ContainmentBase CreateContainmentBase() => NewContainmentBase(GetNewId()); + public virtual ContainmentRemover NewContainmentRemover(string id) => new(id); + public virtual ContainmentRemover CreateContainmentRemover() => NewContainmentRemover(GetNewId()); + public virtual Core NewCore(string id) => new(id); + public virtual Core CreateCore() => NewCore(GetNewId()); + public virtual Datatype NewDatatype(string id) => new(id); + public virtual Datatype CreateDatatype() => NewDatatype(GetNewId()); + public virtual DatatypeBase NewDatatypeBase(string id) => new(id); + public virtual DatatypeBase CreateDatatypeBase() => NewDatatypeBase(GetNewId()); + public virtual Decimal NewDecimal(string id) => new(id); + public virtual Decimal CreateDecimal() => NewDecimal(GetNewId()); + public virtual DetachChild_ NewDetachChild(string id) => new(id); + public virtual DetachChild_ CreateDetachChild() => NewDetachChild(GetNewId()); + public virtual DetachChildInternal NewDetachChildInternal(string id) => new(id); + public virtual DetachChildInternal CreateDetachChildInternal() => NewDetachChildInternal(GetNewId()); + public virtual DetachFromParent_ NewDetachFromParent(string id) => new(id); + public virtual DetachFromParent_ CreateDetachFromParent() => NewDetachFromParent(GetNewId()); + public virtual Diagnostics NewDiagnostics(string id) => new(id); + public virtual Diagnostics CreateDiagnostics() => NewDiagnostics(GetNewId()); + public virtual Enum NewEnum(string id) => new(id); + public virtual Enum CreateEnum() => NewEnum(GetNewId()); + public virtual Enumeration NewEnumeration(string id) => new(id); + public virtual Enumeration CreateEnumeration() => NewEnumeration(GetNewId()); + public virtual EnumerationBase NewEnumerationBase(string id) => new(id); + public virtual EnumerationBase CreateEnumerationBase() => NewEnumerationBase(GetNewId()); + public virtual EnumerationLiteral NewEnumerationLiteral(string id) => new(id); + public virtual EnumerationLiteral CreateEnumerationLiteral() => NewEnumerationLiteral(GetNewId()); + public virtual EnumerationLiteralBase NewEnumerationLiteralBase(string id) => new(id); + public virtual EnumerationLiteralBase CreateEnumerationLiteralBase() => NewEnumerationLiteralBase(GetNewId()); + public virtual Equals NewEquals(string id) => new(id); + public virtual Equals CreateEquals() => NewEquals(GetNewId()); + public virtual ExchangeChildRaw NewExchangeChildRaw(string id) => new(id); + public virtual ExchangeChildRaw CreateExchangeChildRaw() => NewExchangeChildRaw(GetNewId()); + public virtual ExchangeChildrenRaw NewExchangeChildrenRaw(string id) => new(id); + public virtual ExchangeChildrenRaw CreateExchangeChildrenRaw() => NewExchangeChildrenRaw(GetNewId()); + public virtual FeaturesLazy NewFeaturesLazy(string id) => new(id); + public virtual FeaturesLazy CreateFeaturesLazy() => NewFeaturesLazy(GetNewId()); + public virtual Field NewField(string id) => new(id); + public virtual Field CreateField() => NewField(GetNewId()); + public virtual FieldBase NewFieldBase(string id) => new(id); + public virtual FieldBase CreateFieldBase() => NewFieldBase(GetNewId()); + public virtual FieldsLazy NewFieldsLazy(string id) => new(id); + public virtual FieldsLazy CreateFieldsLazy() => NewFieldsLazy(GetNewId()); + public virtual Finalize NewFinalize(string id) => new(id); + public virtual Finalize CreateFinalize() => NewFinalize(GetNewId()); + public virtual Generic NewGeneric(string id) => new(id); + public virtual Generic CreateGeneric() => NewGeneric(GetNewId()); + public virtual Get NewGet(string id) => new(id); + public virtual Get CreateGet() => NewGet(GetNewId()); + public virtual get__builtIns Newget__builtIns(string id) => new(id); + public virtual get__builtIns Createget__builtIns() => Newget__builtIns(GetNewId()); + public virtual get__m3 Newget__m3(string id) => new(id); + public virtual get__m3 Createget__m3() => Newget__m3(GetNewId()); + public virtual GetAnnotation NewGetAnnotation(string id) => new(id); + public virtual GetAnnotation CreateGetAnnotation() => NewGetAnnotation(GetNewId()); + public virtual GetAnnotations NewGetAnnotations(string id) => new(id); + public virtual GetAnnotations CreateGetAnnotations() => NewGetAnnotations(GetNewId()); + public virtual GetAnnotationsRaw NewGetAnnotationsRaw(string id) => new(id); + public virtual GetAnnotationsRaw CreateGetAnnotationsRaw() => NewGetAnnotationsRaw(GetNewId()); + public virtual GetClassifier_ NewGetClassifier(string id) => new(id); + public virtual GetClassifier_ CreateGetClassifier() => NewGetClassifier(GetNewId()); + public virtual GetConcept_ NewGetConcept(string id) => new(id); + public virtual GetConcept_ CreateGetConcept() => NewGetConcept(GetNewId()); + public virtual GetContainmentOf_ NewGetContainmentOf(string id) => new(id); + public virtual GetContainmentOf_ CreateGetContainmentOf() => NewGetContainmentOf(GetNewId()); + public virtual GetHashCode NewGetHashCode(string id) => new(id); + public virtual GetHashCode CreateGetHashCode() => NewGetHashCode(GetNewId()); + public virtual GetId NewGetId(string id) => new(id); + public virtual GetId CreateGetId() => NewGetId(GetNewId()); + public virtual GetInternal_ NewGetInternal(string id) => new(id); + public virtual GetInternal_ CreateGetInternal() => NewGetInternal(GetNewId()); + public virtual GetParent NewGetParent(string id) => new(id); + public virtual GetParent CreateGetParent() => NewGetParent(GetNewId()); + public virtual GetPartitionNotificationProducer_ NewGetPartitionNotificationProducer(string id) => new(id); + public virtual GetPartitionNotificationProducer_ CreateGetPartitionNotificationProducer() => NewGetPartitionNotificationProducer(GetNewId()); + public virtual GetRequiredNonNullReferences NewGetRequiredNonNullReferences(string id) => new(id); + public virtual GetRequiredNonNullReferences CreateGetRequiredNonNullReferences() => NewGetRequiredNonNullReferences(GetNewId()); + public virtual GetRequiredNullableReferences NewGetRequiredNullableReferences(string id) => new(id); + public virtual GetRequiredNullableReferences CreateGetRequiredNullableReferences() => NewGetRequiredNullableReferences(GetNewId()); + public virtual GetRequiredReference NewGetRequiredReference(string id) => new(id); + public virtual GetRequiredReference CreateGetRequiredReference() => NewGetRequiredReference(GetNewId()); + public virtual GetType NewGetType(string id) => new(id); + public virtual GetType CreateGetType() => NewGetType(GetNewId()); + public virtual IEnumerable NewIEnumerable(string id) => new(id); + public virtual IEnumerable CreateIEnumerable() => NewIEnumerable(GetNewId()); + public virtual IFieldValues NewIFieldValues(string id) => new(id); + public virtual IFieldValues CreateIFieldValues() => NewIFieldValues(GetNewId()); + public virtual ImplementsLazy NewImplementsLazy(string id) => new(id); + public virtual ImplementsLazy CreateImplementsLazy() => NewImplementsLazy(GetNewId()); + public virtual INamed NewINamed(string id) => new(id); + public virtual INamed CreateINamed() => NewINamed(GetNewId()); + public virtual INamedWritable NewINamedWritable(string id) => new(id); + public virtual INamedWritable CreateINamedWritable() => NewINamedWritable(GetNewId()); + public virtual INode NewINode(string id) => new(id); + public virtual INode CreateINode() => NewINode(GetNewId()); + public virtual INodeFactory NewINodeFactory(string id) => new(id); + public virtual INodeFactory CreateINodeFactory() => NewINodeFactory(GetNewId()); + public virtual Insert NewInsert(string id) => new(id); + public virtual Insert CreateInsert() => NewInsert(GetNewId()); + public virtual InsertAnnotations NewInsertAnnotations(string id) => new(id); + public virtual InsertAnnotations CreateInsertAnnotations() => NewInsertAnnotations(GetNewId()); + public virtual InsertAnnotationsRaw NewInsertAnnotationsRaw(string id) => new(id); + public virtual InsertAnnotationsRaw CreateInsertAnnotationsRaw() => NewInsertAnnotationsRaw(GetNewId()); + public virtual InsertChildRaw NewInsertChildRaw(string id) => new(id); + public virtual InsertChildRaw CreateInsertChildRaw() => NewInsertChildRaw(GetNewId()); + public virtual InsertContainmentsRaw_ NewInsertContainmentsRaw(string id) => new(id); + public virtual InsertContainmentsRaw_ CreateInsertContainmentsRaw() => NewInsertContainmentsRaw(GetNewId()); + public virtual InsertInternal_ NewInsertInternal(string id) => new(id); + public virtual InsertInternal_ CreateInsertInternal() => NewInsertInternal(GetNewId()); + public virtual InsertOptionalMultipleContainment NewInsertOptionalMultipleContainment(string id) => new(id); + public virtual InsertOptionalMultipleContainment CreateInsertOptionalMultipleContainment() => NewInsertOptionalMultipleContainment(GetNewId()); + public virtual InsertOptionalMultipleReference NewInsertOptionalMultipleReference(string id) => new(id); + public virtual InsertOptionalMultipleReference CreateInsertOptionalMultipleReference() => NewInsertOptionalMultipleReference(GetNewId()); + public virtual InsertReferencesRaw_ NewInsertReferencesRaw(string id) => new(id); + public virtual InsertReferencesRaw_ CreateInsertReferencesRaw() => NewInsertReferencesRaw(GetNewId()); + public virtual InsertRequiredMultipleContainment NewInsertRequiredMultipleContainment(string id) => new(id); + public virtual InsertRequiredMultipleContainment CreateInsertRequiredMultipleContainment() => NewInsertRequiredMultipleContainment(GetNewId()); + public virtual InsertRequiredMultipleReference NewInsertRequiredMultipleReference(string id) => new(id); + public virtual InsertRequiredMultipleReference CreateInsertRequiredMultipleReference() => NewInsertRequiredMultipleReference(GetNewId()); + public virtual Instance NewInstance(string id) => new(id); + public virtual Instance CreateInstance() => NewInstance(GetNewId()); + public virtual Integer NewInteger(string id) => new(id); + public virtual Integer CreateInteger() => NewInteger(GetNewId()); + public virtual Interface NewInterface(string id) => new(id); + public virtual Interface CreateInterface() => NewInterface(GetNewId()); + public virtual InterfaceBase NewInterfaceBase(string id) => new(id); + public virtual InterfaceBase CreateInterfaceBase() => NewInterfaceBase(GetNewId()); + public virtual InvalidValueException NewInvalidValueException(string id) => new(id); + public virtual InvalidValueException CreateInvalidValueException() => NewInvalidValueException(GetNewId()); + public virtual IPartitionInstance NewIPartitionInstance(string id) => new(id); + public virtual IPartitionInstance CreateIPartitionInstance() => NewIPartitionInstance(GetNewId()); + public virtual IReadableNode NewIReadableNode(string id) => new(id); + public virtual IReadableNode CreateIReadableNode() => NewIReadableNode(GetNewId()); + public virtual IReadOnlyList NewIReadOnlyList(string id) => new(id); + public virtual IReadOnlyList CreateIReadOnlyList() => NewIReadOnlyList(GetNewId()); + public virtual IsInRange NewIsInRange(string id) => new(id); + public virtual IsInRange CreateIsInRange() => NewIsInRange(GetNewId()); + public virtual IStructuredDataTypeInstance NewIStructuredDataTypeInstance(string id) => new(id); + public virtual IStructuredDataTypeInstance CreateIStructuredDataTypeInstance() => NewIStructuredDataTypeInstance(GetNewId()); + public virtual IWritableNode NewIWritableNode(string id) => new(id); + public virtual IWritableNode CreateIWritableNode() => NewIWritableNode(GetNewId()); + public virtual Key NewKey(string id) => new(id); + public virtual Key CreateKey() => NewKey(GetNewId()); + public virtual Language NewLanguage(string id) => new(id); + public virtual Language CreateLanguage() => NewLanguage(GetNewId()); + public virtual LanguageBase NewLanguageBase(string id) => new(id); + public virtual LanguageBase CreateLanguageBase() => NewLanguageBase(GetNewId()); + public virtual LanguageEntity NewLanguageEntity(string id) => new(id); + public virtual LanguageEntity CreateLanguageEntity() => NewLanguageEntity(GetNewId()); + public virtual Lazy NewLazy(string id) => new(id); + public virtual Lazy CreateLazy() => NewLazy(GetNewId()); + public virtual Link NewLink(string id) => new(id); + public virtual Link CreateLink() => NewLink(GetNewId()); + public virtual LionCoreFeature NewLionCoreFeature(string id) => new(id); + public virtual LionCoreFeature CreateLionCoreFeature() => NewLionCoreFeature(GetNewId()); + public virtual LionCoreFeatureKind NewLionCoreFeatureKind(string id) => new(id); + public virtual LionCoreFeatureKind CreateLionCoreFeatureKind() => NewLionCoreFeatureKind(GetNewId()); + public virtual LionCoreLanguage NewLionCoreLanguage(string id) => new(id); + public virtual LionCoreLanguage CreateLionCoreLanguage() => NewLionCoreLanguage(GetNewId()); + public virtual LionCoreMetaPointer NewLionCoreMetaPointer(string id) => new(id); + public virtual LionCoreMetaPointer CreateLionCoreMetaPointer() => NewLionCoreMetaPointer(GetNewId()); + public virtual LionWeb NewLionWeb(string id) => new(id); + public virtual LionWeb CreateLionWeb() => NewLionWeb(GetNewId()); + public virtual LionWebVersions NewLionWebVersions(string id) => new(id); + public virtual LionWebVersions CreateLionWebVersions() => NewLionWebVersions(GetNewId()); + public virtual List NewList(string id) => new(id); + public virtual List CreateList() => NewList(GetNewId()); + public virtual LiteralsLazy NewLiteralsLazy(string id) => new(id); + public virtual LiteralsLazy CreateLiteralsLazy() => NewLiteralsLazy(GetNewId()); + public virtual M2 NewM2(string id) => new(id); + public virtual M2 CreateM2() => NewM2(GetNewId()); + public virtual M3 NewM3(string id) => new(id); + public virtual M3 CreateM3() => NewM3(GetNewId()); + public virtual MemberwiseClone NewMemberwiseClone(string id) => new(id); + public virtual MemberwiseClone CreateMemberwiseClone() => NewMemberwiseClone(GetNewId()); + public virtual Multiple NewMultiple(string id) => new(id); + public virtual Multiple CreateMultiple() => NewMultiple(GetNewId()); + public virtual Name NewName(string id) => new(id); + public virtual Name CreateName() => NewName(GetNewId()); + public virtual Notification NewNotification(string id) => new(id); + public virtual Notification CreateNotification() => NewNotification(GetNewId()); + public virtual NotNullWhenAttribute NewNotNullWhenAttribute(string id) => new(id); + public virtual NotNullWhenAttribute CreateNotNullWhenAttribute() => NewNotNullWhenAttribute(GetNewId()); + public virtual Optional NewOptional(string id) => new(id); + public virtual Optional CreateOptional() => NewOptional(GetNewId()); + public virtual Partition NewPartition(string id) => new(id); + public virtual Partition CreatePartition() => NewPartition(GetNewId()); + public virtual Pipe NewPipe(string id) => new(id); + public virtual Pipe CreatePipe() => NewPipe(GetNewId()); + public virtual PrimitiveType NewPrimitiveType(string id) => new(id); + public virtual PrimitiveType CreatePrimitiveType() => NewPrimitiveType(GetNewId()); + public virtual PrimitiveTypeBase NewPrimitiveTypeBase(string id) => new(id); + public virtual PrimitiveTypeBase CreatePrimitiveTypeBase() => NewPrimitiveTypeBase(GetNewId()); + public virtual Property NewProperty(string id) => new(id); + public virtual Property CreateProperty() => NewProperty(GetNewId()); + public virtual PropertyBase NewPropertyBase(string id) => new(id); + public virtual PropertyBase CreatePropertyBase() => NewPropertyBase(GetNewId()); + public virtual Reference NewReference(string id) => new(id); + public virtual Reference CreateReference() => NewReference(GetNewId()); + public virtual ReferenceBase NewReferenceBase(string id) => new(id); + public virtual ReferenceBase CreateReferenceBase() => NewReferenceBase(GetNewId()); + public virtual ReferenceEquals NewReferenceEquals(string id) => new(id); + public virtual ReferenceEquals CreateReferenceEquals() => NewReferenceEquals(GetNewId()); + public virtual ReferenceRemover NewReferenceRemover(string id) => new(id); + public virtual ReferenceRemover CreateReferenceRemover() => NewReferenceRemover(GetNewId()); + public virtual ReferenceTargetNonNullTarget NewReferenceTargetNonNullTarget(string id) => new(id); + public virtual ReferenceTargetNonNullTarget CreateReferenceTargetNonNullTarget() => NewReferenceTargetNonNullTarget(GetNewId()); + public virtual ReferenceTargetNonNullTargets NewReferenceTargetNonNullTargets(string id) => new(id); + public virtual ReferenceTargetNonNullTargets CreateReferenceTargetNonNullTargets() => NewReferenceTargetNonNullTargets(GetNewId()); + public virtual ReferenceTargetNullableTarget NewReferenceTargetNullableTarget(string id) => new(id); + public virtual ReferenceTargetNullableTarget CreateReferenceTargetNullableTarget() => NewReferenceTargetNullableTarget(GetNewId()); + public virtual ReferenceTargetNullableTargets NewReferenceTargetNullableTargets(string id) => new(id); + public virtual ReferenceTargetNullableTargets CreateReferenceTargetNullableTargets() => NewReferenceTargetNullableTargets(GetNewId()); + public virtual Remove NewRemove(string id) => new(id); + public virtual Remove CreateRemove() => NewRemove(GetNewId()); + public virtual RemoveAll NewRemoveAll(string id) => new(id); + public virtual RemoveAll CreateRemoveAll() => NewRemoveAll(GetNewId()); + public virtual RemoveAnnotations NewRemoveAnnotations(string id) => new(id); + public virtual RemoveAnnotations CreateRemoveAnnotations() => NewRemoveAnnotations(GetNewId()); + public virtual RemoveAnnotationsRaw NewRemoveAnnotationsRaw(string id) => new(id); + public virtual RemoveAnnotationsRaw CreateRemoveAnnotationsRaw() => NewRemoveAnnotationsRaw(GetNewId()); + public virtual RemoveChildRaw NewRemoveChildRaw(string id) => new(id); + public virtual RemoveChildRaw CreateRemoveChildRaw() => NewRemoveChildRaw(GetNewId()); + public virtual RemoveContainmentsRaw_ NewRemoveContainmentsRaw(string id) => new(id); + public virtual RemoveContainmentsRaw_ CreateRemoveContainmentsRaw() => NewRemoveContainmentsRaw(GetNewId()); + public virtual RemoveInternal_ NewRemoveInternal(string id) => new(id); + public virtual RemoveInternal_ CreateRemoveInternal() => NewRemoveInternal(GetNewId()); + public virtual RemoveOptionalMultipleContainment NewRemoveOptionalMultipleContainment(string id) => new(id); + public virtual RemoveOptionalMultipleContainment CreateRemoveOptionalMultipleContainment() => NewRemoveOptionalMultipleContainment(GetNewId()); + public virtual RemoveOptionalMultipleReference NewRemoveOptionalMultipleReference(string id) => new(id); + public virtual RemoveOptionalMultipleReference CreateRemoveOptionalMultipleReference() => NewRemoveOptionalMultipleReference(GetNewId()); + public virtual RemoveReferencesRaw_ NewRemoveReferencesRaw(string id) => new(id); + public virtual RemoveReferencesRaw_ CreateRemoveReferencesRaw() => NewRemoveReferencesRaw(GetNewId()); + public virtual RemoveRequiredMultipleContainment NewRemoveRequiredMultipleContainment(string id) => new(id); + public virtual RemoveRequiredMultipleContainment CreateRemoveRequiredMultipleContainment() => NewRemoveRequiredMultipleContainment(GetNewId()); + public virtual RemoveRequiredMultipleReference NewRemoveRequiredMultipleReference(string id) => new(id); + public virtual RemoveRequiredMultipleReference CreateRemoveRequiredMultipleReference() => NewRemoveRequiredMultipleReference(GetNewId()); + public virtual RemoveSelfParent NewRemoveSelfParent(string id) => new(id); + public virtual RemoveSelfParent CreateRemoveSelfParent() => NewRemoveSelfParent(GetNewId()); + public virtual RemoveSelfParentRaw NewRemoveSelfParentRaw(string id) => new(id); + public virtual RemoveSelfParentRaw CreateRemoveSelfParentRaw() => NewRemoveSelfParentRaw(GetNewId()); + public virtual result Newresult(string id) => new(id); + public virtual result Createresult() => Newresult(GetNewId()); + public virtual Set NewSet(string id) => new(id); + public virtual Set CreateSet() => NewSet(GetNewId()); + public virtual SetContainmentRaw_ NewSetContainmentRaw(string id) => new(id); + public virtual SetContainmentRaw_ CreateSetContainmentRaw() => NewSetContainmentRaw(GetNewId()); + public virtual SetInternal_ NewSetInternal(string id) => new(id); + public virtual SetInternal_ CreateSetInternal() => NewSetInternal(GetNewId()); + public virtual SetInternalAnnotation NewSetInternalAnnotation(string id) => new(id); + public virtual SetInternalAnnotation CreateSetInternalAnnotation() => NewSetInternalAnnotation(GetNewId()); + public virtual SetName NewSetName(string id) => new(id); + public virtual SetName CreateSetName() => NewSetName(GetNewId()); + public virtual SetNameRaw NewSetNameRaw(string id) => new(id); + public virtual SetNameRaw CreateSetNameRaw() => NewSetNameRaw(GetNewId()); + public virtual SetOptionalMultipleContainment NewSetOptionalMultipleContainment(string id) => new(id); + public virtual SetOptionalMultipleContainment CreateSetOptionalMultipleContainment() => NewSetOptionalMultipleContainment(GetNewId()); + public virtual SetOptionalMultipleReference NewSetOptionalMultipleReference(string id) => new(id); + public virtual SetOptionalMultipleReference CreateSetOptionalMultipleReference() => NewSetOptionalMultipleReference(GetNewId()); + public virtual SetOptionalReferenceTypeProperty NewSetOptionalReferenceTypeProperty(string id) => new(id); + public virtual SetOptionalReferenceTypeProperty CreateSetOptionalReferenceTypeProperty() => NewSetOptionalReferenceTypeProperty(GetNewId()); + public virtual SetOptionalSingleContainment NewSetOptionalSingleContainment(string id) => new(id); + public virtual SetOptionalSingleContainment CreateSetOptionalSingleContainment() => NewSetOptionalSingleContainment(GetNewId()); + public virtual SetOptionalSingleReference NewSetOptionalSingleReference(string id) => new(id); + public virtual SetOptionalSingleReference CreateSetOptionalSingleReference() => NewSetOptionalSingleReference(GetNewId()); + public virtual SetOptionalValueTypeProperty NewSetOptionalValueTypeProperty(string id) => new(id); + public virtual SetOptionalValueTypeProperty CreateSetOptionalValueTypeProperty() => NewSetOptionalValueTypeProperty(GetNewId()); + public virtual SetParentInternal NewSetParentInternal(string id) => new(id); + public virtual SetParentInternal CreateSetParentInternal() => NewSetParentInternal(GetNewId()); + public virtual SetParentNull NewSetParentNull(string id) => new(id); + public virtual SetParentNull CreateSetParentNull() => NewSetParentNull(GetNewId()); + public virtual SetPropertyRaw_ NewSetPropertyRaw(string id) => new(id); + public virtual SetPropertyRaw_ CreateSetPropertyRaw() => NewSetPropertyRaw(GetNewId()); + public virtual SetRaw_ NewSetRaw(string id) => new(id); + public virtual SetRaw_ CreateSetRaw() => NewSetRaw(GetNewId()); + public virtual SetReferenceRaw_ NewSetReferenceRaw(string id) => new(id); + public virtual SetReferenceRaw_ CreateSetReferenceRaw() => NewSetReferenceRaw(GetNewId()); + public virtual SetReferencesRaw NewSetReferencesRaw(string id) => new(id); + public virtual SetReferencesRaw CreateSetReferencesRaw() => NewSetReferencesRaw(GetNewId()); + public virtual SetRequiredMultipleContainment NewSetRequiredMultipleContainment(string id) => new(id); + public virtual SetRequiredMultipleContainment CreateSetRequiredMultipleContainment() => NewSetRequiredMultipleContainment(GetNewId()); + public virtual SetRequiredMultipleReference NewSetRequiredMultipleReference(string id) => new(id); + public virtual SetRequiredMultipleReference CreateSetRequiredMultipleReference() => NewSetRequiredMultipleReference(GetNewId()); + public virtual SetRequiredReferenceTypeProperty NewSetRequiredReferenceTypeProperty(string id) => new(id); + public virtual SetRequiredReferenceTypeProperty CreateSetRequiredReferenceTypeProperty() => NewSetRequiredReferenceTypeProperty(GetNewId()); + public virtual SetRequiredSingleContainment NewSetRequiredSingleContainment(string id) => new(id); + public virtual SetRequiredSingleContainment CreateSetRequiredSingleContainment() => NewSetRequiredSingleContainment(GetNewId()); + public virtual SetRequiredSingleReference NewSetRequiredSingleReference(string id) => new(id); + public virtual SetRequiredSingleReference CreateSetRequiredSingleReference() => NewSetRequiredSingleReference(GetNewId()); + public virtual SetRequiredValueTypeProperty NewSetRequiredValueTypeProperty(string id) => new(id); + public virtual SetRequiredValueTypeProperty CreateSetRequiredValueTypeProperty() => NewSetRequiredValueTypeProperty(GetNewId()); + public virtual SetSelfParent NewSetSelfParent(string id) => new(id); + public virtual SetSelfParent CreateSetSelfParent() => NewSetSelfParent(GetNewId()); + public virtual SetSelfParentRaw NewSetSelfParentRaw(string id) => new(id); + public virtual SetSelfParentRaw CreateSetSelfParentRaw() => NewSetSelfParentRaw(GetNewId()); + public virtual String NewString(string id) => new(id); + public virtual String CreateString() => NewString(GetNewId()); + public virtual StructuredDataType NewStructuredDataType(string id) => new(id); + public virtual StructuredDataType CreateStructuredDataType() => NewStructuredDataType(GetNewId()); + public virtual StructuredDataTypeBase NewStructuredDataTypeBase(string id) => new(id); + public virtual StructuredDataTypeBase CreateStructuredDataTypeBase() => NewStructuredDataTypeBase(GetNewId()); + public virtual System NewSystem(string id) => new(id); + public virtual System CreateSystem() => NewSystem(GetNewId()); + public virtual ToString NewToString(string id) => new(id); + public virtual ToString CreateToString() => NewToString(GetNewId()); + public virtual TryGet_ NewTryGet(string id) => new(id); + public virtual TryGet_ CreateTryGet() => NewTryGet(GetNewId()); + public virtual TryGetContainmentRaw_ NewTryGetContainmentRaw(string id) => new(id); + public virtual TryGetContainmentRaw_ CreateTryGetContainmentRaw() => NewTryGetContainmentRaw(GetNewId()); + public virtual TryGetContainmentsRaw_ NewTryGetContainmentsRaw(string id) => new(id); + public virtual TryGetContainmentsRaw_ CreateTryGetContainmentsRaw() => NewTryGetContainmentsRaw(GetNewId()); + public virtual TryGetName NewTryGetName(string id) => new(id); + public virtual TryGetName CreateTryGetName() => NewTryGetName(GetNewId()); + public virtual TryGetPropertyRaw_ NewTryGetPropertyRaw(string id) => new(id); + public virtual TryGetPropertyRaw_ CreateTryGetPropertyRaw() => NewTryGetPropertyRaw(GetNewId()); + public virtual TryGetReference NewTryGetReference(string id) => new(id); + public virtual TryGetReference CreateTryGetReference() => NewTryGetReference(GetNewId()); + public virtual TryGetReferenceRaw_ NewTryGetReferenceRaw(string id) => new(id); + public virtual TryGetReferenceRaw_ CreateTryGetReferenceRaw() => NewTryGetReferenceRaw(GetNewId()); + public virtual TryGetReferencesRaw_ NewTryGetReferencesRaw(string id) => new(id); + public virtual TryGetReferencesRaw_ CreateTryGetReferencesRaw() => NewTryGetReferencesRaw(GetNewId()); + public virtual Type NewType(string id) => new(id); + public virtual Type CreateType() => NewType(GetNewId()); + public virtual UnsetFeatureException NewUnsetFeatureException(string id) => new(id); + public virtual UnsetFeatureException CreateUnsetFeatureException() => NewUnsetFeatureException(GetNewId()); + public virtual UnsetFieldException NewUnsetFieldException(string id) => new(id); + public virtual UnsetFieldException CreateUnsetFieldException() => NewUnsetFieldException(GetNewId()); + public virtual UnsupportedClassifierException NewUnsupportedClassifierException(string id) => new(id); + public virtual UnsupportedClassifierException CreateUnsupportedClassifierException() => NewUnsupportedClassifierException(GetNewId()); + public virtual UnsupportedEnumerationLiteralException NewUnsupportedEnumerationLiteralException(string id) => new(id); + public virtual UnsupportedEnumerationLiteralException CreateUnsupportedEnumerationLiteralException() => NewUnsupportedEnumerationLiteralException(GetNewId()); + public virtual UnsupportedStructuredDataTypeException NewUnsupportedStructuredDataTypeException(string id) => new(id); + public virtual UnsupportedStructuredDataTypeException CreateUnsupportedStructuredDataTypeException() => NewUnsupportedStructuredDataTypeException(GetNewId()); + public virtual Utilities NewUtilities(string id) => new(id); + public virtual Utilities CreateUtilities() => NewUtilities(GetNewId()); + public virtual V2023_1 NewV2023_1(string id) => new(id); + public virtual V2023_1 CreateV2023_1() => NewV2023_1(GetNewId()); + public virtual V2024_1 NewV2024_1(string id) => new(id); + public virtual V2024_1 CreateV2024_1() => NewV2024_1(GetNewId()); + public virtual V2024_1_Compatible NewV2024_1_Compatible(string id) => new(id); + public virtual V2024_1_Compatible CreateV2024_1_Compatible() => NewV2024_1_Compatible(GetNewId()); + public virtual V2025_1 NewV2025_1(string id) => new(id); + public virtual V2025_1 CreateV2025_1() => NewV2025_1(GetNewId()); + public virtual V2025_1_Compatible NewV2025_1_Compatible(string id) => new(id); + public virtual V2025_1_Compatible CreateV2025_1_Compatible() => NewV2025_1_Compatible(GetNewId()); + public virtual VersionSpecific NewVersionSpecific(string id) => new(id); + public virtual VersionSpecific CreateVersionSpecific() => NewVersionSpecific(GetNewId()); +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-_builtIns")] +public partial class _builtIns : global::LionWeb.Core.ConceptInstanceBase +{ + public _builtIns(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance._builtIns_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Abstract")] +public partial class Abstract : global::LionWeb.Core.ConceptInstanceBase +{ + public Abstract(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Abstract; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AbstractBaseNodeFactory")] +public partial class AbstractBaseNodeFactory : global::LionWeb.Core.ConceptInstanceBase +{ + public AbstractBaseNodeFactory(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AbstractBaseNodeFactory; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Add")] +public partial class Add : global::LionWeb.Core.ConceptInstanceBase +{ + public Add(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Add; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddAnnotations")] +public partial class AddAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public AddAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddAnnotationsRaw")] +public partial class AddAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public AddAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddChildRaw")] +public partial class AddChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public AddChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddContainmentsRaw")] +public partial class AddContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddInternal")] +public partial class AddInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddOptionalMultipleContainment")] +public partial class AddOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public AddOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddOptionalMultipleReference")] +public partial class AddOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public AddOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddReferencesRaw")] +public partial class AddReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public AddReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddRequiredMultipleContainment")] +public partial class AddRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public AddRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AddRequiredMultipleReference")] +public partial class AddRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public AddRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AddRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotatesLazy")] +public partial class AnnotatesLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotatesLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotatesLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Annotation")] +public partial class Annotation : global::LionWeb.Core.ConceptInstanceBase +{ + public Annotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Annotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationBase")] +public partial class AnnotationBase : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationInstanceBase")] +public partial class AnnotationInstanceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationInstanceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationInstanceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AnnotationRemover")] +public partial class AnnotationRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public AnnotationRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AnnotationRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ArgumentOutOfRangeException")] +public partial class ArgumentOutOfRangeException : global::LionWeb.Core.ConceptInstanceBase +{ + public ArgumentOutOfRangeException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ArgumentOutOfRangeException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AsList")] +public partial class AsList : global::LionWeb.Core.ConceptInstanceBase +{ + public AsList(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AsList; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AsNonEmptyReadOnly")] +public partial class AsNonEmptyReadOnly : global::LionWeb.Core.ConceptInstanceBase +{ + public AsNonEmptyReadOnly(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AsNonEmptyReadOnly; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureAnnotations")] +public partial class AssureAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureInRange")] +public partial class AssureInRange : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureInRange(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureInRange; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNonEmpty")] +public partial class AssureNonEmpty : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNonEmpty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNonEmpty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNoSelfMove")] +public partial class AssureNoSelfMove : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNoSelfMove(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNoSelfMove; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotClearing")] +public partial class AssureNotClearing : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotClearing(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotClearing; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNull")] +public partial class AssureNotNull : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNull(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNull; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNullInstance")] +public partial class AssureNotNullInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNullInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNullInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNotNullMembers")] +public partial class AssureNotNullMembers : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNotNullMembers(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNotNullMembers; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AssureNullableInstance")] +public partial class AssureNullableInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public AssureNullableInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AssureNullableInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-AttachChild")] +public partial class AttachChild : global::LionWeb.Core.ConceptInstanceBase +{ + public AttachChild(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.AttachChild; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Bool")] +public partial class Bool : global::LionWeb.Core.ConceptInstanceBase +{ + public Bool(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Bool; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Boolean")] +public partial class Boolean : global::LionWeb.Core.ConceptInstanceBase +{ + public Boolean(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Boolean; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Char")] +public partial class Char : global::LionWeb.Core.ConceptInstanceBase +{ + public Char(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Char; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Character")] +public partial class Character : global::LionWeb.Core.ConceptInstanceBase +{ + public Character(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Character; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Classifier")] +public partial class Classifier : global::LionWeb.Core.ConceptInstanceBase +{ + public Classifier(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Classifier; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-CodeAnalysis")] +public partial class CodeAnalysis : global::LionWeb.Core.ConceptInstanceBase +{ + public CodeAnalysis(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.CodeAnalysis; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-CollectAllSetFeatures")] +public partial class CollectAllSetFeatures_ : global::LionWeb.Core.ConceptInstanceBase +{ + public CollectAllSetFeatures_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.CollectAllSetFeatures_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Collections")] +public partial class Collections : global::LionWeb.Core.ConceptInstanceBase +{ + public Collections(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Collections; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Concept")] +public partial class Concept : global::LionWeb.Core.ConceptInstanceBase +{ + public Concept(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Concept; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ConceptBase")] +public partial class ConceptBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ConceptBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ConceptBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ConceptInstanceBase")] +public partial class ConceptInstanceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ConceptInstanceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ConceptInstanceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Containment")] +public partial class Containment : global::LionWeb.Core.ConceptInstanceBase +{ + public Containment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Containment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ContainmentBase")] +public partial class ContainmentBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ContainmentBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ContainmentBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ContainmentRemover")] +public partial class ContainmentRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public ContainmentRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ContainmentRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Core")] +public partial class Core : global::LionWeb.Core.ConceptInstanceBase +{ + public Core(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Core; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Datatype")] +public partial class Datatype : global::LionWeb.Core.ConceptInstanceBase +{ + public Datatype(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Datatype; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DatatypeBase")] +public partial class DatatypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public DatatypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DatatypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Decimal")] +public partial class Decimal : global::LionWeb.Core.ConceptInstanceBase +{ + public Decimal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Decimal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachChild")] +public partial class DetachChild_ : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachChild_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachChild; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachChildInternal")] +public partial class DetachChildInternal : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachChildInternal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachChildInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-DetachFromParent")] +public partial class DetachFromParent_ : global::LionWeb.Core.ConceptInstanceBase +{ + public DetachFromParent_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.DetachFromParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Diagnostics")] +public partial class Diagnostics : global::LionWeb.Core.ConceptInstanceBase +{ + public Diagnostics(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Diagnostics; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Enum")] +public partial class Enum : global::LionWeb.Core.ConceptInstanceBase +{ + public Enum(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Enum; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Enumeration")] +public partial class Enumeration : global::LionWeb.Core.ConceptInstanceBase +{ + public Enumeration(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Enumeration; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationBase")] +public partial class EnumerationBase : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationLiteral")] +public partial class EnumerationLiteral : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationLiteral(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationLiteral; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-EnumerationLiteralBase")] +public partial class EnumerationLiteralBase : global::LionWeb.Core.ConceptInstanceBase +{ + public EnumerationLiteralBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.EnumerationLiteralBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Equals")] +public partial class Equals : global::LionWeb.Core.ConceptInstanceBase +{ + public Equals(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Equals_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ExchangeChildRaw")] +public partial class ExchangeChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public ExchangeChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ExchangeChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ExchangeChildrenRaw")] +public partial class ExchangeChildrenRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public ExchangeChildrenRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ExchangeChildrenRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FeaturesLazy")] +public partial class FeaturesLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public FeaturesLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FeaturesLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Field")] +public partial class Field : global::LionWeb.Core.ConceptInstanceBase +{ + public Field(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Field; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FieldBase")] +public partial class FieldBase : global::LionWeb.Core.ConceptInstanceBase +{ + public FieldBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FieldBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-FieldsLazy")] +public partial class FieldsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public FieldsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.FieldsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Finalize")] +public partial class Finalize : global::LionWeb.Core.ConceptInstanceBase +{ + public Finalize(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Finalize; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Generic")] +public partial class Generic : global::LionWeb.Core.ConceptInstanceBase +{ + public Generic(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Generic; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Get")] +public partial class Get : global::LionWeb.Core.ConceptInstanceBase +{ + public Get(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Get_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-get__builtIns")] +public partial class get__builtIns : global::LionWeb.Core.ConceptInstanceBase +{ + public get__builtIns(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.get__builtIns; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-get__m3")] +public partial class get__m3 : global::LionWeb.Core.ConceptInstanceBase +{ + public get__m3(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.get__m3; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotation")] +public partial class GetAnnotation : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotations")] +public partial class GetAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotations_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetAnnotationsRaw")] +public partial class GetAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public GetAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetAnnotationsRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetClassifier")] +public partial class GetClassifier_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetClassifier_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetClassifier_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetConcept")] +public partial class GetConcept_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetConcept_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetConcept_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetContainmentOf")] +public partial class GetContainmentOf_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetContainmentOf_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetContainmentOf; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetHashCode")] +public partial class GetHashCode : global::LionWeb.Core.ConceptInstanceBase +{ + public GetHashCode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetHashCode_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetId")] +public partial class GetId : global::LionWeb.Core.ConceptInstanceBase +{ + public GetId(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetId_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetInternal")] +public partial class GetInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetParent")] +public partial class GetParent : global::LionWeb.Core.ConceptInstanceBase +{ + public GetParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetParent_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetPartitionNotificationProducer")] +public partial class GetPartitionNotificationProducer_ : global::LionWeb.Core.ConceptInstanceBase +{ + public GetPartitionNotificationProducer_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetPartitionNotificationProducer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredNonNullReferences")] +public partial class GetRequiredNonNullReferences : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredNonNullReferences(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredNonNullReferences; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredNullableReferences")] +public partial class GetRequiredNullableReferences : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredNullableReferences(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredNullableReferences; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetRequiredReference")] +public partial class GetRequiredReference : global::LionWeb.Core.ConceptInstanceBase +{ + public GetRequiredReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetRequiredReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-GetType")] +public partial class GetType : global::LionWeb.Core.ConceptInstanceBase +{ + public GetType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.GetType_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IEnumerable")] +public partial class IEnumerable : global::LionWeb.Core.ConceptInstanceBase +{ + public IEnumerable(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IEnumerable; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IFieldValues")] +public partial class IFieldValues : global::LionWeb.Core.ConceptInstanceBase +{ + public IFieldValues(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IFieldValues; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ImplementsLazy")] +public partial class ImplementsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public ImplementsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ImplementsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INamed")] +public partial class INamed : global::LionWeb.Core.ConceptInstanceBase +{ + public INamed(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INamed; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INamedWritable")] +public partial class INamedWritable : global::LionWeb.Core.ConceptInstanceBase +{ + public INamedWritable(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INamedWritable; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INode")] +public partial class INode : global::LionWeb.Core.ConceptInstanceBase +{ + public INode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-INodeFactory")] +public partial class INodeFactory : global::LionWeb.Core.ConceptInstanceBase +{ + public INodeFactory(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.INodeFactory; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Insert")] +public partial class Insert : global::LionWeb.Core.ConceptInstanceBase +{ + public Insert(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Insert; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertAnnotations")] +public partial class InsertAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertAnnotationsRaw")] +public partial class InsertAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertChildRaw")] +public partial class InsertChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertContainmentsRaw")] +public partial class InsertContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertInternal")] +public partial class InsertInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertOptionalMultipleContainment")] +public partial class InsertOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertOptionalMultipleReference")] +public partial class InsertOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertReferencesRaw")] +public partial class InsertReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertRequiredMultipleContainment")] +public partial class InsertRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InsertRequiredMultipleReference")] +public partial class InsertRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public InsertRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InsertRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Instance")] +public partial class Instance : global::LionWeb.Core.ConceptInstanceBase +{ + public Instance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Instance_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Integer")] +public partial class Integer : global::LionWeb.Core.ConceptInstanceBase +{ + public Integer(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Integer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Interface")] +public partial class Interface : global::LionWeb.Core.ConceptInstanceBase +{ + public Interface(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Interface; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InterfaceBase")] +public partial class InterfaceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public InterfaceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InterfaceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-InvalidValueException")] +public partial class InvalidValueException : global::LionWeb.Core.ConceptInstanceBase +{ + public InvalidValueException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.InvalidValueException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IPartitionInstance")] +public partial class IPartitionInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public IPartitionInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IPartitionInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IReadableNode")] +public partial class IReadableNode : global::LionWeb.Core.ConceptInstanceBase +{ + public IReadableNode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IReadableNode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IReadOnlyList")] +public partial class IReadOnlyList : global::LionWeb.Core.ConceptInstanceBase +{ + public IReadOnlyList(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IReadOnlyList; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IsInRange")] +public partial class IsInRange : global::LionWeb.Core.ConceptInstanceBase +{ + public IsInRange(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IsInRange; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IStructuredDataTypeInstance")] +public partial class IStructuredDataTypeInstance : global::LionWeb.Core.ConceptInstanceBase +{ + public IStructuredDataTypeInstance(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IStructuredDataTypeInstance; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-IWritableNode")] +public partial class IWritableNode : global::LionWeb.Core.ConceptInstanceBase +{ + public IWritableNode(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.IWritableNode; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Key")] +public partial class Key : global::LionWeb.Core.ConceptInstanceBase +{ + public Key(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Key_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Language")] +public partial class Language : global::LionWeb.Core.ConceptInstanceBase +{ + public Language(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Language; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LanguageBase")] +public partial class LanguageBase : global::LionWeb.Core.ConceptInstanceBase +{ + public LanguageBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LanguageBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LanguageEntity")] +public partial class LanguageEntity : global::LionWeb.Core.ConceptInstanceBase +{ + public LanguageEntity(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LanguageEntity; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Lazy")] +public partial class Lazy : global::LionWeb.Core.ConceptInstanceBase +{ + public Lazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Lazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Link")] +public partial class Link : global::LionWeb.Core.ConceptInstanceBase +{ + public Link(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Link; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreFeature")] +public partial class LionCoreFeature : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreFeature(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreFeature; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreFeatureKind")] +public partial class LionCoreFeatureKind : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreFeatureKind(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreFeatureKind; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreLanguage")] +public partial class LionCoreLanguage : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreLanguage(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreLanguage; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionCoreMetaPointer")] +public partial class LionCoreMetaPointer : global::LionWeb.Core.ConceptInstanceBase +{ + public LionCoreMetaPointer(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionCoreMetaPointer; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionWeb")] +public partial class LionWeb : global::LionWeb.Core.ConceptInstanceBase +{ + public LionWeb(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionWeb; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LionWebVersions")] +public partial class LionWebVersions : global::LionWeb.Core.ConceptInstanceBase +{ + public LionWebVersions(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LionWebVersions; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-List")] +public partial class List : global::LionWeb.Core.ConceptInstanceBase +{ + public List(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.List; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-LiteralsLazy")] +public partial class LiteralsLazy : global::LionWeb.Core.ConceptInstanceBase +{ + public LiteralsLazy(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.LiteralsLazy; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-M2")] +public partial class M2 : global::LionWeb.Core.ConceptInstanceBase +{ + public M2(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.M2; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-M3")] +public partial class M3 : global::LionWeb.Core.ConceptInstanceBase +{ + public M3(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.M3; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-MemberwiseClone")] +public partial class MemberwiseClone : global::LionWeb.Core.ConceptInstanceBase +{ + public MemberwiseClone(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.MemberwiseClone_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Multiple")] +public partial class Multiple : global::LionWeb.Core.ConceptInstanceBase +{ + public Multiple(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Multiple; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Name")] +public partial class Name : global::LionWeb.Core.ConceptInstanceBase +{ + public Name(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Name_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Notification")] +public partial class Notification : global::LionWeb.Core.ConceptInstanceBase +{ + public Notification(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Notification; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-NotNullWhenAttribute")] +public partial class NotNullWhenAttribute : global::LionWeb.Core.ConceptInstanceBase +{ + public NotNullWhenAttribute(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.NotNullWhenAttribute; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Optional")] +public partial class Optional : global::LionWeb.Core.ConceptInstanceBase +{ + public Optional(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Optional; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Partition")] +public partial class Partition : global::LionWeb.Core.ConceptInstanceBase +{ + public Partition(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Partition; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Pipe")] +public partial class Pipe : global::LionWeb.Core.ConceptInstanceBase +{ + public Pipe(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Pipe; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PrimitiveType")] +public partial class PrimitiveType : global::LionWeb.Core.ConceptInstanceBase +{ + public PrimitiveType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PrimitiveType; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PrimitiveTypeBase")] +public partial class PrimitiveTypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public PrimitiveTypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PrimitiveTypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Property")] +public partial class Property : global::LionWeb.Core.ConceptInstanceBase +{ + public Property(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Property; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-PropertyBase")] +public partial class PropertyBase : global::LionWeb.Core.ConceptInstanceBase +{ + public PropertyBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.PropertyBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Reference")] +public partial class Reference : global::LionWeb.Core.ConceptInstanceBase +{ + public Reference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Reference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceBase")] +public partial class ReferenceBase : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceEquals")] +public partial class ReferenceEquals : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceEquals(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceEquals_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceRemover")] +public partial class ReferenceRemover : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceRemover(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceRemover; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNonNullTarget")] +public partial class ReferenceTargetNonNullTarget : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNonNullTarget(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNonNullTarget; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNonNullTargets")] +public partial class ReferenceTargetNonNullTargets : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNonNullTargets(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNonNullTargets; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNullableTarget")] +public partial class ReferenceTargetNullableTarget : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNullableTarget(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNullableTarget; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ReferenceTargetNullableTargets")] +public partial class ReferenceTargetNullableTargets : global::LionWeb.Core.ConceptInstanceBase +{ + public ReferenceTargetNullableTargets(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ReferenceTargetNullableTargets; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Remove")] +public partial class Remove : global::LionWeb.Core.ConceptInstanceBase +{ + public Remove(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Remove; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAll")] +public partial class RemoveAll : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAll(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAll; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAnnotations")] +public partial class RemoveAnnotations : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAnnotations(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAnnotations; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveAnnotationsRaw")] +public partial class RemoveAnnotationsRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveAnnotationsRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveAnnotationsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveChildRaw")] +public partial class RemoveChildRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveChildRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveChildRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveContainmentsRaw")] +public partial class RemoveContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveContainmentsRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveInternal")] +public partial class RemoveInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveOptionalMultipleContainment")] +public partial class RemoveOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveOptionalMultipleReference")] +public partial class RemoveOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveReferencesRaw")] +public partial class RemoveReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveRequiredMultipleContainment")] +public partial class RemoveRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveRequiredMultipleReference")] +public partial class RemoveRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveSelfParent")] +public partial class RemoveSelfParent : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveSelfParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveSelfParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-RemoveSelfParentRaw")] +public partial class RemoveSelfParentRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public RemoveSelfParentRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.RemoveSelfParentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-result")] +public partial class result : global::LionWeb.Core.ConceptInstanceBase +{ + public result(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.result; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Set")] +public partial class Set : global::LionWeb.Core.ConceptInstanceBase +{ + public Set(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Set; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetContainmentRaw")] +public partial class SetContainmentRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetContainmentRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetContainmentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetInternal")] +public partial class SetInternal_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetInternal_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetInternalAnnotation")] +public partial class SetInternalAnnotation : global::LionWeb.Core.ConceptInstanceBase +{ + public SetInternalAnnotation(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetInternalAnnotation; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetName")] +public partial class SetName : global::LionWeb.Core.ConceptInstanceBase +{ + public SetName(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetName; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetNameRaw")] +public partial class SetNameRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetNameRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetNameRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalMultipleContainment")] +public partial class SetOptionalMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalMultipleReference")] +public partial class SetOptionalMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalReferenceTypeProperty")] +public partial class SetOptionalReferenceTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalReferenceTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalReferenceTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalSingleContainment")] +public partial class SetOptionalSingleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalSingleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalSingleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalSingleReference")] +public partial class SetOptionalSingleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalSingleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalSingleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetOptionalValueTypeProperty")] +public partial class SetOptionalValueTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetOptionalValueTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetOptionalValueTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetParentInternal")] +public partial class SetParentInternal : global::LionWeb.Core.ConceptInstanceBase +{ + public SetParentInternal(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetParentInternal; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetParentNull")] +public partial class SetParentNull : global::LionWeb.Core.ConceptInstanceBase +{ + public SetParentNull(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetParentNull; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetPropertyRaw")] +public partial class SetPropertyRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetPropertyRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetPropertyRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRaw")] +public partial class SetRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetReferenceRaw")] +public partial class SetReferenceRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public SetReferenceRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetReferenceRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetReferencesRaw")] +public partial class SetReferencesRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetReferencesRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetReferencesRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredMultipleContainment")] +public partial class SetRequiredMultipleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredMultipleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredMultipleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredMultipleReference")] +public partial class SetRequiredMultipleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredMultipleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredMultipleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredReferenceTypeProperty")] +public partial class SetRequiredReferenceTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredReferenceTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredReferenceTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredSingleContainment")] +public partial class SetRequiredSingleContainment : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredSingleContainment(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredSingleContainment; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredSingleReference")] +public partial class SetRequiredSingleReference : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredSingleReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredSingleReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetRequiredValueTypeProperty")] +public partial class SetRequiredValueTypeProperty : global::LionWeb.Core.ConceptInstanceBase +{ + public SetRequiredValueTypeProperty(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetRequiredValueTypeProperty; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetSelfParent")] +public partial class SetSelfParent : global::LionWeb.Core.ConceptInstanceBase +{ + public SetSelfParent(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetSelfParent; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-SetSelfParentRaw")] +public partial class SetSelfParentRaw : global::LionWeb.Core.ConceptInstanceBase +{ + public SetSelfParentRaw(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.SetSelfParentRaw; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-String")] +public partial class String : global::LionWeb.Core.ConceptInstanceBase +{ + public String(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.String; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-StructuredDataType")] +public partial class StructuredDataType : global::LionWeb.Core.ConceptInstanceBase +{ + public StructuredDataType(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.StructuredDataType; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-StructuredDataTypeBase")] +public partial class StructuredDataTypeBase : global::LionWeb.Core.ConceptInstanceBase +{ + public StructuredDataTypeBase(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.StructuredDataTypeBase; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-System")] +public partial class System : global::LionWeb.Core.ConceptInstanceBase +{ + public System(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.System; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-ToString")] +public partial class ToString : global::LionWeb.Core.ConceptInstanceBase +{ + public ToString(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.ToString_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGet")] +public partial class TryGet_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGet_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGet_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetContainmentRaw")] +public partial class TryGetContainmentRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetContainmentRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetContainmentRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetContainmentsRaw")] +public partial class TryGetContainmentsRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetContainmentsRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetContainmentsRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetName")] +public partial class TryGetName : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetName(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetName_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetPropertyRaw")] +public partial class TryGetPropertyRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetPropertyRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetPropertyRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReference")] +public partial class TryGetReference : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReference(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReference; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReferenceRaw")] +public partial class TryGetReferenceRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReferenceRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReferenceRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-TryGetReferencesRaw")] +public partial class TryGetReferencesRaw_ : global::LionWeb.Core.ConceptInstanceBase +{ + public TryGetReferencesRaw_(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.TryGetReferencesRaw_; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Type")] +public partial class Type : global::LionWeb.Core.ConceptInstanceBase +{ + public Type(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Type; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsetFeatureException")] +public partial class UnsetFeatureException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsetFeatureException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsetFeatureException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsetFieldException")] +public partial class UnsetFieldException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsetFieldException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsetFieldException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedClassifierException")] +public partial class UnsupportedClassifierException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedClassifierException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedClassifierException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedEnumerationLiteralException")] +public partial class UnsupportedEnumerationLiteralException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedEnumerationLiteralException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedEnumerationLiteralException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-UnsupportedStructuredDataTypeException")] +public partial class UnsupportedStructuredDataTypeException : global::LionWeb.Core.ConceptInstanceBase +{ + public UnsupportedStructuredDataTypeException(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.UnsupportedStructuredDataTypeException; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-Utilities")] +public partial class Utilities : global::LionWeb.Core.ConceptInstanceBase +{ + public Utilities(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.Utilities; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2023_1")] +public partial class V2023_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2023_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2023_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2024_1")] +public partial class V2024_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2024_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2024_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2024_1_Compatible")] +public partial class V2024_1_Compatible : global::LionWeb.Core.ConceptInstanceBase +{ + public V2024_1_Compatible(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2024_1_Compatible; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2025_1")] +public partial class V2025_1 : global::LionWeb.Core.ConceptInstanceBase +{ + public V2025_1(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2025_1; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-V2025_1_Compatible")] +public partial class V2025_1_Compatible : global::LionWeb.Core.ConceptInstanceBase +{ + public V2025_1_Compatible(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.V2025_1_Compatible; +} + +[global::LionWeb.Core.M2.LionCoreMetaPointer(Language = typeof(LanguageWithLionWebNamedConceptsLanguage), Key = "key-VersionSpecific")] +public partial class VersionSpecific : global::LionWeb.Core.ConceptInstanceBase +{ + public VersionSpecific(string id) : base(id) + { + } + + /// + public override global::LionWeb.Core.M3.Concept GetConcept() => LanguageWithLionWebNamedConceptsLanguage.Instance.VersionSpecific; +} \ No newline at end of file From f6ff2e8ed45a2b7021191a97f4907279dd48ecc5 Mon Sep 17 00:00:00 2001 From: Niko Date: Fri, 19 Dec 2025 00:50:44 +0100 Subject: [PATCH 3/7] Don't generate current namespace as fully qualified name --- CHANGELOG.md | 1 + build/LionWeb-CSharp-Build/Generate.cs | 1 - src/LionWeb.Generator/Names/Names.cs | 2 +- 3 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 42013ba43..38d3efe65 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ and this project adheres _loosely_ to [Semantic Versioning](https://semver.org/s * Bugfix: `DeltaDeserializerHandler` is made public. This handler enables deserializer to accept node id that appears both in received delta(s) and local nodes. In the context of delta protocol, this enables replacing a node in a model with a new node with the same id, which results in a valid model. * `a.InsertBefore(b)` / `a.InsertAfter(b)` work correctly if both `a` and `b` are siblings. ### Changed +* Don't generate current namespace as fully qualified name. * Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. * Generator escapes user language names conflicting with framework names. * Use `IReferenceTarget` both as return and parameter type of `IDeserializerHandler.UnresolvableReferenceTarget()`. diff --git a/build/LionWeb-CSharp-Build/Generate.cs b/build/LionWeb-CSharp-Build/Generate.cs index 19c024b51..abdc6035e 100644 --- a/build/LionWeb-CSharp-Build/Generate.cs +++ b/build/LionWeb-CSharp-Build/Generate.cs @@ -127,7 +127,6 @@ { NamespaceMappings = testLanguagesDefinitions .MixedLangs - .Except([l]) .Select(n => (n, $"{prefix}.Mixed.{n.Name}")) .ToDictionary() } diff --git a/src/LionWeb.Generator/Names/Names.cs b/src/LionWeb.Generator/Names/Names.cs index 8df53b987..4e7ae556b 100644 --- a/src/LionWeb.Generator/Names/Names.cs +++ b/src/LionWeb.Generator/Names/Names.cs @@ -72,7 +72,7 @@ public IDictionary NamespaceMappings get => _namespaceMappings; init { - foreach ((Language? lang, var ns) in value) + foreach ((Language? lang, var ns) in value.Where(p => p.Key != _language)) { _namespaceMappings[lang] = ns; } From 3f877a312679e5e1b67ad3eda4d7a0e211cddcdc Mon Sep 17 00:00:00 2001 From: Niko Date: Fri, 19 Dec 2025 01:05:10 +0100 Subject: [PATCH 4/7] Escape feature names that have the same name as an implementing type during generation --- CHANGELOG.md | 1 + build/LionWeb-CSharp-Build/Generate.cs | 2 + .../TestLanguagesDefinitions.cs | 37 + src/LionWeb.Generator/Names/INames.cs | 2 +- src/LionWeb.Generator/Names/Names.cs | 18 +- .../Names/UniqueFeatureNames.cs | 8 +- .../FeatureSameNameAsContainingConcept.g.cs | 850 ++++++++++++++++++ .../FeatureSameNameAsContainingConcept.g.cs | 850 ++++++++++++++++++ .../FeatureSameNameAsContainingConcept.g.cs | 850 ++++++++++++++++++ 9 files changed, 2612 insertions(+), 6 deletions(-) create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2023_1/FeatureSameNameAsContainingConcept.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2024_1/FeatureSameNameAsContainingConcept.g.cs create mode 100644 test/LionWeb.Core.Test.Languages/Generated/V2025_1/FeatureSameNameAsContainingConcept.g.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index 38d3efe65..b47dbd07c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ and this project adheres _loosely_ to [Semantic Versioning](https://semver.org/s * Bugfix: `DeltaDeserializerHandler` is made public. This handler enables deserializer to accept node id that appears both in received delta(s) and local nodes. In the context of delta protocol, this enables replacing a node in a model with a new node with the same id, which results in a valid model. * `a.InsertBefore(b)` / `a.InsertAfter(b)` work correctly if both `a` and `b` are siblings. ### Changed +* Escape feature names that have the same name as an implementing type during generation. * Don't generate current namespace as fully qualified name. * Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. * Generator escapes user language names conflicting with framework names. diff --git a/build/LionWeb-CSharp-Build/Generate.cs b/build/LionWeb-CSharp-Build/Generate.cs index abdc6035e..5ee0a1ac2 100644 --- a/build/LionWeb-CSharp-Build/Generate.cs +++ b/build/LionWeb-CSharp-Build/Generate.cs @@ -73,6 +73,7 @@ var namespaceStartsWithLionWebLang = testLanguagesDefinitions.NamespaceStartsWithLionWebLang; var namespaceContainsLionWebLang = testLanguagesDefinitions.NamespaceContainsLionWebLang; var languageWithLionWebNamedConcepts = testLanguagesDefinitions.LanguageWithLionWebNamedConcepts; + var featureSameNameAsContainingConcept = testLanguagesDefinitions.FeatureSameNameAsContainingConcept; var lionWebVersionNamespace = "V" + lionWebVersion.VersionString.Replace('.', '_'); string prefix = $"LionWeb.Core.Test.Languages.Generated.{lionWebVersionNamespace}"; @@ -96,6 +97,7 @@ new(namespaceStartsWithLionWebLang, $"LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang"), new(namespaceContainsLionWebLang, $"io.LionWeb.Generated.{lionWebVersionNamespace}.namespaceStartsWithLionWebLang"), new(languageWithLionWebNamedConcepts, $"{prefix}.LanguageWithLionWebNamedConcepts"), + new(featureSameNameAsContainingConcept, $"{prefix}.FeatureSameNameAsContainingConcept"), // We don't really want these file in tests project, but update the version in Generator. // However, it's not worth writing a separate code path for this one language (as we want to externalize it anyways). // Step 3: Uncomment the line below diff --git a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs index d424ce998..99da1608c 100644 --- a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs +++ b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs @@ -43,6 +43,7 @@ public class TestLanguagesDefinitions public Language NamespaceStartsWithLionWebLang { get; private set; } public Language NamespaceContainsLionWebLang { get; private set; } public Language LanguageWithLionWebNamedConcepts { get; private set; } + public Language FeatureSameNameAsContainingConcept { get; private set; } public List MixedLangs { get; private set; } = []; @@ -58,6 +59,7 @@ public TestLanguagesDefinitions(LionWebVersions lionWebVersion) CreateNamespaceStartsWithLionWebLang(); CreateNamespaceContainsLionWebLang(); CreateLanguageWithLionWebNamedConcepts(); + CreateFeatureSameNameAsContainingConcept(); if (lionWebVersion.LionCore is ILionCoreLanguageWithStructuredDataType) { @@ -746,6 +748,36 @@ private void CreateLanguageWithLionWebNamedConcepts() LanguageWithLionWebNamedConcepts = lang; } + + private void CreateFeatureSameNameAsContainingConcept() + { + var lang = new DynamicLanguage("id-FeatureSameNameAsContainingConcept-lang", _lionWebVersion) + { + Name = "FeatureSameNameAsContainingConcept", Key = "key-FeatureSameNameAsContainingConcept", Version = "1" + }; + + var baseConceptA = lang.Concept("BaseConceptA").IsAbstract(); + baseConceptA.Property("BaseConceptA"); + lang.Concept("SubConceptA").Extending(baseConceptA); + + var baseConceptB = lang.Concept("BaseConceptB").IsAbstract(); + baseConceptB.Property("SubConceptB"); + lang.Concept("SubConceptB").Extending(baseConceptB); + + var iface = lang.Interface("Iface"); + iface.Property("IfaceMethod"); + var ifaceImplA = lang.Concept("IfaceImplA").Implementing(iface); + lang.Concept("IfaceImplB").Implementing(iface); + var ifaceMethodConcept = lang.Concept("IfaceMethod").Extending(ifaceImplA); + + var baseConceptC = lang.Concept("BaseConceptC").IsAbstract(); + baseConceptC.Property("BaseConceptD"); + + var baseConceptD = lang.Concept("BaseConceptD").IsAbstract(); + baseConceptD.Property("BaseConceptE"); + + FeatureSameNameAsContainingConcept = lang; + } } internal static class LanguageExtensions @@ -753,4 +785,9 @@ internal static class LanguageExtensions internal static DynamicConcept Concept(this DynamicLanguage language, string name) => language.Concept($"id-{name}", $"key-{name}", name); + internal static DynamicInterface Interface(this DynamicLanguage language, string name) => + language.Interface($"id-{name}", $"key-{name}", name); + + internal static DynamicProperty Property(this DynamicClassifier classifier, string name) => + classifier.Property($"id-{name}", $"key-{name}", name).OfType(classifier.GetLanguage().LionWebVersion.BuiltIns.String); } \ No newline at end of file diff --git a/src/LionWeb.Generator/Names/INames.cs b/src/LionWeb.Generator/Names/INames.cs index db4ff6d2c..7ad9facf3 100644 --- a/src/LionWeb.Generator/Names/INames.cs +++ b/src/LionWeb.Generator/Names/INames.cs @@ -128,7 +128,7 @@ public interface INames IdentifierNameSyntax FeatureField(Feature feature); /// MyFeature - IdentifierNameSyntax FeatureProperty(Feature feature); + IdentifierNameSyntax FeatureProperty(Feature feature, Classifier container); /// myFeature string FeatureParam(Feature feature); diff --git a/src/LionWeb.Generator/Names/Names.cs b/src/LionWeb.Generator/Names/Names.cs index 4e7ae556b..b30fbc11d 100644 --- a/src/LionWeb.Generator/Names/Names.cs +++ b/src/LionWeb.Generator/Names/Names.cs @@ -38,7 +38,8 @@ namespace LionWeb.Generator.Names; public partial class Names : INames { private const char _namespaceSeparator = '.'; - + protected internal const string FeatureSameNameAsContainingClassifier_Suffix = "_"; + private readonly HashSet _usedTypes = []; /// @@ -356,7 +357,8 @@ public TypeSyntax AsType(Datatype datatype, bool disambiguate = false) Language l => AsType(l), Classifier c => ToName(AsType(c, disambiguate)), Datatype d => ToName(AsType(d, disambiguate)), - Feature f => QualifiedName(ToName(AsType(f.GetFeatureClassifier(), disambiguate)), FeatureProperty(f)), + Feature f => QualifiedName(ToName(AsType(f.GetFeatureClassifier(), disambiguate)), + FeatureProperty(f, f.GetFeatureClassifier())), Field f => QualifiedName(ToName(AsType(f.GetStructuredDataType(), disambiguate)), FieldProperty(f)), EnumerationLiteral f => QualifiedName(ToName(AsType(f.GetEnumeration(), disambiguate)), IdentifierName(f.Name.PrefixKeyword())) @@ -425,8 +427,16 @@ public IdentifierNameSyntax FeatureField(Feature feature) => IdentifierName($"_{feature.Name.ToFirstLower()}".PrefixKeyword()); /// - public IdentifierNameSyntax FeatureProperty(Feature feature) => - IdentifierName(feature.Name.ToFirstUpper().PrefixKeyword()); + public IdentifierNameSyntax FeatureProperty(Feature feature, Classifier container) + { + var name = FeaturePropertyInternal(feature); + if (name == AsName(container).ToString()) + name += FeatureSameNameAsContainingClassifier_Suffix; + return IdentifierName(name); + } + + protected internal static string FeaturePropertyInternal(Feature feature) => + feature.Name.ToFirstUpper().PrefixKeyword(); /// public string FeatureParam(Feature feature) => diff --git a/src/LionWeb.Generator/Names/UniqueFeatureNames.cs b/src/LionWeb.Generator/Names/UniqueFeatureNames.cs index 6c358451f..6e0c55a2f 100644 --- a/src/LionWeb.Generator/Names/UniqueFeatureNames.cs +++ b/src/LionWeb.Generator/Names/UniqueFeatureNames.cs @@ -118,7 +118,7 @@ public IdentifierNameSyntax FeatureField(Feature feature) } /// - public IdentifierNameSyntax FeatureProperty(Feature feature) + public IdentifierNameSyntax FeatureProperty(Feature feature, Classifier container) { RegisterFeatureName(feature); return IdentifierName(_featureNames[feature].ToFirstUpper().PrefixKeyword()); @@ -137,6 +137,12 @@ private void RegisterFeatureName(Feature feature) return; var featureName = feature.Name; + var mangledName = Names.FeaturePropertyInternal(feature); + + var sameNameClassifiers = Language.Entities.OfType().Where(c => AsName(c).ToString() == mangledName); + if (sameNameClassifiers.Any(c => c.AllFeatures().Contains(feature))) + featureName += Names.FeatureSameNameAsContainingClassifier_Suffix; + int i = 0; while (_featureNames.ContainsValue(featureName)) { diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2023_1/FeatureSameNameAsContainingConcept.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/FeatureSameNameAsContainingConcept.g.cs new file mode 100644 index 000000000..1feafe388 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2023_1/FeatureSameNameAsContainingConcept.g.cs @@ -0,0 +1,850 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Core.Test.Languages.Generated.V2023_1.FeatureSameNameAsContainingConcept; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2023_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; + +[LionCoreLanguage(Key = "key-FeatureSameNameAsContainingConcept", Version = "1")] +public partial class FeatureSameNameAsContainingConceptLanguage : LanguageBase +{ + public static readonly FeatureSameNameAsContainingConceptLanguage Instance = new Lazy(() => new("id-FeatureSameNameAsContainingConcept-lang")).Value; + public FeatureSameNameAsContainingConceptLanguage(string id) : base(id, LionWebVersions.v2023_1) + { + _baseConceptA = new(() => new ConceptBase("id-BaseConceptA", this) { Key = "key-BaseConceptA", Name = "BaseConceptA", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptA_BaseConceptA]) }); + _baseConceptA_BaseConceptA = new(() => new PropertyBase("id-BaseConceptA", BaseConceptA, this) { Key = "key-BaseConceptA", Name = "BaseConceptA", Optional = false, Type = _builtIns.String }); + _baseConceptB = new(() => new ConceptBase("id-BaseConceptB", this) { Key = "key-BaseConceptB", Name = "BaseConceptB", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptB_SubConceptB]) }); + _baseConceptB_SubConceptB = new(() => new PropertyBase("id-SubConceptB", BaseConceptB, this) { Key = "key-SubConceptB", Name = "SubConceptB", Optional = false, Type = _builtIns.String }); + _baseConceptC = new(() => new ConceptBase("id-BaseConceptC", this) { Key = "key-BaseConceptC", Name = "BaseConceptC", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptC_BaseConceptD]) }); + _baseConceptC_BaseConceptD = new(() => new PropertyBase("id-BaseConceptD", BaseConceptC, this) { Key = "key-BaseConceptD", Name = "BaseConceptD", Optional = false, Type = _builtIns.String }); + _baseConceptD = new(() => new ConceptBase("id-BaseConceptD", this) { Key = "key-BaseConceptD", Name = "BaseConceptD", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptD_BaseConceptE]) }); + _baseConceptD_BaseConceptE = new(() => new PropertyBase("id-BaseConceptE", BaseConceptD, this) { Key = "key-BaseConceptE", Name = "BaseConceptE", Optional = false, Type = _builtIns.String }); + _iface = new(() => new InterfaceBase("id-Iface", this) { Key = "key-Iface", Name = "Iface", FeaturesLazy = new(() => [Iface_IfaceMethod]) }); + _iface_IfaceMethod = new(() => new PropertyBase("id-IfaceMethod", Iface, this) { Key = "key-IfaceMethod", Name = "IfaceMethod", Optional = false, Type = _builtIns.String }); + _ifaceImplA = new(() => new ConceptBase("id-IfaceImplA", this) { Key = "key-IfaceImplA", Name = "IfaceImplA", Abstract = false, Partition = false, ImplementsLazy = new(() => [Iface]) }); + _ifaceImplB = new(() => new ConceptBase("id-IfaceImplB", this) { Key = "key-IfaceImplB", Name = "IfaceImplB", Abstract = false, Partition = false, ImplementsLazy = new(() => [Iface]) }); + _ifaceMethod = new(() => new ConceptBase("id-IfaceMethod", this) { Key = "key-IfaceMethod", Name = "IfaceMethod", Abstract = false, Partition = false, ExtendsLazy = new(() => IfaceImplA) }); + _subConceptA = new(() => new ConceptBase("id-SubConceptA", this) { Key = "key-SubConceptA", Name = "SubConceptA", Abstract = false, Partition = false, ExtendsLazy = new(() => BaseConceptA) }); + _subConceptB = new(() => new ConceptBase("id-SubConceptB", this) { Key = "key-SubConceptB", Name = "SubConceptB", Abstract = false, Partition = false, ExtendsLazy = new(() => BaseConceptB) }); + _factory = new FeatureSameNameAsContainingConceptFactory(this); + } + + /// + public override IReadOnlyList Entities => [BaseConceptA, BaseConceptB, BaseConceptC, BaseConceptD, Iface, IfaceImplA, IfaceImplB, IfaceMethod, SubConceptA, SubConceptB]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-FeatureSameNameAsContainingConcept"; + /// + public override string Key => _key; + + private const string _name = "FeatureSameNameAsContainingConcept"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _baseConceptA; + public Concept BaseConceptA => _baseConceptA.Value; + + private readonly Lazy _baseConceptA_BaseConceptA; + public Property BaseConceptA_BaseConceptA => _baseConceptA_BaseConceptA.Value; + + private readonly Lazy _baseConceptB; + public Concept BaseConceptB => _baseConceptB.Value; + + private readonly Lazy _baseConceptB_SubConceptB; + public Property BaseConceptB_SubConceptB => _baseConceptB_SubConceptB.Value; + + private readonly Lazy _baseConceptC; + public Concept BaseConceptC => _baseConceptC.Value; + + private readonly Lazy _baseConceptC_BaseConceptD; + public Property BaseConceptC_BaseConceptD => _baseConceptC_BaseConceptD.Value; + + private readonly Lazy _baseConceptD; + public Concept BaseConceptD => _baseConceptD.Value; + + private readonly Lazy _baseConceptD_BaseConceptE; + public Property BaseConceptD_BaseConceptE => _baseConceptD_BaseConceptE.Value; + + private readonly Lazy _iface; + public Interface Iface => _iface.Value; + + private readonly Lazy _iface_IfaceMethod; + public Property Iface_IfaceMethod => _iface_IfaceMethod.Value; + + private readonly Lazy _ifaceImplA; + public Concept IfaceImplA => _ifaceImplA.Value; + + private readonly Lazy _ifaceImplB; + public Concept IfaceImplB => _ifaceImplB.Value; + + private readonly Lazy _ifaceMethod; + public Concept IfaceMethod => _ifaceMethod.Value; + + private readonly Lazy _subConceptA; + public Concept SubConceptA => _subConceptA.Value; + + private readonly Lazy _subConceptB; + public Concept SubConceptB => _subConceptB.Value; +} + +public partial interface IFeatureSameNameAsContainingConceptFactory : INodeFactory +{ + public IfaceImplA NewIfaceImplA(string id); + public IfaceImplA CreateIfaceImplA(); + public IfaceImplB NewIfaceImplB(string id); + public IfaceImplB CreateIfaceImplB(); + public IfaceMethod NewIfaceMethod(string id); + public IfaceMethod CreateIfaceMethod(); + public SubConceptA NewSubConceptA(string id); + public SubConceptA CreateSubConceptA(); + public SubConceptB NewSubConceptB(string id); + public SubConceptB CreateSubConceptB(); +} + +public class FeatureSameNameAsContainingConceptFactory : AbstractBaseNodeFactory, IFeatureSameNameAsContainingConceptFactory +{ + private readonly FeatureSameNameAsContainingConceptLanguage _language; + public FeatureSameNameAsContainingConceptFactory(FeatureSameNameAsContainingConceptLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.IfaceImplA.EqualsIdentity(classifier)) + return NewIfaceImplA(id); + if (_language.IfaceImplB.EqualsIdentity(classifier)) + return NewIfaceImplB(id); + if (_language.IfaceMethod.EqualsIdentity(classifier)) + return NewIfaceMethod(id); + if (_language.SubConceptA.EqualsIdentity(classifier)) + return NewSubConceptA(id); + if (_language.SubConceptB.EqualsIdentity(classifier)) + return NewSubConceptB(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual IfaceImplA NewIfaceImplA(string id) => new(id); + public virtual IfaceImplA CreateIfaceImplA() => NewIfaceImplA(GetNewId()); + public virtual IfaceImplB NewIfaceImplB(string id) => new(id); + public virtual IfaceImplB CreateIfaceImplB() => NewIfaceImplB(GetNewId()); + public virtual IfaceMethod NewIfaceMethod(string id) => new(id); + public virtual IfaceMethod CreateIfaceMethod() => NewIfaceMethod(GetNewId()); + public virtual SubConceptA NewSubConceptA(string id) => new(id); + public virtual SubConceptA CreateSubConceptA() => NewSubConceptA(GetNewId()); + public virtual SubConceptB NewSubConceptB(string id) => new(id); + public virtual SubConceptB CreateSubConceptB() => NewSubConceptB(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptA")] +public abstract partial class BaseConceptA : ConceptInstanceBase +{ + private string? _baseConceptA_ = null; + private bool SetBaseConceptARaw(string? value) + { + if (value == _baseConceptA_) + return false; + _baseConceptA_ = value; + return true; + } + + /// Required Property + /// If BaseConceptA_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptA")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptA_ { get => _baseConceptA_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA); set => SetBaseConceptA(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptA([NotNullWhenAttribute(true)] out string? baseConceptA_) + { + baseConceptA_ = _baseConceptA_; + return baseConceptA_ != null; + } + + /// Required Property + /// If set to null + public BaseConceptA SetBaseConceptA(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA, _baseConceptA_, SetBaseConceptARaw); + return this; + } + + public BaseConceptA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + result = BaseConceptA_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + result = _baseConceptA_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptA(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptARaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptA(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptB")] +public abstract partial class BaseConceptB : ConceptInstanceBase +{ + private string? _subConceptB_ = null; + private bool SetSubConceptBRaw(string? value) + { + if (value == _subConceptB_) + return false; + _subConceptB_ = value; + return true; + } + + /// Required Property + /// If SubConceptB_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptB")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string SubConceptB_ { get => _subConceptB_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB); set => SetSubConceptB(value); } + + /// Required Property + /// If set to null + public bool TryGetSubConceptB([NotNullWhenAttribute(true)] out string? subConceptB_) + { + subConceptB_ = _subConceptB_; + return subConceptB_ != null; + } + + /// Required Property + /// If set to null + public BaseConceptB SetSubConceptB(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB, _subConceptB_, SetSubConceptBRaw); + return this; + } + + public BaseConceptB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + result = SubConceptB_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + result = _subConceptB_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + if (value is string v) + { + SetSubConceptB(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature) && value is null or string) + return SetSubConceptBRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetSubConceptB(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptC")] +public abstract partial class BaseConceptC : ConceptInstanceBase +{ + private string? _baseConceptD = null; + private bool SetBaseConceptDRaw(string? value) + { + if (value == _baseConceptD) + return false; + _baseConceptD = value; + return true; + } + + /// Required Property + /// If BaseConceptD has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptD")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptD { get => _baseConceptD ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD); set => SetBaseConceptD(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptD([NotNullWhenAttribute(true)] out string? baseConceptD) + { + baseConceptD = _baseConceptD; + return baseConceptD != null; + } + + /// Required Property + /// If set to null + public BaseConceptC SetBaseConceptD(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD, _baseConceptD, SetBaseConceptDRaw); + return this; + } + + public BaseConceptC(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + result = BaseConceptD; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + result = _baseConceptD; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptD(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptDRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptD(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptD")] +public abstract partial class BaseConceptD : ConceptInstanceBase +{ + private string? _baseConceptE = null; + private bool SetBaseConceptERaw(string? value) + { + if (value == _baseConceptE) + return false; + _baseConceptE = value; + return true; + } + + /// Required Property + /// If BaseConceptE has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptE")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptE { get => _baseConceptE ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE); set => SetBaseConceptE(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptE([NotNullWhenAttribute(true)] out string? baseConceptE) + { + baseConceptE = _baseConceptE; + return baseConceptE != null; + } + + /// Required Property + /// If set to null + public BaseConceptD SetBaseConceptE(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE, _baseConceptE, SetBaseConceptERaw); + return this; + } + + public BaseConceptD(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + result = BaseConceptE; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + result = _baseConceptE; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptE(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptERaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptE(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-Iface")] +public partial interface Iface : INode +{ + /// Required Property + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get; set; } + + /// Required Property + public Iface SetIfaceMethod(string value); +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceImplA")] +public partial class IfaceImplA : ConceptInstanceBase, Iface +{ + private string? _ifaceMethod_ = null; + private bool SetIfaceMethodRaw(string? value) + { + if (value == _ifaceMethod_) + return false; + _ifaceMethod_ = value; + return true; + } + + /// Required Property + /// If IfaceMethod_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get => _ifaceMethod_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); set => SetIfaceMethod(value); } + + /// Required Property + /// If set to null + public bool TryGetIfaceMethod([NotNullWhenAttribute(true)] out string? ifaceMethod_) + { + ifaceMethod_ = _ifaceMethod_; + return ifaceMethod_ != null; + } +/// Required Property +/// If set to null + Iface Iface.SetIfaceMethod(string value) => SetIfaceMethod(value); + /// Required Property + /// If set to null + public IfaceImplA SetIfaceMethod(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod, _ifaceMethod_, SetIfaceMethodRaw); + return this; + } + + public IfaceImplA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceImplA; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = IfaceMethod_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = _ifaceMethod_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + if (value is string v) + { + SetIfaceMethod(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature) && value is null or string) + return SetIfaceMethodRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetIfaceMethod(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceImplB")] +public partial class IfaceImplB : ConceptInstanceBase, Iface +{ + private string? _ifaceMethod_ = null; + private bool SetIfaceMethodRaw(string? value) + { + if (value == _ifaceMethod_) + return false; + _ifaceMethod_ = value; + return true; + } + + /// Required Property + /// If IfaceMethod_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get => _ifaceMethod_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); set => SetIfaceMethod(value); } + + /// Required Property + /// If set to null + public bool TryGetIfaceMethod([NotNullWhenAttribute(true)] out string? ifaceMethod_) + { + ifaceMethod_ = _ifaceMethod_; + return ifaceMethod_ != null; + } +/// Required Property +/// If set to null + Iface Iface.SetIfaceMethod(string value) => SetIfaceMethod(value); + /// Required Property + /// If set to null + public IfaceImplB SetIfaceMethod(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod, _ifaceMethod_, SetIfaceMethodRaw); + return this; + } + + public IfaceImplB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceImplB; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = IfaceMethod_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = _ifaceMethod_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + if (value is string v) + { + SetIfaceMethod(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature) && value is null or string) + return SetIfaceMethodRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetIfaceMethod(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] +public partial class IfaceMethod : IfaceImplA +{ + public IfaceMethod(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceMethod; +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptA")] +public partial class SubConceptA : BaseConceptA +{ + public SubConceptA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.SubConceptA; +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptB")] +public partial class SubConceptB : BaseConceptB +{ + public SubConceptB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.SubConceptB; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2024_1/FeatureSameNameAsContainingConcept.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/FeatureSameNameAsContainingConcept.g.cs new file mode 100644 index 000000000..b227cd66f --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2024_1/FeatureSameNameAsContainingConcept.g.cs @@ -0,0 +1,850 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Core.Test.Languages.Generated.V2024_1.FeatureSameNameAsContainingConcept; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2024_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; + +[LionCoreLanguage(Key = "key-FeatureSameNameAsContainingConcept", Version = "1")] +public partial class FeatureSameNameAsContainingConceptLanguage : LanguageBase +{ + public static readonly FeatureSameNameAsContainingConceptLanguage Instance = new Lazy(() => new("id-FeatureSameNameAsContainingConcept-lang")).Value; + public FeatureSameNameAsContainingConceptLanguage(string id) : base(id, LionWebVersions.v2024_1) + { + _baseConceptA = new(() => new ConceptBase("id-BaseConceptA", this) { Key = "key-BaseConceptA", Name = "BaseConceptA", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptA_BaseConceptA]) }); + _baseConceptA_BaseConceptA = new(() => new PropertyBase("id-BaseConceptA", BaseConceptA, this) { Key = "key-BaseConceptA", Name = "BaseConceptA", Optional = false, Type = _builtIns.String }); + _baseConceptB = new(() => new ConceptBase("id-BaseConceptB", this) { Key = "key-BaseConceptB", Name = "BaseConceptB", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptB_SubConceptB]) }); + _baseConceptB_SubConceptB = new(() => new PropertyBase("id-SubConceptB", BaseConceptB, this) { Key = "key-SubConceptB", Name = "SubConceptB", Optional = false, Type = _builtIns.String }); + _baseConceptC = new(() => new ConceptBase("id-BaseConceptC", this) { Key = "key-BaseConceptC", Name = "BaseConceptC", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptC_BaseConceptD]) }); + _baseConceptC_BaseConceptD = new(() => new PropertyBase("id-BaseConceptD", BaseConceptC, this) { Key = "key-BaseConceptD", Name = "BaseConceptD", Optional = false, Type = _builtIns.String }); + _baseConceptD = new(() => new ConceptBase("id-BaseConceptD", this) { Key = "key-BaseConceptD", Name = "BaseConceptD", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptD_BaseConceptE]) }); + _baseConceptD_BaseConceptE = new(() => new PropertyBase("id-BaseConceptE", BaseConceptD, this) { Key = "key-BaseConceptE", Name = "BaseConceptE", Optional = false, Type = _builtIns.String }); + _iface = new(() => new InterfaceBase("id-Iface", this) { Key = "key-Iface", Name = "Iface", FeaturesLazy = new(() => [Iface_IfaceMethod]) }); + _iface_IfaceMethod = new(() => new PropertyBase("id-IfaceMethod", Iface, this) { Key = "key-IfaceMethod", Name = "IfaceMethod", Optional = false, Type = _builtIns.String }); + _ifaceImplA = new(() => new ConceptBase("id-IfaceImplA", this) { Key = "key-IfaceImplA", Name = "IfaceImplA", Abstract = false, Partition = false, ImplementsLazy = new(() => [Iface]) }); + _ifaceImplB = new(() => new ConceptBase("id-IfaceImplB", this) { Key = "key-IfaceImplB", Name = "IfaceImplB", Abstract = false, Partition = false, ImplementsLazy = new(() => [Iface]) }); + _ifaceMethod = new(() => new ConceptBase("id-IfaceMethod", this) { Key = "key-IfaceMethod", Name = "IfaceMethod", Abstract = false, Partition = false, ExtendsLazy = new(() => IfaceImplA) }); + _subConceptA = new(() => new ConceptBase("id-SubConceptA", this) { Key = "key-SubConceptA", Name = "SubConceptA", Abstract = false, Partition = false, ExtendsLazy = new(() => BaseConceptA) }); + _subConceptB = new(() => new ConceptBase("id-SubConceptB", this) { Key = "key-SubConceptB", Name = "SubConceptB", Abstract = false, Partition = false, ExtendsLazy = new(() => BaseConceptB) }); + _factory = new FeatureSameNameAsContainingConceptFactory(this); + } + + /// + public override IReadOnlyList Entities => [BaseConceptA, BaseConceptB, BaseConceptC, BaseConceptD, Iface, IfaceImplA, IfaceImplB, IfaceMethod, SubConceptA, SubConceptB]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-FeatureSameNameAsContainingConcept"; + /// + public override string Key => _key; + + private const string _name = "FeatureSameNameAsContainingConcept"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _baseConceptA; + public Concept BaseConceptA => _baseConceptA.Value; + + private readonly Lazy _baseConceptA_BaseConceptA; + public Property BaseConceptA_BaseConceptA => _baseConceptA_BaseConceptA.Value; + + private readonly Lazy _baseConceptB; + public Concept BaseConceptB => _baseConceptB.Value; + + private readonly Lazy _baseConceptB_SubConceptB; + public Property BaseConceptB_SubConceptB => _baseConceptB_SubConceptB.Value; + + private readonly Lazy _baseConceptC; + public Concept BaseConceptC => _baseConceptC.Value; + + private readonly Lazy _baseConceptC_BaseConceptD; + public Property BaseConceptC_BaseConceptD => _baseConceptC_BaseConceptD.Value; + + private readonly Lazy _baseConceptD; + public Concept BaseConceptD => _baseConceptD.Value; + + private readonly Lazy _baseConceptD_BaseConceptE; + public Property BaseConceptD_BaseConceptE => _baseConceptD_BaseConceptE.Value; + + private readonly Lazy _iface; + public Interface Iface => _iface.Value; + + private readonly Lazy _iface_IfaceMethod; + public Property Iface_IfaceMethod => _iface_IfaceMethod.Value; + + private readonly Lazy _ifaceImplA; + public Concept IfaceImplA => _ifaceImplA.Value; + + private readonly Lazy _ifaceImplB; + public Concept IfaceImplB => _ifaceImplB.Value; + + private readonly Lazy _ifaceMethod; + public Concept IfaceMethod => _ifaceMethod.Value; + + private readonly Lazy _subConceptA; + public Concept SubConceptA => _subConceptA.Value; + + private readonly Lazy _subConceptB; + public Concept SubConceptB => _subConceptB.Value; +} + +public partial interface IFeatureSameNameAsContainingConceptFactory : INodeFactory +{ + public IfaceImplA NewIfaceImplA(string id); + public IfaceImplA CreateIfaceImplA(); + public IfaceImplB NewIfaceImplB(string id); + public IfaceImplB CreateIfaceImplB(); + public IfaceMethod NewIfaceMethod(string id); + public IfaceMethod CreateIfaceMethod(); + public SubConceptA NewSubConceptA(string id); + public SubConceptA CreateSubConceptA(); + public SubConceptB NewSubConceptB(string id); + public SubConceptB CreateSubConceptB(); +} + +public class FeatureSameNameAsContainingConceptFactory : AbstractBaseNodeFactory, IFeatureSameNameAsContainingConceptFactory +{ + private readonly FeatureSameNameAsContainingConceptLanguage _language; + public FeatureSameNameAsContainingConceptFactory(FeatureSameNameAsContainingConceptLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.IfaceImplA.EqualsIdentity(classifier)) + return NewIfaceImplA(id); + if (_language.IfaceImplB.EqualsIdentity(classifier)) + return NewIfaceImplB(id); + if (_language.IfaceMethod.EqualsIdentity(classifier)) + return NewIfaceMethod(id); + if (_language.SubConceptA.EqualsIdentity(classifier)) + return NewSubConceptA(id); + if (_language.SubConceptB.EqualsIdentity(classifier)) + return NewSubConceptB(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual IfaceImplA NewIfaceImplA(string id) => new(id); + public virtual IfaceImplA CreateIfaceImplA() => NewIfaceImplA(GetNewId()); + public virtual IfaceImplB NewIfaceImplB(string id) => new(id); + public virtual IfaceImplB CreateIfaceImplB() => NewIfaceImplB(GetNewId()); + public virtual IfaceMethod NewIfaceMethod(string id) => new(id); + public virtual IfaceMethod CreateIfaceMethod() => NewIfaceMethod(GetNewId()); + public virtual SubConceptA NewSubConceptA(string id) => new(id); + public virtual SubConceptA CreateSubConceptA() => NewSubConceptA(GetNewId()); + public virtual SubConceptB NewSubConceptB(string id) => new(id); + public virtual SubConceptB CreateSubConceptB() => NewSubConceptB(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptA")] +public abstract partial class BaseConceptA : ConceptInstanceBase +{ + private string? _baseConceptA_ = null; + private bool SetBaseConceptARaw(string? value) + { + if (value == _baseConceptA_) + return false; + _baseConceptA_ = value; + return true; + } + + /// Required Property + /// If BaseConceptA_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptA")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptA_ { get => _baseConceptA_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA); set => SetBaseConceptA(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptA([NotNullWhenAttribute(true)] out string? baseConceptA_) + { + baseConceptA_ = _baseConceptA_; + return baseConceptA_ != null; + } + + /// Required Property + /// If set to null + public BaseConceptA SetBaseConceptA(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA, _baseConceptA_, SetBaseConceptARaw); + return this; + } + + public BaseConceptA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + result = BaseConceptA_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + result = _baseConceptA_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptA(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptARaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptA(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptB")] +public abstract partial class BaseConceptB : ConceptInstanceBase +{ + private string? _subConceptB_ = null; + private bool SetSubConceptBRaw(string? value) + { + if (value == _subConceptB_) + return false; + _subConceptB_ = value; + return true; + } + + /// Required Property + /// If SubConceptB_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptB")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string SubConceptB_ { get => _subConceptB_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB); set => SetSubConceptB(value); } + + /// Required Property + /// If set to null + public bool TryGetSubConceptB([NotNullWhenAttribute(true)] out string? subConceptB_) + { + subConceptB_ = _subConceptB_; + return subConceptB_ != null; + } + + /// Required Property + /// If set to null + public BaseConceptB SetSubConceptB(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB, _subConceptB_, SetSubConceptBRaw); + return this; + } + + public BaseConceptB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + result = SubConceptB_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + result = _subConceptB_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + if (value is string v) + { + SetSubConceptB(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature) && value is null or string) + return SetSubConceptBRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetSubConceptB(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptC")] +public abstract partial class BaseConceptC : ConceptInstanceBase +{ + private string? _baseConceptD = null; + private bool SetBaseConceptDRaw(string? value) + { + if (value == _baseConceptD) + return false; + _baseConceptD = value; + return true; + } + + /// Required Property + /// If BaseConceptD has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptD")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptD { get => _baseConceptD ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD); set => SetBaseConceptD(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptD([NotNullWhenAttribute(true)] out string? baseConceptD) + { + baseConceptD = _baseConceptD; + return baseConceptD != null; + } + + /// Required Property + /// If set to null + public BaseConceptC SetBaseConceptD(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD, _baseConceptD, SetBaseConceptDRaw); + return this; + } + + public BaseConceptC(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + result = BaseConceptD; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + result = _baseConceptD; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptD(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptDRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptD(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptD")] +public abstract partial class BaseConceptD : ConceptInstanceBase +{ + private string? _baseConceptE = null; + private bool SetBaseConceptERaw(string? value) + { + if (value == _baseConceptE) + return false; + _baseConceptE = value; + return true; + } + + /// Required Property + /// If BaseConceptE has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptE")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptE { get => _baseConceptE ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE); set => SetBaseConceptE(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptE([NotNullWhenAttribute(true)] out string? baseConceptE) + { + baseConceptE = _baseConceptE; + return baseConceptE != null; + } + + /// Required Property + /// If set to null + public BaseConceptD SetBaseConceptE(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE, _baseConceptE, SetBaseConceptERaw); + return this; + } + + public BaseConceptD(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + result = BaseConceptE; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + result = _baseConceptE; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptE(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptERaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptE(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-Iface")] +public partial interface Iface : INode +{ + /// Required Property + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get; set; } + + /// Required Property + public Iface SetIfaceMethod(string value); +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceImplA")] +public partial class IfaceImplA : ConceptInstanceBase, Iface +{ + private string? _ifaceMethod_ = null; + private bool SetIfaceMethodRaw(string? value) + { + if (value == _ifaceMethod_) + return false; + _ifaceMethod_ = value; + return true; + } + + /// Required Property + /// If IfaceMethod_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get => _ifaceMethod_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); set => SetIfaceMethod(value); } + + /// Required Property + /// If set to null + public bool TryGetIfaceMethod([NotNullWhenAttribute(true)] out string? ifaceMethod_) + { + ifaceMethod_ = _ifaceMethod_; + return ifaceMethod_ != null; + } +/// Required Property +/// If set to null + Iface Iface.SetIfaceMethod(string value) => SetIfaceMethod(value); + /// Required Property + /// If set to null + public IfaceImplA SetIfaceMethod(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod, _ifaceMethod_, SetIfaceMethodRaw); + return this; + } + + public IfaceImplA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceImplA; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = IfaceMethod_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = _ifaceMethod_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + if (value is string v) + { + SetIfaceMethod(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature) && value is null or string) + return SetIfaceMethodRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetIfaceMethod(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceImplB")] +public partial class IfaceImplB : ConceptInstanceBase, Iface +{ + private string? _ifaceMethod_ = null; + private bool SetIfaceMethodRaw(string? value) + { + if (value == _ifaceMethod_) + return false; + _ifaceMethod_ = value; + return true; + } + + /// Required Property + /// If IfaceMethod_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get => _ifaceMethod_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); set => SetIfaceMethod(value); } + + /// Required Property + /// If set to null + public bool TryGetIfaceMethod([NotNullWhenAttribute(true)] out string? ifaceMethod_) + { + ifaceMethod_ = _ifaceMethod_; + return ifaceMethod_ != null; + } +/// Required Property +/// If set to null + Iface Iface.SetIfaceMethod(string value) => SetIfaceMethod(value); + /// Required Property + /// If set to null + public IfaceImplB SetIfaceMethod(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod, _ifaceMethod_, SetIfaceMethodRaw); + return this; + } + + public IfaceImplB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceImplB; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = IfaceMethod_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = _ifaceMethod_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + if (value is string v) + { + SetIfaceMethod(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature) && value is null or string) + return SetIfaceMethodRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetIfaceMethod(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] +public partial class IfaceMethod : IfaceImplA +{ + public IfaceMethod(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceMethod; +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptA")] +public partial class SubConceptA : BaseConceptA +{ + public SubConceptA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.SubConceptA; +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptB")] +public partial class SubConceptB : BaseConceptB +{ + public SubConceptB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.SubConceptB; +} \ No newline at end of file diff --git a/test/LionWeb.Core.Test.Languages/Generated/V2025_1/FeatureSameNameAsContainingConcept.g.cs b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/FeatureSameNameAsContainingConcept.g.cs new file mode 100644 index 000000000..4cd667554 --- /dev/null +++ b/test/LionWeb.Core.Test.Languages/Generated/V2025_1/FeatureSameNameAsContainingConcept.g.cs @@ -0,0 +1,850 @@ +// Generated by the C# M2TypesGenerator: modify at your own risk! +// ReSharper disable InconsistentNaming +// ReSharper disable SuggestVarOrType_SimpleTypes +// ReSharper disable SuggestVarOrType_Elsewhere +#pragma warning disable 1591 +#nullable enable +namespace LionWeb.Core.Test.Languages.Generated.V2025_1.FeatureSameNameAsContainingConcept; +using global::LionWeb.Core; +using global::LionWeb.Core.M2; +using global::LionWeb.Core.M3; +using global::LionWeb.Core.Notification; +using global::LionWeb.Core.Utilities; +using global::LionWeb.Core.VersionSpecific.V2025_1; +using global::System; +using global::System.Collections.Generic; +using global::System.Diagnostics.CodeAnalysis; + +[LionCoreLanguage(Key = "key-FeatureSameNameAsContainingConcept", Version = "1")] +public partial class FeatureSameNameAsContainingConceptLanguage : LanguageBase +{ + public static readonly FeatureSameNameAsContainingConceptLanguage Instance = new Lazy(() => new("id-FeatureSameNameAsContainingConcept-lang")).Value; + public FeatureSameNameAsContainingConceptLanguage(string id) : base(id, LionWebVersions.v2025_1) + { + _baseConceptA = new(() => new ConceptBase("id-BaseConceptA", this) { Key = "key-BaseConceptA", Name = "BaseConceptA", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptA_BaseConceptA]) }); + _baseConceptA_BaseConceptA = new(() => new PropertyBase("id-BaseConceptA", BaseConceptA, this) { Key = "key-BaseConceptA", Name = "BaseConceptA", Optional = false, Type = _builtIns.String }); + _baseConceptB = new(() => new ConceptBase("id-BaseConceptB", this) { Key = "key-BaseConceptB", Name = "BaseConceptB", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptB_SubConceptB]) }); + _baseConceptB_SubConceptB = new(() => new PropertyBase("id-SubConceptB", BaseConceptB, this) { Key = "key-SubConceptB", Name = "SubConceptB", Optional = false, Type = _builtIns.String }); + _baseConceptC = new(() => new ConceptBase("id-BaseConceptC", this) { Key = "key-BaseConceptC", Name = "BaseConceptC", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptC_BaseConceptD]) }); + _baseConceptC_BaseConceptD = new(() => new PropertyBase("id-BaseConceptD", BaseConceptC, this) { Key = "key-BaseConceptD", Name = "BaseConceptD", Optional = false, Type = _builtIns.String }); + _baseConceptD = new(() => new ConceptBase("id-BaseConceptD", this) { Key = "key-BaseConceptD", Name = "BaseConceptD", Abstract = true, Partition = false, FeaturesLazy = new(() => [BaseConceptD_BaseConceptE]) }); + _baseConceptD_BaseConceptE = new(() => new PropertyBase("id-BaseConceptE", BaseConceptD, this) { Key = "key-BaseConceptE", Name = "BaseConceptE", Optional = false, Type = _builtIns.String }); + _iface = new(() => new InterfaceBase("id-Iface", this) { Key = "key-Iface", Name = "Iface", FeaturesLazy = new(() => [Iface_IfaceMethod]) }); + _iface_IfaceMethod = new(() => new PropertyBase("id-IfaceMethod", Iface, this) { Key = "key-IfaceMethod", Name = "IfaceMethod", Optional = false, Type = _builtIns.String }); + _ifaceImplA = new(() => new ConceptBase("id-IfaceImplA", this) { Key = "key-IfaceImplA", Name = "IfaceImplA", Abstract = false, Partition = false, ImplementsLazy = new(() => [Iface]) }); + _ifaceImplB = new(() => new ConceptBase("id-IfaceImplB", this) { Key = "key-IfaceImplB", Name = "IfaceImplB", Abstract = false, Partition = false, ImplementsLazy = new(() => [Iface]) }); + _ifaceMethod = new(() => new ConceptBase("id-IfaceMethod", this) { Key = "key-IfaceMethod", Name = "IfaceMethod", Abstract = false, Partition = false, ExtendsLazy = new(() => IfaceImplA) }); + _subConceptA = new(() => new ConceptBase("id-SubConceptA", this) { Key = "key-SubConceptA", Name = "SubConceptA", Abstract = false, Partition = false, ExtendsLazy = new(() => BaseConceptA) }); + _subConceptB = new(() => new ConceptBase("id-SubConceptB", this) { Key = "key-SubConceptB", Name = "SubConceptB", Abstract = false, Partition = false, ExtendsLazy = new(() => BaseConceptB) }); + _factory = new FeatureSameNameAsContainingConceptFactory(this); + } + + /// + public override IReadOnlyList Entities => [BaseConceptA, BaseConceptB, BaseConceptC, BaseConceptD, Iface, IfaceImplA, IfaceImplB, IfaceMethod, SubConceptA, SubConceptB]; + /// + public override IReadOnlyList DependsOn => []; + + private const string _key = "key-FeatureSameNameAsContainingConcept"; + /// + public override string Key => _key; + + private const string _name = "FeatureSameNameAsContainingConcept"; + /// + public override string Name => _name; + + private const string _version = "1"; + /// + public override string Version => _version; + + private readonly Lazy _baseConceptA; + public Concept BaseConceptA => _baseConceptA.Value; + + private readonly Lazy _baseConceptA_BaseConceptA; + public Property BaseConceptA_BaseConceptA => _baseConceptA_BaseConceptA.Value; + + private readonly Lazy _baseConceptB; + public Concept BaseConceptB => _baseConceptB.Value; + + private readonly Lazy _baseConceptB_SubConceptB; + public Property BaseConceptB_SubConceptB => _baseConceptB_SubConceptB.Value; + + private readonly Lazy _baseConceptC; + public Concept BaseConceptC => _baseConceptC.Value; + + private readonly Lazy _baseConceptC_BaseConceptD; + public Property BaseConceptC_BaseConceptD => _baseConceptC_BaseConceptD.Value; + + private readonly Lazy _baseConceptD; + public Concept BaseConceptD => _baseConceptD.Value; + + private readonly Lazy _baseConceptD_BaseConceptE; + public Property BaseConceptD_BaseConceptE => _baseConceptD_BaseConceptE.Value; + + private readonly Lazy _iface; + public Interface Iface => _iface.Value; + + private readonly Lazy _iface_IfaceMethod; + public Property Iface_IfaceMethod => _iface_IfaceMethod.Value; + + private readonly Lazy _ifaceImplA; + public Concept IfaceImplA => _ifaceImplA.Value; + + private readonly Lazy _ifaceImplB; + public Concept IfaceImplB => _ifaceImplB.Value; + + private readonly Lazy _ifaceMethod; + public Concept IfaceMethod => _ifaceMethod.Value; + + private readonly Lazy _subConceptA; + public Concept SubConceptA => _subConceptA.Value; + + private readonly Lazy _subConceptB; + public Concept SubConceptB => _subConceptB.Value; +} + +public partial interface IFeatureSameNameAsContainingConceptFactory : INodeFactory +{ + public IfaceImplA NewIfaceImplA(string id); + public IfaceImplA CreateIfaceImplA(); + public IfaceImplB NewIfaceImplB(string id); + public IfaceImplB CreateIfaceImplB(); + public IfaceMethod NewIfaceMethod(string id); + public IfaceMethod CreateIfaceMethod(); + public SubConceptA NewSubConceptA(string id); + public SubConceptA CreateSubConceptA(); + public SubConceptB NewSubConceptB(string id); + public SubConceptB CreateSubConceptB(); +} + +public class FeatureSameNameAsContainingConceptFactory : AbstractBaseNodeFactory, IFeatureSameNameAsContainingConceptFactory +{ + private readonly FeatureSameNameAsContainingConceptLanguage _language; + public FeatureSameNameAsContainingConceptFactory(FeatureSameNameAsContainingConceptLanguage language) : base(language) + { + _language = language; + } + + /// + public override INode CreateNode(string id, Classifier classifier) + { + if (_language.IfaceImplA.EqualsIdentity(classifier)) + return NewIfaceImplA(id); + if (_language.IfaceImplB.EqualsIdentity(classifier)) + return NewIfaceImplB(id); + if (_language.IfaceMethod.EqualsIdentity(classifier)) + return NewIfaceMethod(id); + if (_language.SubConceptA.EqualsIdentity(classifier)) + return NewSubConceptA(id); + if (_language.SubConceptB.EqualsIdentity(classifier)) + return NewSubConceptB(id); + throw new UnsupportedClassifierException(classifier); + } + + /// + public override Enum GetEnumerationLiteral(EnumerationLiteral literal) + { + throw new UnsupportedEnumerationLiteralException(literal); + } + + /// + public override IStructuredDataTypeInstance CreateStructuredDataTypeInstance(StructuredDataType structuredDataType, IFieldValues fieldValues) + { + throw new UnsupportedStructuredDataTypeException(structuredDataType); + } + + public virtual IfaceImplA NewIfaceImplA(string id) => new(id); + public virtual IfaceImplA CreateIfaceImplA() => NewIfaceImplA(GetNewId()); + public virtual IfaceImplB NewIfaceImplB(string id) => new(id); + public virtual IfaceImplB CreateIfaceImplB() => NewIfaceImplB(GetNewId()); + public virtual IfaceMethod NewIfaceMethod(string id) => new(id); + public virtual IfaceMethod CreateIfaceMethod() => NewIfaceMethod(GetNewId()); + public virtual SubConceptA NewSubConceptA(string id) => new(id); + public virtual SubConceptA CreateSubConceptA() => NewSubConceptA(GetNewId()); + public virtual SubConceptB NewSubConceptB(string id) => new(id); + public virtual SubConceptB CreateSubConceptB() => NewSubConceptB(GetNewId()); +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptA")] +public abstract partial class BaseConceptA : ConceptInstanceBase +{ + private string? _baseConceptA_ = null; + private bool SetBaseConceptARaw(string? value) + { + if (value == _baseConceptA_) + return false; + _baseConceptA_ = value; + return true; + } + + /// Required Property + /// If BaseConceptA_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptA")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptA_ { get => _baseConceptA_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA); set => SetBaseConceptA(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptA([NotNullWhenAttribute(true)] out string? baseConceptA_) + { + baseConceptA_ = _baseConceptA_; + return baseConceptA_ != null; + } + + /// Required Property + /// If set to null + public BaseConceptA SetBaseConceptA(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA, _baseConceptA_, SetBaseConceptARaw); + return this; + } + + public BaseConceptA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + result = BaseConceptA_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + result = _baseConceptA_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptA(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptARaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptA(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptA_BaseConceptA); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptB")] +public abstract partial class BaseConceptB : ConceptInstanceBase +{ + private string? _subConceptB_ = null; + private bool SetSubConceptBRaw(string? value) + { + if (value == _subConceptB_) + return false; + _subConceptB_ = value; + return true; + } + + /// Required Property + /// If SubConceptB_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptB")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string SubConceptB_ { get => _subConceptB_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB); set => SetSubConceptB(value); } + + /// Required Property + /// If set to null + public bool TryGetSubConceptB([NotNullWhenAttribute(true)] out string? subConceptB_) + { + subConceptB_ = _subConceptB_; + return subConceptB_ != null; + } + + /// Required Property + /// If set to null + public BaseConceptB SetSubConceptB(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB, _subConceptB_, SetSubConceptBRaw); + return this; + } + + public BaseConceptB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + result = SubConceptB_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + result = _subConceptB_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature)) + { + if (value is string v) + { + SetSubConceptB(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB.EqualsIdentity(feature) && value is null or string) + return SetSubConceptBRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetSubConceptB(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptB_SubConceptB); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptC")] +public abstract partial class BaseConceptC : ConceptInstanceBase +{ + private string? _baseConceptD = null; + private bool SetBaseConceptDRaw(string? value) + { + if (value == _baseConceptD) + return false; + _baseConceptD = value; + return true; + } + + /// Required Property + /// If BaseConceptD has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptD")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptD { get => _baseConceptD ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD); set => SetBaseConceptD(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptD([NotNullWhenAttribute(true)] out string? baseConceptD) + { + baseConceptD = _baseConceptD; + return baseConceptD != null; + } + + /// Required Property + /// If set to null + public BaseConceptC SetBaseConceptD(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD, _baseConceptD, SetBaseConceptDRaw); + return this; + } + + public BaseConceptC(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + result = BaseConceptD; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + result = _baseConceptD; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptD(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptDRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptD(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptC_BaseConceptD); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptD")] +public abstract partial class BaseConceptD : ConceptInstanceBase +{ + private string? _baseConceptE = null; + private bool SetBaseConceptERaw(string? value) + { + if (value == _baseConceptE) + return false; + _baseConceptE = value; + return true; + } + + /// Required Property + /// If BaseConceptE has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-BaseConceptE")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string BaseConceptE { get => _baseConceptE ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE); set => SetBaseConceptE(value); } + + /// Required Property + /// If set to null + public bool TryGetBaseConceptE([NotNullWhenAttribute(true)] out string? baseConceptE) + { + baseConceptE = _baseConceptE; + return baseConceptE != null; + } + + /// Required Property + /// If set to null + public BaseConceptD SetBaseConceptE(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE, _baseConceptE, SetBaseConceptERaw); + return this; + } + + public BaseConceptD(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + result = BaseConceptE; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + result = _baseConceptE; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature)) + { + if (value is string v) + { + SetBaseConceptE(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE.EqualsIdentity(feature) && value is null or string) + return SetBaseConceptERaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetBaseConceptE(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.BaseConceptD_BaseConceptE); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-Iface")] +public partial interface Iface : INode +{ + /// Required Property + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get; set; } + + /// Required Property + public Iface SetIfaceMethod(string value); +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceImplA")] +public partial class IfaceImplA : ConceptInstanceBase, Iface +{ + private string? _ifaceMethod_ = null; + private bool SetIfaceMethodRaw(string? value) + { + if (value == _ifaceMethod_) + return false; + _ifaceMethod_ = value; + return true; + } + + /// Required Property + /// If IfaceMethod_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get => _ifaceMethod_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); set => SetIfaceMethod(value); } + + /// Required Property + /// If set to null + public bool TryGetIfaceMethod([NotNullWhenAttribute(true)] out string? ifaceMethod_) + { + ifaceMethod_ = _ifaceMethod_; + return ifaceMethod_ != null; + } +/// Required Property +/// If set to null + Iface Iface.SetIfaceMethod(string value) => SetIfaceMethod(value); + /// Required Property + /// If set to null + public IfaceImplA SetIfaceMethod(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod, _ifaceMethod_, SetIfaceMethodRaw); + return this; + } + + public IfaceImplA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceImplA; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = IfaceMethod_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = _ifaceMethod_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + if (value is string v) + { + SetIfaceMethod(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature) && value is null or string) + return SetIfaceMethodRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetIfaceMethod(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceImplB")] +public partial class IfaceImplB : ConceptInstanceBase, Iface +{ + private string? _ifaceMethod_ = null; + private bool SetIfaceMethodRaw(string? value) + { + if (value == _ifaceMethod_) + return false; + _ifaceMethod_ = value; + return true; + } + + /// Required Property + /// If IfaceMethod_ has not been set + /// If set to null + [LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] + [LionCoreFeature(Kind = LionCoreFeatureKind.Property, Optional = false, Multiple = false)] + public string IfaceMethod_ { get => _ifaceMethod_ ?? throw new UnsetFeatureException(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); set => SetIfaceMethod(value); } + + /// Required Property + /// If set to null + public bool TryGetIfaceMethod([NotNullWhenAttribute(true)] out string? ifaceMethod_) + { + ifaceMethod_ = _ifaceMethod_; + return ifaceMethod_ != null; + } +/// Required Property +/// If set to null + Iface Iface.SetIfaceMethod(string value) => SetIfaceMethod(value); + /// Required Property + /// If set to null + public IfaceImplB SetIfaceMethod(string value) + { + SetRequiredReferenceTypeProperty(value, FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod, _ifaceMethod_, SetIfaceMethodRaw); + return this; + } + + public IfaceImplB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceImplB; + /// + protected override bool GetInternal(Feature? feature, out object? result) + { + if (base.GetInternal(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = IfaceMethod_; + return true; + } + + return false; + } + + protected override bool TryGetPropertyRaw(Property feature, out object? result) + { + if (base.TryGetPropertyRaw(feature, out result)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + result = _ifaceMethod_; + return true; + } + + return false; + } + + /// + protected override bool SetInternal(Feature? feature, object? value) + { + if (base.SetInternal(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature)) + { + if (value is string v) + { + SetIfaceMethod(v); + return true; + } + + throw new InvalidValueException(feature, value); + } + + return false; + } + + protected override bool SetPropertyRaw(Property feature, object? value) + { + if (base.SetPropertyRaw(feature, value)) + return true; + if (FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod.EqualsIdentity(feature) && value is null or string) + return SetIfaceMethodRaw((string?)value); + return false; + } + + /// + public override IEnumerable CollectAllSetFeatures() + { + List result = base.CollectAllSetFeatures().ToList(); + if (TryGetIfaceMethod(out _)) + result.Add(FeatureSameNameAsContainingConceptLanguage.Instance.Iface_IfaceMethod); + return result; + } +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-IfaceMethod")] +public partial class IfaceMethod : IfaceImplA +{ + public IfaceMethod(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.IfaceMethod; +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptA")] +public partial class SubConceptA : BaseConceptA +{ + public SubConceptA(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.SubConceptA; +} + +[LionCoreMetaPointer(Language = typeof(FeatureSameNameAsContainingConceptLanguage), Key = "key-SubConceptB")] +public partial class SubConceptB : BaseConceptB +{ + public SubConceptB(string id) : base(id) + { + } + + /// + public override Concept GetConcept() => FeatureSameNameAsContainingConceptLanguage.Instance.SubConceptB; +} \ No newline at end of file From b7cb02b2803e0e7e1fe2b6567ee6963ca723d876 Mon Sep 17 00:00:00 2001 From: Niko Date: Fri, 19 Dec 2025 01:13:35 +0100 Subject: [PATCH 5/7] Make formatting optional during persisting generated classes --- CHANGELOG.md | 1 + src/LionWeb.Generator/GeneratorFacade.cs | 16 +++++++++------- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b47dbd07c..e57bf46f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ and this project adheres _loosely_ to [Semantic Versioning](https://semver.org/s * Bugfix: `DeltaDeserializerHandler` is made public. This handler enables deserializer to accept node id that appears both in received delta(s) and local nodes. In the context of delta protocol, this enables replacing a node in a model with a new node with the same id, which results in a valid model. * `a.InsertBefore(b)` / `a.InsertAfter(b)` work correctly if both `a` and `b` are siblings. ### Changed +* Make formatting optional during persisting generated classes. * Escape feature names that have the same name as an implementing type during generation. * Don't generate current namespace as fully qualified name. * Add `global::` prefix to `using` statements to support generating languages that contain `LionWeb` in their namespace. diff --git a/src/LionWeb.Generator/GeneratorFacade.cs b/src/LionWeb.Generator/GeneratorFacade.cs index 4aec13c7a..6f6255126 100644 --- a/src/LionWeb.Generator/GeneratorFacade.cs +++ b/src/LionWeb.Generator/GeneratorFacade.cs @@ -77,7 +77,7 @@ public void Persist(string path) => Persist(path, Generate()); /// Stores the output of to the file at . - public void Persist(string path, CompilationUnitSyntax compilationUnit) + public void Persist(string path, CompilationUnitSyntax compilationUnit, bool formatted = true) { var workspace = new AdhocWorkspace(); var options = workspace.Options @@ -87,7 +87,9 @@ public void Persist(string path, CompilationUnitSyntax compilationUnit) .WithChangedOption(CSharpFormattingOptions.WrappingKeepStatementsOnSingleLine, value: false) .WithChangedOption(CSharpFormattingOptions.NewLineForMembersInAnonymousTypes, value: true) .WithChangedOption(CSharpFormattingOptions.NewLineForMembersInObjectInit, value: true); - var formattedCompilationUnit = (CompilationUnitSyntax)Formatter.Format(compilationUnit, workspace, options); + var formattedCompilationUnit = formatted + ? (CompilationUnitSyntax)Formatter.Format(compilationUnit, workspace, options) + : compilationUnit; using var streamWriter = new StreamWriter(path, false); streamWriter.Write(formattedCompilationUnit.GetText().ToString().ReplaceLineEndings()); @@ -101,19 +103,19 @@ public void Persist(string path, CompilationUnitSyntax compilationUnit) /// Compiles the output of and returns all diagnostic messages. public ImmutableArray Compile() => - Compile(Generate()); + Compile([Generate()]); - /// Compiles and returns all diagnostic messages. - public ImmutableArray Compile(CompilationUnitSyntax compilationUnit) + /// Compiles and returns all diagnostic messages. + public ImmutableArray Compile(IEnumerable compilationUnits) { - var tree = SyntaxTree(compilationUnit); + var trees = compilationUnits.Select(cu => SyntaxTree(cu)); var refApis = AppDomain.CurrentDomain.GetAssemblies() .Where(a => !a.IsDynamic) .Select(a => MetadataReference.CreateFromFile(a.Location)) .Append(MetadataReference.CreateFromFile(typeof(Stack<>).Assembly.Location)) .Append(MetadataReference.CreateFromFile(typeof(ISet<>).Assembly.Location)) .Append(MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location)); - var compilation = CSharpCompilation.Create("foo", [tree], refApis); + var compilation = CSharpCompilation.Create("foo", trees, refApis); var diagnostics = compilation.GetDiagnostics(); return diagnostics; } From 62454150fa3885a550bb99bbaff1e905a9dc4e54 Mon Sep 17 00:00:00 2001 From: Niko Date: Fri, 19 Dec 2025 01:14:47 +0100 Subject: [PATCH 6/7] Use generator postprocessing to split up generated files per class. Implemented as an example/test to generate SysML2 --- .../PostprocessGeneratorTests.cs | 92 ++++++++++++++++++- 1 file changed, 90 insertions(+), 2 deletions(-) diff --git a/test/LionWeb.Generator.Test/PostprocessGeneratorTests.cs b/test/LionWeb.Generator.Test/PostprocessGeneratorTests.cs index b26686f9b..ebeb445e4 100644 --- a/test/LionWeb.Generator.Test/PostprocessGeneratorTests.cs +++ b/test/LionWeb.Generator.Test/PostprocessGeneratorTests.cs @@ -17,13 +17,16 @@ namespace LionWeb.Generator.Test; +using Core; using Core.M2; using Core.M3; +using Core.Serialization; using Core.Test.Languages.Generated.V2023_1.MultiInheritLang; using Core.Test.Languages.Generated.V2023_1.TestLanguage; using GeneratorExtensions; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; using Names; using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; @@ -34,7 +37,7 @@ public class PostprocessGeneratorTests public void AddSealed() { var language = MultiInheritLangLanguage.Instance; - + var generator = new GeneratorFacade { Names = new Names(language, "TestLanguage"), @@ -48,7 +51,7 @@ public void AddSealed() .OfType() .Where(c => !c.AllSpecializations([language]).Any()) .Select(c => correlator.FindAll(c).Single()); - + foreach (var correlation in classifiersWithoutSpecializations) { var typeDeclaration = correlation.LookupIn(compilationUnit); @@ -73,4 +76,89 @@ public void AddSealed() File.Delete(path); } } + + [TestMethod] + public void SplitClassesInFiles() + { + // Supposed to check out https://github.com/LionWeb-io/sysmlv2-demo/tree/main next to lionweb-csharp + var sysml2Dir = "./../../../../../../sysmlv2-demo/models"; + + SerializationChunk typesChunk = + JsonUtils.ReadJsonFromString(File.ReadAllText($"{sysml2Dir}/types_lionweb.json")); + SerializationChunk kermlChunk = + JsonUtils.ReadJsonFromString( + File.ReadAllText($"{sysml2Dir}/kerml_lionweb_lionweb.json")); + SerializationChunk sysmlChunk = + JsonUtils.ReadJsonFromString( + File.ReadAllText($"{sysml2Dir}/SysML_lionweb_lionweb.json")); + + var lionWebVersion = LionWebVersions.v2023_1; + + List dependentLanguages = []; + + var typesLanguage = Deserialize(lionWebVersion, typesChunk, dependentLanguages); + dependentLanguages.Add(typesLanguage); + var kermlLanguage = Deserialize(lionWebVersion, kermlChunk, dependentLanguages); + dependentLanguages.Add(kermlLanguage); + var sysmlLanguage = Deserialize(lionWebVersion, sysmlChunk, dependentLanguages); + dependentLanguages.Add(sysmlLanguage); + + var namespaceMappings = new Dictionary + { + { typesLanguage, "io.LionWeb.SysMl2.Types" }, + { kermlLanguage, "io.LionWeb.SysMl2.KerMl" }, + { sysmlLanguage, "io.LionWeb.SysMl2.SysMl2" }, + }; + + var primitiveTypeMappings = new Dictionary + { + { typesLanguage.FindByKey("types-Boolean"), typeof(bool) }, + { typesLanguage.FindByKey("types-Integer"), typeof(int) }, + { typesLanguage.FindByKey("types-Real"), typeof(decimal) }, + { typesLanguage.FindByKey("types-String"), typeof(string) }, + { typesLanguage.FindByKey("types-UnlimitedNatural"), typeof(decimal) } + }; + + var basePath = Directory.CreateTempSubdirectory(); + Console.WriteLine($"BasePath: {basePath}"); + + foreach (var language in dependentLanguages) + { + var generator = new GeneratorFacade + { + Names = new Names(language, namespaceMappings[language]) + { + NamespaceMappings = namespaceMappings, PrimitiveTypeMappings = primitiveTypeMappings + }, + LionWebVersion = lionWebVersion + }; + + var compilationUnit = generator.Generate(); + + List compilationUnits = []; + + foreach (var ns in compilationUnit.Members.OfType()) + { + foreach (var type in ns.Members.OfType()) + { + var copy = compilationUnit.ReplaceNode(ns, + ns.WithMembers(SingletonList(type))); + var namespaces = namespaceMappings[language].Split('.'); + var directory = Path.Combine([basePath.FullName, ..namespaces]); + Directory.CreateDirectory(directory); + var file = Path.Combine(directory, $"{type.Identifier.Text}.g.cs"); + generator.Persist(file, copy, false); + Console.WriteLine($"Wrote output to {file}"); + } + } + } + } + + private static DynamicLanguage Deserialize(IVersion2023_1 lionWebVersion, SerializationChunk typesChunk, + List dependentLanguages) => + new LanguageDeserializerBuilder() + .WithLionWebVersion(lionWebVersion) + .WithCompressedIds(new(KeepOriginal: true)) + .Build() + .Deserialize(typesChunk, dependentLanguages).First(); } \ No newline at end of file From 83c12b4f7d27d05635e97c09ec32dee02509f9b3 Mon Sep 17 00:00:00 2001 From: Niko Date: Fri, 19 Dec 2025 01:15:22 +0100 Subject: [PATCH 7/7] WIP: Customize user-defined primitive types --- .../Impl/FeatureGeneratorProperty.cs | 1 + src/LionWeb.Generator/Names/INames.cs | 3 + src/LionWeb.Generator/Names/Names.cs | 76 ++++++++++++++----- .../Names/UniqueFeatureNames.cs | 3 + 4 files changed, 66 insertions(+), 17 deletions(-) diff --git a/src/LionWeb.Generator/Impl/FeatureGeneratorProperty.cs b/src/LionWeb.Generator/Impl/FeatureGeneratorProperty.cs index 755a7585a..09fd40016 100644 --- a/src/LionWeb.Generator/Impl/FeatureGeneratorProperty.cs +++ b/src/LionWeb.Generator/Impl/FeatureGeneratorProperty.cs @@ -79,5 +79,6 @@ private bool IsReferenceType() => || _builtIns.Integer.EqualsIdentity(property.Type) || property.Type is Enumeration || property.Type is StructuredDataType + || property.Type is PrimitiveType p && _names.PrimitiveTypeMappings.TryGetValue(p, out var t) && t.IsValueType ); } \ No newline at end of file diff --git a/src/LionWeb.Generator/Names/INames.cs b/src/LionWeb.Generator/Names/INames.cs index 7ad9facf3..ed78543e3 100644 --- a/src/LionWeb.Generator/Names/INames.cs +++ b/src/LionWeb.Generator/Names/INames.cs @@ -40,6 +40,9 @@ public interface INames /// Maps external languages to their namespaces. IDictionary NamespaceMappings { get; } + /// Maps custom primitive types between LionWeb and C#. + IDictionary PrimitiveTypeMappings { get; } + /// Register a new NamespaceMapping. void AddNamespaceMapping(Language lang, string nsName); diff --git a/src/LionWeb.Generator/Names/Names.cs b/src/LionWeb.Generator/Names/Names.cs index b30fbc11d..12234c8be 100644 --- a/src/LionWeb.Generator/Names/Names.cs +++ b/src/LionWeb.Generator/Names/Names.cs @@ -51,6 +51,7 @@ public partial class Names : INames protected readonly IBuiltInsLanguage _builtIns; private readonly Dictionary _namespaceMappings = new(); + private readonly Dictionary _primitiveTypeMappings = new(); /// /// Central handling of all naming. @@ -61,7 +62,8 @@ public partial class Names : INames public Names(Language language, string namespaceName) { _language = language; - _namespaceName = string.Join(_namespaceSeparator, namespaceName.Split(_namespaceSeparator).Select(p => p.PrefixKeyword())); + _namespaceName = string.Join(_namespaceSeparator, + namespaceName.Split(_namespaceSeparator).Select(p => p.PrefixKeyword())); _m3 = language.LionWebVersion.LionCore; _builtIns = language.LionWebVersion.BuiltIns; @@ -80,6 +82,19 @@ public IDictionary NamespaceMappings } } + /// + public IDictionary PrimitiveTypeMappings + { + get => _primitiveTypeMappings; + init + { + foreach ((PrimitiveType key, Type type) in value) + { + _primitiveTypeMappings[key] = type; + } + } + } + /// public void AddNamespaceMapping(Language lang, string nsName) => _namespaceMappings[lang] = nsName; @@ -87,7 +102,8 @@ public void AddNamespaceMapping(Language lang, string nsName) => /// public string LanguageName(Language lang) => LanguageBaseName(lang) + "Language"; - private string LanguageBaseName(Language lang) => lang.Name.Split(_namespaceSeparator).Last().ToFirstUpper().PrefixKeyword(); + private string LanguageBaseName(Language lang) => + lang.Name.Split(_namespaceSeparator).Last().ToFirstUpper().PrefixKeyword(); /// public NameSyntax LanguageType => AsType(_language); @@ -231,15 +247,33 @@ public TypeSyntax AsType(Type type, params TypeSyntax?[] generics) { TypeSyntax? result = null; - if (type == typeof(string)) - result = PredefinedType(Token(SyntaxKind.StringKeyword)); - else if (type == typeof(int)) - result = PredefinedType(Token(SyntaxKind.IntKeyword)); - else if (type == typeof(bool)) - result = PredefinedType(Token(SyntaxKind.BoolKeyword)); - else if (type == typeof(object)) + if (type.IsPrimitive) + { + result = PredefinedType(Token( + type switch + { + _ when type == typeof(bool) => SyntaxKind.BoolKeyword, + _ when type == typeof(byte) => SyntaxKind.ByteKeyword, + _ when type == typeof(char) => SyntaxKind.CharKeyword, + _ when type == typeof(double) => SyntaxKind.DoubleKeyword, + _ when type == typeof(short) => SyntaxKind.ShortKeyword, + _ when type == typeof(int) => SyntaxKind.IntKeyword, + _ when type == typeof(long) => SyntaxKind.LongKeyword, + _ when type == typeof(sbyte) => SyntaxKind.SByteKeyword, + _ when type == typeof(float) => SyntaxKind.FloatKeyword, + _ when type == typeof(ushort) => SyntaxKind.UShortKeyword, + _ when type == typeof(uint) => SyntaxKind.UIntKeyword, + _ when type == typeof(ulong) => SyntaxKind.StringKeyword + })); + } else if (type == typeof(object)) result = PredefinedType(Token(SyntaxKind.ObjectKeyword)); - + else if (type == typeof(string)) + result = PredefinedType(Token(SyntaxKind.StringKeyword)); + else if (type == typeof(decimal)) + result = PredefinedType(Token(SyntaxKind.DecimalKeyword)); + else if (_internalTypes.Contains(type) + && M1Extensions.Descendants(_language, true).Any(k => k.Name == type.Name)) + result = ParseName($"global::" + type.FullName); else if (generics == null || generics.Length == 0) { if (type.GenericTypeArguments is { Length: > 0 }) @@ -252,7 +286,7 @@ public TypeSyntax AsType(Type type, params TypeSyntax?[] generics) } if (result == null) - result = GenericName(Use(type)) + result = GenericName(IdentifierName(Use(type)).ToString()) .WithTypeArgumentList(TypeArgumentList(SeparatedList(generics))); return result; @@ -339,16 +373,24 @@ public TypeSyntax AsType(Classifier classifier, bool disambiguate = false, bool /// public TypeSyntax AsType(Datatype datatype, bool disambiguate = false) { - var result = VersionSpecifics.AsType(datatype, _namespaceMappings); - if (result != null) - return result; + TypeSyntax type; + if (datatype is PrimitiveType p && _primitiveTypeMappings.TryGetValue(p, out var t)) + { + type = AsType(t); + } else + { + var result = VersionSpecifics.AsType(datatype, _namespaceMappings); + if (result != null) + return result; + + type = IdentifierName(datatype.Name.PrefixKeyword()); + } - var type = IdentifierName(datatype.Name.PrefixKeyword()); - if (!disambiguate || datatype is PrimitiveType) + if (!disambiguate || type is not SimpleNameSyntax s) return type; - return QualifiedName(ParseName(NamespaceName), type); + return QualifiedName(ParseName(NamespaceName), s); } /// diff --git a/src/LionWeb.Generator/Names/UniqueFeatureNames.cs b/src/LionWeb.Generator/Names/UniqueFeatureNames.cs index 6e0c55a2f..8a08b49f6 100644 --- a/src/LionWeb.Generator/Names/UniqueFeatureNames.cs +++ b/src/LionWeb.Generator/Names/UniqueFeatureNames.cs @@ -45,6 +45,9 @@ public class UniqueFeatureNames(INames parent) : INames /// public IDictionary NamespaceMappings => parent.NamespaceMappings; + /// + public IDictionary PrimitiveTypeMappings => parent.PrimitiveTypeMappings; + /// public string LanguageName(Language lang) => parent.LanguageName(lang);