/* ========================================================================
 * Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
 *
 * OPC Foundation MIT License 1.00
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * The complete license agreement can be found here:
 * http://opcfoundation.org/License/MIT/1.00/
 * ======================================================================*/

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml;
using Microsoft.Extensions.Logging;
using Opc.Ua.Schema.Model;
using Opc.Ua.Types;

namespace Opc.Ua.SourceGeneration
{
    /// <summary>
    /// Generates data types and node state classes.
    /// </summary>
    internal sealed class NodeStateGenerator : IGenerator
    {
        /// <summary>
        /// Create node state generator
        /// </summary>
        public NodeStateGenerator(IGeneratorContext context)
        {
            m_context = context ?? throw new ArgumentNullException(nameof(context));
            m_messageContext = ServiceMessageContext.CreateEmpty(context.Telemetry);
            m_logger = context.Telemetry.CreateLogger<NodeStateGenerator>();
            CollectNodesToGenerate();
        }

        /// <summary>
        /// When <c>true</c>, emits the model's public NodeSet import factory
        /// provider. Only set for models whose consumer references
        /// <c>Opc.Ua.Server</c>.
        /// </summary>
        public bool GenerateNodeSetImportSupport { get; init; }

        /// <summary>
        /// When <c>true</c>, emits the import factory provider on its own and
        /// leaves the model types to the assembly that owns them. Set when a
        /// node manager binds to a model a referenced assembly supplies: the
        /// provider implements an <c>Opc.Ua.Server</c> contract that a
        /// model-only assembly cannot reference, so it has to be emitted
        /// beside the manager rather than beside the model.
        /// </summary>
        public bool ImportSupportOnly { get; init; }

        /// <inheritdoc/>
        public IEnumerable<Resource> Emit()
        {
            m_initializers.Clear();
            if (ImportSupportOnly)
            {
                return GenerateNodeSetImportSupport
                    ? [EmitNodeSetImportSupport()]
                    : [];
            }
            if (m_instances.Count + m_nodes.Count == 0)
            {
                return GenerateNodeSetImportSupport
                    ? [EmitNodeSetImportSupport()]
                    : [];
            }
            List<Resource> resources =
            [
                EmitNodeStateClasses(),
                EmitExtensions()
            ];
            if (GenerateNodeSetImportSupport)
            {
                resources.Add(EmitNodeSetImportSupport());
            }
            Resource? initializers = EmbedInitializers();
            if (initializers != null)
            {
                resources.Add(initializers);
            }
            return resources;
        }

        /// <summary>
        /// Create the nodestates classes
        /// </summary>
        private TextFileResource EmitNodeStateClasses()
        {
            string nsPrefix = m_context.ModelDesign.TargetNamespace.Prefix;
            string fileName = Path.Combine(m_context.OutputFolder, CoreUtils.Format(
                "{0}.NodeStates.g.cs",
                nsPrefix));
            using TextWriter writer = m_context.FileSystem.CreateTextWriter(fileName);
            using var templateWriter = new TemplateWriter(writer);
            var template = new Template(templateWriter, NodeStateTemplates.File);
            template.AddReplacement(Tokens.NamespacePrefix, nsPrefix);
            template.AddReplacement(
                Tokens.Namespace,
                nsPrefix.Replace(".", string.Empty, StringComparison.Ordinal));
            template.AddReplacement(
                Tokens.NamespaceUri,
                m_context.ModelDesign.Namespaces.GetConstantSymbolForNamespace(
                    m_context.ModelDesign.TargetNamespace.Value));

            // TODO: Switch to "instance" list and get "type" from entry.IsInstanceOfType
            template.AddReplacement(
                Tokens.ListOfTypes,
                m_nodes.Values,
                LoadTemplate_ListOfNodeStateClasses,
                WriteTemplate_ListOfNodeStateClasses);
            template.AddReplacement(
                Tokens.ListOfTypeActivators,
                NodeStateTemplates.ActivatorClass,
                m_nodes.Values,
                LoadTemplate_ListOfNodeStateActivators,
                WriteTemplate_ListOfNodeStateActivators);

            template.Render();
            return fileName.AsTextFileResource();
        }

        /// <summary>
        /// Create extensions
        /// </summary>
        /// <summary>
        /// Create the model's NodeSet import factory provider
        /// </summary>
        private TextFileResource EmitNodeSetImportSupport()
        {
            string nsPrefix = m_context.ModelDesign.TargetNamespace.Prefix;
            string typeStem = nsPrefix.Replace(".", string.Empty, StringComparison.Ordinal);
            string fileName = Path.Combine(m_context.OutputFolder, CoreUtils.Format(
                "{0}.NodeSetImportSupport.g.cs",
                nsPrefix));
            using TextWriter writer = m_context.FileSystem.CreateTextWriter(fileName);
            using var templateWriter = new TemplateWriter(writer);
            var template = new Template(
                templateWriter,
                NodeStateTemplates.NodeSetImportSupport_File);
            template.AddReplacement(Tokens.NamespacePrefix, nsPrefix);
            template.AddReplacement(
                Tokens.ListOfTypes,
                ["body"],
                onLoad: context =>
                {
                    EmitNodeSetImportFactoryProvider(
                        context.Out,
                        typeStem + "NodeSetImportFactoryProvider");
                    return null;
                });
            template.Render();
            return fileName.AsTextFileResource();
        }

        private void EmitNodeSetImportFactoryProvider(
            ITemplateWriter writer,
            string className)
        {
            List<ImportFactoryRegistration> registrations =
                GetNodeSetImportFactoryRegistrations();

            writer.WriteLine("    /// <summary>");
            writer.WriteLine(
                "    /// Public registration provider for typed NodeSet imports.");
            writer.WriteLine("    /// </summary>");
            writer.WriteLine(
                "    [global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"{0}\", \"{1}\")]",
                typeof(NodeStateGenerator).Assembly.GetName().Name,
                typeof(NodeStateGenerator).Assembly.GetName().Version);
            writer.WriteLine(
                "    public sealed class {0} :",
                className);
            writer.WriteLine(
                "        global::Opc.Ua.Server.Nodes.INodeSetImportFactoryProvider");
            writer.WriteLine("    {");
            writer.WriteLine("        /// <summary>");
            writer.WriteLine("        /// Initializes a provider.");
            writer.WriteLine("        /// </summary>");
            writer.WriteLine("        public {0}()", className);
            writer.WriteLine("        {");
            writer.WriteLine("        }");
            writer.WriteLine();
            writer.WriteLine("        /// <summary>");
            writer.WriteLine("        /// Gets the shared provider instance.");
            writer.WriteLine("        /// </summary>");
            writer.WriteLine(
                "        public static {0} Instance {{ get; }} = new {0}();",
                className);
            writer.WriteLine();
            writer.WriteLine("        /// <inheritdoc/>");
            writer.WriteLine(
                "        public global::Opc.Ua.ArrayOf<global::Opc.Ua.Server.Nodes.INodeSetImportFactory>");
            writer.WriteLine("            GetNodeSetImportFactories()");
            writer.WriteLine("        {");
            if (registrations.Count == 0)
            {
                writer.WriteLine(
                    "            return new global::Opc.Ua.ArrayOf<" +
                    "global::Opc.Ua.Server.Nodes.INodeSetImportFactory>(");
                writer.WriteLine(
                    "                global::System.Array.Empty<" +
                    "global::Opc.Ua.Server.Nodes.INodeSetImportFactory>());");
            }
            else
            {
                writer.WriteLine(
                    "            return new global::Opc.Ua.ArrayOf<" +
                    "global::Opc.Ua.Server.Nodes.INodeSetImportFactory>(");
                writer.WriteLine(
                    "                new global::Opc.Ua.Server.Nodes.INodeSetImportFactory[]");
                writer.WriteLine("                {");
                for (int i = 0; i < registrations.Count; i++)
                {
                    writer.WriteLine(
                        "                    ImportFactory{0:D4}.Instance{1}",
                        i,
                        i + 1 == registrations.Count ? string.Empty : ",");
                }
                writer.WriteLine("                });");
            }
            writer.WriteLine("        }");

            for (int i = 0; i < registrations.Count; i++)
            {
                EmitNodeSetImportFactory(writer, registrations[i], i);
            }

            writer.WriteLine("    }");
        }

        private static void EmitNodeSetImportFactory(
            ITemplateWriter writer,
            ImportFactoryRegistration registration,
            int index)
        {
            writer.WriteLine();
            writer.WriteLine(
                "        private sealed class ImportFactory{0:D4} :",
                index);
            writer.WriteLine(
                "            global::Opc.Ua.Server.Nodes.INodeSetImportFactory");
            writer.WriteLine("        {");
            writer.WriteLine(
                "            private ImportFactory{0:D4}()",
                index);
            writer.WriteLine("            {");
            writer.WriteLine("            }");
            writer.WriteLine();
            writer.WriteLine(
                "            public static ImportFactory{0:D4} Instance {{ get; }} = new ImportFactory{0:D4}();",
                index);
            writer.WriteLine();
            writer.WriteLine(
                "            public global::Opc.Ua.NodeClass NodeClass");
            writer.WriteLine(
                "                => global::Opc.Ua.NodeClass.{0};",
                registration.NodeClass);
            writer.WriteLine();
            writer.WriteLine(
                "            public global::Opc.Ua.Server.Nodes.NodeSetImportDiscriminator Discriminator");
            writer.WriteLine(
                "                => global::Opc.Ua.Server.Nodes.NodeSetImportDiscriminator.{0};",
                registration.Discriminator);
            writer.WriteLine();
            writer.WriteLine(
                "            public global::Opc.Ua.ExpandedNodeId DiscriminatorId");
            writer.WriteLine(
                "                => {0};",
                registration.DiscriminatorId);
            writer.WriteLine();
            writer.WriteLine(
                "            public global::Opc.Ua.NodeState CreateEmptyState()");
            writer.WriteLine("            {");
            writer.WriteLine(
                "                return {0};",
                registration.CreateExpression);
            writer.WriteLine("            }");
            writer.WriteLine("        }");
        }

        private List<ImportFactoryRegistration>
            GetNodeSetImportFactoryRegistrations()
        {
            var registrations = new Dictionary<string, ImportFactoryRegistration>(
                StringComparer.Ordinal);
            string targetNamespace = m_context.ModelDesign.TargetNamespace.Value;

            void Add(
                string nodeClass,
                string discriminator,
                NodeDesign discriminatorNode,
                string? createExpression)
            {
                if (discriminatorNode == null ||
                    string.IsNullOrEmpty(createExpression) ||
                    !HasResolvableNodeId(discriminatorNode))
                {
                    return;
                }

                string discriminatorId = discriminatorNode.GetExpandedNodeIdAsCode(
                    m_context.ModelDesign.Namespaces);
                string key = nodeClass + "|" + discriminator + "|" + discriminatorId;
                registrations.TryAdd(
                    key,
                    new ImportFactoryRegistration(
                        nodeClass,
                        discriminator,
                        discriminatorId,
                        createExpression));
            }

            foreach (NodeToGenerate node in m_nodes.Values)
            {
                if (node.Parent != null ||
                    !string.Equals(
                        node.Design!.SymbolicId.Namespace,
                        targetNamespace,
                        StringComparison.Ordinal))
                {
                    continue;
                }

                switch (node.Design)
                {
                    case ObjectTypeDesign objectType:
                        Add(
                            "ObjectType",
                            "NodeId",
                            objectType,
                            "new global::Opc.Ua.BaseObjectTypeState()");
                        if (!objectType.IsAbstract && node.Instance != null)
                        {
                            Add(
                                "Object",
                                "TypeDefinition",
                                objectType,
                                GetDirectEmptyStateCreation(
                                    (InstanceDesign)node.Instance.Design!));
                        }
                        break;
                    case VariableTypeDesign variableType:
                        Add(
                            "VariableType",
                            "NodeId",
                            variableType,
                            "new global::Opc.Ua.BaseDataVariableTypeState()");
                        if (!variableType.IsAbstract && node.Instance != null)
                        {
                            Add(
                                "Variable",
                                "TypeDefinition",
                                variableType,
                                GetDirectEmptyStateCreation(
                                    (InstanceDesign)node.Instance.Design!));
                        }
                        break;
                    case DataTypeDesign dataType:
                        Add(
                            "DataType",
                            "NodeId",
                            dataType,
                            "new global::Opc.Ua.DataTypeState()");
                        break;
                    case ReferenceTypeDesign referenceType:
                        Add(
                            "ReferenceType",
                            "NodeId",
                            referenceType,
                            "new global::Opc.Ua.ReferenceTypeState()");
                        break;
                    case ViewDesign view:
                        Add(
                            "View",
                            "NodeId",
                            view,
                            "new global::Opc.Ua.ViewState()");
                        break;
                    case MethodDesign method
                        when method.IsMethodTypeDesign():
                        string? createExpression =
                            GetDirectEmptyStateCreation(method);
                        Add(
                            "Method",
                            "NodeId",
                            method,
                            createExpression);
                        Add(
                            "Method",
                            "MethodDeclaration",
                            method,
                            createExpression);
                        break;
                }
            }

            foreach (NodeToGenerate node in m_nodes.Values)
            {
                if (node.Design is MethodDesign method &&
                    node.RootIsTypeDefinition &&
                    !method.IsMethodTypeDesign() &&
                    string.Equals(
                        method.SymbolicId.Namespace,
                        targetNamespace,
                        StringComparison.Ordinal))
                {
                    Add(
                        "Method",
                        "MethodDeclaration",
                        method,
                        GetDirectEmptyStateCreation(method));
                }
            }

            foreach (NodeToGenerate node in m_nodes.Values)
            {
                if (node.Design is not InstanceDesign instance ||
                    !string.Equals(
                        instance.SymbolicId.Namespace,
                        targetNamespace,
                        StringComparison.Ordinal) ||
                    !IsInAddressSpace(node))
                {
                    continue;
                }

                string? nodeClass = GetImportNodeClass(instance);
                if (nodeClass == null)
                {
                    continue;
                }

                // Only declarations get an exact-NodeId factory. Registering
                // one per address-space instance would emit a factory per node
                // of the model, and an imported node that re-declares an
                // instance still resolves through its TypeDefinition or
                // MethodDeclaration below.
                if (IsDeclarationNode(node))
                {
                    Add(
                        nodeClass,
                        "NodeId",
                        instance,
                        GetDirectEmptyStateCreation(instance));
                }

                if (instance is ObjectDesign &&
                    instance.TypeDefinitionNode is ObjectTypeDesign objectType &&
                    string.Equals(
                        objectType.SymbolicId.Namespace,
                        targetNamespace,
                        StringComparison.Ordinal))
                {
                    Add(
                        "Object",
                        "TypeDefinition",
                        objectType,
                        GetDirectTypeInstanceCreation(objectType, instance));
                }
                else if (instance is VariableDesign &&
                    instance.TypeDefinitionNode is VariableTypeDesign variableType &&
                    string.Equals(
                        variableType.SymbolicId.Namespace,
                        targetNamespace,
                        StringComparison.Ordinal))
                {
                    Add(
                        "Variable",
                        "TypeDefinition",
                        variableType,
                        GetDirectTypeInstanceCreation(variableType, instance));
                }

                if (instance is MethodDesign method &&
                    method.MethodDeclarationNode != null)
                {
                    Add(
                        "Method",
                        "MethodDeclaration",
                        method.MethodDeclarationNode,
                        GetDirectEmptyStateCreation(method));
                }
            }

            return
            [
                .. registrations.Values
                    .OrderBy(
                        registration => registration.Discriminator,
                        StringComparer.Ordinal)
                    .ThenBy(
                        registration => registration.NodeClass,
                        StringComparer.Ordinal)
                    .ThenBy(
                        registration => registration.DiscriminatorId,
                        StringComparer.Ordinal)
            ];
        }

        private string? GetDirectTypeInstanceCreation(
            TypeDesign type,
            InstanceDesign fallbackInstance)
        {
            if (m_nodes.TryGetValue(
                    type.SymbolicId,
                    out NodeToGenerate? typeNode) &&
                typeNode.Instance?.Design is InstanceDesign typeInstance)
            {
                return GetDirectEmptyStateCreation(typeInstance);
            }
            return GetDirectEmptyStateCreation(fallbackInstance);
        }

        private string? GetDirectEmptyStateCreation(InstanceDesign? instance)
        {
            string factory = instance.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                asFactory: true);
            return ConvertStateFactoryToDirectConstructor(factory);
        }

