diff --git a/eng/Packages.Data.props b/eng/Packages.Data.props
index 60f46b2492c7..0acc25fb20b1 100644
--- a/eng/Packages.Data.props
+++ b/eng/Packages.Data.props
@@ -209,6 +209,7 @@
     <PackageReference Update="Microsoft.TypeSpec.Generator.ClientModel" Version="[$(UnbrandedGeneratorVersion)]" />
     <PackageReference Update="Microsoft.TypeSpec.Generator.Input" Version="[$(UnbrandedGeneratorVersion)]" />
     <PackageReference Update="Azure.Generator" Version="[$(AzureGeneratorVersion)]" />
+    <PackageReference Update="Humanizer.Core" Version="2.14.1" />
   </ItemGroup>
 
   <!--
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Azure.Generator.Management.csproj b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Azure.Generator.Management.csproj
index fd60acff8447..0b27c3fd6b5f 100644
--- a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Azure.Generator.Management.csproj
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Azure.Generator.Management.csproj
@@ -9,6 +9,7 @@
 		<PackageReference Include="Azure.Core" />
 		<PackageReference Include="Azure.Generator" />
 		<PackageReference Include="Azure.ResourceManager" />
+		<PackageReference Include="Humanizer.Core" />
 	</ItemGroup>
 
 	<Target Name="CheckEmitterBuild" BeforeTargets="Build">
@@ -91,7 +92,10 @@
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\..\..\sdk\core\Azure.Core\src\Shared\RequestHeaderExtensions.cs" LinkBase="Shared/Core">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Compile>
-	<Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\..\..\sdk\core\Azure.Core\src\Shared\NoValueResponseOfT.cs" LinkBase="Shared/Core">
+		<Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\..\..\sdk\core\Azure.Core\src\Shared\NoValueResponseOfT.cs" LinkBase="Shared/Core">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Compile>
+		<Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\..\..\sdk\core\Azure.Core\src\Shared\ForwardsClientCallsAttribute.cs" LinkBase="Shared/Core">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Compile>
 	</ItemGroup>
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementOutputLibrary.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementOutputLibrary.cs
index f539301b9b48..b78f5552d595 100644
--- a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementOutputLibrary.cs
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementOutputLibrary.cs
@@ -1,8 +1,13 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Azure.Generator.Management.Models;
 using Azure.Generator.Management.Providers;
+using Azure.ResourceManager;
+using Azure.ResourceManager.Resources;
+using Microsoft.TypeSpec.Generator.Input;
 using Microsoft.TypeSpec.Generator.Providers;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -28,20 +33,63 @@ public class ManagementOutputLibrary : AzureOutputLibrary
             return (resources, collections);
         }
 
-        private static void BuildResourceCore(List<ResourceClientProvider> resources, List<ResourceCollectionClientProvider> collections, Microsoft.TypeSpec.Generator.Input.InputClient client)
+        private static readonly IReadOnlyDictionary<ResourceScope, Type> _scopeToTypes = new Dictionary<ResourceScope, Type>
+        {
+            [ResourceScope.ResourceGroup] = typeof(ResourceGroupResource),
+            [ResourceScope.Subscription] = typeof(SubscriptionResource),
+            [ResourceScope.Tenant] = typeof(TenantResource),
+        };
+
+        // TODO -- build extensions and their corresponding mockable resources
+        private IReadOnlyList<TypeProvider> BuildExtensions(IReadOnlyList<ResourceClientProvider> resources)
+        {
+            // walk through all resources to figure out their scopes
+            var scopeCandidates = new Dictionary<ResourceScope, List<ResourceClientProvider>>
+            {
+                [ResourceScope.ResourceGroup] = [],
+                [ResourceScope.Subscription] = [],
+                [ResourceScope.Tenant] = [],
+            };
+            foreach (var resource in resources)
+            {
+                scopeCandidates[resource.ResourceScope].Add(resource);
+            }
+
+            var mockableResources = new List<MockableResourceProvider>(scopeCandidates.Count)
+            {
+                // add the arm client mockable resource
+                new MockableArmClientProvider(typeof(ArmClient), resources)
+            };
+
+            foreach (var (scope, candidates) in scopeCandidates)
+            {
+                if (candidates.Count > 0)
+                {
+                    var mockableExtension = new MockableResourceProvider(_scopeToTypes[scope], candidates);
+                    ManagementClientGenerator.Instance.AddTypeToKeep(mockableExtension.Name);
+                    mockableResources.Add(mockableExtension);
+                }
+            }
+
+            var extensionProvider = new ExtensionProvider(mockableResources);
+            ManagementClientGenerator.Instance.AddTypeToKeep(extensionProvider.Name);
+
+            return [.. mockableResources, extensionProvider];
+        }
+
+        private static void BuildResourceCore(List<ResourceClientProvider> resources, List<ResourceCollectionClientProvider> collections, InputClient client)
         {
             // A resource client should contain the decorator "Azure.ResourceManager.@resourceMetadata"
             var resourceMetadata = ManagementClientGenerator.Instance.InputLibrary.GetResourceMetadata(client);
             if (resourceMetadata is not null)
             {
-                var resource = new ResourceClientProvider(client, resourceMetadata);
+                var resource = ResourceClientProvider.Create(client, resourceMetadata);
                 ManagementClientGenerator.Instance.AddTypeToKeep(resource.Name);
                 resources.Add(resource);
-                if (!resource.IsSingleton)
+                if (resource.ResourceCollection is not null)
                 {
-                    var collection = new ResourceCollectionClientProvider(client, resourceMetadata, resource);
-                    ManagementClientGenerator.Instance.AddTypeToKeep(collection.Name);
-                    collections.Add(collection);
+                    ManagementClientGenerator.Instance.AddTypeToKeep(resource.ResourceCollection.Name);
+                    collections.Add(resource.ResourceCollection);
                 }
             }
         }
