@azure-typespec/http-client-csharp-mgmt 1.0.0-alpha.20250409.15

package/dist/generator/Azure.Generator.xml

@@ -0,0 +1,163 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Azure.Generator</name>
+    </assembly>
+    <members>
+        <member name="T:Azure.Generator.AzureClientGenerator">
+            <summary>
+            The Azure client generator to generate the Azure client SDK.
+            </summary>
+        </member>
+        <member name="P:Azure.Generator.AzureClientGenerator.TypeFactory">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureClientGenerator.OutputLibrary">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.AzureClientGenerator.#ctor(Microsoft.TypeSpec.Generator.GeneratorContext)">
+            <summary>
+            Constructs the Azure client generator used to generate the Azure client SDK.
+            </summary>
+            <param name="context"></param>
+        </member>
+        <member name="M:Azure.Generator.AzureClientGenerator.Configure">
+            <summary>
+            Customize the generation output for Azure client SDK.
+            </summary>
+        </member>
+        <member name="T:Azure.Generator.AzureOutputLibrary">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.AzureOutputLibrary.BuildTypeProviders">
+            <inheritdoc/>
+        </member>
+        <member name="T:Azure.Generator.AzureTypeFactory">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.ClientResponseApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.HttpResponseApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.ClientPipelineApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.HttpMessageApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.HttpRequestApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.StatusCodeClassifierApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.RequestContentApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.HttpRequestOptionsApi">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.AzureTypeFactory.AzureDependencyPackages">
+            <summary>
+            Get dependency packages for Azure.
+            </summary>
+        </member>
+        <member name="M:Azure.Generator.AzureTypeFactory.CreateCSharpTypeCore(Microsoft.TypeSpec.Generator.Input.InputType)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.AzureTypeFactory.DeserializeJsonValue(System.Type,Microsoft.TypeSpec.Generator.Snippets.ScopedApi{System.Text.Json.JsonElement},Microsoft.TypeSpec.Generator.Input.SerializationFormat)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.AzureTypeFactory.SerializeJsonValue(System.Type,Microsoft.TypeSpec.Generator.Expressions.ValueExpression,Microsoft.TypeSpec.Generator.Snippets.ScopedApi{System.Text.Json.Utf8JsonWriter},Microsoft.TypeSpec.Generator.Snippets.ScopedApi{System.ClientModel.Primitives.ModelReaderWriterOptions},Microsoft.TypeSpec.Generator.Input.SerializationFormat)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.AzureTypeFactory.CreateNewProjectScaffolding">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Management.Models.RequestPath.IsAncestorOf(Azure.Generator.Management.Models.RequestPath)">
+            <summary>
+            Check if this <see cref="T:Azure.Generator.Management.Models.RequestPath"/> is a prefix path of the other request path.
+            Note that this.IsAncestorOf(this) will return false which indicates that this method is testing the "proper ancestor" like a proper subset.
+            </summary>
+            <param name="other"></param>
+            <returns></returns>
+        </member>
+        <member name="M:Azure.Generator.Management.Models.RequestPath.TrimAncestorFrom(Azure.Generator.Management.Models.RequestPath)">
+            <summary>
+            Trim this from the other and return the <see cref="T:Azure.Generator.Management.Models.RequestPath"/>that remain.
+            The result is "other - this" by removing this as a prefix of other.
+            If this == other, return empty request path
+            </summary>
+            <param name="other"></param>
+            <returns></returns>
+            <exception cref="T:System.InvalidOperationException">if this.IsAncestorOf(other) is false</exception>
+        </member>
+        <member name="T:Azure.Generator.Primitives.NewAzureProjectScaffolding">
+            <summary>
+            Defines the new project scaffolding needed for an azure sdk.
+            </summary>
+        </member>
+        <member name="M:Azure.Generator.Primitives.NewAzureProjectScaffolding.GetSourceProjectFileContent">
+            <inheritdoc/>
+        </member>
+        <member name="T:Azure.Generator.Providers.Abstraction.HttpPipelineProvider">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.#ctor(Microsoft.TypeSpec.Generator.Expressions.ValueExpression)">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.ClientPipelineType">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.ClientPipelineOptionsType">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.PipelinePolicyType">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.KeyCredentialType">
+            <inheritdoc/>
+        </member>
+        <member name="P:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.TokenCredentialType">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.Create(Microsoft.TypeSpec.Generator.Expressions.ValueExpression,Microsoft.TypeSpec.Generator.Expressions.ValueExpression)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.CreateMessage(Microsoft.TypeSpec.Generator.ClientModel.Providers.HttpRequestOptionsApi,Microsoft.TypeSpec.Generator.Expressions.ValueExpression)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.FromExpression(Microsoft.TypeSpec.Generator.Expressions.ValueExpression)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.KeyAuthorizationPolicy(Microsoft.TypeSpec.Generator.Expressions.ValueExpression,Microsoft.TypeSpec.Generator.Expressions.ValueExpression,Microsoft.TypeSpec.Generator.Expressions.ValueExpression)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.TokenAuthorizationPolicy(Microsoft.TypeSpec.Generator.Expressions.ValueExpression,Microsoft.TypeSpec.Generator.Expressions.ValueExpression)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.ToExpression">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.ProcessMessage(Microsoft.TypeSpec.Generator.ClientModel.Providers.HttpMessageApi,Microsoft.TypeSpec.Generator.ClientModel.Providers.HttpRequestOptionsApi)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Generator.Providers.Abstraction.HttpPipelineProvider.ProcessMessageAsync(Microsoft.TypeSpec.Generator.ClientModel.Providers.HttpMessageApi,Microsoft.TypeSpec.Generator.ClientModel.Providers.HttpRequestOptionsApi)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Azure.Core.AzureKeyCredentialPolicy.#ctor(Azure.AzureKeyCredential,System.String,System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:Azure.Core.AzureKeyCredentialPolicy"/> class.
+            </summary>
+            <param name="credential">The <see cref="T:Azure.AzureKeyCredential"/> used to authenticate requests.</param>
+            <param name="name">The name of the key header used for the credential.</param>
+            <param name="prefix">The prefix to apply before the credential key. For example, a prefix of "SharedAccessKey" would result in
+            a value of "SharedAccessKey {credential.Key}" being stamped on the request header with header key of <paramref name="name"/>.</param>
+        </member>
+        <member name="M:Azure.Core.AzureKeyCredentialPolicy.OnSendingRequest(Azure.Core.HttpMessage)">
+            <inheritdoc/>
+        </member>
+    </members>
+</doc>

