Use provider C# reference map with pre-write internalization

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs

@@ -43,6 +43,7 @@ private record ApiVersionFields(FieldProvider Field, PropertyProvider? Correspon
         private const string ClientSuffix = "Client";
         private readonly FormattableString _publicCtorDescription;
         private readonly InputClient _inputClient;
+        protected override bool IsReferenceMapRoot => true;
         internal InputClient InputClient => _inputClient;
         private readonly InputAuth? _inputAuth;
         private readonly ParameterProvider _endpointParameter;
@@ -426,6 +427,82 @@ private IReadOnlyList<ParameterProvider> GetClientParameters()
 
         protected override string BuildName() => _inputClient.IsExactName ? _inputClient.Name : _inputClient.Name.ToIdentifierName();
 
+        protected override IReadOnlyList<CSharpType> BuildHelperDependencyTypes()
+        {
+            foreach (var method in Methods.OfType<ScmMethodProvider>())
+            {
+                if (!method.IsMethodSuppressed() && method.BodyStatements != null)
+                {
+                    return [new CancellationTokenExtensionsDefinition().Type, new ClientPipelineExtensionsDefinition().Type];
+                }
+            }
+
+            return [];
+        }
+
+        protected override IReadOnlyList<CSharpType> BuildBodyDependencyTypes()
+        {
+            var dependencies = new List<CSharpType>();
+            foreach (var method in Methods.OfType<ScmMethodProvider>())
+            {
+                if (method.BodyStatements == null)
+                {
+                    continue;
+                }
+
+                if (method.CollectionDefinition != null)
+                {
+                    dependencies.Add(method.CollectionDefinition.Type);
+                }
+
+                if (method.ServiceMethod == null)
+                {
+                    continue;
+                }
+
+                AddInputTypeDependency(dependencies, method.ServiceMethod.Response.Type);
+                AddInputTypeDependency(dependencies, method.ServiceMethod.Exception?.Type);
+                foreach (var parameter in method.ServiceMethod.Parameters)
+                {
+                    if (IsContentTypeParameter(parameter))
+                    {
+                        continue;
+                    }
+
+                    AddInputTypeDependency(dependencies, parameter.Type);
+                }
+
+                foreach (var parameter in method.ServiceMethod.Operation.Parameters)
+                {
+                    if (IsContentTypeParameter(parameter))
+                    {
+                        continue;
+                    }
+
+                    AddInputTypeDependency(dependencies, parameter.Type);
+                }
+
+                // Operation responses are input metadata. The generated method signature and body
+                // dependencies above capture the response types that are actually used.
+            }
+
+            return dependencies;
+        }
+
+        private static bool IsContentTypeParameter(InputParameter parameter) =>
+            parameter is InputHeaderParameter { IsContentType: true } ||
+                parameter is InputMethodParameter { Location: InputRequestLocation.Header } &&
+                string.Equals(parameter.SerializedName, "Content-Type", StringComparison.OrdinalIgnoreCase);
+
+        private static void AddInputTypeDependency(List<CSharpType> dependencies, InputType? inputType)
+        {
+            var type = inputType == null ? null : ScmCodeModelGenerator.Instance.TypeFactory.CreateCSharpType(inputType);
+            if (type != null)
+            {
+                dependencies.Add(type);
+            }
+        }
+
         protected override FieldProvider[] BuildFields()
         {
             List<FieldProvider> fields = [EndpointField];

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientUriBuilderDefinition.cs

@@ -28,6 +28,7 @@ internal sealed class ClientUriBuilderDefinition : TypeProvider
         private readonly FieldProvider _uriBuilderField;
         private readonly FieldProvider _pathAndQueryField;
         private readonly FieldProvider _pathLengthField;
+        protected override bool IncludeGeneratedBodyReferences => true;
 
         private PropertyProvider? _uriBuilderProperty;
         private PropertyProvider UriBuilderProperty => _uriBuilderProperty ??= new(

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/CollectionResultDefinition.cs

@@ -217,6 +217,22 @@ private bool HasPagingOperationNameCollision(string operationName)
         protected override TypeSignatureModifiers BuildDeclarationModifiers()
             => TypeSignatureModifiers.Internal | TypeSignatureModifiers.Partial | TypeSignatureModifiers.Class;
 
+        protected override IReadOnlyList<CSharpType> BuildBodyDependencyTypes()
+        {
+            var dependencies = new List<CSharpType> { Client.Type, ResponseModelType, NextPagePropertyType, new ClientPipelineExtensionsDefinition().Type };
+            if (ItemModelType != null)
+            {
+                dependencies.Add(ItemModelType);
+            }
+
+            foreach (var field in RequestFields)
+            {
+                dependencies.Add(field.Type);
+            }
+
+            return dependencies;
+        }
+
         protected override FieldProvider[] BuildFields() => [ClientField, .. RequestFields];
 
         protected override CSharpType[] BuildImplements() =>

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/MrwSerializationTypeDefinition.Xml.cs

@@ -67,7 +67,7 @@ private MethodProvider BuildXmlModelWriteCoreMethod()
             MethodSignatureModifiers modifiers = _isStruct
                 ? MethodSignatureModifiers.Private
                 : MethodSignatureModifiers.Internal | MethodSignatureModifiers.Virtual;
-            if (_shouldOverrideXmlMethods)
+            if (_shouldOverrideMethods)
             {
                 modifiers = MethodSignatureModifiers.Internal | MethodSignatureModifiers.Override;
             }
@@ -81,7 +81,7 @@ private MethodProvider BuildXmlModelWriteCoreMethod()
 
         private MethodBodyStatement[] BuildXmlModelWriteCoreMethodBody()
         {
-            var categorizedProperties = _shouldOverrideXmlMethods
+            var categorizedProperties = _shouldOverrideMethods
                 ? CategorizedXmlProperties
                 : AllCategorizedXmlProperties;
             var statements = new List<MethodBodyStatement>
@@ -90,7 +90,7 @@ private MethodBodyStatement[] BuildXmlModelWriteCoreMethodBody()
                 MethodBodyStatement.EmptyLine
             };
 
-            if (_shouldOverrideXmlMethods)
+            if (_shouldOverrideMethods)
             {
                 statements.Add(Base.Invoke(XmlModelWriteCoreMethodName, _xmlWriterParameter, _serializationOptionsParameter).Terminate());
             }