@@ -50,12 +98,14 @@ private static void BuildResourceCore(List<ResourceClientProvider> resources, Li
         protected override TypeProvider[] BuildTypeProviders()
         {
             var (resources, collections) = BuildResources();
+            var extensions = BuildExtensions(resources);
             return [
                 .. base.BuildTypeProviders().Where(t => t is not InheritableSystemObjectModelProvider),
                 ArmOperation,
                 GenericArmOperation,
                 .. resources,
                 .. collections,
+                .. extensions,
                 .. resources.Select(r => r.Source),
                 .. resources.SelectMany(r => r.SerializationProviders)];
         }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementTypeFactory.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementTypeFactory.cs
index 8f4bfd850db4..7431ab00c78d 100644
--- a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementTypeFactory.cs
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/ManagementTypeFactory.cs
@@ -2,8 +2,10 @@
 // Licensed under the MIT License.
 
 using Azure.Generator.Management.InputTransformation;
-using Azure.Generator.Management.Providers.Abstraction;
 using Azure.Generator.Management.Primitives;
+using Azure.Generator.Management.Providers;
+using Azure.Generator.Management.Providers.Abstraction;
+using Azure.Generator.Primitives;
 using Microsoft.TypeSpec.Generator;
 using Microsoft.TypeSpec.Generator.ClientModel.Providers;
 using Microsoft.TypeSpec.Generator.Expressions;
@@ -12,18 +14,35 @@
 using Microsoft.TypeSpec.Generator.Providers;
 using Microsoft.TypeSpec.Generator.Snippets;
 using Microsoft.TypeSpec.Generator.Statements;
-using System.ClientModel.Primitives;
 using System;
+using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.Text.Json;
 using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
-using Azure.Generator.Management.Providers;
 
 namespace Azure.Generator.Management
 {
     /// <inheritdoc/>
     public class ManagementTypeFactory : AzureTypeFactory
     {
+        private string? _resourceProviderName;
+
+        /// <summary>
+        /// The name for this resource provider.
+        /// For instance, if the namespace is "Azure.ResourceManager.Compute", the resource provider name will be "Compute".
+        /// </summary>
+        public string ResourceProviderName => _resourceProviderName ??= BuildResourceProviderName();
+
+        private string BuildResourceProviderName()
+        {
+            const string armNamespacePrefix = "Azure.ResourceManager.";
+            if (PrimaryNamespace.StartsWith(armNamespacePrefix))
+            {
+                return PrimaryNamespace[(armNamespacePrefix.Length + 1)..]; // TODO -- we need to call ToCleanName here to trim off invalid characters
+            }
+            return PrimaryNamespace;
+        }
+
         /// <inheritdoc/>
         public override IClientPipelineApi ClientPipelineApi => MgmtHttpPipelineProvider.Instance;
 
@@ -86,5 +105,11 @@ public override ValueExpression DeserializeJsonValue(Type valueType, ScopedApi<J
             }
             return base.DeserializeJsonValue(valueType, element, format);
         }
+
+        /// <inheritdoc/>
+        public override NewProjectScaffolding CreateNewProjectScaffolding()
+        {
+            return new NewManagementProjectScaffolding();
+        }
     }
 }
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Primitives/NewManagementProjectScaffolding.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Primitives/NewManagementProjectScaffolding.cs
new file mode 100644
index 000000000000..d163c8f64f31
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Primitives/NewManagementProjectScaffolding.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Azure.Generator.Primitives;
+
+namespace Azure.Generator.Management.Primitives
+{
+    internal class NewManagementProjectScaffolding : NewAzureProjectScaffolding
+    {
+        // TODO -- call the hook to add new files that mgmt projects need
+        // current list:
+        // - ForwardsClientCallsAttribute.cs
+    }
+}
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ExtensionProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ExtensionProvider.cs
new file mode 100644
index 000000000000..6b10bffc003a
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ExtensionProvider.cs
@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.TypeSpec.Generator.Expressions;
+using Microsoft.TypeSpec.Generator.Input.Extensions;
+using Microsoft.TypeSpec.Generator.Primitives;
+using Microsoft.TypeSpec.Generator.Providers;
+using Microsoft.TypeSpec.Generator.Snippets;
+using Microsoft.TypeSpec.Generator.Statements;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
+
+namespace Azure.Generator.Management.Providers
+{
+    internal class ExtensionProvider : TypeProvider
+    {
+        private const string GetCachedClient = "GetCachedClient";
+        private const string IdProperty = "Id";
+
+        private readonly IReadOnlyList<MockableResourceProvider> _mockableResources;
+        public ExtensionProvider(IReadOnlyList<MockableResourceProvider> mockableResources)
+        {
+            _mockableResources = mockableResources;
+        }
+
+        protected override TypeSignatureModifiers BuildDeclarationModifiers() => TypeSignatureModifiers.Public | TypeSignatureModifiers.Static;
+
+        protected override string BuildName() => $"{ManagementClientGenerator.Instance.TypeFactory.ResourceProviderName}Extensions";
+
+        protected override string BuildRelativeFilePath() => Path.Combine("src", "Generated", "Extensions", $"{Name}.cs");
+
+        protected override MethodProvider[] BuildMethods()
+        {
+            // we have a few methods to get the cached clients for those mockable resources
+            var getCachedClientMethods = new Dictionary<CSharpType, MethodProvider>();
+            foreach (var mockableResource in _mockableResources)
+            {
+                var getCachedClientMethod = BuildGetCachedClientMethod(mockableResource);
+                getCachedClientMethods.Add(mockableResource.ArmCoreType, getCachedClientMethod);
+            }
+
+            // then all the methods are just forwarding to the mockable resource methods
+            var redirectedMethods = new List<MethodProvider>(_mockableResources.Sum(m => m.Methods.Count));
+            foreach (var mockableResource in _mockableResources)
+            {
+                var getCachedClientMethod = getCachedClientMethods[mockableResource.ArmCoreType];
+                redirectedMethods.AddRange(
+                    mockableResource.Methods.Select(m => BuildRedirectMethod(mockableResource.ArmCoreType, m, getCachedClientMethod))
+                    );
+            }
+
+            return [
+                .. getCachedClientMethods.Values,
+                .. redirectedMethods
+                ];
+        }
+
+        private MethodProvider BuildGetCachedClientMethod(MockableResourceProvider mockableResource)
+        {
+            var coreType = mockableResource.ArmCoreType;
+            var parameter = new ParameterProvider(coreType.Name.ToVariableName(), $"", coreType);
+            var methodSignature = new MethodSignature(
+                $"Get{mockableResource.Name}",
+                null,
+                MethodSignatureModifiers.Public | MethodSignatureModifiers.Static,
+                mockableResource.Type,
+                null,
+                [parameter]);
+            var clientVar = new CodeWriterDeclaration("client");
+            var lambda = new FuncExpression([clientVar], New.Instance(mockableResource.Type, new ValueExpression[] { new VariableExpression(mockableResource.Type, clientVar), parameter.Property(IdProperty) }));
+            var statements = new List<MethodBodyStatement>
+            {
+                Return(parameter.Invoke(GetCachedClient, lambda))
+            };
+            return new MethodProvider(methodSignature, statements, this);
+        }
+
+        private MethodProvider BuildRedirectMethod(CSharpType armCoreType, MethodProvider targetMethod, MethodProvider getCachedClientMethod)
+        {
+            var target = targetMethod.Signature;
+            // TODO -- add mocking information in method description
+            var extensionParameter = new ParameterProvider(
+                armCoreType.Name.ToVariableName(),
+                $"The {armCoreType:C} the method will execute against.",
+                armCoreType,
+                validation: ParameterValidationType.AssertNotNull);
+            IReadOnlyList<ParameterProvider> parameters = [
+                extensionParameter,
+                ..target.Parameters
+                ];
+            var modifiers = (target.Modifiers & ~MethodSignatureModifiers.Virtual) | MethodSignatureModifiers.Static | MethodSignatureModifiers.Extension;
+            var methodSignature = new MethodSignature(
+                target.Name,
+                target.Description,
+                modifiers,
+                target.ReturnType,
+                target.ReturnDescription,
+                parameters);
+
+            var body = new MethodBodyStatement[]
+            {
+                Return(Static().Invoke(getCachedClientMethod.Signature, [extensionParameter]).Invoke(target))
+            };
+
+            return new MethodProvider(methodSignature, body, this);
+        }
+    }
+}
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/MockableArmClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/MockableArmClientProvider.cs
new file mode 100644
index 000000000000..8439e3af5052
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/MockableArmClientProvider.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.TypeSpec.Generator.Primitives;
+using System.Collections.Generic;
+
+namespace Azure.Generator.Management.Providers
+{
+    internal sealed class MockableArmClientProvider : MockableResourceProvider
+    {
+        public MockableArmClientProvider(CSharpType armCoreType, IReadOnlyList<ResourceClientProvider> resources) : base(armCoreType, resources)
+        {
+        }
+
+        // TODO -- override the BuildMethods method to introduce the methods on this extension.
+    }
+}
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/MockableResourceProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/MockableResourceProvider.cs
new file mode 100644
index 000000000000..4c069498d6f4
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/MockableResourceProvider.cs
@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Azure.Core;
+using Azure.Generator.Management.Utilities;
+using Azure.ResourceManager;
+using Humanizer;
+using Microsoft.TypeSpec.Generator.Expressions;
+using Microsoft.TypeSpec.Generator.Primitives;
+using Microsoft.TypeSpec.Generator.Providers;
+using Microsoft.TypeSpec.Generator.Statements;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
+
+namespace Azure.Generator.Management.Providers
+{
+    internal class MockableResourceProvider : TypeProvider
+    {
+        private readonly IReadOnlyList<ResourceClientProvider> _resources;
+
+        private const string GetCachedClient = "GetCachedClient";
+        private const string IdProperty = "Id";
+
+        // TODO -- in the future we need to update this to include the operations this mockable resource should include.
+        public MockableResourceProvider(CSharpType armCoreType, IReadOnlyList<ResourceClientProvider> resources)
+        {
+            ArmCoreType = armCoreType;
+            _resources = resources;
+        }
+        internal CSharpType ArmCoreType { get; }
+
+        protected override string BuildName() => $"Mockable{ManagementClientGenerator.Instance.TypeFactory.ResourceProviderName}{ArmCoreType.Name}";
+
+        protected override string BuildRelativeFilePath() => Path.Combine("src", "Generated", "Extensions", $"{Name}.cs");
+
+        protected override CSharpType? GetBaseType() => typeof(ArmResource);
+
+        protected override ConstructorProvider[] BuildConstructors()
+            => [ConstructorProviderHelper.BuildMockingConstructor(this), BuildResourceIdentifierConstructor()];
+
+        private ConstructorProvider BuildResourceIdentifierConstructor()
+        {
+            var idParameter = new ParameterProvider("id", $"The identifier of the resource that is the target of operations.", typeof(ResourceIdentifier));
+            var parameters = new List<ParameterProvider>
+            {
+                new("client", $"The client parameters to use in these operations.", typeof(ArmClient)),
+                idParameter
+            };
+
+            var initializer = new ConstructorInitializer(true, parameters);
+            var signature = new ConstructorSignature(
+                Type,
+                $"Initializes a new instance of {Type:C} class.",
+                MethodSignatureModifiers.Internal,
+                parameters,
+                null,
+                initializer);
+
+            return new ConstructorProvider(signature, MethodBodyStatement.Empty, this);
+        }
+
+        protected override MethodProvider[] BuildMethods()
+        {
+            var methods = new List<MethodProvider>(_resources.Count * 3);
+            foreach (var resource in _resources)
+            {
+                methods.AddRange(BuildMethodsForResource(resource));
+            }
+            return [.. methods];
+        }
+
+        private IEnumerable<MethodProvider> BuildMethodsForResource(ResourceClientProvider resource)
+        {
+            if (resource.IsSingleton)
+            {
+                // TODO -- not implemented yet.
+                yield break;
+            }
+            else
+            {
+                var collection = resource.ResourceCollection!;
+                // the first method is returning the collection
+                var pluralOfResourceName = resource.SpecName.Pluralize();
+                var collectionMethodSignature = new MethodSignature(
+                    $"Get{pluralOfResourceName}",
+                    $"Gets a collection of {pluralOfResourceName} in the {ArmCoreType:C}",
+                    MethodSignatureModifiers.Public | MethodSignatureModifiers.Virtual,
+                    collection.Type,
+                    $"An object representing collection of {pluralOfResourceName} and their operations over a {resource.Name}.",
+                    []
+                    );
+                var clientVar = new CodeWriterDeclaration("client");
+                var lambda = new FuncExpression([clientVar], New.Instance(collection.Type, new ValueExpression[] { new VariableExpression(typeof(ArmClient), clientVar), This.Property(IdProperty) }));
+                var bodyStatement = new MethodBodyStatement[]
+                {
+                    Return(This.Invoke(GetCachedClient, lambda))
+                };
+                yield return new MethodProvider(
+                    collectionMethodSignature,
+                    bodyStatement,
+                    this);
+                // the second and third methods are the sync and async version of the Get method on the collection
+                // find the method
+                var getMethod = collection.Methods.FirstOrDefault(m => m.Signature.Name == "Get");
+                var getAsyncMethod = collection.Methods.FirstOrDefault(m => m.Signature.Name == "GetAsync");
+                if (getMethod is not null)
+                {
+                    // we should be sure that this would never be null, but this null check here is just ensuring that we never crash
+                    // TODO -- figure out how to remove the parameter validation
+                    var getResourceMethodSignature = new MethodSignature(
+                        getMethod.Signature.Name,
+                        getMethod.Signature.Description,
+                        getMethod.Signature.Modifiers,
+                        getMethod.Signature.ReturnType,
+                        getMethod.Signature.ReturnDescription,
+                        getMethod.Signature.Parameters);
+                    // TODO -- we need to add the ForwardsClientCallsAttribute attribute when the hook to add more shared source is available
+                    // Attributes: [new AttributeStatement(typeof(ForwardsClientCallsAttribute))]);
+
+                    yield return new MethodProvider(
+                        getResourceMethodSignature,
+                        new MethodBodyStatement[]
+                        {
+                            Return(This.Invoke(collectionMethodSignature).Invoke(getMethod.Signature))
+                        },
+                        this);
+                }
+
+                if (getAsyncMethod is not null)
+                {
+                    // we should be sure that this would never be null, but this null check here is just ensuring that we never crash
+                    // TODO -- figure out how to remove the parameter validation
+                    var getResourceAsyncMethodSignature = new MethodSignature(
+                        getAsyncMethod.Signature.Name,
+                        getAsyncMethod.Signature.Description,
+                        getAsyncMethod.Signature.Modifiers,
+                        getAsyncMethod.Signature.ReturnType,
+                        getAsyncMethod.Signature.ReturnDescription,
+                        getAsyncMethod.Signature.Parameters);
+                    // TODO -- we need to add the ForwardsClientCallsAttribute attribute when the hook to add more shared source is available
+                    // Attributes: [new AttributeStatement(typeof(ForwardsClientCallsAttribute))]);
+                    yield return new MethodProvider(
+                        getResourceAsyncMethodSignature,
+                        new MethodBodyStatement[]
+                        {
+                            Return(This.Invoke(collectionMethodSignature).Invoke(getAsyncMethod.Signature))
+                        },
+                        this);
+                }
+            }
+        }
+    }
+}
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs
index 2b92dea88709..a8c0b4b533a0 100644
--- a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceClientProvider.cs
@@ -10,6 +10,7 @@
 using Microsoft.TypeSpec.Generator.ClientModel.Providers;
 using Microsoft.TypeSpec.Generator.Expressions;
 using Microsoft.TypeSpec.Generator.Input;