package/dist/generator/Microsoft.TypeSpec.Generator.runtimeconfig.json

@@ -0,0 +1,12 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "8.0.0"
+    },
+    "configProperties": {
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

package/dist/generator/Shared/Core/AppContextSwitchHelper.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+
+#nullable enable
+
+namespace Azure.Core
+{
+    /// <summary>
+    /// Helper for interacting with AppConfig settings and their related Environment variable settings.
+    /// </summary>
+    internal static class AppContextSwitchHelper
+    {
+        /// <summary>
+        /// Determines if either an AppContext switch or its corresponding Environment Variable is set
+        /// </summary>
+        /// <param name="appContexSwitchName">Name of the AppContext switch.</param>
+        /// <param name="environmentVariableName">Name of the Environment variable.</param>
+        /// <returns>If the AppContext switch has been set, returns the value of the switch.
+        /// If the AppContext switch has not been set, returns the value of the environment variable.
+        /// False if neither is set.
+        /// </returns>
+        public static bool GetConfigValue(string appContexSwitchName, string environmentVariableName)
+        {
+            // First check for the AppContext switch, giving it priority over the environment variable.
+            if (AppContext.TryGetSwitch(appContexSwitchName, out bool value))
+            {
+                return value;
+            }
+            // AppContext switch wasn't used. Check the environment variable.
+            string? envVar = Environment.GetEnvironmentVariable(environmentVariableName);
+            if (envVar != null && (envVar.Equals("true", StringComparison.OrdinalIgnoreCase) || envVar.Equals("1")))
+            {
+                return true;
+            }
+
+            // Default to false.
+            return false;
+        }
+    }
+}

package/dist/generator/Shared/Core/AsyncLockWithValue.cs

@@ -0,0 +1,260 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure.Core.Pipeline;
+
+namespace Azure.Core
+{
+    /// <summary>
+    /// Primitive that combines async lock and value cache
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal sealed class AsyncLockWithValue<T>
+    {
+        private readonly object _syncObj = new();
+        private Queue<TaskCompletionSource<LockOrValue>>? _waiters;
+        private bool _isLocked;
+        private bool _hasValue;
+        private long _index;
+        private T? _value;
+
+        public bool HasValue
+        {
+            get
+            {
+                lock (_syncObj)
+                {
+                    return _hasValue;
+                }
+            }
+        }
+
+        public AsyncLockWithValue() { }
+
+        public AsyncLockWithValue(T value)
+        {
+            _hasValue = true;
+            _value = value;
+        }
+
+        public bool TryGetValue(out T? value)
+        {
+            lock (_syncObj)
+            {
+                if (_hasValue)
+                {
+                    value = _value;
+                    return true;
+                }
+            }
+
+            value = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Method that either returns cached value or acquire a lock.
+        /// If one caller has acquired a lock, other callers will be waiting for the lock to be released.
+        /// If value is set, lock is released and all waiters get that value.
+        /// If value isn't set, the next waiter in the queue will get the lock.
+        /// </summary>
+        /// <param name="async"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async ValueTask<LockOrValue> GetLockOrValueAsync(bool async, CancellationToken cancellationToken = default)
+        {
+            TaskCompletionSource<LockOrValue> valueTcs;
+            lock (_syncObj)
+            {
+                // If there is a value, just return it
+                if (_hasValue)
+                {
+                    return new LockOrValue(_value!);
+                }
+
+                // If lock isn't acquire yet, acquire it and return to the caller
+                if (!_isLocked)
+                {
+                    _isLocked = true;
+                    _index = unchecked(_index + 1);
+                    return new LockOrValue(this, _index);
+                }
+
+                // Check cancellationToken before instantiating waiter
+                cancellationToken.ThrowIfCancellationRequested();
+
+                // If lock is already taken, create a waiter and wait either until value is set or lock can be acquired by this waiter
+                _waiters ??= new Queue<TaskCompletionSource<LockOrValue>>();
+                // if async == false, valueTcs will be waited only in this thread and only synchronously, so RunContinuationsAsynchronously isn't needed.
+                valueTcs = new TaskCompletionSource<LockOrValue>(async ? TaskCreationOptions.RunContinuationsAsynchronously : TaskCreationOptions.None);
+                _waiters.Enqueue(valueTcs);
+            }
+
+            try
+            {
+                if (async)
+                {
+                    return await valueTcs.Task.AwaitWithCancellation(cancellationToken);
+                }
+
+#pragma warning disable AZC0104 // Use EnsureCompleted() directly on asynchronous method return value.
+#pragma warning disable AZC0111 // DO NOT use EnsureCompleted in possibly asynchronous scope.
+                valueTcs.Task.Wait(cancellationToken);
+                return valueTcs.Task.EnsureCompleted();
+#pragma warning restore AZC0111 // DO NOT use EnsureCompleted in possibly asynchronous scope.
+#pragma warning restore AZC0104 // Use EnsureCompleted() directly on asynchronous method return value.
+            }
+            catch (OperationCanceledException)
+            {
+                // Throw OperationCanceledException only if another thread hasn't set a value to this waiter
+                // by calling either Reset or SetValue
+                if (valueTcs.TrySetCanceled(cancellationToken))
+                {
+                    throw;
+                }
+
+                return valueTcs.Task.Result;
+            }
+        }
+
+        /// <summary>
+        /// Set value to the cache and to all the waiters
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="lockIndex"></param>
+        private void SetValue(T value, in long lockIndex)
+        {
+            Queue<TaskCompletionSource<LockOrValue>> waiters;
+            lock (_syncObj)
+            {
+                if (lockIndex != _index)
+                {
+                    throw new InvalidOperationException($"Disposed {nameof(LockOrValue)} tries to set value. Current index: {_index}, {nameof(LockOrValue)} index: {lockIndex}");
+                }
+
+                _value = value;
+                _hasValue = true;
+                _index = 0;
+                _isLocked = false;
+                if (_waiters == default)
+                {
+                    return;
+                }
+
+                waiters = _waiters;
+                _waiters = default;
+            }
+
+            while (waiters.Count > 0)
+            {
+                waiters.Dequeue().TrySetResult(new LockOrValue(value));
+            }
+        }
+
+        /// <summary>
+        /// Release the lock and allow next waiter acquire it
+        /// </summary>
+        private void Reset(in long lockIndex)
+        {
+            UnlockOrGetNextWaiter(lockIndex, out var nextWaiter);
+            while (nextWaiter != default && !nextWaiter.TrySetResult(new LockOrValue(this, unchecked(lockIndex + 1))))
+            {
+                UnlockOrGetNextWaiter(lockIndex, out nextWaiter);
+            }
+        }
+
+        private void UnlockOrGetNextWaiter(in long lockIndex, out TaskCompletionSource<LockOrValue>? nextWaiter)
+        {
+            lock (_syncObj)
+            {
+                nextWaiter = default;
+                // If lock isn't acquired, just return
+                if (!_isLocked || lockIndex != _index)
+                {
+                    return;
+                }
+
+                _index = unchecked(lockIndex + 1);
+
+                // If lock was acquired, but there are no waiters, unlock and return
+                if (_waiters == default)
+                {
+                    _isLocked = false;
+                    return;
+                }
+
+                // Find the next waiter
+                while (_waiters.Count > 0)
+                {
+                    nextWaiter = _waiters.Dequeue();
+                    if (!nextWaiter.Task.IsCompleted)
+                    {
+                        // Return the waiter only if it wasn't canceled already
+                        return;
+                    }
+                }
+
+                // If no next waiter has been found, unlock and return
+                _isLocked = false;
+            }
+        }
+
+        public readonly struct LockOrValue : IDisposable
+        {
+            private readonly AsyncLockWithValue<T>? _owner;
+            private readonly T? _value;
+            private readonly long _index;
+
+            /// <summary>
+            /// Returns true if lock contains the cached value. Otherwise false.
+            /// </summary>
+            public bool HasValue => _owner == default;
+
+            /// <summary>
+            /// Returns cached value if it was set when lock has been created. Throws exception otherwise.
+            /// </summary>
+            /// <exception cref="InvalidOperationException">Value isn't set.</exception>
+            public T Value => HasValue ? _value! : throw new InvalidOperationException("Value isn't set");
+
+            public LockOrValue(T value)
+            {
+                _owner = default;
+                _value = value;
+                _index = 0;
+            }
+
+            public LockOrValue(AsyncLockWithValue<T> owner, long index)
+            {
+                _owner = owner;
+                _index = index;
+                _value = default;
+            }
+
+            /// <summary>
+            /// Set value to the cache and to all the waiters.
+            /// </summary>
+            /// <param name="value"></param>
+            /// <exception cref="InvalidOperationException">Value is set already.</exception>
+            public void SetValue(T value)
+            {
+                if (_owner != null)
+                {
+                    _owner.SetValue(value, _index);
+                }
+                else
+                {
+                    throw new InvalidOperationException("Value for the lock is set already");
+                }
+            }
+
+            public void Dispose() => _owner?.Reset(_index);
+        }
+    }
+}

package/dist/generator/Shared/Core/AzureKeyCredentialPolicy.cs

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using Azure.Core.Pipeline;
+
+#nullable enable
+
+namespace Azure.Core
+{
+    internal class AzureKeyCredentialPolicy : HttpPipelineSynchronousPolicy
+    {
+        private readonly string _name;
+        private readonly AzureKeyCredential _credential;
+        private readonly string? _prefix;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AzureKeyCredentialPolicy"/> class.
+        /// </summary>
+        /// <param name="credential">The <see cref="AzureKeyCredential"/> used to authenticate requests.</param>
+        /// <param name="name">The name of the key header used for the credential.</param>
+        /// <param name="prefix">The prefix to apply before the credential key. For example, a prefix of "SharedAccessKey" would result in
+        /// a value of "SharedAccessKey {credential.Key}" being stamped on the request header with header key of <paramref name="name"/>.</param>
+        public AzureKeyCredentialPolicy(AzureKeyCredential credential, string name, string? prefix = null)
+        {
+            if (credential is null)
+            {
+                throw new ArgumentNullException(nameof(credential));
+            }
+            if (name is null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+            if (name.Length == 0)
+            {
+                throw new ArgumentException("Value cannot be an empty string.", nameof(name));
+            }
+            _credential = credential;
+            _name = name;
+            _prefix = prefix;
+        }
+
+        /// <inheritdoc/>
+        public override void OnSendingRequest(HttpMessage message)
+        {
+            base.OnSendingRequest(message);
+            message.Request.Headers.SetValue(_name, _prefix != null ? $"{_prefix} {_credential.Key}" :  _credential.Key);
+        }
+    }
+}

package/dist/generator/Shared/Core/ClientDiagnostics.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+#nullable enable
+
+namespace Azure.Core.Pipeline
+{
+    internal class ClientDiagnostics : DiagnosticScopeFactory
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClientDiagnostics"/> class.
+        /// </summary>
+        /// <param name="options">The customer provided client options object.</param>
+        /// <param name="suppressNestedClientActivities">Flag controlling if <see cref="System.Diagnostics.Activity"/>
+        ///  created by this <see cref="ClientDiagnostics"/> for client method calls should be suppressed when called
+        ///  by other Azure SDK client methods.  It's recommended to set it to true for new clients; use default (null)
+        ///  for backward compatibility reasons, or set it to false to explicitly disable suppression for specific cases.
+        ///  The default value could change in the future, the flag should be only set to false if suppression for the client
+        ///  should never be enabled.</param>
+        public ClientDiagnostics(ClientOptions options, bool? suppressNestedClientActivities = null)
+                    : this(options.GetType().Namespace!,
+                    GetResourceProviderNamespace(options.GetType().Assembly),
+                    options.Diagnostics,
+                    suppressNestedClientActivities)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClientDiagnostics"/> class.
+        /// </summary>
+        /// <param name="optionsNamespace">Namespace of the client class, such as Azure.Storage or Azure.AppConfiguration.</param>
+        /// <param name="providerNamespace">Azure Resource Provider namespace of the Azure service SDK is primarily used for.</param>
+        /// <param name="diagnosticsOptions">The customer provided client diagnostics options.</param>
+        /// <param name="suppressNestedClientActivities">Flag controlling if <see cref="System.Diagnostics.Activity"/>
+        ///  created by this <see cref="ClientDiagnostics"/> for client method calls should be suppressed when called
+        ///  by other Azure SDK client methods.  It's recommended to set it to true for new clients, use default (null) for old clients
+        ///  for backward compatibility reasons, or set it to false to explicitly disable suppression for specific cases.
+        ///  The default value could change in the future, the flag should be only set to false if suppression for the client
+        ///  should never be enabled.</param>
+        public ClientDiagnostics(string optionsNamespace, string? providerNamespace, DiagnosticsOptions diagnosticsOptions, bool? suppressNestedClientActivities = null)
+            : base(optionsNamespace, providerNamespace, diagnosticsOptions.IsDistributedTracingEnabled, suppressNestedClientActivities.GetValueOrDefault(true), true)
+        {
+        }
+
+        internal static HttpMessageSanitizer CreateMessageSanitizer(DiagnosticsOptions diagnostics)
+        {
+            return new HttpMessageSanitizer(
+                diagnostics.LoggedQueryParameters.ToArray(),
+                diagnostics.LoggedHeaderNames.ToArray());
+        }
+
+        internal static string? GetResourceProviderNamespace(Assembly assembly)
+        {
+            foreach (var customAttribute in assembly.GetCustomAttributesData())
+            {
+                // Weak bind internal shared type
+                Type attributeType = customAttribute.AttributeType!;
+                if (attributeType.FullName == ("Azure.Core.AzureResourceProviderNamespaceAttribute"))
+                {
+                    IList<CustomAttributeTypedArgument> namedArguments = customAttribute.ConstructorArguments;
+                    return namedArguments.Single().Value as string;
+                }
+            }
+
+            return null;
+        }
+    }
+}