diff --git a/CHANGELOG.md b/CHANGELOG.md index 86ed80fd1..e57bf46f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,11 @@ 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. +* 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 86247d486..5ee0a1ac2 100644 --- a/build/LionWeb-CSharp-Build/Generate.cs +++ b/build/LionWeb-CSharp-Build/Generate.cs @@ -70,6 +70,10 @@ var generalNodeLang = testLanguagesDefinitions.GeneralNodeLang; var lowerCaseLang = testLanguagesDefinitions.LowerCaseLang; var upperCaseLang = testLanguagesDefinitions.UpperCaseLang; + 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}"; @@ -90,6 +94,10 @@ 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"), + 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 @@ -121,7 +129,6 @@ { NamespaceMappings = testLanguagesDefinitions .MixedLangs - .Except([l]) .Select(n => (n, $"{prefix}.Mixed.{n.Name}")) .ToDictionary() } diff --git a/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs b/build/LionWeb-CSharp-Build/TestLanguagesDefinitions.cs index 87de2e603..99da1608c 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 @@ -38,6 +40,11 @@ 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 Language LanguageWithLionWebNamedConcepts { get; private set; } + public Language FeatureSameNameAsContainingConcept { get; private set; } + public List MixedLangs { get; private set; } = []; public TestLanguagesDefinitions(LionWebVersions lionWebVersion) @@ -49,6 +56,10 @@ public TestLanguagesDefinitions(LionWebVersions lionWebVersion) CreateMultiInheritLang(); CreateNamedLang(); CreateGeneralNodeLang(); + CreateNamespaceStartsWithLionWebLang(); + CreateNamespaceContainsLionWebLang(); + CreateLanguageWithLionWebNamedConcepts(); + CreateFeatureSameNameAsContainingConcept(); if (lionWebVersion.LionCore is ILionCoreLanguageWithStructuredDataType) { @@ -519,4 +530,264 @@ 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; + } + + 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; + } + + 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 +{ + 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/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; } 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/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/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/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/INames.cs b/src/LionWeb.Generator/Names/INames.cs index db4ff6d2c..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); @@ -128,7 +131,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 8a9d024b1..12234c8be 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; @@ -36,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 = []; /// @@ -48,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. @@ -58,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; @@ -70,13 +75,26 @@ 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; } } } + /// + 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; @@ -84,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); @@ -107,20 +126,154 @@ 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) { 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 }) @@ -133,12 +286,66 @@ 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; } + 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 +361,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); @@ -166,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); } /// @@ -184,7 +399,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())) @@ -227,7 +443,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) => @@ -253,8 +469,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 9832859be..8a08b49f6 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; @@ -44,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); @@ -117,7 +121,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()); @@ -136,6 +140,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/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/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/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/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/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/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/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/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/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/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 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/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 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 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