+using Microsoft.TypeSpec.Generator.Input.Extensions;
 using Microsoft.TypeSpec.Generator.Primitives;
 using Microsoft.TypeSpec.Generator.Providers;
 using Microsoft.TypeSpec.Generator.Snippets;
@@ -31,35 +32,53 @@ namespace Azure.Generator.Management.Providers
     /// </summary>
     internal class ResourceClientProvider : TypeProvider
     {
+        public static ResourceClientProvider Create(InputClient inputClient, ResourceMetadata resourceMetadata)
+        {
+            var resource = new ResourceClientProvider(inputClient, resourceMetadata);
+            if (!resource.IsSingleton)
+            {
+                var collection = new ResourceCollectionClientProvider(inputClient, resourceMetadata, resource);
+                resource.ResourceCollection = collection;
+            }
+
+            return resource;
+        }
+
         private IReadOnlyCollection<InputServiceMethod> _resourceServiceMethods;
 
         private FieldProvider _dataField;
         private FieldProvider _resourceTypeField;
-        protected ClientProvider _clientProvider;
+        protected ClientProvider _restClientProvider;
         protected FieldProvider _clientDiagonosticsField;
         protected FieldProvider _restClientField;
 
-        public ResourceClientProvider(InputClient inputClient, ResourceMetadata resourceMetadata)
+        private protected ResourceClientProvider(InputClient inputClient, ResourceMetadata resourceMetadata)
         {
             IsSingleton = resourceMetadata.IsSingleton;
+            ResourceScope = resourceMetadata.ResourceScope;
             var resourceType = resourceMetadata.ResourceType;
             _resourceTypeField = new FieldProvider(FieldModifiers.Public | FieldModifiers.Static | FieldModifiers.ReadOnly, typeof(ResourceType), "ResourceType", this, description: $"Gets the resource type for the operations.", initializationValue: Literal(resourceType));
             var resourceModel = resourceMetadata.ResourceModel;
-            SpecName = resourceModel.Name;
+            // TODO -- the name of a resource is not always the name of its model. Maybe the resource metadata should have a property for the name of the resource?
+            SpecName = resourceModel.Name.ToIdentifierName();
 
             // We should be able to assume that all operations in the resource client are for the same resource
             var requestPath = new RequestPath(inputClient.Methods.First().Operation.Path);
             _resourceServiceMethods = inputClient.Methods;
             ResourceData = ManagementClientGenerator.Instance.TypeFactory.CreateModel(resourceModel)!;
-            _clientProvider = ManagementClientGenerator.Instance.TypeFactory.CreateClient(inputClient)!;
+            _restClientProvider = ManagementClientGenerator.Instance.TypeFactory.CreateClient(inputClient)!;
 
             ContextualParameters = GetContextualParameters(requestPath);
 
             _dataField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, ResourceData.Type, "_data", this);
             _clientDiagonosticsField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, typeof(ClientDiagnostics), $"_{SpecName.ToLower()}ClientDiagnostics", this);