        private string? GetDirectEmptyStateCreation(MethodDesign method)
        {
            string factory = method.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                asFactory: true);
            return ConvertStateFactoryToDirectConstructor(factory);
        }

        private static string? ConvertStateFactoryToDirectConstructor(
            string factory)
        {
            if (string.IsNullOrEmpty(factory))
            {
                return null;
            }
            if (factory.StartsWith("new ", StringComparison.Ordinal))
            {
                return factory + "(null)";
            }

            const string withMarker = ".With<";
            int withIndex = factory.LastIndexOf(
                withMarker,
                StringComparison.Ordinal);
            if (withIndex >= 0)
            {
                string stateType = factory[..withIndex];
                string builderType = factory[(withIndex + ".With".Length)..];
                return "new " +
                    stateType +
                    ".Implementation" +
                    builderType +
                    "(null)";
            }

            return null;
        }

        /// <summary>
        /// Gets whether a node belongs to a declaration - a type definition or
        /// a method type - rather than to the model's address space.
        /// </summary>
        private static bool IsDeclarationNode(NodeToGenerate node)
        {
            NodeToGenerate root = node;
            while (root.Parent != null)
            {
                root = root.Parent;
            }
            return root.RootIsTypeDefinition ||
                (root.Design is MethodDesign method && method.IsMethodTypeDesign());
        }

        private static string? GetImportNodeClass(InstanceDesign instance)
        {
            return instance switch
            {
                ObjectDesign => "Object",
                VariableDesign => "Variable",
                MethodDesign => "Method",
                _ => null
            };
        }

        private TextFileResource EmitExtensions()
        {
            string nsPrefix = m_context.ModelDesign.TargetNamespace.Prefix;
            string fileName = Path.Combine(m_context.OutputFolder, CoreUtils.Format(
                "{0}.NodeStates.ex.g.cs",
                nsPrefix));
            using TextWriter writer = m_context.FileSystem.CreateTextWriter(fileName);
            using var templateWriter = new TemplateWriter(writer);
            var template = new Template(
                templateWriter,
                NodeStateTemplates.Extensions_File);

            template.AddReplacement(Tokens.NamespacePrefix, nsPrefix);
            template.AddReplacement(
                Tokens.Namespace,
                nsPrefix.Replace(".", string.Empty, StringComparison.Ordinal));
            template.AddReplacement(
                Tokens.NamespaceUri,
                m_context.ModelDesign.Namespaces.GetConstantSymbolForNamespace(
                    m_context.ModelDesign.TargetNamespace.Value));

            template.AddReplacement(
                Tokens.ListOfNodeStateInitializers,
                m_nodes.Values,
                LoadTemplate_ListOfNodeStateInitializers,
                WriteTemplate_ListOfNodeStateInitializers);
            template.AddReplacement(
                Tokens.ListOfNodeStateTypeFactories,
                m_nodes.Values,
                LoadTemplate_ListOfNodeStateFactories,
                WriteTemplate_ListOfNodeStateFactories);

            template.AddReplacement(
                Tokens.ListOfNodeStateInstanceFactories,
                m_instances.Values,
                LoadTemplate_ListOfNodeStateFactories,
                WriteTemplate_ListOfNodeStateFactories);

            // TODO: Adopt to "instance" list and get "type" from entry.IsInstanceOfType
            template.AddReplacement(
                Tokens.ListOfActivatorRegistrations,
                NodeStateTemplates.ActivatorRegistration,
                m_nodes.Values,
                LoadTemplate_ListOfNodeStateActivators,
                WriteTemplate_ListOfNodeStateActivators);

            template.Render();
            return fileName.AsTextFileResource();
        }

        private TemplateString? LoadTemplate_ListOfNodeStateActivators(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return null;
            }
            if (ExcludeNodeStateClassGeneration(node))
            {
                return null;
            }
            switch (node.Design)
            {
                case ObjectTypeDesign:
                case VariableTypeDesign:
                case MethodDesign method
                    when MethodDesignArgumentResolver.HasMethodArguments(method) &&
                        method.IsMethodTypeDesign():
                    return context.TemplateString;
                default:
                    return null;
            }
        }

        private bool WriteTemplate_ListOfNodeStateActivators(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return false;
            }
            string nodeClass = node.Design!.GetNodeClassAsString();
            context.Template.AddReplacement(Tokens.NodeClass, nodeClass);
            context.Template.AddBrowseNameReplacement(
                Tokens.BrowseName,
                Tokens.BrowseNameLiteral,
                node.Design!.SymbolicName.Name,
                m_logger);
            context.Template.AddReplacement(Tokens.SymbolicId, node.Design.SymbolicId.Name);
            if (node.Design is TypeDesign type)
            {
                context.Template.AddReplacement(
                    Tokens.StateClassName,
                    CoreUtils.Format("{0}State", type.ClassName));
            }
            else if (node.Design is MethodDesign method)
            {
                context.Template.AddReplacement(
                    Tokens.StateClassName,
                    method.GetNodeStateClassName(
                        m_context.ModelDesign.TargetNamespace.Value, []));
            }
            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_ListOfNodeStateClasses(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return null;
            }
            if (ExcludeNodeStateClassGeneration(node))
            {
                return null;
            }

            return node.Design switch
            {
                ObjectTypeDesign
                    => NodeStateTemplates.ObjectType_Class,
                VariableTypeDesign
                    => NodeStateTemplates.VariableType_Class,
                MethodDesign method when
                    MethodDesignArgumentResolver.HasMethodArguments(method)
                    => NodeStateTemplates.MethodType_Class,
                _ => null
            };
        }

        private bool WriteTemplate_ListOfNodeStateClasses(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return false;
            }
            NodeDesign? root = node.Design;
            context.Template.AddReplacement(Tokens.NodeClass, root!.GetNodeClassAsString());
            context.Template.AddReplacement(Tokens.TypeName, root!.SymbolicName.Name);
            context.Template.AddReplacement(Tokens.SymbolicId, root.SymbolicId.Name);
            context.Template.AddBrowseNameReplacement(
                Tokens.BrowseName,
                Tokens.BrowseNameLiteral,
                root.SymbolicName.Name,
                m_logger);
            context.Template.AddReplacement(
                Tokens.Description,
                root.Description != null ? root.Description.Value : string.Empty);
            context.Template.AddReplacement(
                Tokens.NamespaceUri,
                m_context.ModelDesign.Namespaces.GetConstantSymbolForNamespace(
                    root.SymbolicName.Namespace));
            context.Template.AddReplacement(
                Tokens.NamespacePrefix,
                m_context.ModelDesign.Namespaces.GetNamespacePrefix(
                    root.SymbolicId.Namespace));
            context.Template.AddReplacement(
                Tokens.XmlNamespaceUri,
                m_context.ModelDesign.Namespaces.GetConstantForXmlNamespace(
                    root.SymbolicId.Namespace));
            context.Template.AddReplacement(
                Tokens.BrowseNameNamespaceUri,
                m_context.ModelDesign.Namespaces.GetNamespaceUriAsCode(
                    root.SymbolicName.Namespace));

            switch (root)
            {
                case MethodDesign method:
                    AddNodeStateClassMethodTypeReplacements(context, method);
                    break;
                case ObjectTypeDesign objectType:
                    AddNodeStateClassObjectTypeReplacements(context, objectType);
                    break;
                case VariableTypeDesign variableType:
                    AddNodeStateClassVariableTypeReplacements(context, variableType);
                    break;
                default:
                    return false;
            }

            context.Template.AddReplacement(
                Tokens.InitializeOptionalChildren,
                NodeStateTemplates.InitializeOptionalChild,
                node.Children.Values,
                LoadTemplate_InitializeOptionalChildren,
                WriteTemplate_InitializeOptionalChildren);
            context.Template.AddReplacement(
                Tokens.ListOfNonMandatoryChildren,
                node.Children.Values,
                LoadTemplate_ListOfNonMandatoryChildren,
                WriteTemplate_ListOfNonMandatoryChildren);
            context.Template.AddReplacement(
                Tokens.ListOfFields,
                node.Children.Values,
                LoadTemplate_ListOfFields);
            context.Template.AddReplacement(
                Tokens.ListOfProperties,
                node.Children.Values,
                LoadTemplate_ListOfProperties,
                WriteTemplate_ListOfProperties);

            context.Template.AddReplacement(
                Tokens.ListOfChildOperations,
                NodeStateTemplates.ChildOperations,
                [node],
                LoadTemplate_FindChildMethods,
                WriteTemplate_FindChildMethods);

            List<InstanceDesign> properties =
                GetChildrenWithProperties(node, true);
            context.Template.AddReplacement(
                Tokens.ListOfChildCopies,
                NodeStateTemplates.CloneChild,
                properties,
                WriteTemplate_ListOfChildren);
            context.Template.AddReplacement(
                Tokens.ListOfChildHashes,
                NodeStateTemplates.HashChild,
                properties,
                WriteTemplate_ListOfChildren);
            context.Template.AddReplacement(
                Tokens.ListOfEqualityComparers,
                NodeStateTemplates.CompareChild,
                properties,
                WriteTemplate_ListOfChildren);

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_ListOfNonMandatoryChildren(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return null;
            }

            if (node.IsNotExplicitlyDefined)

            {
                return null;
            }
            if (instance.IsOverriddenWithSameClass(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces))
            {
                return null;
            }

            switch (GetEffectiveModellingRule(node, instance))
            {
                case ModellingRule.Optional:
                    return NodeStateTemplates.OptionalMethod;
                case ModellingRule.OptionalPlaceholder:
                case ModellingRule.MandatoryPlaceholder:
                    return NodeStateTemplates.PlaceHolderMethod;
                case ModellingRule.ExposesItsArray:
                case ModellingRule.CardinalityRestriction:
                case ModellingRule.MandatoryShared:
                    // TODO?
                    break;
            }

            return null;
        }

        private bool WriteTemplate_ListOfNonMandatoryChildren(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return false;
            }

            context.Template.AddReplacement(Tokens.AccessorSymbol, "public new");
            if (!instance.IsOverridden())
            {
                if (!s_builtInMethodNames.Contains(instance.SymbolicName.Name) &&
                    !HidesInheritedPlaceholderHelper(instance))
                {
                    context.Template.AddReplacement(Tokens.AccessorSymbol, "public");
                }
            }
            else
            {
                instance = instance.GetMergedInstance();
            }

            context.Template.AddReplacement(Tokens.Description,
                instance.Description != null ? instance.Description.Value : string.Empty);
            context.Template.AddReplacement(Tokens.ClassName, instance.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(Tokens.ChildName, instance.SymbolicName.Name);
            context.Template.AddReplacement(Tokens.SymbolicId, instance.SymbolicId.Name);
            context.Template.AddReplacement(
                Tokens.NodeIdConstant,
                instance.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));

            return context.Template.Render();
        }

        /// <summary>
        /// Tests the CLR helper signature rather than the qualified browse name: a placeholder
        /// in a different wire namespace can still hide the same Add helper on a generated base class.
        /// </summary>
        private static bool HidesInheritedPlaceholderHelper(InstanceDesign instance)
        {
            if (instance.ModellingRule is not ModellingRule.MandatoryPlaceholder and
                not ModellingRule.OptionalPlaceholder ||
                instance.Parent is not TypeDesign declaringType)
            {
                return false;
            }
            for (TypeDesign? baseType = declaringType.BaseTypeNode; baseType != null; baseType = baseType.BaseTypeNode)
            {
                if (baseType.Children?.Items == null)
                {
                    continue;
                }
                foreach (InstanceDesign child in baseType.Children.Items)
                {
                    if (child.ModellingRule is
                        ModellingRule.MandatoryPlaceholder or ModellingRule.OptionalPlaceholder &&
                        child.SymbolicName.Name == instance.SymbolicName.Name)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private TemplateString? LoadTemplate_TypedVariableType(ILoadContext context)
        {
            if (context.Target is not VariableTypeDesign variableType)
            {
                return null;
            }
            if (variableType.DataTypeNode!.IsTemplateParameterRequired(variableType.ValueRank))
            {
                return null;
            }

            return context.TemplateString;
        }

        private bool WriteTemplate_TypedVariableType(IWriteContext context)
        {
            if (context.Target is not VariableTypeDesign type)
            {
                return false;
            }
            context.Template.AddReplacement(Tokens.NodeClass, type.GetNodeClassAsString());
            context.Template.AddReplacement(Tokens.ClassName, type.ClassName);
            context.Template.AddReplacement(Tokens.TypeName, type.SymbolicName.Name);
            context.Template.AddBrowseNameReplacement(
                Tokens.BrowseName,
                Tokens.BrowseNameLiteral,
                type.SymbolicName.Name,
                m_logger);

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_VariableTypeValue(ILoadContext context)
        {
            if (context.Target is not VariableTypeDesign variableType)
            {
                return null;
            }
            Dictionary<string, Parameter> fields = [];
            CollectMatchingFields(variableType, fields);

            if (fields.Count == 0)

            {
                return null;
            }
            return context.TemplateString;
        }

        private bool WriteTemplate_VariableTypeValue(IWriteContext context)
        {
            if (context.Target is not VariableTypeDesign type)
            {
                return false;
            }
            Dictionary<string, Parameter> fields = [];
            CollectMatchingFields(type, fields);

            if (fields.Count == 0)

            {
                return false;
            }
            context.Template.AddReplacement(Tokens.ClassName, type.ClassName);
            context.Template.AddReplacement(Tokens.DataType, type.DataTypeNode!.GetDotNetTypeName(
                ValueRank.Scalar,
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                nullable: NullableAnnotation.NonNullable));

            context.Template.AddReplacement(
                Tokens.ListOfChildInitializers,
                fields,
                LoadTemplate_VariableTypeValueInitializers);

            context.Template.AddReplacement(
                Tokens.ListOfUpdateChildrenChangeMasks,
                fields,
                LoadTemplate_VariableTypeValueChangeMasks);

            context.Template.AddReplacement(
                Tokens.ListOfChildMethods,
                NodeStateTemplates.VariableType_ValueMethods,
                fields,
                WriteTemplate_VariableTypeValueField);

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_VariableTypeValueInitializers(ILoadContext context)
        {
            if (context.Target is not KeyValuePair<string, Parameter> field || field.Value == null)
            {
                return null;
            }
            string name = field.Key;
            string path = field.Key;

            context.Out.WriteLine("instance = m_variable.{0};", path);
            context.Out.WriteLine("if (instance != null)");
            context.Out.WriteLine("{");
            context.Out.WriteLine("    instance.OnReadValue = OnRead_{0};", name);
            context.Out.WriteLine("    instance.OnWriteValue = OnWrite_{0};", name);
            context.Out.WriteLine("    updateList.Add(instance);");
            context.Out.WriteLine("}");

            return null;
        }

        private TemplateString? LoadTemplate_VariableTypeValueChangeMasks(ILoadContext context)
        {
            if (context.Target is not KeyValuePair<string, Parameter> field ||
                field.Value == null)
            {
                return null;
            }

            var dataType = field.Value.Parent as DataTypeDesign;
            string path = field.Key;
            // The value is addressed through the generated structure property,
            // which can differ from the authored field name (e.g. a field named
            // like its enclosing type or a reserved member gets a suffix).
            string valuePath = field.Value.GetPropertyName();

            if (dataType!.IsDotNetEqualityComparable(field.Value.ValueRank))
            {
                context.Out.WriteLine("if (m_value.{0} != newValue.{0})", valuePath);
            }
            else
            {
                context.Out.WriteLine(
                    "if (!global::Opc.Ua.CoreUtils.IsEqual(m_value.{0}, newValue.{0}))",
                    valuePath);
            }
            context.Out.WriteLine("{");
            context.Out.WriteLine(
                "    UpdateChildVariableStatus(m_variable.{0}, ref statusCode, ref timestamp);",
                path);
            context.Out.WriteLine("}");

            return null;
        }

        private bool WriteTemplate_VariableTypeValueField(IWriteContext context)
        {
            if (context.Target is not KeyValuePair<string, Parameter> field ||
                field.Value == null)
            {
                return false;
            }

            context.Template.AddReplacement(Tokens.ChildName, field.Key);
            context.Template.AddReplacement(Tokens.ChildPath, field.Key);
            context.Template.AddReplacement(Tokens.PropertyName, field.Value.GetPropertyName());

            string childDataType = field.Value.DataTypeNode!.GetDotNetTypeName(
                field.Value.ValueRank,
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                nullable: NullableAnnotation.NonNullable);

            context.Template.AddReplacement(Tokens.ChildDataType, childDataType);

            if (field.Value.DataTypeNode!.NeedsCloning())
            {
                context.Template.AddReplacement(
                    Tokens.ValueWrite,
                    CoreUtils.Format(
                        "CopyOnWrite ? ({0})global::Opc.Ua.CoreUtils.Clone(newValue) : newValue",
                        childDataType));
            }
            else
            {
                context.Template.AddReplacement(Tokens.ValueWrite, "newValue");
            }

            AddVariantAccessor(context, field.Value.DataTypeNode!);

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_ListOfFields(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return null;
            }

            bool isMethodOverrideWithDifferentClass =
                IsMethodOverrideWithDifferentClass(instance);
            if (node.IsNotExplicitlyDefined ||
                (instance.IsOverridden() && !isMethodOverrideWithDifferentClass))
            {
                return null;
            }

            ModellingRule effectiveRule = GetEffectiveModellingRule(node, instance);

            if (effectiveRule
                is ModellingRule.ExposesItsArray
                or ModellingRule.MandatoryPlaceholder
                or ModellingRule.OptionalPlaceholder)
            {
                return null;
            }

            if (effectiveRule == ModellingRule.None)

            {
                return null;
            }
            if (instance is MethodDesign method &&
                GetEffectiveModellingRule(node, method) != ModellingRule.Mandatory &&
                GetEffectiveModellingRule(node, method) != ModellingRule.Optional)
            {
                return null;
            }

            if (IsBuiltInProperty(node))
            {
                return null;
            }

            if (isMethodOverrideWithDifferentClass)
            {
                instance = instance.GetMergedInstance();
            }
            context.Out.WriteLine(
                "private {0}? {1};",
                instance.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces),
                instance.GetChildFieldName());

            return null;
        }

        private TemplateString? LoadTemplate_ListOfInputArguments(ILoadContext context)
        {
            if (context.Target is not Parameter field)
            {
                return null;
            }
            string fieldName = GetMethodArgumentIdentifier(field);
            string typeName = field.DataTypeNode!.GetMethodArgumentTypeAsCode(
                field.ValueRank,
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                false);

            switch (field.DataTypeNode!.BasicDataType)
            {
                case BasicDataType.UserDefined when HasTypedArgumentValueRank(field):
                    context.Out.WriteLine(
                        "_inputArguments[{2}].TryGetValue(" +
                        "out {1} {0}, " +
                        "global::Opc.Ua.SystemContextExtensions.AsMessageContext(_context)" +
                        ");",
                        fieldName,
                        typeName,
                        context.Index);
                    break;
                case BasicDataType.BaseDataType when field.ValueRank == ValueRank.Scalar:
                    context.Out.WriteLine(
                        "{1} {0} = _inputArguments[{2}];",
                        fieldName,
                        typeName,
                        context.Index);
                    break;
                default:
                    context.Out.WriteLine(
                        "_inputArguments[{2}].TryGetValue(out {1} {0});",
                        fieldName,
                        typeName,
                        context.Index);
                    break;
            }
            return null;
        }

        private TemplateString? LoadTemplate_ListOfOutputDeclarations(ILoadContext context)
        {
            if (context.Target is not Parameter field)
            {
                return null;
            }
            string fieldName = GetMethodArgumentIdentifier(field);
            string typeName = field.DataTypeNode!.GetMethodArgumentTypeAsCode(
                field.ValueRank,
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                field.IsOptional);

            switch (field.DataTypeNode!.BasicDataType)
            {
                case BasicDataType.UserDefined when HasTypedArgumentValueRank(field):
                    context.Out.WriteLine(
                        "_outputArguments[{2}].TryGetValue(" +
                        "out {1} {0}, " +
                        "global::Opc.Ua.SystemContextExtensions.AsMessageContext(_context)" +
                        ");",
                        fieldName,
                        typeName,
                        context.Index);
                    break;
                case BasicDataType.BaseDataType when field.ValueRank == ValueRank.Scalar:
                    context.Out.WriteLine(
                        "{1} {0} = _outputArguments[{2}];",
                        fieldName,
                        typeName,
                        context.Index);
                    break;
                default:
                    context.Out.WriteLine(
                        "_outputArguments[{2}].TryGetValue(out {1} {0});",
                        fieldName,
                        typeName,
                        context.Index);
                    break;
            }
            return null;
        }

        private TemplateString? LoadTemplate_ListOfOutputArguments(ILoadContext context)
        {
            if (context.Target is not Parameter field)
            {
                return null;
            }
            string fieldName = GetMethodArgumentIdentifier(field);
            switch (field.DataTypeNode!.BasicDataType)
            {
                case BasicDataType.UserDefined when HasTypedArgumentValueRank(field):
                    context.Out.WriteLine(
                        "_outputArguments[{1}] = global::Opc.Ua.Variant.FromStructure({0});",
                        fieldName,
                        context.Index);
                    break;
                case BasicDataType.BaseDataType:
                    context.Out.WriteLine(
                        "_outputArguments[{1}] = {0};",
                        fieldName,
                        context.Index);
                    break;
                default:
                    context.Out.WriteLine(
                        "_outputArguments[{1}] = global::Opc.Ua.Variant.From({0});",
                        fieldName,
                        context.Index);
                    break;
            }
            return null;
        }

        private TemplateString? LoadTemplate_OnCallDeclaration(ILoadContext context)
        {
            if (context.Target is not MethodDesign method)
            {
                return null;
            }
            (Parameter[] inputArguments, Parameter[] outputArguments) =
                MethodDesignArgumentResolver.ResolveMethodArguments(method);
            AssignMethodArgumentCodeNames(method, inputArguments, outputArguments);
            context.Out.WriteLine("global::Opc.Ua.ISystemContext _context,");
            context.Out.WriteLine("global::Opc.Ua.MethodState _method,");
            context.Out.Write("global::Opc.Ua.NodeId _objectId");

            for (int ii = 0; ii < inputArguments.Length; ii++)
            {
                Parameter argument = inputArguments[ii];

                context.Out.WriteLine(",");
                context.Out.Write("{1} {0}", GetMethodArgumentIdentifier(argument),
                    argument.DataTypeNode!.GetMethodArgumentTypeAsCode(
                        argument.ValueRank,
                        m_context.ModelDesign.TargetNamespace.Value,
                        m_context.ModelDesign.Namespaces,
                        argument.IsOptional));
            }

            for (int ii = 0; ii < outputArguments.Length; ii++)
            {
                Parameter argument = outputArguments[ii];

                context.Out.WriteLine(",");
                context.Out.Write("ref {1} {0}", GetMethodArgumentIdentifier(argument),
                    argument.DataTypeNode!.GetMethodArgumentTypeAsCode(
                        argument.ValueRank,
                        m_context.ModelDesign.TargetNamespace.Value,
                        m_context.ModelDesign.Namespaces,
                        argument.IsOptional));
            }

            context.Out.WriteLine(");");

            return null;
        }

        private TemplateString? LoadTemplate_OnCallAsyncDeclaration(ILoadContext context)
        {
            if (context.Target is not MethodDesign method)
            {
                return null;
            }
            (Parameter[] inputArguments, Parameter[] outputArguments) =
                MethodDesignArgumentResolver.ResolveMethodArguments(method);
            AssignMethodArgumentCodeNames(method, inputArguments, outputArguments);
            context.Out.WriteLine("global::Opc.Ua.ISystemContext _context,");
            context.Out.WriteLine("global::Opc.Ua.MethodState _method,");
            context.Out.Write("global::Opc.Ua.NodeId _objectId");

            for (int ii = 0; ii < inputArguments.Length; ii++)
            {
                Parameter argument = inputArguments[ii];

                context.Out.WriteLine(",");
                context.Out.Write("{1} {0}", GetMethodArgumentIdentifier(argument),
                    argument.DataTypeNode!.GetMethodArgumentTypeAsCode(
                        argument.ValueRank,
                        m_context.ModelDesign.TargetNamespace.Value,
                        m_context.ModelDesign.Namespaces,
                        argument.IsOptional));
            }

            context.Out.WriteLine(",");
            context.Out.Write(
                "global::System.Threading.CancellationToken cancellationToken");
            context.Out.WriteLine(");");

            return null;
        }

        private TemplateString? LoadTemplate_ListOfOutputArgumentsFromResult(ILoadContext context)
        {
            if (context.Target is not Parameter field)
            {
                return null;
            }
            string fieldName = GetMethodArgumentIdentifier(field, upperCamelCase: true);
            switch (field.DataTypeNode!.BasicDataType)
            {
                case BasicDataType.UserDefined when HasTypedArgumentValueRank(field):
                    context.Out.WriteLine(
                        "_outputArguments[{1}] = global::Opc.Ua.Variant.FromStructure(_result.{0});",
                        fieldName,
                        context.Index);
                    break;
                case BasicDataType.BaseDataType when field.ValueRank == ValueRank.Scalar:
                    context.Out.WriteLine(
                        "_outputArguments[{1}] = _result.{0};",
                        fieldName,
                        context.Index);
                    break;
                default:
                    context.Out.WriteLine(
                        "_outputArguments[{1}] = global::Opc.Ua.Variant.From(_result.{0});",
                        fieldName,
                        context.Index);
                    break;
            }
            return null;
        }

        private TemplateString? LoadTemplate_ListOfResultProperties(ILoadContext context)
        {
            if (context.Target is not Parameter field)
            {
                return null;
            }
            string fieldName = GetMethodArgumentIdentifier(field, upperCamelCase: true);
            context.Out.WriteLine(
               "public {1} {0} {{ get; set; }}",
               fieldName,
               field.DataTypeNode!.GetMethodArgumentTypeAsCode(
                   field.ValueRank,
                   m_context.ModelDesign.TargetNamespace.Value,
                   m_context.ModelDesign.Namespaces,
                   field.IsOptional));

            return null;
        }

        private TemplateString? LoadTemplate_OnCallImplementation(ILoadContext context)
        {
            if (context.Target is not MethodDesign method)
            {
                return null;
            }
            (Parameter[] inputArguments, Parameter[] outputArguments) =
                MethodDesignArgumentResolver.ResolveMethodArguments(method);
            AssignMethodArgumentCodeNames(method, inputArguments, outputArguments);
            context.Out.WriteLine("_result = OnCall(");
            context.Out.WriteLine("    _context,");
            context.Out.WriteLine("    this,");
            context.Out.Write("    _objectId");

            for (int ii = 0; ii < inputArguments.Length; ii++)
            {
                context.Out.WriteLine(",");
                context.Out.Write("    {0}", GetMethodArgumentIdentifier(inputArguments[ii]));
            }

            for (int ii = 0; ii < outputArguments.Length; ii++)
            {
                context.Out.WriteLine(",");
                context.Out.Write("    ref {0}", GetMethodArgumentIdentifier(outputArguments[ii]));
            }

            context.Out.WriteLine(");");

            return null;
        }

        private TemplateString? LoadTemplate_OnCallAsyncImplementation(ILoadContext context)
        {
            if (context.Target is not MethodDesign method)
            {
                return null;
            }
            (Parameter[] inputArguments, Parameter[] outputArguments) =
                MethodDesignArgumentResolver.ResolveMethodArguments(method);
            AssignMethodArgumentCodeNames(method, inputArguments, outputArguments);
            context.Out.WriteLine("_result = await OnCallAsync(");
            context.Out.WriteLine("    _context,");
            context.Out.WriteLine("    this,");
            context.Out.Write("    _objectId");

            for (int ii = 0; ii < inputArguments.Length; ii++)
            {
                context.Out.WriteLine(",");
                context.Out.Write("    {0}", GetMethodArgumentIdentifier(inputArguments[ii]));
            }

            context.Out.WriteLine(",");
            context.Out.WriteLine("    cancellationToken).ConfigureAwait(false);");
            return null;
        }

        private TemplateString? LoadTemplate_InitializeOptionalChildren(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return null;
            }

            if (node.IsNotExplicitlyDefined)

            {
                return null;
            }
            if (GetEffectiveModellingRule(node, instance) != ModellingRule.Optional)
            {
                return null;
            }

            if (IsBuiltInProperty(node))
            {
                return null;
            }

            return context.TemplateString;
        }

        private bool WriteTemplate_InitializeOptionalChildren(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return context.Template.Render();
            }

            context.Template.AddReplacement(Tokens.ChildName, instance.SymbolicName.Name);
            context.Template.AddReplacement(Tokens.SymbolicId, instance.SymbolicId.Name);
            context.Template.AddReplacement(Tokens.FieldName, instance.GetChildFieldName());
            if (instance.Parent is MethodDesign method)
            {
                context.Template.AddReplacement(Tokens.ClassName, method.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    []));
            }
            else if (instance.Parent is TypeDesign type)
            {
                context.Template.AddReplacement(
                    Tokens.ClassName,
                    type.ClassName);
            }

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_ListOfProperties(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return null;
            }

            if (node.IsNotExplicitlyDefined)

            {
                return null;
            }
            ModellingRule effectiveRule = GetEffectiveModellingRule(node, instance);

            if (effectiveRule
                is ModellingRule.ExposesItsArray
                or ModellingRule.MandatoryPlaceholder
                or ModellingRule.OptionalPlaceholder)
            {
                return null;
            }

            if (effectiveRule == ModellingRule.None)

            {
                return null;
            }
            if (instance is MethodDesign method &&
                GetEffectiveModellingRule(node, method) != ModellingRule.Mandatory &&
                GetEffectiveModellingRule(node, method) != ModellingRule.Optional)
            {
                return null;
            }

            if (instance.IsOverridden())
            {
                if (instance.IsOverriddenWithSameClass(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces))
                {
                    return null;
                }
                if (instance is MethodDesign)
                {
                    return NodeStateTemplates.Property;
                }
                return NodeStateTemplates.PropertyOverride;
            }

            if (IsBuiltInProperty(node))
            {
                return null;
            }

            return NodeStateTemplates.Property;
        }

        private bool WriteTemplate_ListOfProperties(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance)
            {
                return false;
            }

            context.Template.AddReplacement(Tokens.AccessorSymbol, "public new");
            if (!instance.IsOverridden())
            {
                if (!RequiresNewModifier((node.Parent?.Design)!, instance.SymbolicName.Name) ||
                    (instance is VariableDesign && instance.SymbolicName.Name == "Value"))
                {
                    context.Template.AddReplacement(Tokens.AccessorSymbol, "public");
                }
            }
            else
            {
                instance = instance.GetMergedInstance();
            }

            context.Template.AddReplacement(Tokens.Description,
                instance.Description != null ? instance.Description.Value : string.Empty);
            context.Template.AddReplacement(Tokens.ClassName, instance.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(Tokens.ChildName, instance.SymbolicName.Name);
            context.Template.AddReplacement(Tokens.FieldName, instance.GetChildFieldName());

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_FindChildMethods(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return null;
            }
            int count = 0;
            foreach (NodeToGenerate child in node.Children.Values)
            {
                if (child.Design is not InstanceDesign instance)
                {
                    continue;
                }
                if (child.IsNotExplicitlyDefined)

                {
                    continue;
                }
                ModellingRule childEffectiveRule =
                    GetEffectiveModellingRule(child, instance);

                if (childEffectiveRule is
                    ModellingRule.ExposesItsArray or
                    ModellingRule.MandatoryPlaceholder or
                    ModellingRule.OptionalPlaceholder)
                {
                    continue;
                }

                if (childEffectiveRule is ModellingRule.None)

                {
                    continue;
                }
                if (childEffectiveRule is
                    ModellingRule.OptionalPlaceholder or
                    ModellingRule.MandatoryPlaceholder)
                {
                    continue;
                }

                if (instance.IsOverriddenWithSameClass(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces))
                {
                    continue;
                }

                count++;
            }

            if (count == 0)

            {
                return null;
            }
            return context.TemplateString;
        }

        private bool WriteTemplate_FindChildMethods(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not TypeDesign type)
            {
                return false;
            }

            List<InstanceDesign> childrenWithProperties = GetChildrenWithProperties(node);

            context.Template.AddReplacement(
                Tokens.ListOfFindChildCase,
                NodeStateTemplates.FindChildCase,
                childrenWithProperties,
                WriteTemplate_ListOfChildren);

            context.Template.AddReplacement(
                Tokens.ListOfCreateOrReplaceChild,
                NodeStateTemplates.CreateOrReplaceChild,
                childrenWithProperties,
                WriteTemplate_ListOfChildren);

            List<InstanceDesign> additionalChildren = GetAdditionalChildren(node);

            context.Template.AddReplacement(
                Tokens.ListOfFindChildren,
                NodeStateTemplates.FindChildren,
                additionalChildren,
                WriteTemplate_ListOfChildren);

            context.Template.AddReplacement(
                Tokens.ListOfRemoveChild,
                NodeStateTemplates.RemoveChild,
                additionalChildren,
                WriteTemplate_ListOfChildren);

            return context.Template.Render();
        }

        private bool WriteTemplate_ListOfChildren(IWriteContext context)
        {
            if (context.Target is not InstanceDesign instance)
            {
                return false;
            }
            context.Template.AddReplacement(Tokens.AccessorSymbol, "public new");
            if (!instance.IsOverridden())
            {
                context.Template.AddReplacement(Tokens.AccessorSymbol, "public");
            }

            context.Template.AddReplacement(Tokens.ClassName, instance.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(Tokens.ClassFactory, instance.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                m_context.ModelDesign.Namespaces,
                asFactory: true));
            context.Template.AddReplacement(Tokens.SymbolicId, instance.SymbolicId.Name);
            context.Template.AddReplacement(Tokens.ChildName, instance.SymbolicName.Name);
            // The child's declaration NodeId. CreateOrReplace{Child} uses it to
            // detect a child that still carries the type-level id (and may
            // therefore be rebased onto a per-instance NodeId) versus one whose
            // NodeId the caller already owns.
            context.Template.AddReplacement(
                Tokens.NodeIdConstant,
                instance.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            // The runtime BrowseName.Name may differ from the symbolic name
            // (the design's <opc:BrowseName> attribute can override it, e.g.
            // Boiler's "InputPipe" InstanceDesign with BrowseName "PipeX001").
            // FindChild switches on the runtime browse name, so the case
            // label must use that string verbatim.
            context.Template.AddBrowseNameReplacement(
                Tokens.ChildBrowseName,
                Tokens.ChildBrowseNameLiteral,
                !string.IsNullOrEmpty(instance.BrowseName)
                    ? instance.BrowseName
                    : instance.SymbolicName.Name,
                m_logger);
            context.Template.AddReplacement(Tokens.FieldName, instance.GetChildFieldName());
            context.Template.AddReplacement(Tokens.NodeClass, instance.GetNodeClassAsString());
            context.Template.AddBrowseNameReplacement(
                Tokens.BrowseName,
                Tokens.BrowseNameLiteral,
                instance.SymbolicName.Name,
                m_logger);
            context.Template.AddReplacement(
                Tokens.BrowseNameNamespacePrefix,
                m_context.ModelDesign.Namespaces.GetNamespacePrefix(
                    instance.SymbolicName.Namespace));
            context.Template.AddReplacement(
                Tokens.BrowseNameNamespaceUri,
                m_context.ModelDesign.Namespaces.GetNamespaceUriAsCode(
                    instance.SymbolicName.Namespace));

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_ListOfNodeStateInitializers(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return null;
            }
            if (node.Design.IsMethodTypeDesign() ||
                node.InstanceOf != null ||
                !IsInAddressSpace(node) ||
                node.Design!.Purpose == DataTypePurpose.Testing)
            {
                return null;
            }
            if (node.Parent != null)
            {
                // No registering of children
                return null;
            }
            if (node.Design is MethodDesign method)
            {
                return MethodDesignArgumentResolver.HasMethodArguments(method)
                    ? NodeStateTemplates.AddMethod
                    : null;
            }
            return NodeStateTemplates.Add;
        }

        private bool WriteTemplate_ListOfNodeStateInitializers(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return false;
            }
            context.Template.AddReplacement(Tokens.SymbolicId, node.Design!.SymbolicId.Name);
            context.Template.AddReplacement(Tokens.SymbolicName, node.Design.SymbolicName.Name);
            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_ListOfNodeStateFactories(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return null;
            }
            if (context.Token == Tokens.ListOfNodeStateInstanceFactories)
            {
                if (node.Parent != null)
                {
                    return null;
                }
                return node.Design switch
                {
                    ObjectDesign => NodeStateTemplates.Create_InstanceOfObjectType,
                    VariableDesign => NodeStateTemplates.Create_InstanceOfVariableType,
                    MethodDesign => NodeStateTemplates.Create_InstanceOfMethodType,
                    _ => null
                };
            }

            if (node.Parent != null)
            {
                if (node.Design is ViewDesign)
                {
                    // Views are never emitted as AddChild components (ViewState is
                    // not a BaseInstanceState). They are collected as standalone
                    // root nodes and linked purely via Organizes references, the
                    // same way DataType/ReferenceType type designs are handled.
                    return null;
                }
                if (node.Design is not InstanceDesign instance)
                {
                    return null;
                }
                if (GetEffectiveModellingRule(node, instance) is
                    not ModellingRule.MandatoryPlaceholder and
                    not ModellingRule.OptionalPlaceholder)
                {
                    return node.Design switch
                    {
                        ObjectDesign => NodeStateTemplates.Create_ChildObject,
                        VariableDesign => NodeStateTemplates.Create_ChildVariable,
                        MethodDesign => NodeStateTemplates.Create_ChildMethod,
                        _ => null
                    };
                }
                return node.Design switch
                {
                    ObjectDesign => NodeStateTemplates.Create_ChildObject_Placeholder,
                    VariableDesign => NodeStateTemplates.Create_ChildVariable_Placeholder,
                    MethodDesign => NodeStateTemplates.Create_ChildMethod_Placeholder,
                    _ => null
                };
            }

            return node.Design switch
            {
                ObjectTypeDesign => NodeStateTemplates.Create_ObjectType,
                VariableTypeDesign => NodeStateTemplates.Create_VariableType,
                ReferenceTypeDesign => NodeStateTemplates.Create_ReferenceType,
                DataTypeDesign => NodeStateTemplates.Create_DataType,
                ObjectDesign => NodeStateTemplates.Create_Object,
                VariableDesign => NodeStateTemplates.Create_Variable,
                ViewDesign => NodeStateTemplates.Create_View,
                _ => null
            };
        }

        private bool WriteTemplate_ListOfNodeStateFactories(IWriteContext context)
        {
            if (context.Target is not NodeToGenerate node)
            {
                return false;
            }
            NodeDesign? root = node.Design;

            // Common replacements for all node types
            context.Template.AddReplacement(
                Tokens.SymbolicId,
                root!.SymbolicId.Name);
            context.Template.AddReplacement(
                Tokens.SymbolicName,
                root.SymbolicName.Name);
            context.Template.AddBrowseNameReplacement(
                Tokens.BrowseName,
                Tokens.BrowseNameLiteral,
                root.SymbolicName.Name,
                m_logger);
            context.Template.AddReplacement(Tokens.NumericIdValue, root.FindNumericIdentifier() ?? 0);
            context.Template.AddReplacement(
                Tokens.TypeName,
                node.InstanceOf?.Design!.SymbolicName.Name);
            context.Template.AddReplacement(
                Tokens.NodeIdConstant,
                root.GetNodeIdAsCode(m_context.ModelDesign.Namespaces, kNamespaceTableContextVariable));
            AddInstanceNodeIdOverrideReplacement(context, node);

            // .net efficiently interns constant string, so usage of the BrowseName constants is not needed.
            string symbolicNameSymbol = root.SymbolicName.Name.AsStringLiteral();
            context.Template.AddReplacement(Tokens.BrowseNameSymbol,
                string.IsNullOrEmpty(root.BrowseName) ? symbolicNameSymbol : root.BrowseName.AsStringLiteral());
            context.Template.AddReplacement(Tokens.SymbolicNameSymbol, symbolicNameSymbol);
            context.Template.AddReplacement(Tokens.DisplayName, GetDisplayNameValue(root) ?? symbolicNameSymbol);

            context.Template.AddReplacement(
                Tokens.BrowseNameNamespaceUri,
                m_context.ModelDesign.Namespaces.GetNamespaceUriAsCode(
                    root.SymbolicName.Namespace));
            context.Template.AddReplacement(
                Tokens.DescriptionValue,
                GetDescriptionValue(root));
            context.Template.AddReplacement(
                Tokens.WriteMaskValue,
                root.GetWriteMaskAsCode());
            context.Template.AddReplacement(
                Tokens.UserWriteMaskValue,
                root.GetWriteMaskAsCode());

            // Add Children
            context.Template.AddReplacement(
                Tokens.ListOfChildNodeStates,
                node.AllChildren,
                LoadTemplate_ReplaceChild);
            context.Template.AddReplacement(
                Tokens.ListOfOptionalChildNodeStates,
                node.AllChildren,
                LoadTemplate_ReplaceChild);

            // Add References
            HashSet<ReferenceToGenerate> references = GetReferences(node);
            context.Template.AddReplacement(
                Tokens.ListOfReferences,
                references,
                LoadTemplate_AddReference);

            // Node type-specific replacements
            switch (root)
            {
                case ObjectTypeDesign objectType:
                    AddObjectTypeStateFactoryReplacements(context, objectType);
                    break;
                case VariableTypeDesign variableType:
                    AddVariableTypeStateFactoryReplacements(context, variableType);
                    break;
                case ReferenceTypeDesign referenceType:
                    AddReferenceTypeStateFactoryReplacements(context, referenceType);
                    break;
                case DataTypeDesign dataType:
                    AddDataTypeStateFactoryReplacements(context, dataType);
                    break;
                case ObjectDesign objectDesign:
                    AddObjectReplacements(context, node, objectDesign, references);
                    break;
                case VariableDesign variableDesign:
                    AddVariableStateFactoryReplacements(context, node, variableDesign, references);
                    break;
                case MethodDesign methodDesign:
                    AddMethodStateFactoryReplacements(context, node, methodDesign);
                    break;
                case ViewDesign viewDesign:
                    AddViewStateFactoryReplacements(context, viewDesign);
                    break;
            }

            // Release status
            Export.ReleaseStatus releaseStatus =
                root.ReleaseStatus.ToNodeSetReleaseStatus();
            context.Template.AddReplacement(
                Tokens.ReleaseStatusValue,
                releaseStatus != Export.ReleaseStatus.Released
                    ? CoreUtils.Format(
                        "nodeState.ReleaseStatus = global::Opc.Ua.Export.ReleaseStatus.{0};",
                        releaseStatus)
                    : null);
            // Categories
            context.Template.AddReplacement(
                Tokens.CategoriesValue,
                !string.IsNullOrEmpty(root.Category)
                    ? CoreUtils.Format(
                        "nodeState.Categories = new string[] {{ {0} }};",
                        string.Join(
                            ", ",
                            root.Category
                                .Split([','])
                                .Select(c => c.Trim().AsStringLiteral())))
                    : null);
            // Specification
            context.Template.AddReplacement(
                Tokens.SpecificationValue,
                root.PartNo != 0
                    ? CoreUtils.Format("nodeState.Specification = \"Part{0}\";", root.PartNo)
                    : null);

            // Access restrictions — emit on all nodes (type and instance).
            // Type hierarchy nodes carry restrictions as metadata but the server
            // bypasses enforcement via IsPartOfTypeHierarchy at runtime.
            string? accessRestrictions =
                root.AccessRestrictions.GetAccessRestrictionsAsCode(
                    root.AccessRestrictionsSpecified) ??
                root.DefaultAccessRestrictions.GetAccessRestrictionsAsCode(
                    root.DefaultAccessRestrictionsSpecified);
            context.Template.AddReplacement(
                Tokens.AccessRestrictionsValue,
                accessRestrictions != null
                    ? CoreUtils.Format("nodeState.AccessRestrictions = {0};", accessRestrictions)
                    : null);

            // Role permissions
            HashSet<RolePermission> rolePermissions = GetRolePermissions(root);
            context.Template.AddReplacement(
                Tokens.ListOfRolePermissions,
                NodeStateTemplates.ListOfRolePermissions,
                [rolePermissions],
                WriteTemplate_RolePermissions);

            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_AddReference(ILoadContext context)
        {
            if (context.Target is not ReferenceToGenerate reference)
            {
                return null;
            }
            bool placeholder = reference.TargetNode is InstanceDesign
            {
                ModellingRule: ModellingRule.MandatoryPlaceholder or ModellingRule.OptionalPlaceholder
            };
            if (placeholder)
            {
                context.Out.WriteLine("if (!forInstance)");
                context.Out.WriteLine("{");
            }
            context.Out.WriteLine(
                "{0}state.AddReference({1}, {2}, {3});",
                placeholder ? "    " : string.Empty,
                m_context.ModelDesign.GetNodeIdConstant(
                    reference.ReferenceTypeId,
                    "<ReferenceType>",
                    kNamespaceTableContextVariable),
                reference.IsInverse ? "true" : "false",
                reference.TargetNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            if (placeholder)
            {
                context.Out.WriteLine("}");
            }
            return null;
        }

        /// <summary>
        /// Whether <see cref="GeneratorOptions.EmitNodeSetNodesOnly"/> applies:
        /// the option is set and the target model was read from a NodeSet2.
        /// </summary>
        private bool EmitsNodeSetNodesOnly =>
            m_context.Options.EmitNodeSetNodesOnly &&
            m_context.ModelDesign is ModelDesignValidator { IsSourceNodeSet: true };

        /// <summary>
        /// With <see cref="GeneratorOptions.EmitNodeSetNodesOnly"/>, a
        /// predefined node of a NodeSet2 input gets only the children the
        /// NodeSet2 declares: a child the generator derives from a supertype
        /// or a type definition is not added to it.
        /// <para>
        /// The child factories of a type are also called by the
        /// <c>CreateInstanceOf*</c> factories with <c>forInstance: true</c>, so
        /// in a type the omitted child is still created when its parent is
        /// created for an instance; only the factories of a predefined instance
        /// leave it out unconditionally.
        /// </para>
        /// </summary>
        private bool IsOmittedFromNodeSetAddressSpace(NodeToGenerate node)
        {
            return EmitsNodeSetNodesOnly &&
                node.IsNotExplicitlyDefined &&
                GetRoot(node).InstanceOf == null;
        }

        /// <summary>
        /// Whether the predefined instance that <paramref name="node"/> belongs
        /// to omits the undeclared nodes of its hierarchy, so that a reference
        /// may only end in a node of the hierarchy that it creates. The
        /// factories of a type keep their references: they are the ones the
        /// <c>CreateInstanceOf*</c> factories reuse at run time.
        /// </summary>
        private bool OmitsUndeclaredHierarchyNodes(NodeToGenerate node)
        {
            return EmitsNodeSetNodesOnly &&
                !node.RootIsTypeDefinition &&
                GetRoot(node).InstanceOf == null;
        }

        /// <summary>
        /// Whether the predefined instance that <paramref name="node"/> belongs
        /// to creates the node at <paramref name="path"/> of its hierarchy: the
        /// node is generated and neither it nor any of its ancestors is
        /// omitted (see <see cref="IsOmittedFromNodeSetAddressSpace"/>).
        /// </summary>
        private static bool IsCreatedInNodeSetAddressSpace(NodeToGenerate node, string path)
        {
            NodeToGenerate root = GetRoot(node);
            if (path == root.Path)
            {
                return true;
            }

            NodeToGenerate? target = FindDescendant(root, path);
            if (target == null)
            {
                return false;
            }

            for (NodeToGenerate current = target;
                current.Parent != null;
                current = current.Parent)
            {
                if (current.IsNotExplicitlyDefined)
                {
                    return false;
                }
            }
            return true;
        }

        private static NodeToGenerate? FindDescendant(NodeToGenerate node, string path)
        {
            foreach (NodeToGenerate child in node.AllChildren)
            {
                if (child.Path == path)
                {
                    return child;
                }
                NodeToGenerate? descendant = FindDescendant(child, path);
                if (descendant != null)
                {
                    return descendant;
                }
            }
            return null;
        }

        private static NodeToGenerate GetRoot(NodeToGenerate node)
        {
            NodeToGenerate root = node;
            while (root.Parent != null)
            {
                root = root.Parent;
            }
            return root;
        }

        private TemplateString? LoadTemplate_ReplaceChild(ILoadContext context)
        {
            if (context.Target is not NodeToGenerate node ||
                node.Design is not InstanceDesign instance ||
                node.Design is ViewDesign)
            {
                return null;
            }

            // A predefined instance's factories only build that instance, and a
            // factory's type-template block only runs for the predefined type
            // node (forInstance: false), so neither creates the omitted child.
            bool omittedFromNodeSet = IsOmittedFromNodeSetAddressSpace(node);
            if (omittedFromNodeSet &&
                (!node.RootIsTypeDefinition ||
                    context.Token == Tokens.ListOfOptionalChildNodeStates))
            {
                return null;
            }

            // Determine which modelling rule drives factory-method emission.
            //
            // For SINGLETON instance overrides (a top-level <opc:Object> in
            // StandardTypes.xml whose parent has no type def), an override of
            // a type-def Optional child to Mandatory must NOT force emission
            // of the child when UseTypeDefinitionModellingRules is on - the
            // SDK is responsible for adding only those children it actually
            // implements (fixes issue #3768).
            //
            // The gate applies TRANSITIVELY to every Variable/Method descendant
            // of a top-level singleton instance (e.g. Server,
            // ServerConfiguration, HistoryServerCapabilities). Optional
            // Object instances are intentionally exempt: they are still
            // emitted by the singleton-specific factory with their correct
            // instance-level NodeIds, because their subtrees use well-known
            // descendant NodeIds (e.g.
            // ServerConfiguration.CertificateGroups.DefaultHttpsGroup.
            // TrustList.Open at NodeId 14095) and the SDK binds against
            // them directly (e.g. ConfigurationNodeManager pairs
            // CertificateGroupState by NodeId in
            // <see cref="Opc.Ua.Server.ConfigurationNodeManager"/>,
            // RoleStateBinding looks up
            // <see cref="Opc.Ua.ObjectIds.Server_ServerCapabilities_RoleSet"/>).
            // Patching every descendant NodeId from the SDK after a
            // type-level factory call would require hard-coded mapping of
            // dozens of well-known NodeIds per Object root and is brittle.
            // Optional Object descendants' own Variable/Method children are
            // still gated transitively (e.g. OperationLimits.MaxNodesPerRead
            // is suppressed and the SDK programmatically adds it back via
            // <see cref="Opc.Ua.Server.Diagnostics.DiagnosticsNodeManager.
            // AddOperationLimitsSdkOptionalChildren"/>).
            //
            // For TYPE-LEVEL promotions (e.g. AnalogItemType promoting EURange
            // from Optional on BaseAnalogType to Mandatory), the type-def
            // tree itself is being captured and the promotion is part of the
            // declared type definition, so the instance's Mandatory rule
            // must be honoured even when the option is on. The synthetic
            // type-instance NodeToGenerate (root.InstanceOf != null) and the
            // type-def NodeToGenerate (root.RootIsTypeDefinition) are both
            // excluded because IsUnderSingletonInstance is propagated only
            // through the singleton-instance subtree.
            bool isSingletonInstanceContext =
                m_context.Options.UseTypeDefinitionModellingRules &&
                node.IsUnderSingletonInstance &&
                node.Parent != null &&
                instance is VariableDesign or MethodDesign or ObjectDesign;

            ModellingRule effectiveRule = isSingletonInstanceContext
                ? GetEffectiveModellingRule(node, instance)
                : instance.ModellingRule;

            // The "top-level non-typed parent" exception below forces children
            // of an explicitly-declared singleton instance (e.g.
            // <opc:Object SymbolicName="ServerConfiguration" ...> in
            // StandardTypes.xml) into the always-emitted mandatory list so
            // declared overrides materialize on the actual node. This
            // exception must be suppressed for SINGLETON-INSTANCE roots when
            // <see cref="GeneratorOptions.UseTypeDefinitionModellingRules"/>
            // is on; otherwise singleton instance overrides could re-introduce
            // the very Optional/unimplemented children we are trying to
            // exclude from the actual instance.
            //
            // TYPE-DEFINITION roots (ObjectTypeDesign, VariableTypeDesign,
            // MethodTypeDesign) must still emit their Optional children
            // unconditionally — the type-def factory is called from many
            // places (instance.Create, ConfigurationNodeManager.
            // CreateNamespaceMetadataStateAsync, etc.) with
            // forInstance=true, and removing them breaks deep code paths
            // that rely on the type-def factory shape. Only suppress when
            // the parent is itself an InstanceDesign singleton.
            bool topLevelInstanceException =
                node.Parent != null &&
                node.Parent.Parent == null &&
                node.Parent.InstanceOf == null &&
                (node.Parent.Design is not InstanceDesign ||
                    !m_context.Options.UseTypeDefinitionModellingRules);

            // Explicitly-declared descendants of a concrete predefined instance
            // (a user-modelled <opc:Object>/<opc:Variable> declared under
            // Objects, e.g. a device instance) must be materialised on the
            // actual instance regardless of their (possibly type-inherited)
            // modelling rule: they are real nodes present in the model, not
            // modelling-rule-driven optional children the SDK adds on demand.
            // The topLevelInstanceException above only covers the instance's
            // DIRECT children (node.Parent.Parent == null); deeper descendants
            // — e.g. the EURange / EngineeringUnits properties of a
            // BaseAnalogType / AnalogUnitType variable nested under the
            // instance (issue #3964) — inherit IsUnderSingletonInstance and
            // would otherwise land in the `if (!forInstance)` type-template
            // block and be dropped from the instance. SDK-managed singletons
            // (Server, ServerConfiguration, …) are generated with
            // UseTypeDefinitionModellingRules on and keep the #3768
            // optional-child suppression, so they are excluded here.
            bool concreteInstanceDescendant =
                node.IsUnderSingletonInstance &&
                !node.RootIsTypeDefinition &&
                node.InstanceOf == null &&
                !node.IsNotExplicitlyDefined &&
                !m_context.Options.UseTypeDefinitionModellingRules;

            bool alwaysEmitInstanceChild =
                topLevelInstanceException || concreteInstanceDescendant;

            if (context.Token == Tokens.ListOfOptionalChildNodeStates)
            {
                if (effectiveRule == ModellingRule.Mandatory)
                {
                    return null;
                }
                // Real instance children of a top-level (non-typed) parent belong in
                // the always-emitted list so they materialize for the actual instance,
                // not only when the node is treated as a type template.
                if (alwaysEmitInstanceChild)
                {
                    return null;
                }
            }

            // Otherwise only add mandatory children - all others are created on demand
            else if (effectiveRule != ModellingRule.Mandatory)
            {
                // Exception: real instance children of a top-level (non-typed) parent.
                if (!alwaysEmitInstanceChild)
                {
                    return null;
                }
            }

            string forInstanceVariableValue =
                node.RootIsTypeDefinition ? "forInstance" :
                node.Parent?.InstanceOf != null || node.Parent?.Parent == null ? "true" : "forInstance";
            if (!omittedFromNodeSet)
            {
                EmitChildFactoryCall(
                    context.Out,
                    node,
                    instance,
                    effectiveRule,
                    forInstanceVariableValue);
                return null;
            }

            // An omitted child of a type is created for an instance only.
            context.Out.WriteLine("if (forInstance)");
            context.Out.WriteLine("{");
            EmitChildFactoryCall(
                new IndentedTemplateWriter(context.Out),
                node,
                instance,
                effectiveRule,
                forInstanceVariableValue);
            context.Out.WriteLine("}");
            return null;
        }

        /// <summary>
        /// Emits the call that creates <paramref name="node"/> and adds it to
        /// the <c>state</c> of its parent's factory.
        /// </summary>
        private void EmitChildFactoryCall(
            ITemplateWriter output,
            NodeToGenerate node,
            InstanceDesign instance,
            ModellingRule effectiveRule,
            string forInstanceVariableValue)
        {
            if (node.Parent != null && IsInAddressSpace(node.Parent))
            {
                switch (node.Parent.Design)
                {
                    case TypeDesign:
                        output.WriteLine(
                            "state.AddChild(Create{0}(context, state, forInstance: {1}));",
                            instance.SymbolicId.Name,
                            forInstanceVariableValue);
                        return;
                    case InstanceDesign parentInstance:
                        if (HasFixedChildSlot(parentInstance.TypeDefinitionNode, instance.SymbolicName.Name) ||
                            IsBuiltInProperty(node))
                        {
                            // Children whose SymbolicName ends in "_Placeholder"
                            // come from OptionalPlaceholder/MandatoryPlaceholder
                            // slots on the type, which emit Add*_Placeholder
                            // methods (cardinality 0..N) instead of
                            // CreateOrReplace*_Placeholder methods (which only
                            // exist for fixed Mandatory/Optional slots).
                            // Fall through to AddChild for these.
                            bool isPlaceholderSlot = instance.SymbolicName.Name
                                .EndsWith("_Placeholder", StringComparison.Ordinal);
                            if (!isPlaceholderSlot)
                            {
                                switch (effectiveRule)
                                {
                                    case ModellingRule.Mandatory:
                                    case ModellingRule.Optional:
                                        EmitCreateOrReplaceChild(
                                            output,
                                            node,
                                            instance,
                                            forInstanceVariableValue);
                                        return;
                                    case ModellingRule.OptionalPlaceholder:
                                    case ModellingRule.MandatoryPlaceholder:
                                        // TODO
                                        break;
                                    case ModellingRule.ExposesItsArray:
                                    case ModellingRule.None:
                                    case ModellingRule.CardinalityRestriction:
                                    case ModellingRule.MandatoryShared:
                                        break;
                                }
                            }
                        }
                        break;
                }
            }

            output.WriteLine(
                "state.AddChild(Create{0}(context, state, forInstance: {1}));",
                instance.SymbolicId.Name,
                forInstanceVariableValue);
        }

        /// <summary>
        /// Emits the <c>state.CreateOrReplace{Name}(context, Create{Symbolic}(context, state, forInstance: …))</c>
        /// call site for a child of an InstanceDesign parent. When the child
        /// lives in a type-level factory body (<see cref="NodeToGenerate.RootIsTypeDefinition"/>
        /// is <c>true</c>) AND the type has well-known singleton instances
        /// whose corresponding child factories have been collected, also
        /// dispatches the <c>forInstance: true</c> path into the appropriate
        /// singleton-instance child factory. This ensures that lazy-added
        /// methods on singleton owners (e.g.
        /// <c>serverObject.AddGetMonitoredItems(context, MethodIds.Server_GetMonitoredItems)</c>)
        /// produce synthesized children (<c>InputArguments</c>,
        /// <c>OutputArguments</c>) at their well-known instance NodeIds
        /// rather than the type-level placeholders.
        /// </summary>
        private void EmitCreateOrReplaceChild(
            ITemplateWriter output,
            NodeToGenerate node,
            InstanceDesign instance,
            string forInstanceVariableValue)
        {
            List<
                (
                    NodeToGenerate Singleton,
                    NodeToGenerate SingletonChild,
                    string SingletonChildSymbolicId)> singletonChildren = FindSingletonChildren(node);
            if (singletonChildren.Count == 0)
            {
                output.WriteLine(
                    "state.CreateOrReplace{0}(context, Create{1}(context, state, " +
                        "forInstance: {2}), assignInstanceNodeIds: false);",
                    instance.SymbolicName.Name,
                    instance.SymbolicId.Name,
                    forInstanceVariableValue);
                return;
            }

            // Dispatch on the parent's NodeId so the singleton-instance
            // child factory is invoked when the type-level factory is
            // materialising an actual well-known instance subtree. The
            // <paramref name="forInstance"/> gate keeps the type-template
            // emission path (forInstance: false) unchanged.
            output.WriteLine("if ({0} && parent != null)", forInstanceVariableValue);
            output.WriteLine("{");
            for (int i = 0; i < singletonChildren.Count; i++)
            {
                (NodeToGenerate singletonRoot, NodeToGenerate _, string singletonChildSymbolicId)
                    = singletonChildren[i];
                string keyword = i == 0 ? "if" : "else if";
                output.WriteLine(
                    "    {0} (parent.NodeId.Equals({1}))",
                    keyword,
                    singletonRoot.Design.GetNodeIdAsCode(
                        m_context.ModelDesign.Namespaces,
                        kNamespaceTableContextVariable));
                output.WriteLine("    {");
                output.WriteLine(
                    "        state.CreateOrReplace{0}(context, Create{1}(context, state, " +
                        "forInstance: true), assignInstanceNodeIds: false);",
                    instance.SymbolicName.Name,
                    singletonChildSymbolicId);
                output.WriteLine("    }");
            }
            output.WriteLine("    else");
            output.WriteLine("    {");
            output.WriteLine(
                "        state.CreateOrReplace{0}(context, Create{1}(context, state, " +
                    "forInstance: true), assignInstanceNodeIds: false);",
                instance.SymbolicName.Name,
                instance.SymbolicId.Name);
            output.WriteLine("    }");
            output.WriteLine("}");
            output.WriteLine("else");
            output.WriteLine("{");
            output.WriteLine(
                "    state.CreateOrReplace{0}(context, Create{1}(context, state, " +
                    "forInstance: {2}), assignInstanceNodeIds: false);",
                instance.SymbolicName.Name,
                instance.SymbolicId.Name,
                forInstanceVariableValue);
            output.WriteLine("}");
        }

        private bool WriteTemplate_RolePermissions(IWriteContext context)
        {
            if (context.Target is not HashSet<RolePermission> rolePermissions ||
                rolePermissions.Count == 0)
            {
                return false;
            }

            context.Template.AddReplacement(
                Tokens.ListOfRolePermissions,
                NodeStateTemplates.RolePermission,
                rolePermissions,
                LoadTemplate_RolePermissionEntry,
                WriteTemplate_RolePermissionEntry);
            return context.Template.Render();
        }

        private bool WriteTemplate_ArgumentCollection(IWriteContext context)
        {
            switch (context.Target)
            {
                case IList<Argument> arguments:
                    // The parameter that is packed into the Argument value
                    context.Template.AddReplacement(
                        Tokens.ListOfValues,
                        NodeStateTemplates.ArgumentValue,
                        arguments,
                        WriteTemplate_Argument);
                    break;
                case Parameter[] parameters:
                    context.Template.AddReplacement(
                        Tokens.ListOfValues,
                        NodeStateTemplates.ArgumentValue,
                        parameters,
                        WriteTemplate_Argument);
                    break;
                default:
                    return false;
            }
            context.Template.AddReplacement(Tokens.DataType, "global::Opc.Ua.Argument");
            return context.Template.Render();
        }

        private bool WriteTemplate_Argument(IWriteContext context)
        {
            Argument? argument = null;
            Parameter? parameter;
            switch (context.Target)
            {
                case Argument arg:
                    argument = arg;
                    parameter = argument.Value as Parameter;
                    break;
                case Parameter parm:
                    parameter = parm;
                    break;
                default:
                    return false;
            }

            context.Template.AddReplacement(
                Tokens.Name,
                parameter == null ?
                    argument!.Name.AsStringLiteral() :
                    parameter.Name.AsStringLiteral());
            context.Template.AddReplacement(
                Tokens.DataType,
                m_context.ModelDesign.GetNodeIdConstant(
                    parameter?.DataType,
                    "<DataType>",
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.ValueRank,
                parameter?.ValueRank.GetValueRankAsCode(parameter.ArrayDimensions));
            context.Template.AddReplacement(
                Tokens.ArrayDimensions,
                parameter?.ValueRank.GetArrayDimensionsAsCode(parameter.ArrayDimensions) ?? "default");
            context.Template.AddReplacement(
                Tokens.Description,
                (parameter?.Description).GetLocalizedTextAsCode(true));

            return context.Template.Render();
        }

        private bool WriteTemplate_MethodArguments(IWriteContext context)
        {
            if (context.Target is not MethodArgumentsToGenerate arguments)
            {
                return false;
            }
            context.Template.AddReplacement(
                Tokens.PropertyName,
                arguments.PropertyName);
            context.Template.AddReplacement(
                Tokens.BrowseName,
                arguments.BrowseName);
            context.Template.AddReplacement(
                Tokens.ListOfValues,
                NodeStateTemplates.ArgumentValue,
                arguments.Arguments,
                WriteTemplate_Argument);
            return context.Template.Render();
        }

        private TemplateString? LoadTemplate_RolePermissionEntry(ILoadContext context)
        {
            if (context.Target is not RolePermission)
            {
                return null;
            }
            return NodeStateTemplates.RolePermission;
        }

        private bool WriteTemplate_RolePermissionEntry(IWriteContext context)
        {
            if (context.Target is not RolePermission rolePermission)
            {
                return false;
            }
            if (!m_context.ModelDesign.TryFindNode(
                rolePermission.Role,
                rolePermission.Role.Name,
                "RoleType",
                out ObjectDesign? roleNode))
            {
                return false;
            }

            context.Template.AddReplacement(
                Tokens.RoleIdConstant,
                roleNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.PermissionsValue,
                CoreUtils.Format(
                    "(uint)({0})",
                    rolePermission.Permission.GetPermissionTypeAsCode()));

            return context.Template.Render();
        }

        private void AddNodeStateClassVariableTypeReplacements(
            IWriteContext context,
            VariableTypeDesign variableType)
        {
            AddNodeStateClassTypeReplacements(context, variableType);
            BasicDataType basicType = variableType.DataTypeNode!.BasicDataType;

            if (variableType.SymbolicName.Name == "TwoStateDiscreteType")

            {
                variableType.ValueRank = ValueRank.Scalar;
            }
            if (!variableType.DataTypeNode.IsTemplateParameterRequired(variableType.ValueRank))
            {
                // Overrides a variable type that does not require a template parameter so we
                // need to add it
                context.Template.AddReplacement(Tokens.BaseT, string.Empty);
            }
            else
            {
                // Overrides a typed variable type where the base class requires a template
                // parameter, so the same template parameter is needed plus the Variant builder
                // to access the variant content of the type T.
                string parameter = GetTemplateParameter(variableType, out string variantBuilder);
                if (parameter == "<T>" && variableType.ValueRank != ValueRank.Scalar)
                {
                    parameter = "<global::Opc.Ua.Variant>";
                    variantBuilder = "global::Opc.Ua.VariantBuilder";
                }
                if (string.IsNullOrEmpty(parameter))
                {
                    context.Template.AddReplacement(Tokens.BaseT, string.Empty);
                }
                else
                {
                    // The class extends from the generic one through its inner
                    // Implementation<TBuilder> class to provide generic variant
                    // value accessors
                    context.Template.AddReplacement(
                        Tokens.BaseT,
                        CoreUtils.Format("{0}.Implementation<{1}>", parameter, variantBuilder));
                }
            }

            string valueRank = variableType.ValueRank.GetValueRankAsCode(
                variableType.ArrayDimensions);

            if (variableType.ValueRank == ValueRank.ScalarOrArray)
            {
                for (TypeDesign? baseType = variableType.BaseTypeNode;
                    baseType != null;
                    baseType = baseType.BaseTypeNode)
                {
                    if (baseType.SymbolicId ==
                        new XmlQualifiedName("DataItemType", Namespaces.OpcUa))
                    {
                        valueRank = $"global::Opc.Ua.ValueRanks.{ValueRank.Scalar}";
                    }
                }
            }

            AddVariantAccessor(context, variableType.DataTypeNode);

            if (variableType.DataTypeNode.NeedsCloning())
            {
                // Must be the fully qualified type name: the cast lands in the
                // generated VariableTypeValue class, whose enclosing namespace is
                // not the one declaring the data type for a cross-model structure.
                // The same name the value field is declared with.
                context.Template.AddReplacement(
                    Tokens.ValueWrite,
                    CoreUtils.Format(
                        "CopyOnWrite ? ({0})global::Opc.Ua.CoreUtils.Clone(newValue) : newValue",
                        variableType.DataTypeNode.GetDotNetTypeName(
                            ValueRank.Scalar,
                            m_context.ModelDesign.TargetNamespace.Value,
                            m_context.ModelDesign.Namespaces,
                            nullable: NullableAnnotation.NonNullable)));
            }
            else
            {
                context.Template.AddReplacement(Tokens.ValueWrite, "newValue");
            }
            if (variableType.DataTypeNode.IsDotNetEqualityComparable(variableType.ValueRank))
            {
                context.Template.AddReplacement(Tokens.ValueComparison, "m_value != newValue");
            }
            else
            {
                context.Template.AddReplacement(Tokens.ValueComparison,
                    "!global::Opc.Ua.CoreUtils.IsEqual(m_value, newValue)");
            }
            // The VariableType default value is emitted by the type's factory
            // (AddVariableTypeStateFactoryReplacements), which maps namespace
            // indexes through the NodeSet's table (OPC 10000-6 F.14). The state
            // class template has no default value: computing one here without
            // that table produced a NodeSet-local literal nobody rendered and
            // registered an unused XML value resource.
            context.Template.AddReplacement(Tokens.ValueRank, valueRank);
            context.Template.AddReplacement(
                Tokens.ArrayDimensions,
                variableType.ValueRank.GetArrayDimensionsAsCode(
                    variableType.ArrayDimensions) ??
                "default");
            context.Template.AddReplacement(Tokens.IsAbstract, variableType.IsAbstract);
            context.Template.AddReplacement(
                Tokens.AccessLevelValue,
                variableType.AccessLevel.GetAccessLevelAsCode());
            context.Template.AddReplacement(
                Tokens.MinimumSamplingIntervalValue,
                variableType.GetMinimumSamplingIntervalAsCode());
            context.Template.AddReplacement(
                Tokens.Historizing,
                variableType.Historizing);
            context.Template.AddReplacement(
                Tokens.DataType,
                variableType.DataTypeNode.SymbolicName.Name);
            context.Template.AddReplacement(
                Tokens.DataTypeNamespacePrefix,
                m_context.ModelDesign.Namespaces.GetNamespacePrefix(
                    variableType.DataTypeNode.SymbolicId.Namespace));
            context.Template.AddReplacement(
                Tokens.DataTypeNamespaceUri,
                m_context.ModelDesign.Namespaces.GetConstantSymbolForNamespace(
                    variableType.DataTypeNode.SymbolicId.Namespace));
            context.Template.AddReplacement(
                Tokens.TypedVariableType,
                NodeStateTemplates.VariableTypeWithTypedValue_Class,
                [variableType],
                LoadTemplate_TypedVariableType,
                WriteTemplate_TypedVariableType);
            context.Template.AddReplacement(
                Tokens.VariableTypeValue,
                NodeStateTemplates.VariableTypeValue_Class,
                [variableType],
                LoadTemplate_VariableTypeValue,
                WriteTemplate_VariableTypeValue);
        }

        private void AddNodeStateClassObjectTypeReplacements(
            IWriteContext context,
            ObjectTypeDesign objectType)
        {
            AddNodeStateClassTypeReplacements(context, objectType);
            context.Template.AddReplacement(Tokens.BaseT, string.Empty);
            context.Template.AddReplacement(Tokens.IsAbstract, objectType.IsAbstract);
            context.Template.AddReplacement(Tokens.EventNotifier,
                objectType.GetEventNotifierAsCode());
            context.Template.AddReplacement(
                Tokens.ElementNamespaceOverride,
                BuildElementNamespaceOverride(objectType));
        }

        /// <summary>
        /// Emits the <c>ElementNamespaceUri</c> override for
        /// <c>FiniteStateMachineType</c> subtypes. Part 5 qualifies the
        /// numeric state and transition NodeIds a machine reports in
        /// <c>CurrentState/Id</c> and <c>LastTransition/Id</c> with the
        /// namespace of the model that declares those elements — which
        /// is not necessarily the machine's own namespace: a subtype
        /// that adds no states of its own keeps reporting the base
        /// type's, and the base class default (the OPC UA namespace) is
        /// then already right. Returns <c>null</c> (collapsing the
        /// template line) for every other object type.
        /// </summary>
        private string? BuildElementNamespaceOverride(ObjectTypeDesign objectType)
        {
            if (!IsFiniteStateMachineSubtype(objectType))
            {
                return null;
            }

            string? namespaceUri = FindElementNamespaceUri(objectType);
            if (string.IsNullOrEmpty(namespaceUri) ||
                namespaceUri == Namespaces.OpcUa)
            {
                // The base class already returns the OPC UA namespace.
                return null;
            }

            string? constant;
            try
            {
                constant = m_context.ModelDesign.Namespaces
                    .GetConstantSymbolForNamespace(namespaceUri);
            }
            catch (ArgumentException e)
            {
                // A namespace entry with a URI but no Name — surface it
                // instead of failing the whole generation for a
                // diagnostic-only feature.
                m_logger.LogWarning(
                    "Cannot emit ElementNamespaceUri for {Type}: {Error}",
                    objectType.SymbolicName?.Name,
                    e.Message);
                return null;
            }
            if (string.IsNullOrEmpty(constant))
            {
                // Failing open here means the machine keeps the base
                // default (the OPC UA namespace) and its element ids
                // land in namespace 0 — say so rather than being silent.
                m_logger.LogWarning(
                    "No namespace constant for '{Uri}' — {Type} will " +
                    "qualify its state and transition ids with the OPC " +
                    "UA namespace. Add the declaring model to the " +
                    "design's <Namespaces> to fix this.",
                    namespaceUri,
                    objectType.SymbolicName?.Name);
                return null;
            }

            return CoreUtils.Format(
                "/// <inheritdoc/>{0}" +
                "        protected override string ElementNamespaceUri => {1};",
                Environment.NewLine,
                constant);
        }

        /// <summary>
        /// The namespace of the nearest type in the hierarchy that
        /// actually declares <c>StateType</c> / <c>TransitionType</c>
        /// children. A subtype that only adds behaviour inherits its
        /// elements — and therefore their namespace — from its base.
        /// </summary>
        internal static string? FindElementNamespaceUri(ObjectTypeDesign objectType)
        {
            TypeDesign? current = objectType;
            while (current != null)
            {
                if (DeclaresStateMachineElements(current))
                {
                    return current.SymbolicName?.Namespace;
                }
                current = current.BaseTypeNode;
            }
            return null;
        }

        internal static bool DeclaresStateMachineElements(TypeDesign type)
        {
            InstanceDesign[]? children = type.Children?.Items;
            if (children == null)
            {
                return false;
            }
            foreach (InstanceDesign child in children)
            {
                if (child is not ObjectDesign childObject ||
                    childObject.TypeDefinition == null ||
                    !string.Equals(
                        childObject.TypeDefinition.Namespace,
                        Namespaces.OpcUa,
                        StringComparison.Ordinal))
                {
                    continue;
                }
                if (childObject.OveriddenNode != null)
                {
                    // Re-declaring an inherited state (to attach a
                    // description, a modelling rule, ...) does not make
                    // this type the one that declares the elements —
                    // the ids still live in the base model's namespace.
                    continue;
                }
                string typeDefName = childObject.TypeDefinition.Name;
                if (string.Equals(typeDefName, kStateTypeName, StringComparison.Ordinal) ||
                    string.Equals(typeDefName, kInitialStateTypeName, StringComparison.Ordinal) ||
                    string.Equals(typeDefName, kTransitionTypeName, StringComparison.Ordinal))
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// Whether the type derives, however indirectly, from the
        /// standard <c>FiniteStateMachineType</c>.
        /// </summary>
        internal static bool IsFiniteStateMachineSubtype(ObjectTypeDesign objectType)
        {
            TypeDesign? current = objectType;
            while (current != null)
            {
                if (string.Equals(
                        current.SymbolicName?.Name,
                        kFiniteStateMachineTypeName,
                        StringComparison.Ordinal) &&
                    string.Equals(
                        current.SymbolicName?.Namespace,
                        Namespaces.OpcUa,
                        StringComparison.Ordinal))
                {
                    return true;
                }
                current = current.BaseTypeNode;
            }
            return false;
        }

        private const string kFiniteStateMachineTypeName = "FiniteStateMachineType";
        private const string kStateTypeName = "StateType";
        private const string kInitialStateTypeName = "InitialStateType";
        private const string kTransitionTypeName = "TransitionType";

        private void AddNodeStateClassMethodTypeReplacements(
            IWriteContext context,
            MethodDesign method)
        {
            (Parameter[] inputArguments, Parameter[] outputArguments) =
                MethodDesignArgumentResolver.ResolveMethodArguments(method);
            string targetNamespace = m_context.ModelDesign.TargetNamespace.Value;
            string declaredClassName = method.GetNodeStateClassName(
                targetNamespace,
                [],
                applyStandardFallback: false);
            ModelDesignExtensions.AssignMethodArgumentCodeNames(
                inputArguments,
                outputArguments,
                s_methodArgumentCodeNameScope,
                declaredClassName + "Result");
            // Declarations require an unqualified identifier, while fallback
            // tracking requires the fully-qualified name. Neither may apply
            // the reference-only fallback policy.
            StandardMethodStateFallback.RecordDeclaredMethodState(
                method.GetNodeStateClassName(
                    targetNamespace,
                    m_context.ModelDesign.Namespaces,
                    applyStandardFallback: false));
            context.Template.AddReplacement(
                Tokens.ClassName,
                declaredClassName);
            context.Template.AddReplacement(
                Tokens.OwnerClassName,
                declaredClassName);
            context.Template.AddReplacement(
                Tokens.ListOfInputArguments,
                inputArguments,
                LoadTemplate_ListOfInputArguments);
            context.Template.AddReplacement(
                Tokens.OnCallDeclaration,
                [method],
                LoadTemplate_OnCallDeclaration);
            context.Template.AddReplacement(
                Tokens.OnCallAsyncDeclaration,
                [method],
                LoadTemplate_OnCallAsyncDeclaration);
            context.Template.AddReplacement(
                Tokens.OnCallImplementation,
                [method],
                LoadTemplate_OnCallImplementation);
            context.Template.AddReplacement(
                Tokens.OnCallAsyncImplementation,
                [method],
                LoadTemplate_OnCallAsyncImplementation);
            context.Template.AddReplacement(
                Tokens.ListOfOutputDeclarations,
                outputArguments,
                LoadTemplate_ListOfOutputDeclarations);
            context.Template.AddReplacement(
                Tokens.ListOfOutputArgumentsFromResult,
                outputArguments,
                LoadTemplate_ListOfOutputArgumentsFromResult);
            context.Template.AddReplacement(
                Tokens.ListOfOutputArguments,
                outputArguments,
                LoadTemplate_ListOfOutputArguments);
            context.Template.AddReplacement(
                Tokens.ListOfResultProperties,
                outputArguments,
                LoadTemplate_ListOfResultProperties);
        }

        private void AddNodeStateClassTypeReplacements(
            IWriteContext context,
            TypeDesign type)
        {
            context.Template.AddReplacement(Tokens.ClassName, type.ClassName);
            // OwnerClassName mirrors ClassName at the type scope so per-child
            // sub-templates (e.g. NodeStateTemplates.OptionalMethod) can refer
            // to the parent (owner) class when generating Add{Child} methods
            // that return `this` for chaining. The per-child WriteTemplate
            // overrides Tokens.ClassName but leaves OwnerClassName untouched,
            // and the template engine cascades to this outer template when
            // OwnerClassName is not found locally. The class declaration
            // template appends "State" to ClassName (see
            // NodeStateClassObjectType / NodeStateClassVariableType), so do
            // the same here so the return type matches the declared class.
            context.Template.AddReplacement(
                Tokens.OwnerClassName,
                type.ClassName + "State");
            context.Template.AddReplacement(
                Tokens.BaseClassName,
                type.BaseTypeNode!.GetClassName(m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(
                Tokens.BaseTypeNamespacePrefix,
                m_context.ModelDesign.Namespaces.GetNamespacePrefix(
                    type.BaseTypeNode!.SymbolicId.Namespace));
            context.Template.AddReplacement(
                Tokens.BaseTypeNamespaceUri,
                m_context.ModelDesign.Namespaces.GetConstantSymbolForNamespace(
                    type.BaseTypeNode.SymbolicId.Namespace));
        }

        private void AddObjectTypeStateFactoryReplacements(
            IWriteContext context,
            ObjectTypeDesign node)
        {
            context.Template.AddReplacement(
                Tokens.SuperTypeId,
                node.BaseTypeNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(Tokens.IsAbstract, node.IsAbstract);
            context.Template.AddReplacement(
                Tokens.StateClassName,
                "global::Opc.Ua.BaseObjectTypeState");
            context.Template.AddReplacement(
                Tokens.StateClassFactory,
                "new global::Opc.Ua.BaseObjectTypeState");
        }

        private void AddVariableTypeStateFactoryReplacements(
            IWriteContext context,
            VariableTypeDesign node)
        {
            context.Template.AddReplacement(Tokens.SuperTypeId,
                node.BaseTypeNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(Tokens.IsAbstract, node.IsAbstract);
            context.Template.AddReplacement(
                Tokens.StateClassName,
                "global::Opc.Ua.BaseDataVariableTypeState");
            context.Template.AddReplacement(
                Tokens.StateClassFactory,
                "new global::Opc.Ua.BaseDataVariableTypeState");

            if (IsNodeSetValueNull(node.NodeSetValueIsNull, node.DefaultValue, node.DecodedValue))
            {
                context.Template.AddReplacement(Tokens.ValueCode, kNullValueCode);
            }
            else
            {
                context.Template.AddReplacement(Tokens.ValueCode, CoreUtils.Format(
                    "baseState.WrappedValue = {0};",
                    node.DataTypeNode!.GetValueAsCode(
                        node.ValueRank,
                        node.DefaultValue,
                        node.DecodedValue,
                        true,
                        m_context.ModelDesign.TargetNamespace.Value,
                        m_context.ModelDesign.Namespaces,
                        m_messageContext,
                        () => AddXmlInitializerForComplexValue(
                            node,
                            node.DataTypeNode!,
                            node.DefaultValue)!,
                        node.DecodedValueNamespaceUris,
                        kNamespaceTableContextVariable)));
            }
            string dataTypeId =
                GetNodeIdConstantForDataType(node, m_context.ModelDesign.Namespaces);
            context.Template.AddReplacement(
                Tokens.DataTypeIdConstant,
                dataTypeId ?? "global::Opc.Ua.NodeId.Null");
            string valueRank = node.ValueRank.GetValueRankAsCode(
                node.ArrayDimensions);
            context.Template.AddReplacement(Tokens.ValueRank, valueRank);
            string? arrayDims = node.ValueRank.GetArrayDimensionsAsCode(
                node.ArrayDimensions);
            context.Template.AddReplacement(
                Tokens.ArrayDimensions,
                !string.IsNullOrEmpty(arrayDims)
                    ? CoreUtils.Format("baseState.ArrayDimensions = {0};", arrayDims)
                    : null);
        }

        private void AddVariableStateFactoryReplacements(
            IWriteContext context,
            NodeToGenerate nodeToGenerate,
            VariableDesign node,
            HashSet<ReferenceToGenerate> references)
        {
            context.Template.AddReplacement(
                Tokens.StateClassName,
                node.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(
                Tokens.StateClassFactory,
                node.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces,
                    asFactory: true));
            context.Template.AddReplacement(
                Tokens.TypeDefinitionId,
                node.TypeDefinitionNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.ReferenceTypeId,
                m_context.ModelDesign.GetNodeIdConstant(
                    node.ReferenceType,
                    "<ReferenceType>",
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.ModellingRuleId,
                GetModellingRuleReplacement(
                    GetEffectiveModellingRule(nodeToGenerate, node)));
            context.Template.AddReplacement(
                Tokens.DataTypeIdConstant,
                GetNodeIdConstantForDataType(node, m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(
                Tokens.ValueRank,
                node.ValueRank.GetValueRankAsCode(node.ArrayDimensions));

            string? arrayDims = node.ValueRank.GetArrayDimensionsAsCode(node.ArrayDimensions);
            context.Template.AddReplacement(
                Tokens.ArrayDimensions,
                !string.IsNullOrEmpty(arrayDims)
                    ? CoreUtils.Format("baseState.ArrayDimensions = {0};", arrayDims)
                    : null);

            context.Template.AddReplacement(
                Tokens.AccessLevelValue,
                node.GetAccessLevelAsCode());
            context.Template.AddReplacement(
                Tokens.UserAccessLevelValue,
                node.GetUserAccessLevelAsCode());
            context.Template.AddReplacement(
                Tokens.MinimumSamplingIntervalValue,
                node.MinimumSamplingInterval.ToString(CultureInfo.InvariantCulture));
            context.Template.AddReplacement(
                Tokens.HistorizingValue,
                node.Historizing);

            // set dictionary to point to embedded schemas
            if (node.TypeDefinitionNode!.SymbolicId ==
                    new XmlQualifiedName("DataTypeDictionaryType", Namespaces.OpcUa))
            {
                NodeDesign? typeSystemReference = references.FirstOrDefault()?.TargetNode;
                switch (typeSystemReference?.SymbolicId.Name)
                {
                    case "XmlSchema_TypeSystem":
                        context.Template.AddReplacement(
                            Tokens.ValueCode,
                            "baseState.WrappedValue = global::Opc.Ua.Variant.From(" +
                            "global::Opc.Ua.ByteString.From(XmlSchemas.TypesXsd.ToArray()));");
                        return;
                    case "OPCBinarySchema_TypeSystem":
                        context.Template.AddReplacement(
                            Tokens.ValueCode,
                            "baseState.WrappedValue = global::Opc.Ua.Variant.From(" +
                            "global::Opc.Ua.ByteString.From(XmlSchemas.TypesBsd.ToArray()));");
                        return;
                }
                // unknown type system
                context.Template.AddReplacement(
                    Tokens.ValueCode,
                    "baseState.WrappedValue = global::Opc.Ua.Variant.Null;");
                return;
            }

            Parameter[]? methodArguments = GetMethodArgumentParameters(nodeToGenerate);
            if (methodArguments != null)
            {
                context.Template.AddReplacement(
                    Tokens.ValueCode,
                    NodeStateTemplates.VariantArrayOfValue,
                    [methodArguments],
                    WriteTemplate_ArgumentCollection);
            }
            else if (node.DecodedValue is IList<Argument> args)
            {
                context.Template.AddReplacement(
                    Tokens.ValueCode,
                    NodeStateTemplates.VariantArrayOfValue,
                    [args],
                    WriteTemplate_ArgumentCollection);
            }
            else if (node.DecodedValue is ArrayOf<Argument> arguments)
            {
                context.Template.AddReplacement(
                    Tokens.ValueCode,
                    NodeStateTemplates.VariantArrayOfValue,
                    [arguments.ToList()],
                    WriteTemplate_ArgumentCollection);
            }
            else if (IsNodeSetValueNull(node.NodeSetValueIsNull, node.DefaultValue, node.DecodedValue))
            {
                context.Template.AddReplacement(Tokens.ValueCode, kNullValueCode);
            }
            else
            {
                context.Template.AddReplacement(Tokens.ValueCode, CoreUtils.Format(
                    "baseState.WrappedValue = {0};",
                    node.DataTypeNode!.GetValueAsCode(
                        node.ValueRank,
                        node.DefaultValue,
                        node.DecodedValue,
                        true,
                        m_context.ModelDesign.TargetNamespace.Value,
                        m_context.ModelDesign.Namespaces,
                        m_messageContext,
                        () => AddXmlInitializerForComplexValue(
                            node,
                            node.DataTypeNode!,
                            node.DefaultValue)!,
                        node.DecodedValueNamespaceUris,
                        kNamespaceTableContextVariable)));
            }
        }

        /// <summary>
        /// A Variable or VariableType imported from a NodeSet2 without a Value
        /// has a null Value. Only a ModelDesign implies the DataType default.
        /// </summary>
        private static bool IsNodeSetValueNull(
            bool nodeSetValueIsNull,
            System.Xml.XmlElement? defaultValue,
            object? decodedValue)
        {
            return nodeSetValueIsNull && defaultValue == null && decodedValue == null;
        }

        private const string kNullValueCode = "baseState.WrappedValue = global::Opc.Ua.Variant.Null;";

        private static Parameter[]? GetMethodArgumentParameters(NodeToGenerate node)
        {
            if (node.Parent?.Design is not MethodDesign method)
            {
                return null;
            }

            if (node.Design!.SymbolicName == s_inputArgumentsBrowseName)
            {
                return MethodDesignArgumentResolver.ResolveMethodInputs(method);
            }

            if (node.Design.SymbolicName == s_outputArgumentsBrowseName)
            {
                return MethodDesignArgumentResolver.ResolveMethodOutputs(method);
            }

            return null;
        }

        private void AddReferenceTypeStateFactoryReplacements(
            IWriteContext context,
            ReferenceTypeDesign node)
        {
            context.Template.AddReplacement(Tokens.SuperTypeId,
                node.BaseTypeNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(Tokens.IsAbstract, node.IsAbstract);
            context.Template.AddReplacement(Tokens.SymmetricValue, node.Symmetric);
            context.Template.AddReplacement(Tokens.InverseNameValue, GetInverseNameValue(node));
        }

        private void AddDataTypeStateFactoryReplacements(
            IWriteContext context,
            DataTypeDesign node)
        {
            context.Template.AddReplacement(Tokens.SuperTypeId,
                node.BaseTypeNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(Tokens.IsAbstract, node.IsAbstract);
            context.Template.AddReplacement(Tokens.Purpose,
                (Export.DataTypePurpose)(int)(node.Purpose == DataTypePurpose.Testing ?
                    DataTypePurpose.CodeGenerator :
                    node.Purpose));

            if (node.BasicDataType is not BasicDataType.Enumeration and not BasicDataType.UserDefined)
            {
                context.Template.AddReplacement(
                    Tokens.DataTypeDefinition,
                    "global::Opc.Ua.ExtensionObject.Null");
            }
            else
            {
                context.Template.AddReplacement(
                    Tokens.DataTypeDefinition,
                    CoreUtils.Format(
                        "new global::Opc.Ua.ExtensionObject(global::{0}.DataTypeDefinitions.Create{1}({2}))",
                        m_context.ModelDesign.Namespaces.GetNamespacePrefix(node.SymbolicName.Namespace),
                        node.SymbolicName.Name,
                        kNamespaceTableContextVariable));
            }
        }

        private void AddObjectReplacements(
            IWriteContext context,
            NodeToGenerate nodeToGenerate,
            ObjectDesign node,
            HashSet<ReferenceToGenerate> references)
        {
            context.Template.AddReplacement(
                Tokens.StateClassName,
                node.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(
                Tokens.StateClassFactory,
                node.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces,
                    asFactory: true));
            context.Template.AddReplacement(
                Tokens.TypeDefinitionId,
                node.TypeDefinitionNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.ReferenceTypeId,
                m_context.ModelDesign.GetNodeIdConstant(
                    node.ReferenceType,
                    "<ReferenceType>",
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.ModellingRuleId,
                GetModellingRuleReplacement(
                    GetEffectiveModellingRule(nodeToGenerate, node)));
            context.Template.AddReplacement(
                Tokens.EventNotifier,
                node.SupportsEvents || HasForwardEventReferences(references)
                    ? "global::Opc.Ua.EventNotifiers.SubscribeToEvents"
                    : "global::Opc.Ua.EventNotifiers.None");
        }

        private void AddMethodStateFactoryReplacements(
            IWriteContext context,
            NodeToGenerate nodeToGenerate,
            MethodDesign node)
        {
            context.Template.AddReplacement(
                Tokens.ReferenceTypeId,
                m_context.ModelDesign.GetNodeIdConstant(
                    node.ReferenceType,
                    "<ReferenceType>",
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.StateClassName,
                node.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces));
            context.Template.AddReplacement(
                Tokens.StateClassFactory,
                node.GetNodeStateClassName(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces,
                    asFactory: true));
            context.Template.AddReplacement(
                Tokens.ModellingRuleId,
                GetModellingRuleReplacement(
                    GetEffectiveModellingRule(nodeToGenerate, node)));
            bool executable = !node.NonExecutable;
            context.Template.AddReplacement(Tokens.ExecutableValue, executable);

            context.Template.AddReplacement(
                Tokens.MethodDeclarationId,
                node.MethodDeclarationNode != null
                    ? CoreUtils.Format(
                        "baseState.MethodDeclarationId = {0};",
                        (HasResolvableNodeId(node.MethodDeclarationNode) ||
                            !node.NumericIdSpecified
                                ? node.MethodDeclarationNode
                                : node).GetNodeIdAsCode(
                            m_context.ModelDesign.Namespaces,
                            kNamespaceTableContextVariable))
                    : null);
            AddMethodArgumentsReplacement(
                context,
                nodeToGenerate,
                Tokens.ListOfInputArguments,
                BrowseNames.InputArguments,
                "inputArguments",
                node.InputArguments);
            AddMethodArgumentsReplacement(
                context,
                nodeToGenerate,
                Tokens.ListOfOutputArguments,
                BrowseNames.OutputArguments,
                "outputArguments",
                node.OutputArguments);
        }

        /// <summary>
        /// Emits the InputArguments or OutputArguments property of a method.
        /// The property is normally produced by its own child node factory,
        /// which carries the well known NodeId of the argument property and
        /// must therefore not be replaced -
        /// <see cref="MethodState.CreateOrReplaceInputArguments"/> keeps the
        /// property that was assigned first. Only the arguments themselves are
        /// re-emitted from the resolved model, and only when the value of the
        /// property cannot be trusted (see
        /// <see cref="RequiresArgumentValueOverride"/>). When no child factory
        /// exists the whole property is created inline.
        /// </summary>
        private void AddMethodArgumentsReplacement(
            IWriteContext context,
            NodeToGenerate nodeToGenerate,
            string token,
            string browseName,
            string propertyName,
            Parameter[] arguments)
        {
            if (arguments == null || arguments.Length == 0)
            {
                return;
            }
            bool hasChild = HasArgumentChild(nodeToGenerate, browseName);
            if (hasChild && !RequiresArgumentValueOverride(arguments))
            {
                return;
            }
            context.Template.AddReplacement(
                token,
                hasChild
                    ? NodeStateTemplates.Assign_MethodArgumentValues
                    : NodeStateTemplates.Create_MethodArguments,
                [
                    new MethodArgumentsToGenerate(propertyName, browseName, arguments)
                ],
                WriteTemplate_MethodArguments);
        }

        /// <summary>
        /// The value of an argument property imported from a nodeset is emitted
        /// verbatim as the XML of the source nodeset, where the NodeId of the
        /// argument data type is indexed against the namespace table of that
        /// nodeset. Such an index does not survive the import and resolves to
        /// an unrelated namespace at runtime, so the arguments have to be
        /// re-emitted from the resolved model. Arguments that only reference
        /// the OPC UA namespace always decode to the same value and are left
        /// alone.
        /// </summary>
        private static bool RequiresArgumentValueOverride(Parameter[] arguments)
        {
            return Array.Exists(
                arguments,
                argument => argument.DataTypeNode != null &&
                    !string.Equals(
                        argument.DataTypeNode.SymbolicId.Namespace,
                        Namespaces.OpcUa,
                        StringComparison.Ordinal));
        }

        /// <summary>
        /// The declaration node of a method is only usable as
        /// <see cref="MethodState.MethodDeclarationId"/> when it resolves to a
        /// real NodeId. Method type declarations that are synthesized while
        /// importing a nodeset have no identifier of their own and would emit a
        /// NodeId built from their symbolic name, which does not exist in any
        /// address space. In that case the method node itself is the
        /// declaration.
        /// </summary>
        private static bool HasResolvableNodeId(NodeDesign node)
        {
            return node.NumericIdSpecified ||
                !string.IsNullOrEmpty(node.StringId) ||
                node.HasNonConstantIdentifier() ||
                node.FindNumericIdentifier().HasValue;
        }

        /// <summary>
        /// Indicates that the model generates a dedicated child node factory
        /// for the InputArguments or OutputArguments property of a method.
        /// </summary>
        private static bool HasArgumentChild(NodeToGenerate node, string browseName)
        {
            return node.AllChildren.Exists(
                child => child.Design is InstanceDesign instance &&
                    string.Equals(
                        instance.SymbolicName?.Name,
                        browseName,
                        StringComparison.Ordinal));
        }

        private static void AddViewStateFactoryReplacements(
            IWriteContext context,
            ViewDesign node)
        {
            context.Template.AddReplacement(
                Tokens.EventNotifier,
                node.SupportsEvents
                    ? "global::Opc.Ua.EventNotifiers.SubscribeToEvents"
                    : "global::Opc.Ua.EventNotifiers.None");
            context.Template.AddReplacement(Tokens.ContainsNoLoopsValue, node.ContainsNoLoops);
        }

        /// <summary>
        /// Returns true if the references include a forward HasEventSource
        /// (i=36) or HasNotifier (i=48) reference. Per OPC UA Part 3, the
        /// EventNotifier attribute must be set on the source node of these
        /// references to indicate that events can be subscribed to.
        /// </summary>
        private static bool HasForwardEventReferences(HashSet<ReferenceToGenerate> references)
        {
            if (references == null)
            {
                return false;
            }
            foreach (ReferenceToGenerate reference in references)
            {
                if (!reference.IsInverse &&
                    reference.ReferenceTypeId != null &&
                    (reference.ReferenceTypeId.Name == "HasEventSource" ||
                        reference.ReferenceTypeId.Name == "HasNotifier"))
                {
                    return true;
                }
            }

            return false;
        }

        private void CollectNodesToGenerate()
        {
            foreach (NodeDesign node in m_context.ModelDesign.Nodes)
            {
                if (m_context.ModelDesign.IsExcluded(node))
                {
                    continue;
                }

                NodeToGenerate? entry = null;
                if (node is not InstanceDesign)
                {
                    entry = new NodeToGenerate(
                        Parent: null,
                        Path: string.Empty,
                        Hierarchy: node.Hierarchy,
                        Design: node,
                        IsNotExplicitlyDefined: false,
                        RootIsTypeDefinition: true,
                        InstanceOf: null,
                        IsUnderSingletonInstance: false);
                }
                else
                {
                    entry = new NodeToGenerate(
                        Parent: null,
                        Path: string.Empty,
                        Hierarchy: node.Hierarchy,
                        Design: node.Hierarchy!.NodeList[0].Instance,
                        IsNotExplicitlyDefined: false,
                        RootIsTypeDefinition: false,
                        InstanceOf: null,
                        IsUnderSingletonInstance: true);
                }
                if (!m_nodes.TryAdd(entry.Design!.SymbolicId, entry) &&
                    m_logger.IsEnabled(LogLevel.Debug))
                {
                    m_logger.LogDebug(
                        "Removing duplicate entry for {Node}.",
                        entry.Design.SymbolicId.Name);
                }
                GetChildren(entry, m_nodes, false);

                bool isMethodWithArguments =
                    node is MethodDesign method &&
                    MethodDesignArgumentResolver.HasMethodArguments(method);
                if ((node is not ObjectTypeDesign and not VariableTypeDesign) &&
                    !node.IsMethodTypeDesign() &&
                    !isMethodWithArguments)
                {
                    continue;
                }

                // Add instances to generate
                if (node.Hierarchy == null ||
                    !node.Hierarchy.Nodes.TryGetValue(
                        string.Empty,
                        out HierarchyNode? hierarchyNode))
                {
                    continue;
                }
                if (hierarchyNode.Identifier != null)
                {
                    if (hierarchyNode.Identifier is uint numericId)
                    {
                        hierarchyNode.Instance!.NumericId = numericId;
                        hierarchyNode.Instance.NumericIdSpecified = true;
                    }
                    else if (hierarchyNode.Identifier is string stringId)
                    {
                        hierarchyNode.Instance!.StringId = stringId;
                    }
                    else if (hierarchyNode.Identifier is Guid or ByteString)
                    {
                        hierarchyNode.Instance.SetIdentifier(hierarchyNode.Identifier);
                    }
                    else
                    {
                        throw new InvalidOperationException(CoreUtils.Format(
                            "Invalid identifier {0}",
                            hierarchyNode.Identifier));
                    }
                }

                var instanceToGenerate = new NodeToGenerate(
                    Parent: null,
                    Path: string.Empty,
                    Hierarchy: node.Hierarchy,
                    Design: hierarchyNode.Instance,
                    IsNotExplicitlyDefined: false,
                    RootIsTypeDefinition: false,
                    InstanceOf: entry, // Mark as instance of a type design
                    IsUnderSingletonInstance: false);
                entry.Instance = instanceToGenerate;
                if (!m_instances.TryAdd(instanceToGenerate.Design!.SymbolicId, instanceToGenerate) &&
                    m_logger.IsEnabled(LogLevel.Debug))
                {
                    m_logger.LogDebug(
                        "Removing duplicate entry for instance {Node}.",
                        instanceToGenerate.Design.SymbolicId.Name);
                }
                GetChildren(instanceToGenerate, m_instances, true);
            }

            // Collect DataType encoding nodes (Default Binary, Default XML, Default JSON).
            // These are ObjectDesign instances with TypeDefinition=DataTypeEncodingType
            // that are linked to DataTypes via HasEncoding references. They don't have
            // a Hierarchy from the model validation, so we build a minimal one with
            // their references to emit them into the address space.
            CollectEncodingNodes();

            // Index well-known singleton roots by their TypeDefinition so the
            // child-emission writer can dispatch the type-level factory's
            // forInstance: true branch into the matching singleton-instance
            // child factory (e.g. CreateServerType_GetMonitoredItems can
            // produce InputArguments at the well-known Server_*
            // NodeIds when the parent is the Server singleton).
            BuildSingletonInstanceIndex();
        }

        /// <summary>
        /// Populates <see cref="m_singletonsByType"/> with every singleton
        /// instance root or nested well-known instance in
        /// <see cref="m_nodes"/> grouped by its
        /// <see cref="InstanceDesign.TypeDefinitionNode"/>'s SymbolicId.
        /// Top-level entries correspond to declared
        /// <c>&lt;opc:Object&gt;</c> / <c>&lt;opc:Variable&gt;</c>
        /// singletons such as <c>Server</c> or
        /// <c>WellKnownRole_Observer</c>; nested entries cover Mandatory
        /// well-known children such as <c>Server_ServerCapabilities</c>
        /// (an instance of <c>ServerCapabilitiesType</c>) so the type-level
        /// factory's child-dispatch can produce the well-known instance
        /// NodeIds at every depth.
        /// </summary>
        private void BuildSingletonInstanceIndex()
        {
            foreach (NodeToGenerate entry in m_nodes.Values)
            {
                if (entry.Design is not InstanceDesign instance)
                {
                    continue;
                }
                TypeDesign? typeDef = instance.TypeDefinitionNode;
                if (typeDef == null || typeDef.SymbolicId == null)
                {
                    continue;
                }
                if (!m_singletonsByType.TryGetValue(typeDef.SymbolicId,
                    out List<NodeToGenerate>? singletons))
                {
                    singletons = [];
                    m_singletonsByType[typeDef.SymbolicId] = singletons;
                }
                singletons.Add(entry);
            }
        }

        /// <summary>
        /// Given the type-level child <paramref name="typeChild"/> that is
        /// about to be emitted inside a type-level factory body (e.g. the
        /// InputArguments slot inside <c>CreateServerType_GetMonitoredItems</c>),
        /// returns the singleton-instance equivalents — the same relative
        /// path under each known singleton instance of the type root, when
        /// such a child has been collected.
        /// </summary>
        private List<(NodeToGenerate Singleton, NodeToGenerate SingletonChild, string SingletonChildSymbolicId)>
            FindSingletonChildren(NodeToGenerate typeChild)
        {
            var result = new List<
                (
                    NodeToGenerate Singleton,
                    NodeToGenerate SingletonChild,
                    string SingletonChildSymbolicId)>();
            if (typeChild == null || !typeChild.RootIsTypeDefinition)
            {
                return result;
            }

            // Walk up to the type root NodeToGenerate.
            NodeToGenerate typeRoot = typeChild;
            while (typeRoot.Parent != null)
            {
                typeRoot = typeRoot.Parent;
            }
            if (typeRoot.Design is not TypeDesign typeDef ||
                typeDef.SymbolicId == null)
            {
                return result;
            }

            // Find singletons of this type, if any.
            if (!m_singletonsByType.TryGetValue(typeDef.SymbolicId,
                out List<NodeToGenerate>? singletons))
            {
                return result;
            }

            // The relative path suffix is the part of the child's SymbolicId
            // that follows the type-root SymbolicId. Both type and singleton
            // trees use the same "_<ChildSymbolicName>" path scheme, so we
            // can compute the singleton child SymbolicId by prefix swap.
            string typeRootName = typeDef.SymbolicId.Name;
            string childName = typeChild.Design!.SymbolicId.Name;
            if (childName == null ||
                !childName.StartsWith(typeRootName, StringComparison.Ordinal))
            {
                return result;
            }
            string relativeSuffix = childName[typeRootName.Length..];

            // Only count singletons whose corresponding child has actually
            // been collected (m_nodes contains the singleton-instance
            // descendants). For example, RoleType has both modifiable
            // (Observer/Operator/...) and immutable (Anonymous/...)
            // singletons; only the modifiable ones have the Mandatory
            // promoted AddIdentity child.
            foreach (NodeToGenerate singleton in singletons)
            {
                if (singleton.Design?.SymbolicId == null)
                {
                    continue;
                }
                string singletonChildName = singleton.Design.SymbolicId.Name + relativeSuffix;
                var singletonChildSymbolicId = new XmlQualifiedName(
                    singletonChildName,
                    typeChild.Design.SymbolicId.Namespace);
                if (m_nodes.TryGetValue(singletonChildSymbolicId,
                    out NodeToGenerate? singletonChild))
                {
                    result.Add((singleton, singletonChild, singletonChildName));
                }
            }
            return result;
        }

        /// <summary>
        /// Registers the <see cref="Tokens.InstanceNodeIdOverride"/>
        /// replacement for the type-level factory currently being emitted.
        /// When the node has well-known singleton instances (e.g. a method
        /// declared under <c>ServerType</c> whose <c>Server</c> singleton
        /// has its own well-known <c>NodeId</c>), the wrapper template
        /// renders a runtime dispatch that rebinds <c>nodeState.NodeId</c> to
        /// the singleton-instance value when <c>forInstance: true</c> is
        /// passed AND <c>parent</c> matches one of the known singleton
        /// instances. The token expands to nothing when no singleton
        /// dispatch is applicable.
        /// </summary>
        private void AddInstanceNodeIdOverrideReplacement(
            IWriteContext context,
            NodeToGenerate node)
        {
            List<(NodeToGenerate Singleton, NodeToGenerate SingletonChild, string SingletonChildSymbolicId)>
                singletonChildren = FindSingletonChildren(node);
            context.Template.AddReplacement(
                Tokens.InstanceNodeIdOverride,
                NodeStateTemplates.InstanceNodeIdOverride,
                singletonChildren.Count > 0
                    ? [singletonChildren]
                    : [],
                WriteTemplate_InstanceNodeIdOverride);
        }

        /// <summary>
        /// Wrapper writer for <see cref="NodeStateTemplates.InstanceNodeIdOverride"/>;
        /// expands the inner <see cref="Tokens.ListOfInstanceNodeIdBranches"/>
        /// token by iterating the collected per-singleton branches.
        /// </summary>
        private bool WriteTemplate_InstanceNodeIdOverride(IWriteContext context)
        {
            if (context.Target is not List<
                (
                    NodeToGenerate Singleton,
                    NodeToGenerate SingletonChild,
                    string SingletonChildSymbolicId)> branches)
            {
                return false;
            }
            context.Template.AddReplacement(
                Tokens.ListOfInstanceNodeIdBranches,
                NodeStateTemplates.InstanceNodeIdBranch,
                [.. branches.Cast<object>()],
                WriteTemplate_InstanceNodeIdBranch);
            return context.Template.Render();
        }

        /// <summary>
        /// Per-branch writer for <see cref="NodeStateTemplates.InstanceNodeIdBranch"/>;
        /// the first branch emits <c>if</c>, subsequent ones <c>else if</c>.
        /// </summary>
        private bool WriteTemplate_InstanceNodeIdBranch(IWriteContext context)
        {
            if (context.Target is not ValueTuple<NodeToGenerate, NodeToGenerate, string> branch)
            {
                return false;
            }
            context.Template.AddReplacement(
                Tokens.IfOrElseIf,
                context.Index == 0 ? "if" : "else if");
            context.Template.AddReplacement(
                Tokens.ParentNodeIdConstant,
                branch.Item1.Design.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            context.Template.AddReplacement(
                Tokens.NodeIdConstant,
                branch.Item2.Design.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable));
            return context.Template.Render();
        }

        private void CollectEncodingNodes()
        {
            foreach (NodeDesign node in m_context.ModelDesign.Nodes)
            {
                if (node is not ObjectDesign encoding)
                {
                    continue;
                }
                if (encoding.TypeDefinition == null ||
                    encoding.TypeDefinition.Name != "DataTypeEncodingType")
                {
                    continue;
                }

                if (encoding.NotInAddressSpace)

                {
                    continue;
                }
                if (m_context.ModelDesign.IsExcluded(encoding))
                {
                    continue;
                }

                // Skip if already collected
                if (m_nodes.ContainsKey(encoding.SymbolicId))
                {
                    continue;
                }

                // Build a synthetic Hierarchy with the encoding's references
                var hierarchy = new Hierarchy();
                if (encoding.References != null)
                {
                    foreach (Reference reference in encoding.References)
                    {
                        if (reference.ReferenceType == null)
                        {
                            continue;
                        }
                        hierarchy.References.Add(new HierarchyReference
                        {
                            SourcePath = string.Empty,
                            ReferenceType = reference.ReferenceType,
                            IsInverse = reference.IsInverse,
                            TargetId = reference.TargetId,
                            TargetPath = null
                        });
                    }
                }

                encoding.Hierarchy = hierarchy;

                var entry = new NodeToGenerate(
                    Parent: null,
                    Path: string.Empty,
                    Hierarchy: hierarchy,
                    Design: encoding,
                    IsNotExplicitlyDefined: false,
                    RootIsTypeDefinition: false,
                    InstanceOf: null);

                m_nodes.TryAdd(encoding.SymbolicId, entry);
            }
        }

        private bool ExcludeNodeStateClassGeneration(NodeToGenerate node)
        {
            // Filter unncessary nodes
            if (!IsInAddressSpace(node))
            {
                if (m_logger.IsEnabled(LogLevel.Debug))
                {
                    m_logger.LogDebug(
                        "Excluded node {Node} as it is marked NotInAddressSpace.",
                        node.Design!.SymbolicId.Name);
                }
                return true;
            }

            // Only process type designs and method types for definitions
            // Also allow DataTypeEncodingType instances (Default Binary/XML/JSON)
            if (node.Design is not VariableTypeDesign and not ObjectTypeDesign &&
                !node.Design.IsMethodTypeDesign() &&
                !IsDataTypeEncodingInstance(node.Design))
            {
                return true;
            }

            if (node.Design!.SymbolicName.Namespace == Namespaces.OpcUa &&
                node.Design.NumericId < 256)
            {
                switch (node.Design.SymbolicName.Name)
                {
                    case "DataTypeDictionaryType":
                    case "DataTypeDescriptionType":
                    case "DataTypeSystemType":
                    case "DataTypeEncodingType":
                    case "ModellingRuleType":
                        break;
                    default:
                        if (m_logger.IsEnabled(LogLevel.Debug))
                        {
                            m_logger.LogDebug(
                                "Skipping built-in node state class generation for {Node}.",
                                node.Design.SymbolicId.Name);
                        }
                        return true;
                }
            }
            return false;
        }

        private static bool IsInAddressSpace(NodeToGenerate node)
        {
            bool isInAddressSpace = !node.Design!.NotInAddressSpace;
            if (node.Design is InstanceDesign instanceDesign &&
                instanceDesign.TypeDefinition != null &&
                instanceDesign.TypeDefinition.Name == "DataTypeEncodingType")
            {
                isInAddressSpace =
                    instanceDesign.Parent == null ||
                    !instanceDesign.Parent.NotInAddressSpace;
            }
            return isInAddressSpace;
        }

        private static bool IsDataTypeEncodingInstance(NodeDesign? node)
        {
            return node is ObjectDesign objectDesign &&
                objectDesign.TypeDefinition != null &&
                objectDesign.TypeDefinition.Name == "DataTypeEncodingType";
        }

        /// <summary>
        /// Checks if the instance is a built in property of a base node state
        /// implementation (variable/method) that should not be generated because
        /// it is already defined on the root nodestate class.
        /// </summary>
        private static bool IsBuiltInProperty(NodeToGenerate node)
        {
            switch (node.Parent?.Design)
            {
                case MethodDesign:
                    if (node.Design!.SymbolicName ==
                        new XmlQualifiedName("InputArguments", Namespaces.OpcUa))
                    {
                        return true;
                    }

                    if (node.Design.SymbolicName ==
                        new XmlQualifiedName("OutputArguments", Namespaces.OpcUa))
                    {
                        return true;
                    }
                    break;
                case VariableDesign:
                case VariableTypeDesign:
                    if (node.Design!.SymbolicName ==
                        new XmlQualifiedName("EnumStrings", Namespaces.OpcUa))
                    {
                        return true;
                    }
                    break;
            }
            return false;
        }

        internal static bool HasFixedChildSlot(TypeDesign? typeDefinitionNode, string symbolicName)
        {
            if (typeDefinitionNode == null)
            {
                return false;
            }
            if (typeDefinitionNode.Children?.Items != null)
            {
                foreach (InstanceDesign child in typeDefinitionNode.Children.Items)
                {
                    if (child.SymbolicName.Name == symbolicName &&
                        child.ModellingRule is ModellingRule.Mandatory or ModellingRule.Optional)
                    {
                        return true;
                    }
                }
            }
            return HasFixedChildSlot(typeDefinitionNode.BaseTypeNode, symbolicName);
        }

        /// <summary>
        /// Returns the effective modelling rule for a <see cref="NodeToGenerate"/>.
        /// When <see cref="GeneratorOptions.UseTypeDefinitionModellingRules"/>
        /// is enabled (opt-in) and the node belongs to an instance hierarchy,
        /// the type definition's modelling rule is used unconditionally.
        /// When the option is off (default), the instance may only
        /// <em>promote</em> the type-definition rule per OPC UA rules:
        /// <list type="bullet">
        ///   <item><c>Optional → Mandatory</c></item>
        ///   <item><c>OptionalPlaceholder → Mandatory | MandatoryPlaceholder</c></item>
        ///   <item><c>MandatoryPlaceholder → Mandatory</c></item>
        /// </list>
        /// Any other instance override (demotion) is ignored and the
        /// type-definition rule is returned instead.
        /// </summary>
        private ModellingRule GetEffectiveModellingRule(
            NodeToGenerate node,
            InstanceDesign instance)
        {
            if (!node.RootIsTypeDefinition &&
                node.TypeDefinitionModellingRule.HasValue)
            {
                ModellingRule typeDefRule = node.TypeDefinitionModellingRule.Value;

                if (m_context.Options.UseTypeDefinitionModellingRules)

                {
                    return typeDefRule;
                }
                // When not opt-in, only allow valid promotions per
                // the OPC UA modelling rule standard.
                if (!IsValidPromotion(typeDefRule, instance.ModellingRule))
                {
                    return typeDefRule;
                }
            }

            return instance.ModellingRule;
        }

        /// <summary>
        /// Returns the effective modelling rule for a hierarchy node.
        /// Overload used in <see cref="GetChildren"/> where the hierarchy
        /// node and root-is-type-definition flag are available directly.
        /// </summary>
        private ModellingRule GetEffectiveModellingRule(
            HierarchyNode hierarchyNode,
            InstanceDesign child,
            bool rootIsTypeDefinition)
        {
            if (!rootIsTypeDefinition &&
                hierarchyNode.TypeDefinitionModellingRule.HasValue)
            {
                ModellingRule typeDefRule =
                    hierarchyNode.TypeDefinitionModellingRule.Value;

                if (m_context.Options.UseTypeDefinitionModellingRules)

                {
                    return typeDefRule;
                }
                // When not opt-in, only allow valid promotions per
                // the OPC UA modelling rule standard.
                if (!IsValidPromotion(typeDefRule, child.ModellingRule))
                {
                    return typeDefRule;
                }
            }

            return child.ModellingRule;
        }

        /// <summary>
        /// Determines whether the instance modelling rule is a valid
        /// promotion of the type-definition modelling rule per OPC UA:
        /// <list type="bullet">
        ///   <item><c>Optional → Mandatory</c></item>
        ///   <item><c>OptionalPlaceholder → Mandatory | MandatoryPlaceholder</c></item>
        ///   <item><c>MandatoryPlaceholder → Mandatory</c></item>
        /// </list>
        /// Returns <c>true</c> when the instance rule is an allowed
        /// promotion (or identical to the type-definition rule), and
        /// <c>false</c> when it is a demotion that should be rejected.
        /// </summary>
        private static bool IsValidPromotion(
            ModellingRule typeDefRule,
            ModellingRule instanceRule)
        {
            if (instanceRule == typeDefRule)
            {
                return true;
            }
            return typeDefRule switch
            {
                ModellingRule.Optional =>
                    instanceRule == ModellingRule.Mandatory,
                ModellingRule.OptionalPlaceholder =>
                    instanceRule is ModellingRule.Mandatory
                        or ModellingRule.MandatoryPlaceholder,
                ModellingRule.MandatoryPlaceholder =>
                    instanceRule == ModellingRule.Mandatory,
                // Mandatory, None, ExposesItsArray, etc. cannot be promoted
                _ => false
            };
        }

        private void GetChildren(
            NodeToGenerate node,
            Dictionary<XmlQualifiedName, NodeToGenerate> children,
            bool forInstance)
        {
            if (!forInstance)
            {
                if (node.Design!.Children?.Items != null)
                {
                    foreach (InstanceDesign child in node.Design.Children.Items)
                    {
                        if (m_context.ModelDesign.IsExcluded(child))
                        {
                            continue;
                        }
                        string childPath = child.SymbolicName.Name;
                        if (!string.IsNullOrEmpty(node.Path))
                        {
                            childPath = CoreUtils.Format(
                                "{0}{1}{2}",
                                node.Path,
                                NodeDesign.PathChar,
                                childPath);
                        }
                        node.Children[child.SymbolicName.Name] = new NodeToGenerate(
                            node,
                            childPath,
                            node.Hierarchy,
                            child,
                            IsNotExplicitlyDefined: false,
                            RootIsTypeDefinition: node.RootIsTypeDefinition,
                            InstanceOf: null);
                    }
                }
            }

            if (node.Hierarchy == null)

            {
                return;
            }
            foreach (HierarchyNode current in node.Hierarchy.NodeList)
            {
                string? childPath = current.RelativePath;

                // only looking for nodes in the current tree.
                if (!childPath!.StartsWith(node.Path!, StringComparison.Ordinal))
                {
                    continue;
                }

                // ignore reference to the current base node.
                if (childPath == node.Path)
                {
                    continue;
                }
                // relative should always end in the name of the current instance.
                if (!childPath.EndsWith(
                    current.Instance!.SymbolicName.Name,
                    StringComparison.Ordinal))
                {
                    continue;
                }

                // get the parent path.
                if (childPath.Length <= current.Instance.SymbolicName.Name.Length)
                {
                    if (!string.IsNullOrEmpty(node.Path))
                    {
                        continue;
                    }
                }
                else
                {
                    int idx = childPath.Length - current.Instance.SymbolicName.Name.Length - 1;
                    string parentPath = current.RelativePath![..idx];

                    if (parentPath != node.Path)

                    {
                        continue;
                    }
                }

                if (!string.IsNullOrEmpty(node.Path))
                {
                    childPath = childPath[(node.Path.Length + 1)..];
                    childPath = CoreUtils.Format(
                        "{0}{1}{2}",
                        node.Path,
                        NodeDesign.PathChar,
                        childPath);
                }

                if (current.Instance is not InstanceDesign child)

                {
                    continue;
                }
                ModellingRule effectiveRule = GetEffectiveModellingRule(
                    current, child, node.RootIsTypeDefinition);

                if (!node.RootIsTypeDefinition &&
                    !current.ExplicitlyDefined &&
                    effectiveRule != ModellingRule.Mandatory &&
                    effectiveRule != ModellingRule.Optional)
                {
                    continue;
                }

                if (!current.ExplicitlyDefined &&
                    effectiveRule != ModellingRule.Mandatory &&
                    effectiveRule != ModellingRule.None &&
                    effectiveRule != ModellingRule.ExposesItsArray &&
                    effectiveRule != ModellingRule.OptionalPlaceholder &&
                    effectiveRule != ModellingRule.MandatoryPlaceholder)
                {
                    continue;
                }

                if (node.RootIsTypeDefinition &&
                    !current.ExplicitlyDefined &&
                    current.Inherited &&
                    current.AdHocInstance &&
                    effectiveRule != ModellingRule.Mandatory)
                {
                    // Required descendants of generic containers such as DI ParameterSet
                    // must also initialize derived instances. Keep this shallow-level
                    // suppression only for non-mandatory inherited ad-hoc declarations.
                    if (!node.Path!.Contains(NodeDesign.PathChar, StringComparison.Ordinal))
                    {
                        continue;
                    }
                }

                bool add = false;
                if (node.Design is DataTypeDesign or ViewDesign or ReferenceTypeDesign)
                {
                    add = true;
                }
                else if (node.RootIsTypeDefinition)
                {
                    if (effectiveRule == ModellingRule.Mandatory)
                    {
                        add = true;
                    }
                    else if (current.ExplicitlyDefined &&
                        effectiveRule == ModellingRule.Optional)
                    {
                        add = true;
                    }
                    else if (current.ExplicitlyDefined &&
                        (effectiveRule is
                            ModellingRule.ExposesItsArray or
                            ModellingRule.OptionalPlaceholder or
                            ModellingRule.MandatoryPlaceholder))
                    {
                        add = true;
                    }
                    else if (current.StaticValue && !current.Inherited)
                    {
                        add = true;
                    }
                    else if (effectiveRule == ModellingRule.None &&
                        current.ExplicitlyDefined)
                    {
                        // Include ModellingRule=None children that are explicitly defined
                        // on this type (e.g., state machine states/transitions, type-level
                        // methods like ConditionRefresh, and type-level properties like
                        // Creatable or SupportsFilteredRetain).
                        add = true;
                    }
                    else if (effectiveRule is not ModellingRule.None)
                    {
                        if (m_logger.IsEnabled(LogLevel.Debug))
                        {
                            m_logger.LogDebug(
                                "Excluding child node {Node} from generation.",
                                current.Instance.SymbolicId.Name);
                        }
                    }
                }
                else if (effectiveRule == ModellingRule.Mandatory)
                {
                    add = true;
                }
                else if (current.ExplicitlyDefined)
                {
                    add = true;
                }
                else if (m_logger.IsEnabled(LogLevel.Information))
                {
                    m_logger.LogInformation(
                        "Excluding child node {Node} from generation.",
                        current.Instance.SymbolicId.Name);
                }

                if (add)
                {
                    XmlQualifiedName symbolicId = current.Instance.SymbolicId;
                    var childNodeToGenerate = new NodeToGenerate(
                        node,
                        childPath,
                        node.Hierarchy,
                        child,
                        IsNotExplicitlyDefined: !current.ExplicitlyDefined,
                        RootIsTypeDefinition: node.RootIsTypeDefinition,
                        InstanceOf: null,
                        TypeDefinitionModellingRule:
                            current.TypeDefinitionModellingRule,
                        IsUnderSingletonInstance: node.IsUnderSingletonInstance);
                    if (!children.TryAdd(symbolicId, childNodeToGenerate) &&
                        m_logger.IsEnabled(LogLevel.Information))
                    {
                        m_logger.LogInformation(
                            "Removing duplicate entry for child {Node}.",
                            symbolicId.Name);
                    }
                    node.AllChildren.Add(childNodeToGenerate);
                    GetChildren(childNodeToGenerate, children, forInstance);
                }
            }
        }

        private HashSet<ReferenceToGenerate> GetReferences(NodeToGenerate node)
        {
            if (node.Hierarchy == null)
            {
                return [];
            }
            Hierarchy hierarchy = node.Hierarchy;
            NodeDesign? root = node.Design;
            // A predefined instance of a NodeSet2 input does not create the
            // nodes it omits, so no reference may end in one of them.
            bool omitsUndeclaredNodes = OmitsUndeclaredHierarchyNodes(node);
            HashSet<ReferenceToGenerate> references = [];
            foreach (HierarchyReference reference in hierarchy.References)
            {
                if (reference.SourcePath != node.Path &&
                    reference.TargetPath != node.Path)
                {
                    continue;
                }

                bool isInverse = reference.IsInverse;

                // The type's GeneratesEvent references describe its instances; an Object or
                // Variable cannot be their source (Part 3 §7.15), so they stay on the type.
                if (!isInverse &&
                    reference.DefinedOnType &&
                    reference.SourcePath == node.Path &&
                    root is ObjectDesign or VariableDesign &&
                    IsGeneratesEventReference(reference.ReferenceType))
                {
                    continue;
                }

                if (reference.TargetId != null)
                {
                    if (!m_context.ModelDesign.TryFindNode(
                        reference.TargetId,
                        root!.SymbolicId.Name,
                        reference.ReferenceType!.Name,
                        out NodeDesign? targetNode))
                    {
                        continue;
                    }

                    references.Add(new ReferenceToGenerate(
                        targetNode,
                        reference.ReferenceType,
                        isInverse));
                    continue;
                }

                if (reference.TargetPath != null &&
                    reference.TargetPath.Length == 0 &&
                    node.Parent?.Design != null)
                {
                    // An empty target path names the root of the hierarchy
                    // (the type or the top-level instance), which is only the
                    // immediate parent for a direct child.
                    NodeToGenerate hierarchyRoot = node.Parent;
                    while (hierarchyRoot.Parent?.Design != null)
                    {
                        hierarchyRoot = hierarchyRoot.Parent;
                    }
                    references.Add(new ReferenceToGenerate(
                        hierarchyRoot.Design!,
                        reference.ReferenceType!,
                        isInverse));
                    continue;
                }
                if (reference.SourcePath == node.Path)
                {
                    if (!hierarchy.Nodes.TryGetValue(
                        reference.TargetPath!,
                        out HierarchyNode? target))
                    {
                        continue;
                    }

                    if (!target.ExplicitlyDefined && node.RootIsTypeDefinition)

                    {
                        continue;
                    }
                    if (omitsUndeclaredNodes &&
                        !IsCreatedInNodeSetAddressSpace(node, reference.TargetPath!))
                    {
                        continue;
                    }
                    references.Add(new ReferenceToGenerate(
                        target.Instance!,
                        reference.ReferenceType!,
                        isInverse));
                    continue;
                }
                if (!hierarchy.Nodes.TryGetValue(reference.SourcePath!, out HierarchyNode? source))
                {
                    continue;
                }
                if (!source.ExplicitlyDefined && node.RootIsTypeDefinition)
                {
                    continue;
                }
                if (omitsUndeclaredNodes &&
                    !IsCreatedInNodeSetAddressSpace(node, reference.SourcePath!))
                {
                    continue;
                }
                references.Add(new ReferenceToGenerate(
                    source.Instance!,
                    reference.ReferenceType!,
                    !isInverse));
            }

            // Apply the instance filter after resolving both identifier and hierarchy-path targets.
            if (!node.RootIsTypeDefinition)
            {
                references.RemoveWhere(reference => reference.TargetNode is InstanceDesign
                {
                    ModellingRule: ModellingRule.MandatoryPlaceholder or ModellingRule.OptionalPlaceholder
                });
            }

            // Inherited and declared designs can differ structurally while
            // resolving to the same runtime reference.
            HashSet<(string ReferenceTypeId, bool IsInverse, string TargetId)> referenceIds = [];
            references.RemoveWhere(reference => !referenceIds.Add((
                m_context.ModelDesign.GetNodeIdConstant(
                    reference.ReferenceTypeId,
                    "<ReferenceType>",
                    kNamespaceTableContextVariable),
                reference.IsInverse,
                reference.TargetNode.GetNodeIdAsCode(
                    m_context.ModelDesign.Namespaces,
                    kNamespaceTableContextVariable))));
            return references;
        }

        /// <summary>
        /// True for GeneratesEvent and its subtypes such as AlwaysGeneratesEvent.
        /// </summary>
        private bool IsGeneratesEventReference(XmlQualifiedName? referenceTypeId)
        {
            var generatesEvent = new XmlQualifiedName("GeneratesEvent", Ua.Types.Namespaces.OpcUa);
            if (referenceTypeId == generatesEvent)
            {
                return true;
            }
            if (referenceTypeId == null ||
                !m_context.ModelDesign.TryFindNode(
                    referenceTypeId,
                    string.Empty,
                    string.Empty,
                    out NodeDesign? design))
            {
                return false;
            }
            for (TypeDesign? type = (design as ReferenceTypeDesign)?.BaseTypeNode;
                type != null;
                type = type.BaseTypeNode)
            {
                if (type.SymbolicId == generatesEvent)
                {
                    return true;
                }
            }
            return false;
        }

        private List<InstanceDesign> GetAdditionalChildren(NodeToGenerate node)
        {
            List<InstanceDesign> additionalChildren = [];
            foreach (NodeToGenerate child in node.Children.Values)
            {
                if (child.Design is not InstanceDesign instance)
                {
                    continue;
                }
                if (child.IsNotExplicitlyDefined)
                {
                    continue;
                }
                if (GetEffectiveModellingRule(child, instance) is
                    not ModellingRule.Mandatory and
                    not ModellingRule.Optional)
                {
                    continue;
                }
                if (instance.IsOverridden() &&
                    !IsMethodOverrideWithDifferentClass(instance))
                {
                    continue;
                }
                additionalChildren.Add(instance);
            }

            return additionalChildren;
        }

        /// <summary>
        /// Returns whether a method overrides the supertype's method with
        /// another method state class. The subtype then declares a field and a
        /// property of its own that hide the supertype's, so it also has to
        /// enumerate and remove the child itself: the supertype's field stays
        /// empty.
        /// </summary>
        private bool IsMethodOverrideWithDifferentClass(InstanceDesign instance)
        {
            return instance is MethodDesign &&
                instance.IsOverridden() &&
                !instance.IsOverriddenWithSameClass(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces);
        }

        private List<InstanceDesign> GetChildrenWithProperties(
            NodeToGenerate node,
            bool excludeBuiltIn = false)
        {
            List<InstanceDesign> childrenWithProperties = [];
            foreach (NodeToGenerate child in node.Children.Values)
            {
                if (child.Design is not InstanceDesign instance)
                {
                    continue;
                }
                if (child.IsNotExplicitlyDefined)
                {
                    continue;
                }
                if (GetEffectiveModellingRule(child, instance) is
                    not ModellingRule.Mandatory and
                    not ModellingRule.Optional)
                {
                    continue;
                }
                if (instance.IsOverriddenWithSameClass(
                    m_context.ModelDesign.TargetNamespace.Value,
                    m_context.ModelDesign.Namespaces))
                {
                    continue;
                }
                if (excludeBuiltIn && IsBuiltInProperty(child))
                {
                    continue;
                }
                childrenWithProperties.Add(instance);
            }

            return childrenWithProperties;
        }

        private HashSet<RolePermission> GetRolePermissions(NodeDesign node)
        {
            var rolePermissions = new HashSet<RolePermission>();
            // Emit RolePermissions on all nodes (type and instance).
            // Type hierarchy nodes carry permissions as metadata but the server
            // bypasses enforcement via IsPartOfTypeHierarchy at runtime.
            RolePermission[]? nodeRolePermissions =
                (node.RolePermissions?.RolePermission) ?? (node.DefaultRolePermissions?.RolePermission);
            if (nodeRolePermissions != null)
            {
                foreach (RolePermission rp in nodeRolePermissions)
                {
                    ObjectDesign? roleNode = m_context.ModelDesign.FindNode<ObjectDesign>(
                        rp.Role,
                        rp.Role.Name,
                        "RoleType");

                    if (roleNode != null)

                    {
                        rolePermissions.Add(rp);
                    }
                }
            }
            return rolePermissions;
        }

        private static string? GetDisplayNameValue(NodeDesign node)
        {
            if (node.DisplayName != null)
            {
                return CoreUtils.Format(
                    "{0}, string.Empty, {1}",
                    node.DisplayName.Key.AsStringLiteral(),
                    (node.DisplayName.Value?.Trim()).AsStringLiteral());
            }
            return null;
        }

        private static string? GetDescriptionValue(NodeDesign node)
        {
            if (node.Description != null && !node.Description.IsAutogenerated)
            {
                // The generated templates assign through a nodeState local that
                // is statically typed as NodeState, so models with a child
                // Property named "Description" cannot shadow this assignment.
                return CoreUtils.Format(
                    "nodeState.Description = {0};",
                    node.Description.GetLocalizedTextAsCode());
            }
            return null;
        }

        private static string? GetInverseNameValue(ReferenceTypeDesign node)
        {
            if (!node.Symmetric && node.InverseName != null)
            {
                return CoreUtils.Format(
                    "state.InverseName = {0};",
                    node.InverseName.GetLocalizedTextAsCode());
            }
            if (node.Symmetric)
            {
                return "state.InverseName = global::Opc.Ua.LocalizedText.Null;";
            }
            return null;
        }

        private static string? GetModellingRuleReplacement(ModellingRule modellingRule)
        {
            string? constant = modellingRule switch
            {
                ModellingRule.Mandatory => "global::Opc.Ua.Objects.ModellingRule_Mandatory",
                ModellingRule.Optional => "global::Opc.Ua.Objects.ModellingRule_Optional",
                ModellingRule.MandatoryPlaceholder => "global::Opc.Ua.Objects.ModellingRule_MandatoryPlaceholder",
                ModellingRule.OptionalPlaceholder => "global::Opc.Ua.Objects.ModellingRule_OptionalPlaceholder",
                ModellingRule.ExposesItsArray => "global::Opc.Ua.Objects.ModellingRule_ExposesItsArray",
                _ => null
            };

            return constant != null
                ? CoreUtils.Format("baseState.ModellingRuleId = new global::Opc.Ua.NodeId({0});", constant)
                : null;
        }

        private string GetNodeIdConstantForDataType(
            VariableTypeDesign type,
            Namespace[] namespaceUris)
        {
            if (!m_context.ModelDesign.UseAllowSubtypes)
            {
                DataTypeDesign? dataType = m_context.ModelDesign.FindNode<DataTypeDesign>(
                    type.DataType,
                    type.SymbolicId.Name,
                    "DataType");
                return dataType.GetNodeIdAsCode(namespaceUris, kNamespaceTableContextVariable);
            }
            return type.DataTypeNode.GetNodeIdAsCode(namespaceUris, kNamespaceTableContextVariable);
        }

        private string GetNodeIdConstantForDataType(
            VariableDesign instance,
            Namespace[] namespaceUris)
        {
            if (!m_context.ModelDesign.UseAllowSubtypes)
            {
                DataTypeDesign? dataType = m_context.ModelDesign.FindNode<DataTypeDesign>(
                    instance.DataType,
                    instance.SymbolicId.Name,
                    "DataType");
                return dataType.GetNodeIdAsCode(namespaceUris, kNamespaceTableContextVariable);
            }
            return instance.DataTypeNode.GetNodeIdAsCode(namespaceUris, kNamespaceTableContextVariable);
        }

        private string GetTemplateParameter(TypeDesign type, out string variantBuilder)
        {
            variantBuilder = "global::Opc.Ua.VariantBuilder";
            if (type is not VariableTypeDesign variableType)
            {
                return string.Empty;
            }
            if (type.BaseTypeNode == null)

            {
                return "<T>";
            }
            if (GetTemplateParameter(type.BaseTypeNode, out variantBuilder) != "<T>")
            {
                return string.Empty;
            }

            BasicDataType basicType = variableType.DataTypeNode!.BasicDataType;

            if (basicType == BasicDataType.BaseDataType) // == Variant, so any
            {
                return "<T>";
            }

            string scalarName;
            switch (basicType)
            {
                case BasicDataType.UserDefined:
                    scalarName = variableType.DataTypeNode.GetClassName(
                        m_context.ModelDesign.Namespaces);
                    variantBuilder = variableType.DataTypeNode.GetVariantBuilder(scalarName);
                    break;
                default:
                    scalarName = variableType.DataTypeNode.GetDotNetTypeName(
                        m_context.ModelDesign.TargetNamespace.Value,
                        m_context.ModelDesign.Namespaces,
                        nullable: NullableAnnotation.NonNullable,
                        true);
                    variantBuilder = variableType.DataTypeNode.GetVariantBuilder(scalarName);
                    break;
            }

            if (variableType.ValueRank == ValueRank.Scalar)
            {
                return $"<{scalarName}>";
            }
            if (variableType.ValueRank == ValueRank.Array)
            {
                return $"<global::Opc.Ua.ArrayOf<{scalarName}>>";
            }
            if (variableType.ValueRank == ValueRank.OneOrMoreDimensions &&
                variableType.DataTypeNode.SupportsMatrixOf())
            {
                return $"<global::Opc.Ua.MatrixOf<{scalarName}>>";
            }
            variantBuilder = "global::Opc.Ua.VariantBuilder";
            return "<global::Opc.Ua.Variant>";
        }

        private static void CollectMatchingFields(
            VariableTypeDesign variableType,
            Dictionary<string, Parameter> fields)
        {
            CollectFields(
                variableType.DataTypeNode!,
                variableType.ValueRank,
                string.Empty,
                fields);

            List<string> availablePaths = [.. fields.Keys];

            for (int ii = 0; ii < availablePaths.Count; ii++)
            {
                if (!variableType.Hierarchy.Nodes.ContainsKey(availablePaths[ii]))
                {
                    fields.Remove(availablePaths[ii]);
                }
            }
        }

        private static void CollectFields(
            DataTypeDesign dataType,
            ValueRank valueRank,
            string basePath,
            Dictionary<string, Parameter> fields)
        {
            if (dataType.BasicDataType != BasicDataType.UserDefined ||
                valueRank != ValueRank.Scalar)
            {
                return;
            }

            for (DataTypeDesign? parent = dataType;
                parent != null;
                parent = parent.BaseTypeNode as DataTypeDesign)
            {
                if (parent.Fields != null)
                {
                    for (int ii = 0; ii < parent.Fields.Length; ii++)
                    {
                        Parameter parameter = parent.Fields[ii];
                        string fieldPath = parameter.Name;

                        if (!string.IsNullOrEmpty(basePath))
                        {
                            fieldPath = CoreUtils.Format("{0}_{1}", basePath, parameter.Name);
                        }

                        fields[fieldPath] = parameter;
                    }
                }
            }
        }

        private string? AddXmlInitializerForComplexValue(
            NodeDesign node,
            DataTypeDesign dataType,
            System.Xml.XmlElement element)
        {
            string? xml = element?.OuterXml;
            if (string.IsNullOrEmpty(xml))
            {
                return null;
            }
            string resourceName = CoreUtils.Format("Values.{0}", node.SymbolicId.Name);
            string uniqueName = resourceName;
            for (int i = 0; i < 1000; i++)
            {
                if (m_initializers.TryAdd(uniqueName, new TextResource(uniqueName, xml)))
                {
                    // Get code to create the variant from the XML resource reference
                    return CoreUtils.Format(
                        "global::Opc.Ua.Variant.FromXml({0}AsStream, context)",
                        uniqueName);
                }
                uniqueName = resourceName + i;
            }
            throw new InvalidOperationException("Unexpected duplicate resource names");
        }

        private static void AddVariantAccessor(IWriteContext context, DataTypeDesign dataType)
        {
            switch (dataType.BasicDataType)
            {
                case BasicDataType.UserDefined when !dataType.IsEnumeration:
                    context.Template.AddReplacement(Tokens.VariantFrom, "FromStructure");
                    context.Template.AddReplacement(Tokens.VariantTryGet, "TryGetStructure");
                    break;
                default:
                    context.Template.AddReplacement(Tokens.VariantFrom, "From");
                    context.Template.AddReplacement(Tokens.VariantTryGet, "TryGetValue");
                    break;
            }
        }

        /// <summary>
        /// Embed all initializers as source code
        /// </summary>
        private Resource? EmbedInitializers()
        {
            if (m_initializers.Count == 0)
            {
                return null;
            }
            var initializers = new ResourceGenerator(m_context);
            return initializers.Embed(
                m_context.ModelDesign.TargetNamespace.Prefix,
                "NodeStates.i",
                internalAccess: true,
                [.. m_initializers.Values]);
        }

        /// <summary>
        /// Node state generation template
        /// </summary>
        private record class NodeToGenerate(
            NodeToGenerate? Parent = null,
            string? Path = null,
            Hierarchy? Hierarchy = null,
            NodeDesign? Design = null,
            bool IsNotExplicitlyDefined = false,
            bool RootIsTypeDefinition = false,
            NodeToGenerate? InstanceOf = null,
            ModellingRule? TypeDefinitionModellingRule = null,
            bool IsUnderSingletonInstance = false)
        {
            /// <summary>
            /// Full inherited list of children
            /// </summary>
            public List<NodeToGenerate> AllChildren { get; } = [];

            /// <summary>
            /// Direclty defined
            /// </summary>
            public Dictionary<string, NodeToGenerate> Children { get; } = [];

            public NodeToGenerate? Instance { get; set; }

            /// <inheritdoc/>
            public override string ToString()
            {
                return CoreUtils.Format("{0} (Parent: {1})", Design, Parent);
            }
        }

        private record class ReferenceToGenerate(
            NodeDesign TargetNode,
            XmlQualifiedName ReferenceTypeId,
            bool IsInverse);

        /// <summary>
        /// True when the argument's code type is the data type itself (scalar,
        /// ArrayOf or MatrixOf). Every other value rank (ScalarOrArray,
        /// ScalarOrOneDimension, Any) is carried as a plain Variant, see
        /// ModelDesignExtensions.GetMethodArgumentTypeAsCode.
        /// </summary>
        private static bool HasTypedArgumentValueRank(Parameter parameter)
        {
            return parameter.ValueRank is
                ValueRank.Scalar or
                ValueRank.Array or
                ValueRank.OneOrMoreDimensions;
        }

        private static string GetMethodArgumentIdentifier(
            Parameter parameter,
            bool upperCamelCase = false)
        {
            return parameter.GetGeneratedCodeIdentifier(
                upperCamelCase,
                s_methodArgumentCodeNameScope);
        }

        private void AssignMethodArgumentCodeNames(
            MethodDesign method,
            Parameter[] inputArguments,
            Parameter[] outputArguments)
        {
            string declaredClassName = method.GetNodeStateClassName(
                m_context.ModelDesign.TargetNamespace.Value,
                [],
                applyStandardFallback: false);
            ModelDesignExtensions.AssignMethodArgumentCodeNames(
                inputArguments,
                outputArguments,
                s_methodArgumentCodeNameScope,
                declaredClassName + "Result");
        }

        private sealed record MethodArgumentsToGenerate(
            string PropertyName,
            string BrowseName,
            Parameter[] Arguments);

        private sealed record ImportFactoryRegistration(
            string NodeClass,
            string Discriminator,
            string DiscriminatorId,
            string CreateExpression);

        private const string kNamespaceTableContextVariable = "context.NamespaceUris";

        private static readonly XmlQualifiedName s_inputArgumentsBrowseName = new(
            "InputArguments",
            Namespaces.OpcUa);

        private static readonly XmlQualifiedName s_outputArgumentsBrowseName = new(
            "OutputArguments",
            Namespaces.OpcUa);

        private static readonly MethodArgumentCodeNameScope s_methodArgumentCodeNameScope = new(
            "_",
            "await",
            "ct",
            "cancellationToken",
            "context",
            "_context",
            "inputArguments",
            "_inputArguments",
            "method",
            "_method",
            "objectId",
            "_objectId",
            "onCall",
            "onCallAsync",
            "outputArguments",
            "_outputArguments",
            "_result",
            "results",
            "serviceResult",
            "ServiceResult");

        private static readonly string[] s_builtInPropertyNames =
        [
            "Description",
            "Save",
            "Handle",
            "Specification",
            "Update",
            "Delete",
            // Children whose generated accessor property shadows the
            // identically-named global::Opc.Ua.NodeState.Extensions property,
            // which carries the NodeSet2 <Extensions> elements rather than an
            // address-space member, and therefore must be declared "public new".
            "Extensions",
            // Method children whose generated accessor property shadows the
            // identically-named global::Opc.Ua.NodeState.Validate(ISystemContext)
            // instance method and therefore must be declared "public new".
            "Validate"
        ];

        /// <summary>
        /// True when a child property named <paramref name="name"/> on the
        /// generated class of <paramref name="parent"/> hides an inherited
        /// member of the runtime base class and must be declared
        /// <c>public new</c>.
        /// </summary>
        internal static bool RequiresNewModifier(NodeDesign parent, string name)
        {
            return s_builtInPropertyNames.Contains(name) ||
                HidesRuntimeBaseMember(parent, name);
        }

        /// <summary>
        /// True when a child property named <paramref name="name"/> on the
        /// generated class of <paramref name="parent"/> hides a member it
        /// inherits from the runtime base class (for example a child Property
        /// named <c>DataType</c> on a VariableType class hides
        /// <c>BaseVariableState.DataType</c>, one named <c>Categories</c>
        /// hides <c>NodeState.Categories</c>), so it must be declared
        /// <c>public new</c>.
        /// </summary>
        private static bool HidesRuntimeBaseMember(NodeDesign parent, string name)
        {
            return parent switch
            {
                ObjectTypeDesign or ObjectDesign => s_objectStateMemberNames.Value.Contains(name),
                VariableTypeDesign or VariableDesign => s_variableStateMemberNames.Value.Contains(name),
                MethodDesign => s_methodStateMemberNames.Value.Contains(name),
                _ => false
            };
        }

        /// <summary>
        /// Returns the names of the members of <paramref name="type"/> and its
        /// base classes that a derived class sees (public and protected), i.e.
        /// the names a generated child property hides. Read from the runtime
        /// types themselves so a member added to them is never missed.
        /// </summary>
        private static HashSet<string> GetInheritedMemberNames(Type type)
        {
            const BindingFlags kFlags = BindingFlags.Public | BindingFlags.NonPublic |
                BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
            var names = new HashSet<string>(StringComparer.Ordinal);
            for (Type? current = type; current != null; current = current.BaseType)
            {
                foreach (MemberInfo member in current.GetMembers(kFlags))
                {
                    bool visible = member switch
                    {
                        ConstructorInfo => false,
                        MethodInfo method => !method.IsSpecialName && IsVisibleToDerived(method),
                        PropertyInfo property => property.GetIndexParameters().Length == 0 &&
                            (IsVisibleToDerived(property.GetGetMethod(true)) ||
                                IsVisibleToDerived(property.GetSetMethod(true))),
                        EventInfo @event => IsVisibleToDerived(@event.GetAddMethod(true)),
                        FieldInfo field => !field.IsSpecialName &&
                            (field.IsPublic || field.IsFamily || field.IsFamilyOrAssembly),
                        Type nested => nested.IsNestedPublic || nested.IsNestedFamily ||
                            nested.IsNestedFamORAssem,
                        _ => false
                    };
                    if (visible)
                    {
                        names.Add(member.Name);
                    }
                }
            }
            return names;
        }

        private static bool IsVisibleToDerived(MethodBase? method)
        {
            return method != null &&
                (method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly);
        }

        /// <summary>
        /// Members inherited by generated Object and ObjectType classes.
        /// </summary>
        private static readonly Lazy<HashSet<string>> s_objectStateMemberNames =
            new(() => GetInheritedMemberNames(typeof(BaseObjectState)));

        /// <summary>
        /// Members inherited by generated Variable and VariableType classes
        /// ("Value" is handled separately).
        /// </summary>
        private static readonly Lazy<HashSet<string>> s_variableStateMemberNames =
            new(() => GetInheritedMemberNames(typeof(BaseVariableState)));

        /// <summary>
        /// Members inherited by generated Method classes.
        /// </summary>
        private static readonly Lazy<HashSet<string>> s_methodStateMemberNames =
            new(() => GetInheritedMemberNames(typeof(MethodState)));

        private static readonly string[] s_builtInMethodNames =
        [
            "Child"
        ];

        private readonly Dictionary<string, Resource> m_initializers = [];
        private readonly Dictionary<XmlQualifiedName, NodeToGenerate> m_nodes = [];
        private readonly Dictionary<XmlQualifiedName, NodeToGenerate> m_instances = [];
        private readonly Dictionary<XmlQualifiedName, List<NodeToGenerate>> m_singletonsByType = [];
        private readonly ILogger m_logger;
        private readonly IServiceMessageContext m_messageContext;
        private readonly IGeneratorContext m_context;
    }
}