-            _restClientField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, _clientProvider.Type, $"_{SpecName.ToLower()}RestClient", this);
+            _restClientField = new FieldProvider(FieldModifiers.Private | FieldModifiers.ReadOnly, _restClientProvider.Type, $"_{SpecName.ToLower()}RestClient", this);
         }
 
+        internal ResourceScope ResourceScope { get; }
+
+        internal ResourceCollectionClientProvider? ResourceCollection { get; private set; }
+
         private IReadOnlyList<string> GetContextualParameters(string contextualRequestPath)
         {
             var contextualParameters = new List<string>();
@@ -168,7 +187,7 @@ protected ConstructorProvider BuildResourceIdentifierConstructor()
             {
                 _clientDiagonosticsField.Assign(New.Instance(typeof(ClientDiagnostics), Literal(Type.Namespace), ResourceTypeExpression.Property(nameof(ResourceType.Namespace)), This.Property("Diagnostics"))).Terminate(),
                 TryGetApiVersion(out var apiVersion).Terminate(),
-                _restClientField.Assign(New.Instance(_clientProvider.Type, _clientDiagonosticsField, This.Property("Pipeline"), This.Property("Endpoint"), apiVersion)).Terminate(),
+                _restClientField.Assign(New.Instance(_restClientProvider.Type, _clientDiagonosticsField, This.Property("Pipeline"), This.Property("Endpoint"), apiVersion)).Terminate(),
                 Static(Type).Invoke(ValidateResourceIdMethodName, idParameter).Terminate()
             };
 
@@ -202,7 +221,7 @@ protected MethodProvider BuildValidateResourceIdMethod()
 
         protected virtual CSharpType ResourceClientCSharpType => this.Type;
 
-        protected override CSharpType[] BuildImplements() => [typeof(ArmResource)];
+        protected override CSharpType? GetBaseType() => typeof(ArmResource);
 
         protected override MethodProvider[] BuildMethods()
         {
@@ -431,10 +450,10 @@ private ValueExpression[] PopulateArguments(IReadOnlyList<ParameterProvider> par
 
         // TODO: get clean name of operation Name
         protected MethodProvider GetCorrespondingConvenienceMethod(InputOperation operation, bool isAsync)
-            => _clientProvider.CanonicalView.Methods.Single(m => m.Signature.Name.Equals(isAsync ? $"{operation.Name}Async" : operation.Name, StringComparison.OrdinalIgnoreCase) && m.Signature.Parameters.Any(p => p.Type.Equals(typeof(CancellationToken))));
+            => _restClientProvider.CanonicalView.Methods.Single(m => m.Signature.Name.Equals(isAsync ? $"{operation.Name}Async" : operation.Name, StringComparison.OrdinalIgnoreCase) && m.Signature.Parameters.Any(p => p.Type.Equals(typeof(CancellationToken))));
 
         private MethodProvider GetCorrespondingRequestMethod(InputOperation operation)
-            => _clientProvider.RestClient.Methods.Single(m => m.Signature.Name.Equals($"Create{operation.Name}Request", StringComparison.OrdinalIgnoreCase));
+            => _restClientProvider.RestClient.Methods.Single(m => m.Signature.Name.Equals($"Create{operation.Name}Request", StringComparison.OrdinalIgnoreCase));
 
         public ScopedApi<bool> TryGetApiVersion(out ScopedApi<string> apiVersion)
         {
diff --git a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs
index 38d85d72664d..615673552b1a 100644
--- a/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs
+++ b/eng/packages/http-client-csharp-mgmt/generator/Azure.Generator.Management/src/Providers/ResourceCollectionClientProvider.cs
@@ -27,7 +27,7 @@ internal class ResourceCollectionClientProvider : ResourceClientProvider
         private InputServiceMethod? _create;
         private InputServiceMethod? _get;
 
-        public ResourceCollectionClientProvider(InputClient inputClient, ResourceMetadata resourceMetadata, ResourceClientProvider resource) : base(inputClient, resourceMetadata)
+        internal ResourceCollectionClientProvider(InputClient inputClient, ResourceMetadata resourceMetadata, ResourceClientProvider resource) : base(inputClient, resourceMetadata)
         {
             _resource = resource;
 
@@ -56,10 +56,12 @@ public ResourceCollectionClientProvider(InputClient inputClient, ResourceMetadat
 
         protected override string BuildName() => $"{SpecName}Collection";
 
+        protected override CSharpType? GetBaseType() => typeof(ArmCollection);
+
         protected override CSharpType[] BuildImplements() =>
             _getAll is null
-            ? [typeof(ArmCollection)]
-            : [typeof(ArmCollection), new CSharpType(typeof(IEnumerable<>), _resource.Type), new CSharpType(typeof(IAsyncEnumerable<>), _resource.Type)];
+            ? []
+            : [new CSharpType(typeof(IEnumerable<>), _resource.Type), new CSharpType(typeof(IAsyncEnumerable<>), _resource.Type)];
 
         protected override PropertyProvider[] BuildProperties() => [];
 
diff --git a/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MgmtTypeSpecExtensions.cs b/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MgmtTypeSpecExtensions.cs
new file mode 100644
index 000000000000..f518174dfdf8
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MgmtTypeSpecExtensions.cs
@@ -0,0 +1,106 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure;
+using Azure.ResourceManager;
+using Azure.ResourceManager.Resources;
+
+namespace MgmtTypeSpec
+{
+    /// <summary></summary>
+    public static partial class MgmtTypeSpecExtensions
+    {
+        /// <param name="armClient"></param>
+        public static MockableMgmtTypeSpecArmClient GetMockableMgmtTypeSpecArmClient(ArmClient armClient)
+        {
+            return armClient.GetCachedClient(client => new MockableMgmtTypeSpecArmClient(client, armClient.Id));
+        }
+
+        /// <param name="resourceGroupResource"></param>
+        public static MockableMgmtTypeSpecResourceGroupResource GetMockableMgmtTypeSpecResourceGroupResource(ResourceGroupResource resourceGroupResource)
+        {
+            return resourceGroupResource.GetCachedClient(client => new MockableMgmtTypeSpecResourceGroupResource(client, resourceGroupResource.Id));
+        }
+
+        /// <summary> Gets a collection of Foos in the <see cref="ArmClient"/>. </summary>
+        /// <param name="armClient"> The <see cref="ArmClient"/> the method will execute against. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="armClient"/> is null. </exception>
+        /// <returns> An object representing collection of Foos and their operations over a FooResource. </returns>
+        public static FooCollection GetFoos(this ArmClient armClient)
+        {
+            Argument.AssertNotNull(armClient, nameof(armClient));
+
+            return GetMockableMgmtTypeSpecArmClient(armClient).GetFoos();
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="armClient"> The <see cref="ArmClient"/> the method will execute against. </param>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="armClient"/> or <paramref name="fooName"/> is null. </exception>
+        public static Response<FooResource> Get(this ArmClient armClient, string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(armClient, nameof(armClient));
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return GetMockableMgmtTypeSpecArmClient(armClient).Get(fooName, cancellationToken);
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="armClient"> The <see cref="ArmClient"/> the method will execute against. </param>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="armClient"/> or <paramref name="fooName"/> is null. </exception>
+        public static async Task<Response<FooResource>> GetAsync(this ArmClient armClient, string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(armClient, nameof(armClient));
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return await GetMockableMgmtTypeSpecArmClient(armClient).GetAsync(fooName, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary> Gets a collection of Foos in the <see cref="ResourceGroupResource"/>. </summary>
+        /// <param name="resourceGroupResource"> The <see cref="ResourceGroupResource"/> the method will execute against. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupResource"/> is null. </exception>
+        /// <returns> An object representing collection of Foos and their operations over a FooResource. </returns>
+        public static FooCollection GetFoos(this ResourceGroupResource resourceGroupResource)
+        {
+            Argument.AssertNotNull(resourceGroupResource, nameof(resourceGroupResource));
+
+            return GetMockableMgmtTypeSpecResourceGroupResource(resourceGroupResource).GetFoos();
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="resourceGroupResource"> The <see cref="ResourceGroupResource"/> the method will execute against. </param>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupResource"/> or <paramref name="fooName"/> is null. </exception>
+        public static Response<FooResource> Get(this ResourceGroupResource resourceGroupResource, string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(resourceGroupResource, nameof(resourceGroupResource));
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return GetMockableMgmtTypeSpecResourceGroupResource(resourceGroupResource).Get(fooName, cancellationToken);
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="resourceGroupResource"> The <see cref="ResourceGroupResource"/> the method will execute against. </param>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="resourceGroupResource"/> or <paramref name="fooName"/> is null. </exception>
+        public static async Task<Response<FooResource>> GetAsync(this ResourceGroupResource resourceGroupResource, string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(resourceGroupResource, nameof(resourceGroupResource));
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return await GetMockableMgmtTypeSpecResourceGroupResource(resourceGroupResource).GetAsync(fooName, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
diff --git a/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MockableMgmtTypeSpecArmClient.cs b/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MockableMgmtTypeSpecArmClient.cs
new file mode 100644
index 000000000000..889e9fefc425
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MockableMgmtTypeSpecArmClient.cs
@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure;
+using Azure.Core;
+using Azure.ResourceManager;
+
+namespace MgmtTypeSpec
+{
+    /// <summary></summary>
+    public partial class MockableMgmtTypeSpecArmClient : ArmResource
+    {
+        /// <summary> Initializes a new instance of MockableMgmtTypeSpecArmClient for mocking. </summary>
+        protected MockableMgmtTypeSpecArmClient()
+        {
+        }
+
+        /// <summary> Initializes a new instance of <see cref="MockableMgmtTypeSpecArmClient"/> class. </summary>
+        /// <param name="client"> The client parameters to use in these operations. </param>
+        /// <param name="id"> The identifier of the resource that is the target of operations. </param>
+        internal MockableMgmtTypeSpecArmClient(ArmClient client, ResourceIdentifier id) : base(client, id)
+        {
+        }
+
+        /// <summary> Gets a collection of Foos in the <see cref="ArmClient"/>. </summary>
+        /// <returns> An object representing collection of Foos and their operations over a FooResource. </returns>
+        public virtual FooCollection GetFoos()
+        {
+            return GetCachedClient(client => new FooCollection(client, Id));
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="fooName"/> is null. </exception>
+        public virtual Response<FooResource> Get(string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return GetFoos().Get(fooName, cancellationToken);
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="fooName"/> is null. </exception>
+        public virtual async Task<Response<FooResource>> GetAsync(string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return await GetFoos().GetAsync(fooName, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}
diff --git a/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MockableMgmtTypeSpecResourceGroupResource.cs b/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MockableMgmtTypeSpecResourceGroupResource.cs
new file mode 100644
index 000000000000..a3229bb2383f
--- /dev/null
+++ b/eng/packages/http-client-csharp-mgmt/generator/TestProjects/Local/Mgmt-TypeSpec/src/Generated/Extensions/MockableMgmtTypeSpecResourceGroupResource.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Azure;
+using Azure.Core;
+using Azure.ResourceManager;
+using Azure.ResourceManager.Resources;
+
+namespace MgmtTypeSpec
+{
+    /// <summary></summary>
+    public partial class MockableMgmtTypeSpecResourceGroupResource : ArmResource
+    {
+        /// <summary> Initializes a new instance of MockableMgmtTypeSpecResourceGroupResource for mocking. </summary>
+        protected MockableMgmtTypeSpecResourceGroupResource()
+        {
+        }
+
+        /// <summary> Initializes a new instance of <see cref="MockableMgmtTypeSpecResourceGroupResource"/> class. </summary>
+        /// <param name="client"> The client parameters to use in these operations. </param>
+        /// <param name="id"> The identifier of the resource that is the target of operations. </param>
+        internal MockableMgmtTypeSpecResourceGroupResource(ArmClient client, ResourceIdentifier id) : base(client, id)
+        {
+        }
+
+        /// <summary> Gets a collection of Foos in the <see cref="ResourceGroupResource"/>. </summary>
+        /// <returns> An object representing collection of Foos and their operations over a FooResource. </returns>
+        public virtual FooCollection GetFoos()
+        {
+            return GetCachedClient(client => new FooCollection(client, Id));
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="fooName"/> is null. </exception>
+        public virtual Response<FooResource> Get(string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return GetFoos().Get(fooName, cancellationToken);
+        }
+
+        /// <summary> Get a Foo. </summary>
+        /// <param name="fooName"> The name of the Foo. </param>
+        /// <param name="cancellationToken"> The cancellation token that can be used to cancel the operation. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="fooName"/> is null. </exception>
+        public virtual async Task<Response<FooResource>> GetAsync(string fooName, CancellationToken cancellationToken = default)
+        {
+            Argument.AssertNotNull(fooName, nameof(fooName));
+
+            return await GetFoos().GetAsync(fooName, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}