From 78e1d56fa669bec21182c186b8e48ef4c19dc134 Mon Sep 17 00:00:00 2001
From: Robin Deeboonchai <rdeeboonchai@microsoft.com>
Date: Mon, 26 Aug 2024 14:23:39 -0700
Subject: [PATCH 1/2] chore: defork cloud-provider-azure

---
 .../cloudprovider/azure/azure_agent_pool.go   |  61 +-
 .../azure/azure_agent_pool_test.go            |  23 +-
 .../cloudprovider/azure/azure_cache.go        |   5 +-
 .../cloudprovider/azure/azure_cache_test.go   |   5 +-
 .../cloudprovider/azure/azure_client.go       | 188 +---
 .../cloudprovider/azure/azure_client_test.go  |  41 +-
 .../azure/azure_cloud_provider_test.go        |  14 +-
 .../cloudprovider/azure/azure_config.go       | 684 ++++++--------
 .../cloudprovider/azure/azure_config_test.go  | 237 ++---
 .../cloudprovider/azure/azure_fakes.go        |  24 +-
 .../cloudprovider/azure/azure_manager.go      |  16 +-
 .../cloudprovider/azure/azure_manager_test.go | 856 +++++++++++++-----
 .../cloudprovider/azure/azure_scale_set.go    |   4 +-
 .../azure/azure_scale_set_instance_cache.go   |   4 +-
 .../azure/azure_scale_set_test.go             |  18 +-
 .../cloudprovider/azure/azure_util.go         |  18 +
 cluster-autoscaler/go.mod                     |  12 +-
 cluster-autoscaler/go.sum                     |  36 +-
 18 files changed, 1170 insertions(+), 1076 deletions(-)

diff --git a/cluster-autoscaler/cloudprovider/azure/azure_agent_pool.go b/cluster-autoscaler/cloudprovider/azure/azure_agent_pool.go
index 01b82b3182d4..7fcc60e286a6 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_agent_pool.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_agent_pool.go
@@ -82,10 +82,10 @@ func (as *AgentPool) initialize() error {
 	ctx, cancel := getContextWithCancel()
 	defer cancel()
 
-	template, err := as.manager.azClient.deploymentsClient.ExportTemplate(ctx, as.manager.config.ResourceGroup, as.manager.config.Deployment)
+	template, err := as.manager.azClient.deploymentClient.ExportTemplate(ctx, as.manager.config.ResourceGroup, as.manager.config.Deployment)
 	if err != nil {
-		klog.Errorf("deploymentsClient.ExportTemplate(%s, %s) failed: %v", as.manager.config.ResourceGroup, as.manager.config.Deployment, err)
-		return err
+		klog.Errorf("deploymentClient.ExportTemplate(%s, %s) failed: %v", as.manager.config.ResourceGroup, as.manager.config.Deployment, err)
+		return err.Error()
 	}
 
 	as.template = template.Template.(map[string]interface{})
@@ -211,18 +211,27 @@ func (as *AgentPool) TargetSize() (int, error) {
 	return int(size), nil
 }
 
-func (as *AgentPool) getAllSucceededAndFailedDeployments() (succeededAndFailedDeployments []resources.DeploymentExtended, err error) {
+func (as *AgentPool) getAllSucceededAndFailedDeployments() ([]resources.DeploymentExtended, error) {
 	ctx, cancel := getContextWithCancel()
 	defer cancel()
 
-	deploymentsFilter := "provisioningState eq 'Succeeded' or provisioningState eq 'Failed'"
-	succeededAndFailedDeployments, err = as.manager.azClient.deploymentsClient.List(ctx, as.manager.config.ResourceGroup, deploymentsFilter, nil)
-	if err != nil {
-		klog.Errorf("getAllSucceededAndFailedDeployments: failed to list succeeded or failed deployments with error: %v", err)
-		return nil, err
+	allDeployments, rerr := as.manager.azClient.deploymentClient.List(ctx, as.manager.config.ResourceGroup)
+	if rerr != nil {
+		klog.Errorf("getAllSucceededAndFailedDeployments: failed to list deployments with error: %v", rerr.Error())
+		return nil, rerr.Error()
+	}
+
+	result := make([]resources.DeploymentExtended, 0)
+	for _, deployment := range allDeployments {
+		if deployment.Properties == nil || deployment.Properties.ProvisioningState == nil {
+			continue
+		}
+		if *deployment.Properties.ProvisioningState == "Succeeded" || *deployment.Properties.ProvisioningState == "Failed" {
+			result = append(result, deployment)
+		}
 	}
 
-	return succeededAndFailedDeployments, err
+	return result, rerr.Error()
 }
 
 // deleteOutdatedDeployments keeps the newest deployments in the resource group and delete others,
@@ -258,9 +267,9 @@ func (as *AgentPool) deleteOutdatedDeployments() (err error) {
 	errList := make([]error, 0)
 	for _, deployment := range toBeDeleted {
 		klog.V(4).Infof("deleteOutdatedDeployments: starts deleting outdated deployment (%s)", *deployment.Name)
-		_, err := as.manager.azClient.deploymentsClient.Delete(ctx, as.manager.config.ResourceGroup, *deployment.Name)
-		if err != nil {
-			errList = append(errList, err)
+		rerr := as.manager.azClient.deploymentClient.Delete(ctx, as.manager.config.ResourceGroup, *deployment.Name)
+		if rerr != nil {
+			errList = append(errList, rerr.Error())
 		}
 	}
 
@@ -317,22 +326,20 @@ func (as *AgentPool) IncreaseSize(delta int) error {
 	}
 	ctx, cancel := getContextWithCancel()
 	defer cancel()
-	klog.V(3).Infof("Waiting for deploymentsClient.CreateOrUpdate(%s, %s, %v)", as.manager.config.ResourceGroup, newDeploymentName, newDeployment)
-	resp, err := as.manager.azClient.deploymentsClient.CreateOrUpdate(ctx, as.manager.config.ResourceGroup, newDeploymentName, newDeployment)
-	isSuccess, realError := isSuccessHTTPResponse(resp, err)
-	if isSuccess {
-		klog.V(3).Infof("deploymentsClient.CreateOrUpdate(%s, %s, %v) success", as.manager.config.ResourceGroup, newDeploymentName, newDeployment)
-
-		// Update cache after scale success.
-		as.curSize = int64(expectedSize)
-		as.lastRefresh = time.Now()
-		klog.V(6).Info("IncreaseSize: invalidating cache")
-		as.manager.invalidateCache()
-		return nil
+	klog.V(3).Infof("Waiting for deploymentClient.CreateOrUpdate(%s, %s, %v)", as.manager.config.ResourceGroup, newDeploymentName, newDeployment)
+	rerr := as.manager.azClient.deploymentClient.CreateOrUpdate(ctx, as.manager.config.ResourceGroup, newDeploymentName, newDeployment, "")
+	if rerr != nil {
+		klog.Errorf("deploymentClient.CreateOrUpdate for deployment %q failed: %v", newDeploymentName, rerr.Error())
+		return rerr.Error()
 	}
+	klog.V(3).Infof("deploymentClient.CreateOrUpdate(%s, %s, %v) success", as.manager.config.ResourceGroup, newDeploymentName, newDeployment)
 
-	klog.Errorf("deploymentsClient.CreateOrUpdate for deployment %q failed: %v", newDeploymentName, realError)
-	return realError
+	// Update cache after scale success.
+	as.curSize = int64(expectedSize)
+	as.lastRefresh = time.Now()
+	klog.V(6).Info("IncreaseSize: invalidating cache")
+	as.manager.invalidateCache()
+	return nil
 }
 
 // AtomicIncreaseSize is not implemented.
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_agent_pool_test.go b/cluster-autoscaler/cloudprovider/azure/azure_agent_pool_test.go
index 444f2f9f235c..a242e0b7b666 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_agent_pool_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_agent_pool_test.go
@@ -28,6 +28,7 @@ import (
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/storageaccountclient/mockstorageaccountclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmclient/mockvmclient"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
 	"sigs.k8s.io/cloud-provider-azure/pkg/retry"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute"
@@ -156,13 +157,13 @@ func TestDeleteOutdatedDeployments(t *testing.T) {
 
 	for _, test := range testCases {
 		testAS := newTestAgentPool(newTestAzureManager(t), "testAS")
-		testAS.manager.azClient.deploymentsClient = &DeploymentsClientMock{
+		testAS.manager.azClient.deploymentClient = &DeploymentClientMock{
 			FakeStore: test.deployments,
 		}
 
 		err := testAS.deleteOutdatedDeployments()
 		assert.Equal(t, test.expectedErr, err, test.desc)
-		existedDeployments, err := testAS.manager.azClient.deploymentsClient.List(context.Background(), "", "", to.Int32Ptr(0))
+		existedDeployments, _ := testAS.manager.azClient.deploymentClient.List(context.Background(), "")
 		existedDeploymentsNames := make(map[string]bool)
 		for _, deployment := range existedDeployments {
 			existedDeploymentsNames[*deployment.Name] = true
@@ -185,7 +186,7 @@ func TestGetVMsFromCache(t *testing.T) {
 	mockVMClient := mockvmclient.NewMockInterface(ctrl)
 	testAS.manager.azClient.virtualMachinesClient = mockVMClient
 	mockVMClient.EXPECT().List(gomock.Any(), testAS.manager.config.ResourceGroup).Return(expectedVMs, nil)
-	testAS.manager.config.VMType = vmTypeStandard
+	testAS.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(testAS.manager.azClient, refreshInterval, *testAS.manager.config)
 	assert.NoError(t, err)
 	testAS.manager.azureCache = ac
@@ -204,7 +205,7 @@ func TestGetVMIndexes(t *testing.T) {
 	mockVMClient := mockvmclient.NewMockInterface(ctrl)
 	as.manager.azClient.virtualMachinesClient = mockVMClient
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
@@ -244,7 +245,7 @@ func TestGetCurSize(t *testing.T) {
 	mockVMClient := mockvmclient.NewMockInterface(ctrl)
 	as.manager.azClient.virtualMachinesClient = mockVMClient
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
@@ -269,7 +270,7 @@ func TestAgentPoolTargetSize(t *testing.T) {
 	as.manager.azClient.virtualMachinesClient = mockVMClient
 	expectedVMs := getExpectedVMs()
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
@@ -289,7 +290,7 @@ func TestAgentPoolIncreaseSize(t *testing.T) {
 	as.manager.azClient.virtualMachinesClient = mockVMClient
 	expectedVMs := getExpectedVMs()
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil).MaxTimes(2)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
@@ -318,7 +319,7 @@ func TestDecreaseTargetSize(t *testing.T) {
 	as.manager.azClient.virtualMachinesClient = mockVMClient
 	expectedVMs := getExpectedVMs()
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil).MaxTimes(3)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
@@ -437,9 +438,9 @@ func TestAgentPoolDeleteNodes(t *testing.T) {
 	mockSAClient := mockstorageaccountclient.NewMockInterface(ctrl)
 	as.manager.azClient.storageAccountsClient = mockSAClient
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
-	as.manager.config.VMType = vmTypeVMSS
+	as.manager.config.VMType = providerazureconsts.VMTypeVMSS
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
 
@@ -505,7 +506,7 @@ func TestAgentPoolNodes(t *testing.T) {
 	mockVMClient := mockvmclient.NewMockInterface(ctrl)
 	as.manager.azClient.virtualMachinesClient = mockVMClient
 	mockVMClient.EXPECT().List(gomock.Any(), as.manager.config.ResourceGroup).Return(expectedVMs, nil)
-	as.manager.config.VMType = vmTypeStandard
+	as.manager.config.VMType = providerazureconsts.VMTypeStandard
 	ac, err := newAzureCache(as.manager.azClient, refreshInterval, *as.manager.config)
 	assert.NoError(t, err)
 	as.manager.azureCache = ac
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_cache.go b/cluster-autoscaler/cloudprovider/azure/azure_cache.go
index bb68567e8f40..c8334ac78771 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_cache.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_cache.go
@@ -28,6 +28,7 @@ import (
 	"github.com/Azure/go-autorest/autorest/to"
 	"github.com/Azure/skewer"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
 
 	"k8s.io/klog/v2"
 )
@@ -436,7 +437,7 @@ func (m *azureCache) FindForInstance(instance *azureRef, vmType string) (cloudpr
 	}
 
 	// cluster with vmss pool only
-	if vmType == vmTypeVMSS && len(vmsPoolSet) == 0 {
+	if vmType == providerazureconsts.VMTypeVMSS && len(vmsPoolSet) == 0 {
 		if m.areAllScaleSetsUniform() {
 			// Omit virtual machines not managed by vmss only in case of uniform scale set.
 			if ok := virtualMachineRE.Match([]byte(inst.Name)); ok {
@@ -447,7 +448,7 @@ func (m *azureCache) FindForInstance(instance *azureRef, vmType string) (cloudpr
 		}
 	}
 
-	if vmType == vmTypeStandard {
+	if vmType == providerazureconsts.VMTypeStandard {
 		// Omit virtual machines with providerID not in Azure resource ID format.
 		if ok := virtualMachineRE.Match([]byte(inst.Name)); !ok {
 			klog.V(3).Infof("Instance %q is not in Azure resource ID format, omit it in autoscaler", instance.Name)
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_cache_test.go b/cluster-autoscaler/cloudprovider/azure/azure_cache_test.go
index 2b87ab938486..3fd801afbe8f 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_cache_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_cache_test.go
@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -60,12 +61,12 @@ func TestFindForInstance(t *testing.T) {
 	inst := azureRef{Name: "/subscriptions/sub/resourceGroups/rg/providers/foo"}
 	ac.unownedInstances = make(map[azureRef]bool)
 	ac.unownedInstances[inst] = true
-	nodeGroup, err := ac.FindForInstance(&inst, vmTypeVMSS)
+	nodeGroup, err := ac.FindForInstance(&inst, providerazureconsts.VMTypeVMSS)
 	assert.Nil(t, nodeGroup)
 	assert.NoError(t, err)
 
 	ac.unownedInstances[inst] = false
-	nodeGroup, err = ac.FindForInstance(&inst, vmTypeStandard)
+	nodeGroup, err = ac.FindForInstance(&inst, providerazureconsts.VMTypeStandard)
 	assert.Nil(t, nodeGroup)
 	assert.NoError(t, err)
 	assert.True(t, ac.unownedInstances[inst])
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_client.go b/cluster-autoscaler/cloudprovider/azure/azure_client.go
index 2bf337a4e8d4..fbc39a62ed28 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_client.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_client.go
@@ -19,10 +19,6 @@ package azure
 import (
 	"context"
 	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"time"
 
 	_ "go.uber.org/mock/mockgen/model" // for go:generate
 
@@ -35,119 +31,22 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
 	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v4"
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-07-01/compute"
-	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2017-05-10/resources"
-	"github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage"
 	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
 	"github.com/Azure/go-autorest/autorest/azure/auth"
 
 	klog "k8s.io/klog/v2"
 
+	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/deploymentclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/diskclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/interfaceclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/storageaccountclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmssclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmssvmclient"
+	providerazureconfig "sigs.k8s.io/cloud-provider-azure/pkg/provider/config"
 )
 
-// DeploymentsClient defines needed functions for azure network.DeploymentsClient.
-type DeploymentsClient interface {
-	Get(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExtended, err error)
-	List(ctx context.Context, resourceGroupName string, filter string, top *int32) (result []resources.DeploymentExtended, err error)
-	ExportTemplate(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExportResult, err error)
-	CreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, parameters resources.Deployment) (resp *http.Response, err error)
-	Delete(ctx context.Context, resourceGroupName string, deploymentName string) (resp *http.Response, err error)
-}
-
-type azDeploymentsClient struct {
-	client resources.DeploymentsClient
-}
-
-func newAzDeploymentsClient(subscriptionID, endpoint string, authorizer autorest.Authorizer) *azDeploymentsClient {
-	deploymentsClient := resources.NewDeploymentsClient(subscriptionID)
-	deploymentsClient.BaseURI = endpoint
-	deploymentsClient.Authorizer = authorizer
-	deploymentsClient.PollingDelay = 5 * time.Second
-	configureUserAgent(&deploymentsClient.Client)
-
-	return &azDeploymentsClient{
-		client: deploymentsClient,
-	}
-}
-
-func (az *azDeploymentsClient) Get(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExtended, err error) {
-	klog.V(10).Infof("azDeploymentsClient.Get(%q,%q): start", resourceGroupName, deploymentName)
-	defer func() {
-		klog.V(10).Infof("azDeploymentsClient.Get(%q,%q): end", resourceGroupName, deploymentName)
-	}()
-
-	return az.client.Get(ctx, resourceGroupName, deploymentName)
-}
-
-func (az *azDeploymentsClient) ExportTemplate(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExportResult, err error) {
-	klog.V(10).Infof("azDeploymentsClient.ExportTemplate(%q,%q): start", resourceGroupName, deploymentName)
-	defer func() {
-		klog.V(10).Infof("azDeploymentsClient.ExportTemplate(%q,%q): end", resourceGroupName, deploymentName)
-	}()
-
-	return az.client.ExportTemplate(ctx, resourceGroupName, deploymentName)
-}
-
-func (az *azDeploymentsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, parameters resources.Deployment) (resp *http.Response, err error) {
-	klog.V(10).Infof("azDeploymentsClient.CreateOrUpdate(%q,%q): start", resourceGroupName, deploymentName)
-	defer func() {
-		klog.V(10).Infof("azDeploymentsClient.CreateOrUpdate(%q,%q): end", resourceGroupName, deploymentName)
-	}()
-
-	future, err := az.client.CreateOrUpdate(ctx, resourceGroupName, deploymentName, parameters)
-	if err != nil {
-		return future.Response(), err
-	}
-
-	err = future.WaitForCompletionRef(ctx, az.client.Client)
-	return future.Response(), err
-}
-
-func (az *azDeploymentsClient) List(ctx context.Context, resourceGroupName, filter string, top *int32) (result []resources.DeploymentExtended, err error) {
-	klog.V(10).Infof("azDeploymentsClient.List(%q): start", resourceGroupName)
-	defer func() {
-		klog.V(10).Infof("azDeploymentsClient.List(%q): end", resourceGroupName)
-	}()
-
-	iterator, err := az.client.ListByResourceGroupComplete(ctx, resourceGroupName, filter, top)
-	if err != nil {
-		return nil, err
-	}
-
-	result = make([]resources.DeploymentExtended, 0)
-	for ; iterator.NotDone(); err = iterator.Next() {
-		if err != nil {
-			return nil, err
-		}
-
-		result = append(result, iterator.Value())
-	}
-
-	return result, err
-}
-
-func (az *azDeploymentsClient) Delete(ctx context.Context, resourceGroupName, deploymentName string) (resp *http.Response, err error) {
-	klog.V(10).Infof("azDeploymentsClient.Delete(%q,%q): start", resourceGroupName, deploymentName)
-	defer func() {
-		klog.V(10).Infof("azDeploymentsClient.Delete(%q,%q): end", resourceGroupName, deploymentName)
-	}()
-
-	future, err := az.client.Delete(ctx, resourceGroupName, deploymentName)
-	if err != nil {
-		return future.Response(), err
-	}
-
-	err = future.WaitForCompletionRef(ctx, az.client.Client)
-	return future.Response(), err
-}
-
 //go:generate sh -c "mockgen k8s.io/autoscaler/cluster-autoscaler/cloudprovider/azure AgentPoolsClient >./agentpool_client.go"
 
 // AgentPoolsClient interface defines the methods needed for scaling vms pool.
@@ -260,15 +159,11 @@ func newAgentpoolClientWithPublicEndpoint(cfg *Config, retryOptions azurecore_po
 	return newAgentpoolClientWithConfig(cfg.SubscriptionID, cred, env.ResourceManagerEndpoint, env.TokenAudience, retryOptions)
 }
 
-type azAccountsClient struct {
-	client storage.AccountsClient
-}
-
 type azClient struct {
 	virtualMachineScaleSetsClient   vmssclient.Interface
 	virtualMachineScaleSetVMsClient vmssvmclient.Interface
 	virtualMachinesClient           vmclient.Interface
-	deploymentsClient               DeploymentsClient
+	deploymentClient                deploymentclient.Interface
 	interfacesClient                interfaceclient.Interface
 	disksClient                     diskclient.Interface
 	storageAccountsClient           storageaccountclient.Interface
@@ -276,80 +171,12 @@ type azClient struct {
 	agentPoolClient                 AgentPoolsClient
 }
 
-// newServicePrincipalTokenFromCredentials creates a new ServicePrincipalToken using values of the
-// passed credentials map.
-func newServicePrincipalTokenFromCredentials(config *Config, env *azure.Environment) (*adal.ServicePrincipalToken, error) {
-	oauthConfig, err := adal.NewOAuthConfig(env.ActiveDirectoryEndpoint, config.TenantID)
-	if err != nil {
-		return nil, fmt.Errorf("creating the OAuth config: %v", err)
-	}
-
-	if config.UseWorkloadIdentityExtension {
-		klog.V(2).Infoln("azure: using workload identity extension to retrieve access token")
-		jwt, err := os.ReadFile(config.AADFederatedTokenFile)
-		if err != nil {
-			return nil, fmt.Errorf("failed to read a file with a federated token: %v", err)
-		}
-		token, err := adal.NewServicePrincipalTokenFromFederatedToken(*oauthConfig, config.AADClientID, string(jwt), env.ResourceManagerEndpoint)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create a workload identity token: %v", err)
-		}
-		return token, nil
-	}
-	if config.UseManagedIdentityExtension {
-		klog.V(2).Infoln("azure: using managed identity extension to retrieve access token")
-		msiEndpoint, err := adal.GetMSIVMEndpoint()
-		if err != nil {
-			return nil, fmt.Errorf("getting the managed service identity endpoint: %v", err)
-		}
-		if config.UserAssignedIdentityID != "" {
-			klog.V(4).Info("azure: using User Assigned MSI ID to retrieve access token")
-			return adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint,
-				env.ServiceManagementEndpoint,
-				config.UserAssignedIdentityID)
-		}
-		klog.V(4).Info("azure: using System Assigned MSI to retrieve access token")
-		return adal.NewServicePrincipalTokenFromMSI(
-			msiEndpoint,
-			env.ServiceManagementEndpoint)
-	}
-
-	if config.AADClientSecret != "" {
-		klog.V(2).Infoln("azure: using client_id+client_secret to retrieve access token")
-		return adal.NewServicePrincipalToken(
-			*oauthConfig,
-			config.AADClientID,
-			config.AADClientSecret,
-			env.ServiceManagementEndpoint)
-	}
-
-	if config.AADClientCertPath != "" {
-		klog.V(2).Infoln("azure: using jwt client_assertion (client_cert+client_private_key) to retrieve access token")
-		certData, err := ioutil.ReadFile(config.AADClientCertPath)
-		if err != nil {
-			return nil, fmt.Errorf("reading the client certificate from file %s: %v", config.AADClientCertPath, err)
-		}
-		certificate, privateKey, err := adal.DecodePfxCertificateData(certData, config.AADClientCertPassword)
-		if err != nil {
-			return nil, fmt.Errorf("decoding the client certificate: %v", err)
-		}
-		return adal.NewServicePrincipalTokenFromCertificate(
-			*oauthConfig,
-			config.AADClientID,
-			certificate,
-			privateKey,
-			env.ServiceManagementEndpoint)
-	}
-
-	return nil, fmt.Errorf("no credentials provided for AAD application %s", config.AADClientID)
-}
-
 func newAuthorizer(config *Config, env *azure.Environment) (autorest.Authorizer, error) {
 	switch config.AuthMethod {
 	case authMethodCLI:
 		return auth.NewAuthorizerFromCLI()
 	case "", authMethodPrincipal:
-		token, err := newServicePrincipalTokenFromCredentials(config, env)
+		token, err := providerazureconfig.GetServicePrincipalToken(&config.AzureAuthConfig, env, "")
 		if err != nil {
 			return nil, fmt.Errorf("retrieve service principal token: %v", err)
 		}
@@ -380,8 +207,9 @@ func newAzClient(cfg *Config, env *azure.Environment) (*azClient, error) {
 	virtualMachinesClient := vmclient.New(vmClientConfig)
 	klog.V(5).Infof("Created vm client with authorizer: %v", virtualMachinesClient)
 
-	deploymentsClient := newAzDeploymentsClient(cfg.SubscriptionID, env.ResourceManagerEndpoint, authorizer)
-	klog.V(5).Infof("Created deployments client with authorizer: %v", deploymentsClient)
+	deploymentConfig := azClientConfig.WithRateLimiter(cfg.DeploymentRateLimit)
+	deploymentClient := deploymentclient.New(deploymentConfig)
+	klog.V(5).Infof("Created deployments client with authorizer: %v", deploymentClient)
 
 	interfaceClientConfig := azClientConfig.WithRateLimiter(cfg.InterfaceRateLimit)
 	interfacesClient := interfaceclient.New(interfaceClientConfig)
@@ -414,7 +242,7 @@ func newAzClient(cfg *Config, env *azure.Environment) (*azClient, error) {
 		interfacesClient:                interfacesClient,
 		virtualMachineScaleSetsClient:   scaleSetsClient,
 		virtualMachineScaleSetVMsClient: scaleSetVMsClient,
-		deploymentsClient:               deploymentsClient,
+		deploymentClient:                deploymentClient,
 		virtualMachinesClient:           virtualMachinesClient,
 		storageAccountsClient:           storageAccountsClient,
 		skuClient:                       skuClient,
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_client_test.go b/cluster-autoscaler/cloudprovider/azure/azure_client_test.go
index 7ed0dd4c01f7..a1e94d9a5316 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_client_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_client_test.go
@@ -23,17 +23,28 @@ import (
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
 	"github.com/stretchr/testify/assert"
+	azclient "sigs.k8s.io/cloud-provider-azure/pkg/azclient"
+	providerazure "sigs.k8s.io/cloud-provider-azure/pkg/provider"
+	providerazureconfig "sigs.k8s.io/cloud-provider-azure/pkg/provider/config"
 )
 
 func TestGetServicePrincipalTokenFromCertificate(t *testing.T) {
 	config := &Config{
-		TenantID:              "TenantID",
-		AADClientID:           "AADClientID",
-		AADClientCertPath:     "./testdata/test.pfx",
-		AADClientCertPassword: "id",
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					TenantID: "TenantID",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:           "AADClientID",
+					AADClientCertPath:     "./testdata/test.pfx",
+					AADClientCertPassword: "id",
+				},
+			},
+		},
 	}
 	env := &azure.PublicCloud
-	token, err := newServicePrincipalTokenFromCredentials(config, env)
+	token, err := providerazureconfig.GetServicePrincipalToken(&config.AzureAuthConfig, env, "")
 	assert.NoError(t, err)
 
 	oauthConfig, err := adal.NewOAuthConfig(env.ActiveDirectoryEndpoint, config.TenantID)
@@ -45,17 +56,25 @@ func TestGetServicePrincipalTokenFromCertificate(t *testing.T) {
 	spt, err := adal.NewServicePrincipalTokenFromCertificate(
 		*oauthConfig, config.AADClientID, certificate, privateKey, env.ServiceManagementEndpoint)
 	assert.NoError(t, err)
-	assert.Equal(t, token, spt)
+	assert.Equal(t, token.Token(), spt.Token())
 }
 
 func TestGetServicePrincipalTokenFromCertificateWithoutPassword(t *testing.T) {
 	config := &Config{
-		TenantID:          "TenantID",
-		AADClientID:       "AADClientID",
-		AADClientCertPath: "./testdata/testnopassword.pfx",
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					TenantID: "TenantID",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:       "AADClientID",
+					AADClientCertPath: "./testdata/testnopassword.pfx",
+				},
+			},
+		},
 	}
 	env := &azure.PublicCloud
-	token, err := newServicePrincipalTokenFromCredentials(config, env)
+	token, err := providerazureconfig.GetServicePrincipalToken(&config.AzureAuthConfig, env, "")
 	assert.NoError(t, err)
 
 	oauthConfig, err := adal.NewOAuthConfig(env.ActiveDirectoryEndpoint, config.TenantID)
@@ -67,5 +86,5 @@ func TestGetServicePrincipalTokenFromCertificateWithoutPassword(t *testing.T) {
 	spt, err := adal.NewServicePrincipalTokenFromCertificate(
 		*oauthConfig, config.AADClientID, certificate, privateKey, env.ServiceManagementEndpoint)
 	assert.NoError(t, err)
-	assert.Equal(t, token, spt)
+	assert.Equal(t, token.Token(), spt.Token())
 }
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_cloud_provider_test.go b/cluster-autoscaler/cloudprovider/azure/azure_cloud_provider_test.go
index da37ed8492da..cd88602da479 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_cloud_provider_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_cloud_provider_test.go
@@ -31,6 +31,8 @@ import (
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmclient/mockvmclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmssclient/mockvmssclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmssvmclient/mockvmssvmclient"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
+	providerazure "sigs.k8s.io/cloud-provider-azure/pkg/provider"
 
 	"github.com/Azure/go-autorest/autorest/azure"
 	"github.com/stretchr/testify/assert"
@@ -55,18 +57,20 @@ func newTestAzureManager(t *testing.T) *AzureManager {
 		env:                  azure.PublicCloud,
 		explicitlyConfigured: make(map[string]bool),
 		config: &Config{
-			ResourceGroup:       "rg",
-			VMType:              vmTypeVMSS,
+			Config: providerazure.Config{
+				ResourceGroup: "rg",
+				VMType:        providerazureconsts.VMTypeVMSS,
+				Location:      "eastus",
+			},
 			MaxDeploymentsCount: 2,
 			Deployment:          "deployment",
 			EnableForceDelete:   true,
-			Location:            "eastus",
 		},
 		azClient: &azClient{
 			virtualMachineScaleSetsClient:   mockVMSSClient,
 			virtualMachineScaleSetVMsClient: mockVMSSVMClient,
 			virtualMachinesClient:           mockVMClient,
-			deploymentsClient: &DeploymentsClientMock{
+			deploymentClient: &DeploymentClientMock{
 				FakeStore: map[string]resources.DeploymentExtended{
 					"deployment": {
 						Name: to.StringPtr("deployment"),
@@ -332,7 +336,7 @@ func TestNodeGroupForNode(t *testing.T) {
 				mockVMSSVMClient.EXPECT().List(gomock.Any(), provider.azureManager.config.ResourceGroup, "test-asg", gomock.Any()).Return(expectedVMSSVMs, nil).AnyTimes()
 				provider.azureManager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 			} else {
-				provider.azureManager.config.EnableVmssFlex = true
+				provider.azureManager.config.EnableVmssFlexNodes = true
 				mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 			}
 
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_config.go b/cluster-autoscaler/cloudprovider/azure/azure_config.go
index 6c354c2a23e4..49d0bdf32d4d 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_config.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_config.go
@@ -18,7 +18,6 @@ package azure
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -32,7 +31,9 @@ import (
 	"github.com/Azure/go-autorest/autorest/azure"
 	"k8s.io/klog/v2"
 	azclients "sigs.k8s.io/cloud-provider-azure/pkg/azureclients"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
 	providerazure "sigs.k8s.io/cloud-provider-azure/pkg/provider"
+	providerazureconfig "sigs.k8s.io/cloud-provider-azure/pkg/provider/config"
 	"sigs.k8s.io/cloud-provider-azure/pkg/retry"
 )
 
@@ -42,60 +43,23 @@ const (
 
 	imdsServerURL = "http://169.254.169.254"
 
-	// backoff
-	backoffRetriesDefault  = 6
-	backoffExponentDefault = 1.5
-	backoffDurationDefault = 5 // in seconds
-	backoffJitterDefault   = 1.0
-
-	// rate limit
-	rateLimitQPSDefault         float32 = 1.0
-	rateLimitBucketDefault              = 5
-	rateLimitReadQPSEnvVar              = "RATE_LIMIT_READ_QPS"
-	rateLimitReadBucketsEnvVar          = "RATE_LIMIT_READ_BUCKETS"
-	rateLimitWriteQPSEnvVar             = "RATE_LIMIT_WRITE_QPS"
-	rateLimitWriteBucketsEnvVar         = "RATE_LIMIT_WRITE_BUCKETS"
-
-	// VmssSizeRefreshPeriodDefault in seconds
-	VmssSizeRefreshPeriodDefault = 30
-
 	// auth methods
 	authMethodPrincipal = "principal"
 	authMethodCLI       = "cli"
-
-	// toggle
-	dynamicInstanceListDefault = false
-	enableVmssFlexDefault      = false
 )
 
-// CloudProviderRateLimitConfig indicates the rate limit config for each clients.
-type CloudProviderRateLimitConfig struct {
-	// The default rate limit config options.
-	azclients.RateLimitConfig
-
-	// Rate limit config for each clients. Values would override default settings above.
-	InterfaceRateLimit              *azclients.RateLimitConfig `json:"interfaceRateLimit,omitempty" yaml:"interfaceRateLimit,omitempty"`
-	VirtualMachineRateLimit         *azclients.RateLimitConfig `json:"virtualMachineRateLimit,omitempty" yaml:"virtualMachineRateLimit,omitempty"`
-	StorageAccountRateLimit         *azclients.RateLimitConfig `json:"storageAccountRateLimit,omitempty" yaml:"storageAccountRateLimit,omitempty"`
-	DiskRateLimit                   *azclients.RateLimitConfig `json:"diskRateLimit,omitempty" yaml:"diskRateLimit,omitempty"`
-	VirtualMachineScaleSetRateLimit *azclients.RateLimitConfig `json:"virtualMachineScaleSetRateLimit,omitempty" yaml:"virtualMachineScaleSetRateLimit,omitempty"`
-	KubernetesServiceRateLimit      *azclients.RateLimitConfig `json:"kubernetesServiceRateLimit,omitempty" yaml:"kubernetesServiceRateLimit,omitempty"`
-}
-
-// Config holds the configuration parsed from the --cloud-config flag
+// Config holds the configuration parsed from the --cloud-config flag or the environment variables.
+// Contains both general Azure cloud provider configuration (i.e., in azure.json) and CAS configurations/options specifically for Azure provider.
 type Config struct {
-	CloudProviderRateLimitConfig
-
-	Cloud          string `json:"cloud" yaml:"cloud"`
-	Location       string `json:"location" yaml:"location"`
-	TenantID       string `json:"tenantId" yaml:"tenantId"`
-	SubscriptionID string `json:"subscriptionId" yaml:"subscriptionId"`
-	ClusterName    string `json:"clusterName" yaml:"clusterName"`
-	// ResourceGroup is the MC_ resource group where the nodes are located.
-	ResourceGroup string `json:"resourceGroup" yaml:"resourceGroup"`
+	// Azure cloud provider configuration, which is generally shared with other Azure components.
+	providerazure.Config `json:",inline" yaml:",inline"`
+
+	// Legacy fields, which are only here for backward compatibility. To be deprecated.
+	legacyConfig `json:",inline" yaml:",inline"`
+
+	ClusterName string `json:"clusterName" yaml:"clusterName"`
 	// ClusterResourceGroup is the resource group where the cluster is located.
 	ClusterResourceGroup string `json:"clusterResourceGroup" yaml:"clusterResourceGroup"`
-	VMType               string `json:"vmType" yaml:"vmType"`
 
 	// ARMBaseURLForAPClient is the URL to use for operations for the VMs pool.
 	// It can override the default public ARM endpoint for VMs pool scale operations.
@@ -105,51 +69,26 @@ type Config struct {
 	// cloud. Valid options are "principal" (= the traditional
 	// service principle approach) and "cli" (= load az command line
 	// config file). The default is "principal".
+	// 08/16/2024: This field is awkward, given the existence of UseManagedIdentityExtension and UseFederatedWorkloadIdentityExtension.
+	// Ideally, either it should be deprecated, or reworked to be on the same "dimension" as the two above, if not reworking those two.
 	AuthMethod string `json:"authMethod" yaml:"authMethod"`
 
-	// Settings for a service principal.
-
-	AADClientID                  string `json:"aadClientId" yaml:"aadClientId"`
-	AADClientSecret              string `json:"aadClientSecret" yaml:"aadClientSecret"`
-	AADClientCertPath            string `json:"aadClientCertPath" yaml:"aadClientCertPath"`
-	AADClientCertPassword        string `json:"aadClientCertPassword" yaml:"aadClientCertPassword"`
-	AADFederatedTokenFile        string `json:"aadFederatedTokenFile" yaml:"aadFederatedTokenFile"`
-	UseManagedIdentityExtension  bool   `json:"useManagedIdentityExtension" yaml:"useManagedIdentityExtension"`
-	UseWorkloadIdentityExtension bool   `json:"useWorkloadIdentityExtension" yaml:"useWorkloadIdentityExtension"`
-	UserAssignedIdentityID       string `json:"userAssignedIdentityID" yaml:"userAssignedIdentityID"`
-
 	// Configs only for standard vmType (agent pools).
 	Deployment           string                 `json:"deployment" yaml:"deployment"`
 	DeploymentParameters map[string]interface{} `json:"deploymentParameters" yaml:"deploymentParameters"`
 
-	// VMSS metadata cache TTL in seconds, only applies for vmss type
-	VmssCacheTTL int64 `json:"vmssCacheTTL" yaml:"vmssCacheTTL"`
-
-	// VMSS instances cache TTL in seconds, only applies for vmss type
-	VmssVmsCacheTTL int64 `json:"vmssVmsCacheTTL" yaml:"vmssVmsCacheTTL"`
-
 	// Jitter in seconds subtracted from the VMSS cache TTL before the first refresh
 	VmssVmsCacheJitter int `json:"vmssVmsCacheJitter" yaml:"vmssVmsCacheJitter"`
 
 	// number of latest deployments that will not be deleted
 	MaxDeploymentsCount int64 `json:"maxDeploymentsCount" yaml:"maxDeploymentsCount"`
 
-	// Enable exponential backoff to manage resource request retries
-	CloudProviderBackoff         bool    `json:"cloudProviderBackoff,omitempty" yaml:"cloudProviderBackoff,omitempty"`
-	CloudProviderBackoffRetries  int     `json:"cloudProviderBackoffRetries,omitempty" yaml:"cloudProviderBackoffRetries,omitempty"`
-	CloudProviderBackoffExponent float64 `json:"cloudProviderBackoffExponent,omitempty" yaml:"cloudProviderBackoffExponent,omitempty"`
-	CloudProviderBackoffDuration int     `json:"cloudProviderBackoffDuration,omitempty" yaml:"cloudProviderBackoffDuration,omitempty"`
-	CloudProviderBackoffJitter   float64 `json:"cloudProviderBackoffJitter,omitempty" yaml:"cloudProviderBackoffJitter,omitempty"`
-
 	// EnableForceDelete defines whether to enable force deletion on the APIs
 	EnableForceDelete bool `json:"enableForceDelete,omitempty" yaml:"enableForceDelete,omitempty"`
 
 	// EnableDynamicInstanceList defines whether to enable dynamic instance workflow for instance information check
 	EnableDynamicInstanceList bool `json:"enableDynamicInstanceList,omitempty" yaml:"enableDynamicInstanceList,omitempty"`
 
-	// EnableVmssFlex defines whether to enable Vmss Flex support or not
-	EnableVmssFlex bool `json:"enableVmssFlex,omitempty" yaml:"enableVmssFlex,omitempty"`
-
 	// (DEPRECATED, DO NOT USE) EnableDetailedCSEMessage defines whether to emit error messages in the CSE error body info
 	EnableDetailedCSEMessage bool `json:"enableDetailedCSEMessage,omitempty" yaml:"enableDetailedCSEMessage,omitempty"`
 
@@ -157,11 +96,34 @@ type Config struct {
 	GetVmssSizeRefreshPeriod int `json:"getVmssSizeRefreshPeriod,omitempty" yaml:"getVmssSizeRefreshPeriod,omitempty"`
 }
 
+// These are only here for backward compabitility. Their equivalent exists in providerazure.Config with a different name.
+type legacyConfig struct {
+	// Being renamed to UseFederatedWorkloadIdentityExtension
+	UseWorkloadIdentityExtension *bool `json:"useWorkloadIdentityExtension" yaml:"useWorkloadIdentityExtension"`
+	// VMSS metadata cache TTL in seconds, only applies for vmss type; being renamed to VmssCacheTTLInSeconds
+	VmssCacheTTL *int64 `json:"vmssCacheTTL" yaml:"vmssCacheTTL"`
+	// VMSS instances cache TTL in seconds, only applies for vmss type; being renamed to VmssVirtualMachinesCacheTTLInSeconds
+	VmssVmsCacheTTL *int64 `json:"vmssVmsCacheTTL" yaml:"vmssVmsCacheTTL"`
+	// EnableVmssFlex defines whether to enable Vmss Flex support or not; being renamed to EnableVmssFlexNodes
+	EnableVmssFlex *bool `json:"enableVmssFlex,omitempty" yaml:"enableVmssFlex,omitempty"`
+}
+
 // BuildAzureConfig returns a Config object for the Azure clients
 func BuildAzureConfig(configReader io.Reader) (*Config, error) {
 	var err error
 	cfg := &Config{}
 
+	// Static defaults
+	cfg.EnableDynamicInstanceList = false
+	cfg.EnableVmssFlexNodes = false
+	cfg.CloudProviderBackoffRetries = providerazureconsts.BackoffRetriesDefault
+	cfg.CloudProviderBackoffExponent = providerazureconsts.BackoffExponentDefault
+	cfg.CloudProviderBackoffDuration = providerazureconsts.BackoffDurationDefault
+	cfg.CloudProviderBackoffJitter = providerazureconsts.BackoffJitterDefault
+	cfg.VMType = providerazureconsts.VMTypeVMSS
+	cfg.MaxDeploymentsCount = int64(defaultMaxDeploymentsCount)
+
+	// Config file overrides defaults
 	if configReader != nil {
 		body, err := ioutil.ReadAll(configReader)
 		if err != nil {
@@ -171,192 +133,181 @@ func BuildAzureConfig(configReader io.Reader) (*Config, error) {
 		if err != nil {
 			return nil, fmt.Errorf("failed to unmarshal config body: %v", err)
 		}
-	} else {
-		cfg.Cloud = os.Getenv("ARM_CLOUD")
-		cfg.Location = os.Getenv("LOCATION")
-		cfg.ResourceGroup = os.Getenv("ARM_RESOURCE_GROUP")
-		cfg.TenantID = os.Getenv("ARM_TENANT_ID")
-		if tenantId := os.Getenv("AZURE_TENANT_ID"); tenantId != "" {
-			cfg.TenantID = tenantId
-		}
-		cfg.AADClientID = os.Getenv("ARM_CLIENT_ID")
-		if clientId := os.Getenv("AZURE_CLIENT_ID"); clientId != "" {
-			cfg.AADClientID = clientId
-		}
-		cfg.AADFederatedTokenFile = os.Getenv("AZURE_FEDERATED_TOKEN_FILE")
-		cfg.AADClientSecret = os.Getenv("ARM_CLIENT_SECRET")
-		cfg.VMType = strings.ToLower(os.Getenv("ARM_VM_TYPE"))
-		cfg.AADClientCertPath = os.Getenv("ARM_CLIENT_CERT_PATH")
-		cfg.AADClientCertPassword = os.Getenv("ARM_CLIENT_CERT_PASSWORD")
-		cfg.Deployment = os.Getenv("ARM_DEPLOYMENT")
-
-		subscriptionID, err := getSubscriptionIdFromInstanceMetadata()
-		if err != nil {
-			return nil, err
-		}
-		cfg.SubscriptionID = subscriptionID
-
-		useManagedIdentityExtensionFromEnv := os.Getenv("ARM_USE_MANAGED_IDENTITY_EXTENSION")
-		if len(useManagedIdentityExtensionFromEnv) > 0 {
-			cfg.UseManagedIdentityExtension, err = strconv.ParseBool(useManagedIdentityExtensionFromEnv)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		useWorkloadIdentityExtensionFromEnv := os.Getenv("ARM_USE_WORKLOAD_IDENTITY_EXTENSION")
-		if len(useWorkloadIdentityExtensionFromEnv) > 0 {
-			cfg.UseWorkloadIdentityExtension, err = strconv.ParseBool(useWorkloadIdentityExtensionFromEnv)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		if cfg.UseManagedIdentityExtension && cfg.UseWorkloadIdentityExtension {
-			return nil, errors.New("you can not combine both managed identity and workload identity as an authentication mechanism")
-		}
-
-		userAssignedIdentityIDFromEnv := os.Getenv("ARM_USER_ASSIGNED_IDENTITY_ID")
-		if userAssignedIdentityIDFromEnv != "" {
-			cfg.UserAssignedIdentityID = userAssignedIdentityIDFromEnv
-		}
-
-		if vmssCacheTTL := os.Getenv("AZURE_VMSS_CACHE_TTL"); vmssCacheTTL != "" {
-			cfg.VmssCacheTTL, err = strconv.ParseInt(vmssCacheTTL, 10, 0)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_VMSS_CACHE_TTL %q: %v", vmssCacheTTL, err)
-			}
-		}
-
-		if vmssVmsCacheTTL := os.Getenv("AZURE_VMSS_VMS_CACHE_TTL"); vmssVmsCacheTTL != "" {
-			cfg.VmssVmsCacheTTL, err = strconv.ParseInt(vmssVmsCacheTTL, 10, 0)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_VMSS_VMS_CACHE_TTL %q: %v", vmssVmsCacheTTL, err)
-			}
-		}
-
-		if vmssVmsCacheJitter := os.Getenv("AZURE_VMSS_VMS_CACHE_JITTER"); vmssVmsCacheJitter != "" {
-			cfg.VmssVmsCacheJitter, err = strconv.Atoi(vmssVmsCacheJitter)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_VMSS_VMS_CACHE_JITTER %q: %v", vmssVmsCacheJitter, err)
-			}
-		}
+	}
 
-		if threshold := os.Getenv("AZURE_MAX_DEPLOYMENT_COUNT"); threshold != "" {
-			cfg.MaxDeploymentsCount, err = strconv.ParseInt(threshold, 10, 0)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_MAX_DEPLOYMENT_COUNT %q: %v", threshold, err)
-			}
+	// Legacy config fields, take precedence if provided.
+	if cfg.UseWorkloadIdentityExtension != nil {
+		cfg.UseFederatedWorkloadIdentityExtension = *cfg.UseWorkloadIdentityExtension
+	}
+	if cfg.VmssCacheTTL != nil {
+		if *cfg.VmssCacheTTL > int64(^uint32(0)) {
+			return nil, fmt.Errorf("VmssCacheTTL value %d is too large", *cfg.VmssCacheTTL)
 		}
-
-		if enableBackoff := os.Getenv("ENABLE_BACKOFF"); enableBackoff != "" {
-			cfg.CloudProviderBackoff, err = strconv.ParseBool(enableBackoff)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse ENABLE_BACKOFF %q: %v", enableBackoff, err)
-			}
+		cfg.VmssCacheTTLInSeconds = int(*cfg.VmssCacheTTL)
+	}
+	if cfg.VmssVmsCacheTTL != nil {
+		if *cfg.VmssVmsCacheTTL > int64(^uint32(0)) {
+			return nil, fmt.Errorf("VmssVmsCacheTTL value %d is too large", *cfg.VmssVmsCacheTTL)
 		}
+		cfg.VmssVirtualMachinesCacheTTLInSeconds = int(*cfg.VmssVmsCacheTTL)
+	}
+	if cfg.EnableVmssFlex != nil {
+		cfg.EnableVmssFlexNodes = *cfg.EnableVmssFlex
+	}
 
-		if enableDynamicInstanceList := os.Getenv("AZURE_ENABLE_DYNAMIC_INSTANCE_LIST"); enableDynamicInstanceList != "" {
-			cfg.EnableDynamicInstanceList, err = strconv.ParseBool(enableDynamicInstanceList)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_ENABLE_DYNAMIC_INSTANCE_LIST %q: %v", enableDynamicInstanceList, err)
-			}
-		} else {
-			cfg.EnableDynamicInstanceList = dynamicInstanceListDefault
+	// Each of these environment variables, if provided, will override what's in the config file.
+	// Note that this "retrieval from env" does not exist in cloud-provider-azure library (at the time of this comment).
+	if _, err = assignFromEnvIfExists(&cfg.ClusterName, "CLUSTER_NAME"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.ClusterResourceGroup, "ARM_CLUSTER_RESOURCE_GROUP"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.ARMBaseURLForAPClient, "ARM_BASE_URL_FOR_AP_CLIENT"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.Cloud, "ARM_CLOUD"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.Location, "LOCATION"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.ResourceGroup, "ARM_RESOURCE_GROUP"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.TenantID, "ARM_TENANT_ID"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.TenantID, "AZURE_TENANT_ID"); err != nil { // taking precedence
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.AADClientID, "ARM_CLIENT_ID"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.AADClientID, "AZURE_CLIENT_ID"); err != nil { // taking precedence
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.AADFederatedTokenFile, "AZURE_FEDERATED_TOKEN_FILE"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.AADClientSecret, "ARM_CLIENT_SECRET"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.VMType, "ARM_VM_TYPE"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.AADClientCertPath, "ARM_CLIENT_CERT_PATH"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.AADClientCertPassword, "ARM_CLIENT_CERT_PASSWORD"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.Deployment, "ARM_DEPLOYMENT"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.SubscriptionID, "ARM_SUBSCRIPTION_ID"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.UseManagedIdentityExtension, "ARM_USE_MANAGED_IDENTITY_EXTENSION"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.UseFederatedWorkloadIdentityExtension, "ARM_USE_FEDERATED_WORKLOAD_IDENTITY_EXTENSION"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.UseFederatedWorkloadIdentityExtension, "ARM_USE_WORKLOAD_IDENTITY_EXTENSION"); err != nil { // taking precedence
+		return nil, err
+	}
+	if _, err = assignFromEnvIfExists(&cfg.UserAssignedIdentityID, "ARM_USER_ASSIGNED_IDENTITY_ID"); err != nil {
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.VmssCacheTTLInSeconds, "AZURE_VMSS_CACHE_TTL_IN_SECONDS"); err != nil {
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.VmssCacheTTLInSeconds, "AZURE_VMSS_CACHE_TTL"); err != nil { // taking precedence
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.VmssVirtualMachinesCacheTTLInSeconds, "AZURE_VMSS_VMS_CACHE_TTL_IN_SECONDS"); err != nil {
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.VmssVirtualMachinesCacheTTLInSeconds, "AZURE_VMSS_VMS_CACHE_TTL"); err != nil { // taking precedence
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.VmssVmsCacheJitter, "AZURE_VMSS_VMS_CACHE_JITTER"); err != nil {
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.GetVmssSizeRefreshPeriod, "AZURE_GET_VMSS_SIZE_REFRESH_PERIOD"); err != nil {
+		return nil, err
+	}
+	if _, err = assignInt64FromEnvIfExists(&cfg.MaxDeploymentsCount, "AZURE_MAX_DEPLOYMENT_COUNT"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.CloudProviderBackoff, "ENABLE_BACKOFF"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.EnableForceDelete, "AZURE_ENABLE_FORCE_DELETE"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.EnableDynamicInstanceList, "AZURE_ENABLE_DYNAMIC_INSTANCE_LIST"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.EnableVmssFlexNodes, "AZURE_ENABLE_VMSS_FLEX_NODES"); err != nil {
+		return nil, err
+	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.EnableVmssFlexNodes, "AZURE_ENABLE_VMSS_FLEX"); err != nil { // taking precedence
+		return nil, err
+	}
+	if cfg.CloudProviderBackoff {
+		if _, err = assignIntFromEnvIfExists(&cfg.CloudProviderBackoffRetries, "BACKOFF_RETRIES"); err != nil {
+			return nil, err
 		}
-
-		if getVmssSizeRefreshPeriod := os.Getenv("AZURE_GET_VMSS_SIZE_REFRESH_PERIOD"); getVmssSizeRefreshPeriod != "" {
-			cfg.GetVmssSizeRefreshPeriod, err = strconv.Atoi(getVmssSizeRefreshPeriod)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_GET_VMSS_SIZE_REFRESH_PERIOD %q: %v", getVmssSizeRefreshPeriod, err)
-			}
-		} else {
-			cfg.GetVmssSizeRefreshPeriod = VmssSizeRefreshPeriodDefault
+		if _, err = assignFloat64FromEnvIfExists(&cfg.CloudProviderBackoffExponent, "BACKOFF_EXPONENT"); err != nil {
+			return nil, err
 		}
-
-		if enableVmssFlex := os.Getenv("AZURE_ENABLE_VMSS_FLEX"); enableVmssFlex != "" {
-			cfg.EnableVmssFlex, err = strconv.ParseBool(enableVmssFlex)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse AZURE_ENABLE_VMSS_FLEX %q: %v", enableVmssFlex, err)
-			}
-		} else {
-			cfg.EnableVmssFlex = enableVmssFlexDefault
+		if _, err = assignIntFromEnvIfExists(&cfg.CloudProviderBackoffDuration, "BACKOFF_DURATION"); err != nil {
+			return nil, err
 		}
-
-		if cfg.CloudProviderBackoff {
-			if backoffRetries := os.Getenv("BACKOFF_RETRIES"); backoffRetries != "" {
-				retries, err := strconv.ParseInt(backoffRetries, 10, 0)
-				if err != nil {
-					return nil, fmt.Errorf("failed to parse BACKOFF_RETRIES %q: %v", retries, err)
-				}
-				cfg.CloudProviderBackoffRetries = int(retries)
-			} else {
-				cfg.CloudProviderBackoffRetries = backoffRetriesDefault
-			}
-
-			if backoffExponent := os.Getenv("BACKOFF_EXPONENT"); backoffExponent != "" {
-				cfg.CloudProviderBackoffExponent, err = strconv.ParseFloat(backoffExponent, 64)
-				if err != nil {
-					return nil, fmt.Errorf("failed to parse BACKOFF_EXPONENT %q: %v", backoffExponent, err)
-				}
-			} else {
-				cfg.CloudProviderBackoffExponent = backoffExponentDefault
-			}
-
-			if backoffDuration := os.Getenv("BACKOFF_DURATION"); backoffDuration != "" {
-				duration, err := strconv.ParseInt(backoffDuration, 10, 0)
-				if err != nil {
-					return nil, fmt.Errorf("failed to parse BACKOFF_DURATION %q: %v", backoffDuration, err)
-				}
-				cfg.CloudProviderBackoffDuration = int(duration)
-			} else {
-				cfg.CloudProviderBackoffDuration = backoffDurationDefault
-			}
-
-			if backoffJitter := os.Getenv("BACKOFF_JITTER"); backoffJitter != "" {
-				cfg.CloudProviderBackoffJitter, err = strconv.ParseFloat(backoffJitter, 64)
-				if err != nil {
-					return nil, fmt.Errorf("failed to parse BACKOFF_JITTER %q: %v", backoffJitter, err)
-				}
-			} else {
-				cfg.CloudProviderBackoffJitter = backoffJitterDefault
-			}
+		if _, err = assignFloat64FromEnvIfExists(&cfg.CloudProviderBackoffJitter, "BACKOFF_JITTER"); err != nil {
+			return nil, err
 		}
 	}
+	if _, err = assignBoolFromEnvIfExists(&cfg.CloudProviderRateLimit, "CLOUD_PROVIDER_RATE_LIMIT"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFloat32FromEnvIfExists(&cfg.CloudProviderRateLimitQPS, "RATE_LIMIT_READ_QPS"); err != nil {
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.CloudProviderRateLimitBucket, "RATE_LIMIT_READ_BUCKETS"); err != nil {
+		return nil, err
+	}
+	if _, err = assignFloat32FromEnvIfExists(&cfg.CloudProviderRateLimitQPSWrite, "RATE_LIMIT_WRITE_QPS"); err != nil {
+		return nil, err
+	}
+	if _, err = assignIntFromEnvIfExists(&cfg.CloudProviderRateLimitBucketWrite, "RATE_LIMIT_WRITE_BUCKETS"); err != nil {
+		return nil, err
+	}
 
-	// always read the following from environment variables since azure.json doesn't have these fields
-	cfg.ClusterName = os.Getenv("CLUSTER_NAME")
-	cfg.ClusterResourceGroup = os.Getenv("ARM_CLUSTER_RESOURCE_GROUP")
-	cfg.ARMBaseURLForAPClient = os.Getenv("ARM_BASE_URL_FOR_AP_CLIENT")
-
-	cfg.TrimSpace()
-
-	if cloudProviderRateLimit := os.Getenv("CLOUD_PROVIDER_RATE_LIMIT"); cloudProviderRateLimit != "" {
-		cfg.CloudProviderRateLimit, err = strconv.ParseBool(cloudProviderRateLimit)
+	// Nonstatic defaults
+	cfg.VMType = strings.ToLower(cfg.VMType)
+	if cfg.MaxDeploymentsCount == 0 {
+		// 0 means "use default" in this case.
+		// This means, if it is valued by the config file, but explicitly set to 0 in the env, it will retreat to default.
+		cfg.MaxDeploymentsCount = int64(defaultMaxDeploymentsCount)
+	}
+	if cfg.SubscriptionID == "" {
+		metadataService, err := providerazure.NewInstanceMetadataService(imdsServerURL)
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse CLOUD_PROVIDER_RATE_LIMIT: %q, %v", cloudProviderRateLimit, err)
+			return nil, err
 		}
-	}
 
-	if enableForceDelete := os.Getenv("AZURE_ENABLE_FORCE_DELETE"); enableForceDelete != "" {
-		cfg.EnableForceDelete, err = strconv.ParseBool(enableForceDelete)
+		metadata, err := metadataService.GetMetadata(0)
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse AZURE_ENABLE_FORCE_DELETE: %q, %v", enableForceDelete, err)
+			return nil, err
 		}
-	}
 
-	err = initializeCloudProviderRateLimitConfig(&cfg.CloudProviderRateLimitConfig)
-	if err != nil {
-		return nil, err
+		cfg.SubscriptionID = metadata.Compute.SubscriptionID
 	}
-
-	// Defaulting vmType to vmss.
-	if cfg.VMType == "" {
-		cfg.VMType = vmTypeVMSS
-	}
-
-	// Read parameters from deploymentParametersPath if it is not set.
-	if cfg.VMType == vmTypeStandard && len(cfg.DeploymentParameters) == 0 {
+	if cfg.VMType == providerazureconsts.VMTypeStandard && len(cfg.DeploymentParameters) == 0 {
+		// Read parameters from deploymentParametersPath if it is not set.
 		parameters, err := readDeploymentParameters(deploymentParametersPath)
 		if err != nil {
 			klog.Errorf("readDeploymentParameters failed with error: %v", err)
@@ -365,10 +316,7 @@ func BuildAzureConfig(configReader io.Reader) (*Config, error) {
 
 		cfg.DeploymentParameters = parameters
 	}
-
-	if cfg.MaxDeploymentsCount == 0 {
-		cfg.MaxDeploymentsCount = int64(defaultMaxDeploymentsCount)
-	}
+	providerazureconfig.InitializeCloudProviderRateLimitConfig(&cfg.CloudProviderRateLimitConfig)
 
 	if err := cfg.validate(); err != nil {
 		return nil, err
@@ -376,104 +324,11 @@ func BuildAzureConfig(configReader io.Reader) (*Config, error) {
 	return cfg, nil
 }
 
-// initializeCloudProviderRateLimitConfig initializes rate limit configs.
-func initializeCloudProviderRateLimitConfig(config *CloudProviderRateLimitConfig) error {
-	if config == nil {
-		return nil
-	}
-
-	// Assign read rate limit defaults if no configuration was passed in.
-	if config.CloudProviderRateLimitQPS == 0 {
-		if rateLimitQPSFromEnv := os.Getenv(rateLimitReadQPSEnvVar); rateLimitQPSFromEnv != "" {
-			rateLimitQPS, err := strconv.ParseFloat(rateLimitQPSFromEnv, 0)
-			if err != nil {
-				return fmt.Errorf("failed to parse %s: %q, %v", rateLimitReadQPSEnvVar, rateLimitQPSFromEnv, err)
-			}
-			config.CloudProviderRateLimitQPS = float32(rateLimitQPS)
-		} else {
-			config.CloudProviderRateLimitQPS = rateLimitQPSDefault
-		}
-	}
-
-	if config.CloudProviderRateLimitBucket == 0 {
-		if rateLimitBucketFromEnv := os.Getenv(rateLimitReadBucketsEnvVar); rateLimitBucketFromEnv != "" {
-			rateLimitBucket, err := strconv.ParseInt(rateLimitBucketFromEnv, 10, 0)
-			if err != nil {
-				return fmt.Errorf("failed to parse %s: %q, %v", rateLimitReadBucketsEnvVar, rateLimitBucketFromEnv, err)
-			}
-			config.CloudProviderRateLimitBucket = int(rateLimitBucket)
-		} else {
-			config.CloudProviderRateLimitBucket = rateLimitBucketDefault
-		}
-	}
-
-	// Assign write rate limit defaults if no configuration was passed in.
-	if config.CloudProviderRateLimitQPSWrite == 0 {
-		if rateLimitQPSWriteFromEnv := os.Getenv(rateLimitWriteQPSEnvVar); rateLimitQPSWriteFromEnv != "" {
-			rateLimitQPSWrite, err := strconv.ParseFloat(rateLimitQPSWriteFromEnv, 0)
-			if err != nil {
-				return fmt.Errorf("failed to parse %s: %q, %v", rateLimitWriteQPSEnvVar, rateLimitQPSWriteFromEnv, err)
-			}
-			config.CloudProviderRateLimitQPSWrite = float32(rateLimitQPSWrite)
-		} else {
-			config.CloudProviderRateLimitQPSWrite = config.CloudProviderRateLimitQPS
-		}
-	}
-
-	if config.CloudProviderRateLimitBucketWrite == 0 {
-		if rateLimitBucketWriteFromEnv := os.Getenv(rateLimitWriteBucketsEnvVar); rateLimitBucketWriteFromEnv != "" {
-			rateLimitBucketWrite, err := strconv.ParseInt(rateLimitBucketWriteFromEnv, 10, 0)
-			if err != nil {
-				return fmt.Errorf("failed to parse %s: %q, %v", rateLimitWriteBucketsEnvVar, rateLimitBucketWriteFromEnv, err)
-			}
-			config.CloudProviderRateLimitBucketWrite = int(rateLimitBucketWrite)
-		} else {
-			config.CloudProviderRateLimitBucketWrite = config.CloudProviderRateLimitBucket
-		}
-	}
-
-	config.InterfaceRateLimit = overrideDefaultRateLimitConfig(&config.RateLimitConfig, config.InterfaceRateLimit)
-	config.VirtualMachineRateLimit = overrideDefaultRateLimitConfig(&config.RateLimitConfig, config.VirtualMachineRateLimit)
-	config.StorageAccountRateLimit = overrideDefaultRateLimitConfig(&config.RateLimitConfig, config.StorageAccountRateLimit)
-	config.DiskRateLimit = overrideDefaultRateLimitConfig(&config.RateLimitConfig, config.DiskRateLimit)
-	config.VirtualMachineScaleSetRateLimit = overrideDefaultRateLimitConfig(&config.RateLimitConfig, config.VirtualMachineScaleSetRateLimit)
-	config.KubernetesServiceRateLimit = overrideDefaultRateLimitConfig(&config.RateLimitConfig, config.KubernetesServiceRateLimit)
-
-	return nil
-}
-
-// overrideDefaultRateLimitConfig overrides the default CloudProviderRateLimitConfig.
-func overrideDefaultRateLimitConfig(defaults, config *azclients.RateLimitConfig) *azclients.RateLimitConfig {
-	// If config not set, apply defaults.
-	if config == nil {
-		return defaults
-	}
-
-	// Remain disabled if it's set explicitly.
-	if !config.CloudProviderRateLimit {
-		return &azclients.RateLimitConfig{CloudProviderRateLimit: false}
-	}
-
-	// Apply default values.
-	if config.CloudProviderRateLimitQPS == 0 {
-		config.CloudProviderRateLimitQPS = defaults.CloudProviderRateLimitQPS
-	}
-	if config.CloudProviderRateLimitBucket == 0 {
-		config.CloudProviderRateLimitBucket = defaults.CloudProviderRateLimitBucket
-	}
-	if config.CloudProviderRateLimitQPSWrite == 0 {
-		config.CloudProviderRateLimitQPSWrite = defaults.CloudProviderRateLimitQPSWrite
-	}
-	if config.CloudProviderRateLimitBucketWrite == 0 {
-		config.CloudProviderRateLimitBucketWrite = defaults.CloudProviderRateLimitBucketWrite
-	}
-
-	return config
-}
-
+// A "fork" of az.getAzureClientConfig with BYO authorizer (e.g., for CLI auth) and custom polling delay support
 func (cfg *Config) getAzureClientConfig(authorizer autorest.Authorizer, env *azure.Environment) *azclients.ClientConfig {
 	pollingDelay := 30 * time.Second
 	azClientConfig := &azclients.ClientConfig{
+		CloudName:               cfg.Cloud,
 		Location:                cfg.Location,
 		SubscriptionID:          cfg.SubscriptionID,
 		ResourceManagerEndpoint: env.ResourceManagerEndpoint,
@@ -482,6 +337,8 @@ func (cfg *Config) getAzureClientConfig(authorizer autorest.Authorizer, env *azu
 		RestClientConfig: azclients.RestClientConfig{
 			PollingDelay: &pollingDelay,
 		},
+		DisableAzureStackCloud: cfg.DisableAzureStackCloud,
+		UserAgent:              cfg.UserAgent,
 	}
 
 	if cfg.CloudProviderBackoff {
@@ -493,24 +350,14 @@ func (cfg *Config) getAzureClientConfig(authorizer autorest.Authorizer, env *azu
 		}
 	}
 
-	return azClientConfig
-}
+	if cfg.HasExtendedLocation() {
+		azClientConfig.ExtendedLocation = &azclients.ExtendedLocation{
+			Name: cfg.ExtendedLocationName,
+			Type: cfg.ExtendedLocationType,
+		}
+	}
 
-// TrimSpace removes all leading and trailing white spaces.
-func (cfg *Config) TrimSpace() {
-	cfg.Cloud = strings.TrimSpace(cfg.Cloud)
-	cfg.Location = strings.TrimSpace(cfg.Location)
-	cfg.TenantID = strings.TrimSpace(cfg.TenantID)
-	cfg.SubscriptionID = strings.TrimSpace(cfg.SubscriptionID)
-	cfg.ClusterName = strings.TrimSpace(cfg.ClusterName)
-	cfg.ResourceGroup = strings.TrimSpace(cfg.ResourceGroup)
-	cfg.ClusterResourceGroup = strings.TrimSpace(cfg.ClusterResourceGroup)
-	cfg.VMType = strings.TrimSpace(cfg.VMType)
-	cfg.AADClientID = strings.TrimSpace(cfg.AADClientID)
-	cfg.AADClientSecret = strings.TrimSpace(cfg.AADClientSecret)
-	cfg.AADClientCertPath = strings.TrimSpace(cfg.AADClientCertPath)
-	cfg.AADClientCertPassword = strings.TrimSpace(cfg.AADClientCertPassword)
-	cfg.Deployment = strings.TrimSpace(cfg.Deployment)
+	return azClientConfig
 }
 
 func (cfg *Config) validate() error {
@@ -518,7 +365,7 @@ func (cfg *Config) validate() error {
 		return fmt.Errorf("resource group not set")
 	}
 
-	if cfg.VMType == vmTypeStandard {
+	if cfg.VMType == providerazureconsts.VMTypeStandard {
 		if cfg.Deployment == "" {
 			return fmt.Errorf("deployment not set")
 		}
@@ -532,23 +379,29 @@ func (cfg *Config) validate() error {
 		return fmt.Errorf("subscription ID not set")
 	}
 
-	if cfg.UseManagedIdentityExtension {
-		return nil
+	if cfg.UseManagedIdentityExtension && cfg.UseFederatedWorkloadIdentityExtension {
+		return fmt.Errorf("you can not combine both managed identity and workload identity as an authentication mechanism")
 	}
 
-	if cfg.TenantID == "" {
-		return fmt.Errorf("tenant ID not set")
+	if cfg.VMType != providerazureconsts.VMTypeStandard && cfg.VMType != providerazureconsts.VMTypeVMSS {
+		return fmt.Errorf("unsupported VM type: %s", cfg.VMType)
 	}
 
-	switch cfg.AuthMethod {
-	case "", authMethodPrincipal:
-		if cfg.AADClientID == "" {
-			return errors.New("ARM Client ID not set")
+	if !cfg.UseManagedIdentityExtension && !cfg.UseFederatedWorkloadIdentityExtension {
+		if cfg.TenantID == "" {
+			return fmt.Errorf("tenant ID not set")
+		}
+
+		switch cfg.AuthMethod {
+		case "", authMethodPrincipal:
+			if cfg.AADClientID == "" {
+				return fmt.Errorf("ARM Client ID not set")
+			}
+		case authMethodCLI:
+			// Nothing to check at the moment.
+		default:
+			return fmt.Errorf("unsupported authorization method: %s", cfg.AuthMethod)
 		}
-	case authMethodCLI:
-		// Nothing to check at the moment.
-	default:
-		return fmt.Errorf("unsupported authorization method: %s", cfg.AuthMethod)
 	}
 
 	if cfg.CloudProviderBackoff && cfg.CloudProviderBackoffRetries == 0 {
@@ -558,21 +411,88 @@ func (cfg *Config) validate() error {
 	return nil
 }
 
-// getSubscriptionId reads the Subscription ID from the instance metadata.
-func getSubscriptionIdFromInstanceMetadata() (string, error) {
-	subscriptionID, present := os.LookupEnv("ARM_SUBSCRIPTION_ID")
-	if !present {
-		metadataService, err := providerazure.NewInstanceMetadataService(imdsServerURL)
+func assignFromEnvIfExists(assignee *string, name string) (bool, error) {
+	if assignee == nil {
+		return false, fmt.Errorf("assignee is nil")
+	}
+	if val, present := os.LookupEnv(name); present && strings.TrimSpace(val) != "" {
+		*assignee = strings.TrimSpace(val)
+		return true, nil
+	}
+	return false, nil
+}
+
+func assignBoolFromEnvIfExists(assignee *bool, name string) (bool, error) {
+	if assignee == nil {
+		return false, fmt.Errorf("assignee is nil")
+	}
+	var err error
+	if val, present := os.LookupEnv(name); present && strings.TrimSpace(val) != "" {
+		*assignee, err = strconv.ParseBool(val)
 		if err != nil {
-			return "", err
+			return false, fmt.Errorf("failed to parse %s %q: %v", name, val, err)
 		}
+		return true, nil
+	}
+	return false, nil
+}
 
-		metadata, err := metadataService.GetMetadata(0)
+func assignIntFromEnvIfExists(assignee *int, name string) (bool, error) {
+	if assignee == nil {
+		return false, fmt.Errorf("assignee is nil")
+	}
+	var err error
+	if val, present := os.LookupEnv(name); present && strings.TrimSpace(val) != "" {
+		*assignee, err = parseInt32(val, 10)
 		if err != nil {
-			return "", err
+			return false, fmt.Errorf("failed to parse %s %q: %v", name, val, err)
 		}
+		return true, nil
+	}
+	return false, nil
+}
 
-		return metadata.Compute.SubscriptionID, nil
+func assignInt64FromEnvIfExists(assignee *int64, name string) (bool, error) {
+	if assignee == nil {
+		return false, fmt.Errorf("assignee is nil")
+	}
+	var err error
+	if val, present := os.LookupEnv(name); present && strings.TrimSpace(val) != "" {
+		*assignee, err = strconv.ParseInt(val, 10, 0)
+		if err != nil {
+			return false, fmt.Errorf("failed to parse %s %q: %v", name, val, err)
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+func assignFloat32FromEnvIfExists(assignee *float32, name string) (bool, error) {
+	if assignee == nil {
+		return false, fmt.Errorf("assignee is nil")
+	}
+	var err error
+	if val, present := os.LookupEnv(name); present && strings.TrimSpace(val) != "" {
+		*assignee, err = parseFloat32(val)
+		if err != nil {
+			return false, fmt.Errorf("failed to parse %s %q: %v", name, val, err)
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+func assignFloat64FromEnvIfExists(assignee *float64, name string) (bool, error) {
+	if assignee == nil {
+		return false, fmt.Errorf("assignee is nil")
+	}
+	var err error
+	if val, present := os.LookupEnv(name); present && strings.TrimSpace(val) != "" {
+		*assignee, err = strconv.ParseFloat(val, 64)
+		if err != nil {
+			return false, fmt.Errorf("failed to parse %s %q: %v", name, val, err)
+		}
+		return true, nil
 	}
-	return subscriptionID, nil
+	return false, nil
 }
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_config_test.go b/cluster-autoscaler/cloudprovider/azure/azure_config_test.go
index 65c74a5c90a1..6bfd19ce2319 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_config_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_config_test.go
@@ -17,174 +17,74 @@ limitations under the License.
 package azure
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	azclients "sigs.k8s.io/cloud-provider-azure/pkg/azureclients"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
+	providerazureconfig "sigs.k8s.io/cloud-provider-azure/pkg/provider/config"
 )
 
-func TestInitializeCloudProviderRateLimitConfigWithNoConfigReturnsNoError(t *testing.T) {
-	err := initializeCloudProviderRateLimitConfig(nil)
-	assert.Nil(t, err, "err should be nil")
+func TestCloudProviderAzureConsts(t *testing.T) {
+	// Just detect user-facing breaking changes from cloud-provider-azure.
+	// Shouldn't really change a lot, but just in case.
+	assert.Equal(t, "vmss", providerazureconsts.VMTypeVMSS)
+	assert.Equal(t, "standard", providerazureconsts.VMTypeStandard)
 }
 
 func TestInitializeCloudProviderRateLimitConfigWithNoRateLimitSettingsReturnsDefaults(t *testing.T) {
-	emptyConfig := &CloudProviderRateLimitConfig{}
-	err := initializeCloudProviderRateLimitConfig(emptyConfig)
-
-	assert.NoError(t, err)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitQPS, rateLimitQPSDefault)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitBucket, rateLimitBucketDefault)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitQPSWrite, rateLimitQPSDefault)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitBucketWrite, rateLimitBucketDefault)
-}
-
-func TestInitializeCloudProviderRateLimitConfigWithReadRateLimitSettingsFromEnv(t *testing.T) {
-	emptyConfig := &CloudProviderRateLimitConfig{}
-	var rateLimitReadQPS float32 = 3.0
-	rateLimitReadBuckets := 10
-	t.Setenv(rateLimitReadQPSEnvVar, fmt.Sprintf("%.1f", rateLimitReadQPS))
-	t.Setenv(rateLimitReadBucketsEnvVar, fmt.Sprintf("%d", rateLimitReadBuckets))
-
-	err := initializeCloudProviderRateLimitConfig(emptyConfig)
-	assert.NoError(t, err)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitQPS, rateLimitReadQPS)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitBucket, rateLimitReadBuckets)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitQPSWrite, rateLimitReadQPS)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitBucketWrite, rateLimitReadBuckets)
-}
-
-func TestInitializeCloudProviderRateLimitConfigWithReadAndWriteRateLimitSettingsFromEnv(t *testing.T) {
-	emptyConfig := &CloudProviderRateLimitConfig{}
-	var rateLimitReadQPS float32 = 3.0
-	rateLimitReadBuckets := 10
-	var rateLimitWriteQPS float32 = 6.0
-	rateLimitWriteBuckets := 20
-
-	t.Setenv(rateLimitReadQPSEnvVar, fmt.Sprintf("%.1f", rateLimitReadQPS))
-	t.Setenv(rateLimitReadBucketsEnvVar, fmt.Sprintf("%d", rateLimitReadBuckets))
-	t.Setenv(rateLimitWriteQPSEnvVar, fmt.Sprintf("%.1f", rateLimitWriteQPS))
-	t.Setenv(rateLimitWriteBucketsEnvVar, fmt.Sprintf("%d", rateLimitWriteBuckets))
+	emptyConfig := &providerazureconfig.CloudProviderRateLimitConfig{}
+	providerazureconfig.InitializeCloudProviderRateLimitConfig(emptyConfig)
 
-	err := initializeCloudProviderRateLimitConfig(emptyConfig)
-
-	assert.NoError(t, err)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitQPS, rateLimitReadQPS)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitBucket, rateLimitReadBuckets)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS)
-	assert.Equal(t, emptyConfig.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets)
+	assert.InDelta(t, emptyConfig.CloudProviderRateLimitQPS, providerazureconsts.RateLimitQPSDefault, 0.0001)
+	assert.InDelta(t, emptyConfig.CloudProviderRateLimitBucket, providerazureconsts.RateLimitBucketDefault, 0.0001)
+	assert.InDelta(t, emptyConfig.CloudProviderRateLimitQPSWrite, providerazureconsts.RateLimitQPSDefault, 0.0001)
+	assert.InDelta(t, emptyConfig.CloudProviderRateLimitBucketWrite, providerazureconsts.RateLimitBucketDefault, 0.0001)
 }
 
-func TestInitializeCloudProviderRateLimitConfigWithReadAndWriteRateLimitAlreadySetInConfig(t *testing.T) {
+func TestInitializeCloudProviderRateLimitConfigWithReadRateLimitSettings(t *testing.T) {
 	var rateLimitReadQPS float32 = 3.0
 	rateLimitReadBuckets := 10
-	var rateLimitWriteQPS float32 = 6.0
-	rateLimitWriteBuckets := 20
 
-	configWithRateLimits := &CloudProviderRateLimitConfig{
+	cfg := &providerazureconfig.CloudProviderRateLimitConfig{
 		RateLimitConfig: azclients.RateLimitConfig{
-			CloudProviderRateLimitBucket:      rateLimitReadBuckets,
-			CloudProviderRateLimitBucketWrite: rateLimitWriteBuckets,
-			CloudProviderRateLimitQPS:         rateLimitReadQPS,
-			CloudProviderRateLimitQPSWrite:    rateLimitWriteQPS,
-		},
-	}
-
-	t.Setenv(rateLimitReadQPSEnvVar, "99")
-	t.Setenv(rateLimitReadBucketsEnvVar, "99")
-	t.Setenv(rateLimitWriteQPSEnvVar, "99")
-	t.Setenv(rateLimitWriteBucketsEnvVar, "99")
-
-	err := initializeCloudProviderRateLimitConfig(configWithRateLimits)
-
-	assert.NoError(t, err)
-	assert.Equal(t, configWithRateLimits.CloudProviderRateLimitQPS, rateLimitReadQPS)
-	assert.Equal(t, configWithRateLimits.CloudProviderRateLimitBucket, rateLimitReadBuckets)
-	assert.Equal(t, configWithRateLimits.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS)
-	assert.Equal(t, configWithRateLimits.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets)
-}
-
-// nolint: goconst
-func TestInitializeCloudProviderRateLimitConfigWithInvalidReadAndWriteRateLimitSettingsFromEnv(t *testing.T) {
-	emptyConfig := &CloudProviderRateLimitConfig{}
-	var rateLimitReadQPS float32 = 3.0
-	rateLimitReadBuckets := 10
-	var rateLimitWriteQPS float32 = 6.0
-	rateLimitWriteBuckets := 20
-
-	invalidSetting := "invalid"
-	testCases := []struct {
-		desc                                 string
-		isInvalidRateLimitReadQPSEnvVar      bool
-		isInvalidRateLimitReadBucketsEnvVar  bool
-		isInvalidRateLimitWriteQPSEnvVar     bool
-		isInvalidRateLimitWriteBucketsEnvVar bool
-		expectedErr                          bool
-		expectedErrMsg                       error
-	}{
-		{
-			desc:                            "an error shall be returned if invalid rateLimitReadQPSEnvVar",
-			isInvalidRateLimitReadQPSEnvVar: true,
-			expectedErr:                     true,
-			expectedErrMsg:                  fmt.Errorf("failed to parse %s: %q, strconv.ParseFloat: parsing \"invalid\": invalid syntax", rateLimitReadQPSEnvVar, invalidSetting),
-		},
-		{
-			desc:                                "an error shall be returned if invalid rateLimitReadBucketsEnvVar",
-			isInvalidRateLimitReadBucketsEnvVar: true,
-			expectedErr:                         true,
-			expectedErrMsg:                      fmt.Errorf("failed to parse %s: %q, strconv.ParseInt: parsing \"invalid\": invalid syntax", rateLimitReadBucketsEnvVar, invalidSetting),
-		},
-		{
-			desc:                             "an error shall be returned if invalid rateLimitWriteQPSEnvVar",
-			isInvalidRateLimitWriteQPSEnvVar: true,
-			expectedErr:                      true,
-			expectedErrMsg:                   fmt.Errorf("failed to parse %s: %q, strconv.ParseFloat: parsing \"invalid\": invalid syntax", rateLimitWriteQPSEnvVar, invalidSetting),
-		},
-		{
-			desc:                                 "an error shall be returned if invalid rateLimitWriteBucketsEnvVar",
-			isInvalidRateLimitWriteBucketsEnvVar: true,
-			expectedErr:                          true,
-			expectedErrMsg:                       fmt.Errorf("failed to parse %s: %q, strconv.ParseInt: parsing \"invalid\": invalid syntax", rateLimitWriteBucketsEnvVar, invalidSetting),
+			CloudProviderRateLimitQPS:    rateLimitReadQPS,
+			CloudProviderRateLimitBucket: rateLimitReadBuckets,
 		},
 	}
-
-	for i, test := range testCases {
-		if test.isInvalidRateLimitReadQPSEnvVar {
-			t.Setenv(rateLimitReadQPSEnvVar, invalidSetting)
-		} else {
-			t.Setenv(rateLimitReadQPSEnvVar, fmt.Sprintf("%.1f", rateLimitReadQPS))
-		}
-		if test.isInvalidRateLimitReadBucketsEnvVar {
-			t.Setenv(rateLimitReadBucketsEnvVar, invalidSetting)
-		} else {
-			t.Setenv(rateLimitReadBucketsEnvVar, fmt.Sprintf("%d", rateLimitReadBuckets))
-		}
-		if test.isInvalidRateLimitWriteQPSEnvVar {
-			t.Setenv(rateLimitWriteQPSEnvVar, invalidSetting)
-		} else {
-			t.Setenv(rateLimitWriteQPSEnvVar, fmt.Sprintf("%.1f", rateLimitWriteQPS))
-		}
-		if test.isInvalidRateLimitWriteBucketsEnvVar {
-			t.Setenv(rateLimitWriteBucketsEnvVar, invalidSetting)
-		} else {
-			t.Setenv(rateLimitWriteBucketsEnvVar, fmt.Sprintf("%d", rateLimitWriteBuckets))
-		}
-
-		err := initializeCloudProviderRateLimitConfig(emptyConfig)
-
-		assert.Equal(t, test.expectedErr, err != nil, "TestCase[%d]: %s, return error: %v", i, test.desc, err)
-		assert.Equal(t, test.expectedErrMsg, err, "TestCase[%d]: %s, expected: %v, return: %v", i, test.desc, test.expectedErrMsg, err)
-	}
+	//t.Setenv("RATE_LIMIT_READ_QPS", fmt.Sprintf("%.1f", rateLimitReadQPS)
+	//t.Setenv("RATE_LIMIT_READ_BUCKETS", fmt.Sprintf("%d", rateLimitReadBuckets)
+
+	providerazureconfig.InitializeCloudProviderRateLimitConfig(cfg)
+	assert.InDelta(t, cfg.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.CloudProviderRateLimitQPSWrite, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.CloudProviderRateLimitBucketWrite, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitQPSWrite, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitBucketWrite, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitQPSWrite, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitBucketWrite, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitQPSWrite, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitBucketWrite, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitQPSWrite, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitBucketWrite, rateLimitReadBuckets, 0.0001)
 }
 
-func TestOverrideDefaultRateLimitConfig(t *testing.T) {
+func TestInitializeCloudProviderRateLimitConfigWithReadAndWriteRateLimitSettings(t *testing.T) {
 	var rateLimitReadQPS float32 = 3.0
 	rateLimitReadBuckets := 10
 	var rateLimitWriteQPS float32 = 6.0
 	rateLimitWriteBuckets := 20
 
-	defaultConfigWithRateLimits := &CloudProviderRateLimitConfig{
+	cfg := &providerazureconfig.CloudProviderRateLimitConfig{
 		RateLimitConfig: azclients.RateLimitConfig{
 			CloudProviderRateLimitBucket:      rateLimitReadBuckets,
 			CloudProviderRateLimitBucketWrite: rateLimitWriteBuckets,
@@ -193,28 +93,31 @@ func TestOverrideDefaultRateLimitConfig(t *testing.T) {
 		},
 	}
 
-	configWithRateLimits := &CloudProviderRateLimitConfig{
-		RateLimitConfig: azclients.RateLimitConfig{
-			CloudProviderRateLimit:            true,
-			CloudProviderRateLimitBucket:      0,
-			CloudProviderRateLimitBucketWrite: 0,
-			CloudProviderRateLimitQPS:         0,
-			CloudProviderRateLimitQPSWrite:    0,
-		},
-	}
-
-	newconfig := overrideDefaultRateLimitConfig(&defaultConfigWithRateLimits.RateLimitConfig, &configWithRateLimits.RateLimitConfig)
-
-	assert.Equal(t, defaultConfigWithRateLimits.CloudProviderRateLimitQPS, newconfig.CloudProviderRateLimitQPS)
-	assert.Equal(t, defaultConfigWithRateLimits.CloudProviderRateLimitBucket, newconfig.CloudProviderRateLimitBucket)
-	assert.Equal(t, defaultConfigWithRateLimits.CloudProviderRateLimitQPSWrite, newconfig.CloudProviderRateLimitQPSWrite)
-	assert.Equal(t, defaultConfigWithRateLimits.CloudProviderRateLimitBucketWrite, newconfig.CloudProviderRateLimitBucketWrite)
-
-	falseCloudProviderRateLimit := &CloudProviderRateLimitConfig{
-		RateLimitConfig: azclients.RateLimitConfig{
-			CloudProviderRateLimit: false,
-		},
-	}
-	newconfig = overrideDefaultRateLimitConfig(&defaultConfigWithRateLimits.RateLimitConfig, &falseCloudProviderRateLimit.RateLimitConfig)
-	assert.Equal(t, &falseCloudProviderRateLimit.RateLimitConfig, newconfig)
+	//t.Setenv("RATE_LIMIT_READ_QPS", fmt.Sprintf("%.1f", rateLimitReadQPS)
+	//t.Setenv("RATE_LIMIT_READ_BUCKETS", fmt.Sprintf("%d", rateLimitReadBuckets)
+	//t.Setenv("RATE_LIMIT_WRITE_QPS", fmt.Sprintf("%.1f", rateLimitWriteQPS)
+	//t.Setenv("RATE_LIMIT_WRITE_BUCKETS", fmt.Sprintf("%d", rateLimitWriteBuckets)
+
+	providerazureconfig.InitializeCloudProviderRateLimitConfig(cfg)
+
+	assert.InDelta(t, cfg.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS, 0.0001)
+	assert.InDelta(t, cfg.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS, 0.0001)
+	assert.InDelta(t, cfg.InterfaceRateLimit.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineRateLimit.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS, 0.0001)
+	assert.InDelta(t, cfg.StorageAccountRateLimit.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitQPS, rateLimitReadQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitBucket, rateLimitReadBuckets, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitQPSWrite, rateLimitWriteQPS, 0.0001)
+	assert.InDelta(t, cfg.VirtualMachineScaleSetRateLimit.CloudProviderRateLimitBucketWrite, rateLimitWriteBuckets, 0.0001)
 }
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_fakes.go b/cluster-autoscaler/cloudprovider/azure/azure_fakes.go
index 481fcaacf837..adc38e80b39a 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_fakes.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_fakes.go
@@ -19,12 +19,12 @@ package azure
 import (
 	"context"
 	"fmt"
-	"net/http"
 	"sync"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute"
 	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2017-05-10/resources"
 	"github.com/stretchr/testify/mock"
+	"sigs.k8s.io/cloud-provider-azure/pkg/retry"
 )
 
 const (
@@ -32,8 +32,8 @@ const (
 	fakeVirtualMachineVMID         = "/subscriptions/test-subscription-id/resourceGroups/test-asg/providers/Microsoft.Compute/virtualMachines/%d"
 )
 
-// DeploymentsClientMock mocks for DeploymentsClient.
-type DeploymentsClientMock struct {
+// DeploymentClientMock mocks for DeploymentsClient.
+type DeploymentClientMock struct {
 	mock.Mock
 
 	mutex     sync.Mutex
@@ -41,26 +41,26 @@ type DeploymentsClientMock struct {
 }
 
 // Get gets the DeploymentExtended by deploymentName.
-func (m *DeploymentsClientMock) Get(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExtended, err error) {
+func (m *DeploymentClientMock) Get(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExtended, err *retry.Error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
 	deploy, ok := m.FakeStore[deploymentName]
 	if !ok {
-		return result, fmt.Errorf("deployment not found")
+		return result, retry.NewError(false, fmt.Errorf("deployment not found"))
 	}
 
 	return deploy, nil
 }
 
 // ExportTemplate exports the deployment's template.
-func (m *DeploymentsClientMock) ExportTemplate(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExportResult, err error) {
+func (m *DeploymentClientMock) ExportTemplate(ctx context.Context, resourceGroupName string, deploymentName string) (result resources.DeploymentExportResult, err *retry.Error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
 	deploy, ok := m.FakeStore[deploymentName]
 	if !ok {
-		return result, fmt.Errorf("deployment not found")
+		return result, retry.NewError(false, fmt.Errorf("deployment not found"))
 	}
 
 	return resources.DeploymentExportResult{
@@ -69,7 +69,7 @@ func (m *DeploymentsClientMock) ExportTemplate(ctx context.Context, resourceGrou
 }
 
 // CreateOrUpdate creates or updates the Deployment.
-func (m *DeploymentsClientMock) CreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, parameters resources.Deployment) (resp *http.Response, err error) {
+func (m *DeploymentClientMock) CreateOrUpdate(ctx context.Context, resourceGroupName string, deploymentName string, parameters resources.Deployment, etag string) (err *retry.Error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
@@ -83,11 +83,11 @@ func (m *DeploymentsClientMock) CreateOrUpdate(ctx context.Context, resourceGrou
 
 	deploy.Properties.Parameters = parameters.Properties.Parameters
 	deploy.Properties.Template = parameters.Properties.Template
-	return &http.Response{StatusCode: 200}, nil
+	return nil
 }
 
 // List gets all the deployments for a resource group.
-func (m *DeploymentsClientMock) List(ctx context.Context, resourceGroupName, filter string, top *int32) (result []resources.DeploymentExtended, err error) {
+func (m *DeploymentClientMock) List(ctx context.Context, resourceGroupName string) (result []resources.DeploymentExtended, err *retry.Error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
@@ -100,12 +100,12 @@ func (m *DeploymentsClientMock) List(ctx context.Context, resourceGroupName, fil
 }
 
 // Delete deletes the given deployment
-func (m *DeploymentsClientMock) Delete(ctx context.Context, resourceGroupName, deploymentName string) (resp *http.Response, err error) {
+func (m *DeploymentClientMock) Delete(ctx context.Context, resourceGroupName, deploymentName string) (err *retry.Error) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
 	if _, ok := m.FakeStore[deploymentName]; !ok {
-		return nil, fmt.Errorf("there is no such a deployment with name %s", deploymentName)
+		return retry.NewError(false, fmt.Errorf("there is no such a deployment with name %s", deploymentName))
 	}
 
 	delete(m.FakeStore, deploymentName)
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_manager.go b/cluster-autoscaler/cloudprovider/azure/azure_manager.go
index 717ec86a402d..4a60051ffe18 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_manager.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_manager.go
@@ -32,15 +32,13 @@ import (
 	"k8s.io/autoscaler/cluster-autoscaler/config/dynamic"
 	kretry "k8s.io/client-go/util/retry"
 	klog "k8s.io/klog/v2"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
 	"sigs.k8s.io/cloud-provider-azure/pkg/retry"
 )
 
 const (
 	azurePrefix = "azure://"
 
-	vmTypeVMSS     = "vmss"
-	vmTypeStandard = "standard"
-
 	scaleToZeroSupportedStandard = false
 	scaleToZeroSupportedVMSS     = true
 	refreshInterval              = 1 * time.Minute
@@ -103,8 +101,8 @@ func createAzureManagerInternal(configReader io.Reader, discoveryOpts cloudprovi
 	}
 
 	cacheTTL := refreshInterval
-	if cfg.VmssCacheTTL != 0 {
-		cacheTTL = time.Duration(cfg.VmssCacheTTL) * time.Second
+	if cfg.VmssCacheTTLInSeconds != 0 {
+		cacheTTL = time.Duration(cfg.VmssCacheTTLInSeconds) * time.Second
 	}
 	cache, err := newAzureCache(azClient, cacheTTL, *cfg)
 	if err != nil {
@@ -166,7 +164,7 @@ func (m *AzureManager) fetchExplicitNodeGroups(specs []string) error {
 
 func (m *AzureManager) buildNodeGroupFromSpec(spec string) (cloudprovider.NodeGroup, error) {
 	scaleToZeroSupported := scaleToZeroSupportedStandard
-	if strings.EqualFold(m.config.VMType, vmTypeVMSS) {
+	if strings.EqualFold(m.config.VMType, providerazureconsts.VMTypeVMSS) {
 		scaleToZeroSupported = scaleToZeroSupportedVMSS
 	}
 	s, err := dynamic.SpecFromString(spec, scaleToZeroSupported)
@@ -179,9 +177,9 @@ func (m *AzureManager) buildNodeGroupFromSpec(spec string) (cloudprovider.NodeGr
 	}
 
 	switch m.config.VMType {
-	case vmTypeStandard:
+	case providerazureconsts.VMTypeStandard:
 		return NewAgentPool(s, m)
-	case vmTypeVMSS:
+	case providerazureconsts.VMTypeVMSS:
 		return NewScaleSet(s, m, -1, false)
 	default:
 		return nil, fmt.Errorf("vmtype %s not supported", m.config.VMType)
@@ -310,7 +308,7 @@ func (m *AzureManager) getFilteredNodeGroups(filter []labelAutoDiscoveryConfig)
 		return nil, nil
 	}
 
-	if m.config.VMType == vmTypeVMSS {
+	if m.config.VMType == providerazureconsts.VMTypeVMSS {
 		return m.getFilteredScaleSets(filter)
 	}
 
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_manager_test.go b/cluster-autoscaler/cloudprovider/azure/azure_manager_test.go
index 8c7fd01df4b8..0fefb34400ce 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_manager_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_manager_test.go
@@ -24,6 +24,7 @@ import (
 	"time"
 
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmclient/mockvmclient"
+	"sigs.k8s.io/cloud-provider-azure/pkg/retry"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute"
 	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2017-05-10/resources"
@@ -33,9 +34,13 @@ import (
 	"go.uber.org/mock/gomock"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
 	"k8s.io/autoscaler/cluster-autoscaler/config"
+	azclient "sigs.k8s.io/cloud-provider-azure/pkg/azclient"
 	azclients "sigs.k8s.io/cloud-provider-azure/pkg/azureclients"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmssclient/mockvmssclient"
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/vmssvmclient/mockvmssvmclient"
+	providerazureconsts "sigs.k8s.io/cloud-provider-azure/pkg/consts"
+	providerazure "sigs.k8s.io/cloud-provider-azure/pkg/provider"
+	providerazureconfig "sigs.k8s.io/cloud-provider-azure/pkg/provider/config"
 )
 
 const validAzureCfg = `{
@@ -51,6 +56,29 @@ const validAzureCfg = `{
 	"vnetName": "fakeName",
 	"routeTableName": "fakeName",
 	"primaryAvailabilitySetName": "fakeName",
+	"vmssCacheTTLInSeconds": 60,
+	"vmssVirtualMachinesCacheTTLInSeconds": 240,
+	"vmssVmsCacheJitter": 120,
+	"maxDeploymentsCount": 8,
+	"cloudProviderRateLimit": false,
+	"routeRateLimit": {
+		"cloudProviderRateLimit": true,
+		"cloudProviderRateLimitQPS": 3
+	}
+}`
+
+const validAzureCfgLegacy = `{
+	"cloud": "AzurePublicCloud",
+	"tenantId": "fakeId",
+	"subscriptionId": "fakeId",
+	"resourceGroup": "fakeId",
+	"location": "southeastasia",
+	"useWorkloadIdentityExtension": true,
+	"subnetName": "fakeName",
+	"securityGroupName": "fakeName",
+	"vnetName": "fakeName",
+	"routeTableName": "fakeName",
+	"primaryAvailabilitySetName": "fakeName",
 	"vmssCacheTTL": 60,
 	"vmssVmsCacheTTL": 240,
 	"vmssVmsCacheJitter": 120,
@@ -76,8 +104,8 @@ const validAzureCfgForStandardVMType = `{
 	"vnetName": "fakeName",
 	"routeTableName": "fakeName",
 	"primaryAvailabilitySetName": "fakeName",
-	"vmssCacheTTL": 60,
-	"vmssVmsCacheTTL": 240,
+	"vmssCacheTTLInSeconds": 60,
+	"vmssVirtualMachinesCacheTTLInSeconds": 240,
 	"vmssVmsCacheJitter": 120,
 	"maxDeploymentsCount": 8,
 	"cloudProviderRateLimit": false,
@@ -111,29 +139,57 @@ const validAzureCfgForStandardVMType = `{
 }`
 
 const validAzureCfgForStandardVMTypeWithoutDeploymentParameters = `{
-        "cloud": "AzurePublicCloud",
-        "tenantId": "fakeId",
-        "subscriptionId": "fakeId",
-        "aadClientId": "fakeId",
-        "aadClientSecret": "fakeId",
-        "resourceGroup": "fakeId",
-        "vmType":"standard",
-        "location": "southeastasia",
-        "subnetName": "fakeName",
-        "securityGroupName": "fakeName",
-        "vnetName": "fakeName",
-        "routeTableName": "fakeName",
-        "primaryAvailabilitySetName": "fakeName",
-        "vmssCacheTTL": 60,
-	"vmssVmsCacheTTL": 240,
+	"cloud": "AzurePublicCloud",
+	"tenantId": "fakeId",
+	"subscriptionId": "fakeId",
+	"aadClientId": "fakeId",
+	"aadClientSecret": "fakeId",
+	"resourceGroup": "fakeId",
+	"vmType":"standard",
+	"location": "southeastasia",
+	"subnetName": "fakeName",
+	"securityGroupName": "fakeName",
+	"vnetName": "fakeName",
+	"routeTableName": "fakeName",
+	"primaryAvailabilitySetName": "fakeName",
+	"vmssCacheTTLInSeconds": 60,
+	"vmssVirtualMachinesCacheTTLInSeconds": 240,
 	"vmssVmsCacheJitter": 120,
-        "maxDeploymentsCount": 8,
-        "cloudProviderRateLimit": false,
-        "routeRateLimit": {
-                "cloudProviderRateLimit": true,
-                "cloudProviderRateLimitQPS": 3
-        },
-        "deployment":"cluster-autoscaler-0001"
+	"maxDeploymentsCount": 8,
+	"cloudProviderRateLimit": false,
+	"routeRateLimit": {
+		"cloudProviderRateLimit": true,
+		"cloudProviderRateLimitQPS": 3
+	},
+	"deployment":"cluster-autoscaler-0001"
+}`
+
+const validAzureCfgForVMsPool = `{
+	"cloud": "AzurePublicCloud",
+	"tenantId": "fakeId",
+	"subscriptionId": "fakeId",
+	"aadClientId": "fakeId",
+	"aadClientSecret": "fakeId",
+	"resourceGroup": "fakeId",
+	"location": "southeastasia",
+	"subnetName": "fakeName",
+	"securityGroupName": "fakeName",
+	"vnetName": "fakeName",
+	"routeTableName": "fakeName",
+	"primaryAvailabilitySetName": "fakeName",
+	"vmssCacheTTLInSeconds": 60,
+	"vmssVirtualMachinesCacheTTLInSeconds": 240,
+	"vmssVmsCacheJitter": 120,
+	"maxDeploymentsCount": 8,
+	"cloudProviderRateLimit": false,
+	"routeRateLimit": {
+		"cloudProviderRateLimit": true,
+		"cloudProviderRateLimitQPS": 3
+	},
+
+	"clusterName": "mycluster",
+	"clusterResourceGroup": "myrg",
+	"armBaseURLForAPClient": "nodeprovisioner-svc.nodeprovisioner.svc.cluster.local"
 }`
 
 const (
@@ -155,73 +211,157 @@ func TestCreateAzureManagerValidConfig(t *testing.T) {
 	manager, err := createAzureManagerInternal(strings.NewReader(validAzureCfg), cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 
 	expectedConfig := &Config{
-		Cloud:               "AzurePublicCloud",
-		Location:            "southeastasia",
-		TenantID:            "fakeId",
-		SubscriptionID:      "fakeId",
-		ResourceGroup:       "fakeId",
-		VMType:              "vmss",
-		AADClientID:         "fakeId",
-		AADClientSecret:     "fakeId",
-		VmssCacheTTL:        60,
-		VmssVmsCacheTTL:     240,
-		VmssVmsCacheJitter:  120,
-		MaxDeploymentsCount: 8,
-		CloudProviderRateLimitConfig: CloudProviderRateLimitConfig{
-			RateLimitConfig: azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			InterfaceRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			VirtualMachineRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			StorageAccountRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					Cloud:    "AzurePublicCloud",
+					TenantID: "fakeId",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:     "fakeId",
+					AADClientSecret: "fakeId",
+				},
+				SubscriptionID: "fakeId",
 			},
-			DiskRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+			Location:                             "southeastasia",
+			ResourceGroup:                        "fakeId",
+			VMType:                               "vmss",
+			VmssCacheTTLInSeconds:                60,
+			VmssVirtualMachinesCacheTTLInSeconds: 240,
+			CloudProviderRateLimitConfig: providerazureconfig.CloudProviderRateLimitConfig{
+				RateLimitConfig: azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				InterfaceRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				StorageAccountRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				DiskRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
 			},
-			VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+		},
+		VmssVmsCacheJitter:  120,
+		MaxDeploymentsCount: 8,
+	}
+
+	assert.NoError(t, err)
+	assertStructsMinimallyEqual(t, *expectedConfig, *manager.config)
+}
+
+func TestCreateAzureManagerLegacyConfig(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockVMClient := mockvmclient.NewMockInterface(ctrl)
+	mockVMSSClient := mockvmssclient.NewMockInterface(ctrl)
+	mockVMSSClient.EXPECT().List(gomock.Any(), "fakeId").Return([]compute.VirtualMachineScaleSet{}, nil).Times(2)
+	mockVMClient.EXPECT().List(gomock.Any(), "fakeId").Return([]compute.VirtualMachine{}, nil).Times(2)
+	mockAzClient := &azClient{
+		virtualMachinesClient:         mockVMClient,
+		virtualMachineScaleSetsClient: mockVMSSClient,
+	}
+	manager, err := createAzureManagerInternal(strings.NewReader(validAzureCfgLegacy), cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
+
+	expectedConfig := &Config{
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					Cloud:    "AzurePublicCloud",
+					TenantID: "fakeId",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					UseFederatedWorkloadIdentityExtension: true,
+				},
+				SubscriptionID: "fakeId",
 			},
-			KubernetesServiceRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+			Location:                             "southeastasia",
+			ResourceGroup:                        "fakeId",
+			VMType:                               "vmss",
+			VmssCacheTTLInSeconds:                60,
+			VmssVirtualMachinesCacheTTLInSeconds: 240,
+			CloudProviderRateLimitConfig: providerazureconfig.CloudProviderRateLimitConfig{
+				RateLimitConfig: azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				InterfaceRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				StorageAccountRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				DiskRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
 			},
 		},
+		VmssVmsCacheJitter:  120,
+		MaxDeploymentsCount: 8,
 	}
 
 	assert.NoError(t, err)
-	assert.Equal(t, true, reflect.DeepEqual(*expectedConfig, *manager.config), "unexpected azure manager configuration")
+	assertStructsMinimallyEqual(t, *expectedConfig, *manager.config)
 }
 
 func TestCreateAzureManagerValidConfigForStandardVMType(t *testing.T) {
@@ -238,70 +378,71 @@ func TestCreateAzureManagerValidConfigForStandardVMType(t *testing.T) {
 	manager, err := createAzureManagerInternal(strings.NewReader(validAzureCfgForStandardVMType), cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 
 	expectedConfig := &Config{
-		Cloud:               "AzurePublicCloud",
-		Location:            "southeastasia",
-		TenantID:            "fakeId",
-		SubscriptionID:      "fakeId",
-		ResourceGroup:       "fakeId",
-		VMType:              "standard",
-		AADClientID:         "fakeId",
-		AADClientSecret:     "fakeId",
-		VmssCacheTTL:        60,
-		VmssVmsCacheTTL:     240,
-		VmssVmsCacheJitter:  120,
-		MaxDeploymentsCount: 8,
-		CloudProviderRateLimitConfig: CloudProviderRateLimitConfig{
-			RateLimitConfig: azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			InterfaceRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			VirtualMachineRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			StorageAccountRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			DiskRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					Cloud:    "AzurePublicCloud",
+					TenantID: "fakeId",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:     "fakeId",
+					AADClientSecret: "fakeId",
+				},
+				SubscriptionID: "fakeId",
 			},
-			KubernetesServiceRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            false,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+			Location:                             "southeastasia",
+			ResourceGroup:                        "fakeId",
+			VMType:                               "standard",
+			VmssCacheTTLInSeconds:                60,
+			VmssVirtualMachinesCacheTTLInSeconds: 240,
+			CloudProviderRateLimitConfig: providerazureconfig.CloudProviderRateLimitConfig{
+				RateLimitConfig: azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				InterfaceRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				StorageAccountRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				DiskRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
 			},
 		},
-		Deployment: "cluster-autoscaler-0001",
+		VmssVmsCacheJitter:  120,
+		MaxDeploymentsCount: 8,
+		Deployment:          "cluster-autoscaler-0001",
 		DeploymentParameters: map[string]interface{}{
 			"Name": "cluster-autoscaler-0001",
 			"Properties": map[string]interface{}{
@@ -327,7 +468,7 @@ func TestCreateAzureManagerValidConfigForStandardVMType(t *testing.T) {
 	}
 
 	assert.NoError(t, err)
-	assert.Equal(t, *expectedConfig, *manager.config, "unexpected azure manager configuration, expected: %v, actual: %v", *expectedConfig, *manager.config)
+	assertStructsMinimallyEqual(t, *expectedConfig, *manager.config)
 }
 
 func TestCreateAzureManagerValidConfigForStandardVMTypeWithoutDeploymentParameters(t *testing.T) {
@@ -336,6 +477,92 @@ func TestCreateAzureManagerValidConfigForStandardVMTypeWithoutDeploymentParamete
 	assert.Nil(t, manager)
 	assert.Equal(t, expectedErr, err.Error(), "return error does not match, expected: %v, actual: %v", expectedErr, err.Error())
 }
+func TestCreateAzureManagerValidConfigForVMsPool(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockVMClient := mockvmclient.NewMockInterface(ctrl)
+	mockVMSSClient := mockvmssclient.NewMockInterface(ctrl)
+	mockVMSSClient.EXPECT().List(gomock.Any(), "fakeId").Return([]compute.VirtualMachineScaleSet{}, nil).Times(2)
+	mockVMClient.EXPECT().List(gomock.Any(), "fakeId").Return([]compute.VirtualMachine{}, nil).Times(2)
+	mockAzClient := &azClient{
+		virtualMachinesClient:         mockVMClient,
+		virtualMachineScaleSetsClient: mockVMSSClient,
+	}
+	manager, err := createAzureManagerInternal(strings.NewReader(validAzureCfgForVMsPool), cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
+
+	expectedConfig := &Config{
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					Cloud:    "AzurePublicCloud",
+					TenantID: "fakeId",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:     "fakeId",
+					AADClientSecret: "fakeId",
+				},
+				SubscriptionID: "fakeId",
+			},
+			Location:                             "southeastasia",
+			ResourceGroup:                        "fakeId",
+			VMType:                               "vmss",
+			VmssCacheTTLInSeconds:                60,
+			VmssVirtualMachinesCacheTTLInSeconds: 240,
+			CloudProviderRateLimitConfig: providerazureconfig.CloudProviderRateLimitConfig{
+				RateLimitConfig: azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				InterfaceRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				StorageAccountRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				DiskRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            false,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+			},
+		},
+		VmssVmsCacheJitter:    120,
+		MaxDeploymentsCount:   8,
+		ClusterName:           "mycluster",
+		ClusterResourceGroup:  "myrg",
+		ARMBaseURLForAPClient: "nodeprovisioner-svc.nodeprovisioner.svc.cluster.local",
+	}
+
+	assert.NoError(t, err)
+	assertStructsMinimallyEqual(t, *expectedConfig, *manager.config)
+}
 
 func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 	ctrl := gomock.NewController(t)
@@ -350,83 +577,83 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 	}
 
 	expectedConfig := &Config{
-		Cloud:                        "AzurePublicCloud",
-		Location:                     "southeastasia",
-		TenantID:                     "tenantId",
-		SubscriptionID:               "subscriptionId",
-		ResourceGroup:                "resourceGroup",
-		ClusterName:                  "mycluster",
-		ClusterResourceGroup:         "myrg",
-		ARMBaseURLForAPClient:        "nodeprovisioner-svc.nodeprovisioner.svc.cluster.local",
-		VMType:                       "vmss",
-		AADClientID:                  "aadClientId",
-		AADClientSecret:              "aadClientSecret",
-		AADClientCertPath:            "aadClientCertPath",
-		AADClientCertPassword:        "aadClientCertPassword",
-		Deployment:                   "deployment",
-		UseManagedIdentityExtension:  true,
-		UserAssignedIdentityID:       "UserAssignedIdentityID",
-		VmssCacheTTL:                 100,
-		VmssVmsCacheTTL:              110,
-		VmssVmsCacheJitter:           90,
-		GetVmssSizeRefreshPeriod:     30,
-		MaxDeploymentsCount:          8,
-		CloudProviderBackoff:         true,
-		CloudProviderBackoffRetries:  1,
-		CloudProviderBackoffExponent: 1,
-		CloudProviderBackoffDuration: 1,
-		CloudProviderBackoffJitter:   1,
-		CloudProviderRateLimitConfig: CloudProviderRateLimitConfig{
-			RateLimitConfig: azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			InterfaceRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			VirtualMachineRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			StorageAccountRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			DiskRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
-			},
-			VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					Cloud:    "AzurePublicCloud",
+					TenantID: "tenantId",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:                 "aadClientId",
+					AADClientSecret:             "aadClientSecret",
+					AADClientCertPath:           "aadClientCertPath",
+					AADClientCertPassword:       "aadClientCertPassword",
+					UseManagedIdentityExtension: true,
+					UserAssignedIdentityID:      "UserAssignedIdentityID",
+				},
+				SubscriptionID: "subscriptionId",
 			},
-			KubernetesServiceRateLimit: &azclients.RateLimitConfig{
-				CloudProviderRateLimit:            true,
-				CloudProviderRateLimitBucket:      5,
-				CloudProviderRateLimitBucketWrite: 5,
-				CloudProviderRateLimitQPS:         1,
-				CloudProviderRateLimitQPSWrite:    1,
+			Location:                             "southeastasia",
+			ResourceGroup:                        "resourceGroup",
+			VMType:                               "vmss",
+			VmssCacheTTLInSeconds:                100,
+			VmssVirtualMachinesCacheTTLInSeconds: 110,
+			CloudProviderBackoff:                 true,
+			CloudProviderBackoffRetries:          1,
+			CloudProviderBackoffExponent:         1,
+			CloudProviderBackoffDuration:         1,
+			CloudProviderBackoffJitter:           1,
+			CloudProviderRateLimitConfig: providerazureconfig.CloudProviderRateLimitConfig{
+				RateLimitConfig: azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				InterfaceRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				StorageAccountRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				DiskRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
 			},
 		},
+		ClusterName:           "mycluster",
+		ClusterResourceGroup:  "myrg",
+		ARMBaseURLForAPClient: "nodeprovisioner-svc.nodeprovisioner.svc.cluster.local",
+		Deployment:            "deployment",
+		VmssVmsCacheJitter:    90,
+		MaxDeploymentsCount:   8,
 	}
 
 	t.Setenv("ARM_CLOUD", "AzurePublicCloud")
@@ -463,15 +690,13 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 	t.Run("environment variables correctly set", func(t *testing.T) {
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 		assert.NoError(t, err)
-		manager.config.TenantID = "tenantId"
-		manager.config.AADClientID = "aadClientId"
-		assert.Equal(t, true, reflect.DeepEqual(*expectedConfig, *manager.config), "unexpected azure manager configuration")
+		assertStructsMinimallyEqual(t, *expectedConfig, *manager.config)
 	})
 
 	t.Run("invalid bool for ARM_USE_MANAGED_IDENTITY_EXTENSION", func(t *testing.T) {
 		t.Setenv("ARM_USE_MANAGED_IDENTITY_EXTENSION", "invalidbool")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
-		expectedErr0 := "strconv.ParseBool: parsing \"invalidbool\": invalid syntax"
+		expectedErr0 := "failed to parse ARM_USE_MANAGED_IDENTITY_EXTENSION \"invalidbool\": strconv.ParseBool: parsing \"invalidbool\": invalid syntax"
 		assert.Nil(t, manager)
 		assert.Equal(t, expectedErr0, err.Error(), "Return err does not match, expected: %v, actual: %v", expectedErr0, err.Error())
 	})
@@ -487,7 +712,7 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 	t.Run("invalid int for AZURE_GET_VMSS_SIZE_REFRESH_PERIOD", func(t *testing.T) {
 		t.Setenv("AZURE_GET_VMSS_SIZE_REFRESH_PERIOD", "invalidint")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
-		expectedErr := fmt.Errorf("failed to parse AZURE_GET_VMSS_SIZE_REFRESH_PERIOD \"invalidint\": strconv.Atoi: parsing \"invalidint\": invalid syntax")
+		expectedErr := fmt.Errorf("failed to parse AZURE_GET_VMSS_SIZE_REFRESH_PERIOD \"invalidint\": strconv.ParseInt: parsing \"invalidint\": invalid syntax")
 		assert.Nil(t, manager)
 		assert.Equal(t, expectedErr, err, "Return err does not match, expected: %v, actual: %v", expectedErr, err)
 	})
@@ -518,7 +743,7 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 	t.Run("invalid int for BACKOFF_RETRIES", func(t *testing.T) {
 		t.Setenv("BACKOFF_RETRIES", "invalidint")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
-		expectedErr := fmt.Errorf("failed to parse BACKOFF_RETRIES '\\x00': strconv.ParseInt: parsing \"invalidint\": invalid syntax")
+		expectedErr := fmt.Errorf("failed to parse BACKOFF_RETRIES \"invalidint\": strconv.ParseInt: parsing \"invalidint\": invalid syntax")
 		assert.Nil(t, manager)
 		assert.Equal(t, expectedErr, err, "Return err does not match, expected: %v, actual: %v", expectedErr, err)
 	})
@@ -527,7 +752,7 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 		t.Setenv("BACKOFF_RETRIES", "")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 		assert.NoError(t, err)
-		assert.Equal(t, backoffRetriesDefault, (*manager.config).CloudProviderBackoffRetries, "CloudProviderBackoffRetries does not match.")
+		assert.Equal(t, providerazureconsts.BackoffRetriesDefault, (*manager.config).CloudProviderBackoffRetries, "CloudProviderBackoffRetries does not match.")
 	})
 
 	t.Run("invalid float for BACKOFF_EXPONENT", func(t *testing.T) {
@@ -542,7 +767,7 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 		t.Setenv("BACKOFF_EXPONENT", "")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 		assert.NoError(t, err)
-		assert.Equal(t, backoffExponentDefault, (*manager.config).CloudProviderBackoffExponent, "CloudProviderBackoffExponent does not match.")
+		assert.Equal(t, providerazureconsts.BackoffExponentDefault, (*manager.config).CloudProviderBackoffExponent, "CloudProviderBackoffExponent does not match.")
 	})
 
 	t.Run("invalid int for BACKOFF_DURATION", func(t *testing.T) {
@@ -557,7 +782,7 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 		t.Setenv("BACKOFF_DURATION", "")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 		assert.NoError(t, err)
-		assert.Equal(t, backoffDurationDefault, (*manager.config).CloudProviderBackoffDuration, "CloudProviderBackoffDuration does not match.")
+		assert.Equal(t, providerazureconsts.BackoffDurationDefault, (*manager.config).CloudProviderBackoffDuration, "CloudProviderBackoffDuration does not match.")
 	})
 
 	t.Run("invalid float for BACKOFF_JITTER", func(t *testing.T) {
@@ -572,18 +797,148 @@ func TestCreateAzureManagerWithNilConfig(t *testing.T) {
 		t.Setenv("BACKOFF_JITTER", "")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
 		assert.NoError(t, err)
-		assert.Equal(t, backoffJitterDefault, (*manager.config).CloudProviderBackoffJitter, "CloudProviderBackoffJitter does not match.")
+		assert.Equal(t, providerazureconsts.BackoffJitterDefault, (*manager.config).CloudProviderBackoffJitter, "CloudProviderBackoffJitter does not match.")
 	})
 
 	t.Run("invalid bool for CLOUD_PROVIDER_RATE_LIMIT", func(t *testing.T) {
 		t.Setenv("CLOUD_PROVIDER_RATE_LIMIT", "invalidbool")
 		manager, err := createAzureManagerInternal(nil, cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
-		expectedErr := fmt.Errorf("failed to parse CLOUD_PROVIDER_RATE_LIMIT: \"invalidbool\", strconv.ParseBool: parsing \"invalidbool\": invalid syntax")
+		expectedErr := fmt.Errorf("failed to parse CLOUD_PROVIDER_RATE_LIMIT \"invalidbool\": strconv.ParseBool: parsing \"invalidbool\": invalid syntax")
 		assert.Nil(t, manager)
 		assert.Equal(t, expectedErr, err, "Return err does not match, expected: %v, actual: %v", expectedErr, err)
 	})
 }
 
+func TestCreateAzureManagerWithEnvOverridingConfig(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockVMClient := mockvmclient.NewMockInterface(ctrl)
+	mockVMSSClient := mockvmssclient.NewMockInterface(ctrl)
+	mockVMSSClient.EXPECT().List(gomock.Any(), "resourceGroup").Return([]compute.VirtualMachineScaleSet{}, nil).AnyTimes()
+	mockVMClient.EXPECT().List(gomock.Any(), "resourceGroup").Return([]compute.VirtualMachine{}, nil).AnyTimes()
+	mockAzClient := &azClient{
+		virtualMachinesClient:         mockVMClient,
+		virtualMachineScaleSetsClient: mockVMSSClient,
+	}
+
+	expectedConfig := &Config{
+		Config: providerazure.Config{
+			AzureAuthConfig: providerazureconfig.AzureAuthConfig{
+				ARMClientConfig: azclient.ARMClientConfig{
+					Cloud:    "AzurePublicCloud",
+					TenantID: "tenantId",
+				},
+				AzureAuthConfig: azclient.AzureAuthConfig{
+					AADClientID:                 "aadClientId",
+					AADClientSecret:             "aadClientSecret",
+					AADClientCertPath:           "aadClientCertPath",
+					AADClientCertPassword:       "aadClientCertPassword",
+					UseManagedIdentityExtension: true,
+					UserAssignedIdentityID:      "UserAssignedIdentityID",
+				},
+				SubscriptionID: "subscriptionId",
+			},
+			Location:                             "southeastasia",
+			ResourceGroup:                        "resourceGroup",
+			VMType:                               "vmss",
+			VmssCacheTTLInSeconds:                100,
+			VmssVirtualMachinesCacheTTLInSeconds: 110,
+			CloudProviderBackoff:                 true,
+			CloudProviderBackoffRetries:          1,
+			CloudProviderBackoffExponent:         1,
+			CloudProviderBackoffDuration:         1,
+			CloudProviderBackoffJitter:           1,
+			CloudProviderRateLimitConfig: providerazureconfig.CloudProviderRateLimitConfig{
+				RateLimitConfig: azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				InterfaceRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				StorageAccountRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				DiskRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+				VirtualMachineScaleSetRateLimit: &azclients.RateLimitConfig{
+					CloudProviderRateLimit:            true,
+					CloudProviderRateLimitBucket:      5,
+					CloudProviderRateLimitBucketWrite: 5,
+					CloudProviderRateLimitQPS:         1,
+					CloudProviderRateLimitQPSWrite:    1,
+				},
+			},
+		},
+		ClusterName:           "mycluster",
+		ClusterResourceGroup:  "myrg",
+		ARMBaseURLForAPClient: "nodeprovisioner-svc.nodeprovisioner.svc.cluster.local",
+		Deployment:            "deployment",
+		VmssVmsCacheJitter:    90,
+		MaxDeploymentsCount:   8,
+	}
+
+	t.Setenv("ARM_CLOUD", "AzurePublicCloud")
+	// LOCATION is not set from env to test getting it from config file
+	t.Setenv("AZURE_TENANT_ID", "tenantId")
+	t.Setenv("AZURE_CLIENT_ID", "aadClientId")
+	t.Setenv("ARM_SUBSCRIPTION_ID", "subscriptionId")
+	t.Setenv("ARM_RESOURCE_GROUP", "resourceGroup")
+	t.Setenv("AZURE_TENANT_ID", "tenantId")
+	t.Setenv("ARM_TENANT_ID", "tenantId")
+	t.Setenv("AZURE_CLIENT_ID", "aadClientId")
+	t.Setenv("ARM_CLIENT_ID", "aadClientId")
+	t.Setenv("ARM_CLIENT_SECRET", "aadClientSecret")
+	t.Setenv("ARM_VM_TYPE", "vmss") // this is one of the differences with the config file, expect this to take precedence
+	t.Setenv("ARM_CLIENT_CERT_PATH", "aadClientCertPath")
+	t.Setenv("ARM_CLIENT_CERT_PASSWORD", "aadClientCertPassword")
+	t.Setenv("ARM_DEPLOYMENT", "deployment")
+	t.Setenv("ARM_USE_MANAGED_IDENTITY_EXTENSION", "true")
+	t.Setenv("ARM_USER_ASSIGNED_IDENTITY_ID", "UserAssignedIdentityID")
+	t.Setenv("AZURE_VMSS_CACHE_TTL", "100")
+	t.Setenv("AZURE_VMSS_VMS_CACHE_TTL", "110")
+	t.Setenv("AZURE_VMSS_VMS_CACHE_JITTER", "90")
+	t.Setenv("AZURE_MAX_DEPLOYMENT_COUNT", "8")
+	t.Setenv("ENABLE_BACKOFF", "true")
+	t.Setenv("BACKOFF_RETRIES", "1")
+	t.Setenv("BACKOFF_EXPONENT", "1")
+	t.Setenv("BACKOFF_DURATION", "1")
+	t.Setenv("BACKOFF_JITTER", "1")
+	t.Setenv("CLOUD_PROVIDER_RATE_LIMIT", "true")
+	t.Setenv("CLUSTER_NAME", "mycluster")
+	t.Setenv("ARM_CLUSTER_RESOURCE_GROUP", "myrg")
+	t.Setenv("ARM_BASE_URL_FOR_AP_CLIENT", "nodeprovisioner-svc.nodeprovisioner.svc.cluster.local")
+
+	t.Run("environment variables correctly set", func(t *testing.T) {
+		manager, err := createAzureManagerInternal(strings.NewReader(validAzureCfgForStandardVMType), cloudprovider.NodeGroupDiscoveryOptions{}, mockAzClient)
+		assert.NoError(t, err)
+		assertStructsMinimallyEqual(t, *expectedConfig, *manager.config)
+	})
+}
+
 func TestCreateAzureManagerInvalidConfig(t *testing.T) {
 	_, err := createAzureManagerInternal(strings.NewReader(invalidAzureCfg), cloudprovider.NodeGroupDiscoveryOptions{}, &azClient{})
 	assert.Error(t, err, "failed to unmarshal config body")
@@ -620,7 +975,7 @@ func TestFetchExplicitNodeGroups(t *testing.T) {
 		} else {
 
 			mockVMClient := mockvmclient.NewMockInterface(ctrl)
-			manager.config.EnableVmssFlex = true
+			manager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 			manager.azClient.virtualMachinesClient = mockVMClient
 		}
@@ -638,7 +993,7 @@ func TestFetchExplicitNodeGroups(t *testing.T) {
 	testAS := newTestAgentPool(newTestAzureManager(t), "testAS")
 	timeLayout := "2006-01-02 15:04:05"
 	timeBenchMark, _ := time.Parse(timeLayout, "2000-01-01 00:00:00")
-	testAS.manager.azClient.deploymentsClient = &DeploymentsClientMock{
+	testAS.manager.azClient.deploymentClient = &DeploymentClientMock{
 		FakeStore: map[string]resources.DeploymentExtended{
 			"cluster-autoscaler-0001": {
 				Name: to.StringPtr("cluster-autoscaler-0001"),
@@ -649,9 +1004,9 @@ func TestFetchExplicitNodeGroups(t *testing.T) {
 			},
 		},
 	}
-	testAS.manager.config.VMType = vmTypeStandard
+	testAS.manager.config.VMType = providerazureconsts.VMTypeStandard
 	err := testAS.manager.fetchExplicitNodeGroups([]string{"1:5:testAS"})
-	expectedErr := fmt.Errorf("failed to parse node group spec: deployment not found")
+	expectedErr := fmt.Errorf("failed to parse node group spec: %v", retry.NewError(false, fmt.Errorf("deployment not found")).Error())
 	assert.Equal(t, expectedErr, err, "testAS.manager.fetchExplicitNodeGroups return error does not match, expected: %v, actual: %v", expectedErr, err)
 	err = testAS.manager.fetchExplicitNodeGroups(nil)
 	assert.NoError(t, err)
@@ -840,3 +1195,36 @@ func TestGetScaleSetOptions(t *testing.T) {
 	opts = manager.GetScaleSetOptions("test3", defaultOptions)
 	assert.Equal(t, *opts, defaultOptions)
 }
+
+func assertStructsMinimallyEqual(t *testing.T, struct1, struct2 interface{}) bool {
+	return compareStructFields(t, reflect.ValueOf(struct1), reflect.ValueOf(struct2))
+}
+
+func compareStructFields(t *testing.T, v1, v2 reflect.Value) bool {
+	if v1.Type() != v2.Type() {
+		return assert.Fail(t, "different types", "v1 type: %v, v2 type: %v", v1.Type(), v2.Type())
+	}
+
+	for i := 0; i < v1.NumField(); i++ {
+		field1 := v1.Field(i)
+		field2 := v2.Field(i)
+		fieldType := v1.Type().Field(i)
+
+		if field1.IsZero() || reflect.DeepEqual(field1.Interface(), reflect.Zero(field1.Type()).Interface()) {
+			continue // Skip zero value fields in struct1
+		}
+
+		if field1.Kind() == reflect.Struct {
+			// Recursively compare nested structs
+			if !compareStructFields(t, field1, field2) {
+				return false
+			}
+		} else {
+			if !assert.Equal(t, field1.Interface(), field2.Interface(), "field %s", fieldType.Name) {
+				return false
+			}
+		}
+	}
+
+	return true
+}
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_scale_set.go b/cluster-autoscaler/cloudprovider/azure/azure_scale_set.go
index 3d03591f5e0c..05cf4301080f 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_scale_set.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_scale_set.go
@@ -112,8 +112,8 @@ func NewScaleSet(spec *dynamic.NodeGroupSpec, az *AzureManager, curSize int64, d
 		dedicatedHost:             dedicatedHost,
 	}
 
-	if az.config.VmssVmsCacheTTL != 0 {
-		scaleSet.instancesRefreshPeriod = time.Duration(az.config.VmssVmsCacheTTL) * time.Second
+	if az.config.VmssVirtualMachinesCacheTTLInSeconds != 0 {
+		scaleSet.instancesRefreshPeriod = time.Duration(az.config.VmssVirtualMachinesCacheTTLInSeconds) * time.Second
 	} else {
 		scaleSet.instancesRefreshPeriod = defaultVmssInstancesRefreshPeriod
 	}
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_scale_set_instance_cache.go b/cluster-autoscaler/cloudprovider/azure/azure_scale_set_instance_cache.go
index 5b6843caf412..bc6bda019f3d 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_scale_set_instance_cache.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_scale_set_instance_cache.go
@@ -106,10 +106,10 @@ func (scaleSet *ScaleSet) updateInstanceCache() error {
 	}
 
 	if orchestrationMode == compute.Flexible {
-		if scaleSet.manager.config.EnableVmssFlex {
+		if scaleSet.manager.config.EnableVmssFlexNodes {
 			return scaleSet.buildScaleSetCacheForFlex()
 		}
-		return fmt.Errorf("vmss - %q with Flexible orchestration detected but 'enableVmssFlex' feature flag is turned off", scaleSet.Name)
+		return fmt.Errorf("vmss - %q with Flexible orchestration detected but 'enableVmssFlexNodes' feature flag is turned off", scaleSet.Name)
 	} else if orchestrationMode == compute.Uniform {
 		return scaleSet.buildScaleSetCacheForUniform()
 	}
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_scale_set_test.go b/cluster-autoscaler/cloudprovider/azure/azure_scale_set_test.go
index f3aa0dc356d8..b3bd5fca5b5c 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_scale_set_test.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_scale_set_test.go
@@ -203,7 +203,7 @@ func TestTargetSize(t *testing.T) {
 			mockVMSSVMClient.EXPECT().List(gomock.Any(), provider.azureManager.config.ResourceGroup, "test-asg", gomock.Any()).Return(expectedVMSSVMs, nil).AnyTimes()
 			provider.azureManager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 		} else {
-			provider.azureManager.config.EnableVmssFlex = true
+			provider.azureManager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 		}
 
@@ -278,7 +278,7 @@ func TestIncreaseSize(t *testing.T) {
 			mockVMSSVMClient.EXPECT().List(gomock.Any(), provider.azureManager.config.ResourceGroup, "test-asg", gomock.Any()).Return(expectedVMSSVMs, nil).AnyTimes()
 			provider.azureManager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 		} else {
-			provider.azureManager.config.EnableVmssFlex = true
+			provider.azureManager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 		}
 		err := provider.azureManager.forceRefresh()
@@ -514,7 +514,7 @@ func TestBelongs(t *testing.T) {
 			mockVMSSVMClient.EXPECT().List(gomock.Any(), provider.azureManager.config.ResourceGroup, "test-asg", gomock.Any()).Return(expectedVMSSVMs, nil).AnyTimes()
 			provider.azureManager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 		} else {
-			provider.azureManager.config.EnableVmssFlex = true
+			provider.azureManager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 		}
 
@@ -603,7 +603,7 @@ func TestDeleteNodes(t *testing.T) {
 			mockVMSSVMClient.EXPECT().List(gomock.Any(), manager.config.ResourceGroup, "test-asg", gomock.Any()).Return(expectedVMSSVMs, nil).AnyTimes()
 			manager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 		} else {
-			manager.config.EnableVmssFlex = true
+			manager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 			manager.azClient.virtualMachinesClient = mockVMClient
 		}
@@ -739,7 +739,7 @@ func TestDeleteNodeUnregistered(t *testing.T) {
 			mockVMSSVMClient.EXPECT().List(gomock.Any(), manager.config.ResourceGroup, "test-asg", gomock.Any()).Return(expectedVMSSVMs, nil).AnyTimes()
 			manager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 		} else {
-			manager.config.EnableVmssFlex = true
+			manager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 		}
 		err := manager.forceRefresh()
@@ -1013,7 +1013,7 @@ func TestScaleSetNodes(t *testing.T) {
 			provider.azureManager.azClient.virtualMachineScaleSetVMsClient = mockVMSSVMClient
 
 		} else {
-			provider.azureManager.config.EnableVmssFlex = true
+			provider.azureManager.config.EnableVmssFlexNodes = true
 			mockVMClient.EXPECT().ListVmssFlexVMsWithoutInstanceView(gomock.Any(), "test-asg").Return(expectedVMs, nil).AnyTimes()
 		}
 
@@ -1057,7 +1057,7 @@ func TestScaleSetNodes(t *testing.T) {
 
 }
 
-func TestEnableVmssFlexFlag(t *testing.T) {
+func TestEnableVmssFlexNodesFlag(t *testing.T) {
 
 	// flag set to false
 	ctrl := gomock.NewController(t)
@@ -1069,7 +1069,7 @@ func TestEnableVmssFlexFlag(t *testing.T) {
 	provider := newTestProvider(t)
 	mockVMSSClient := mockvmssclient.NewMockInterface(ctrl)
 	mockVMSSClient.EXPECT().List(gomock.Any(), provider.azureManager.config.ResourceGroup).Return(expectedScaleSets, nil).AnyTimes()
-	provider.azureManager.config.EnableVmssFlex = false
+	provider.azureManager.config.EnableVmssFlexNodes = false
 	provider.azureManager.azClient.virtualMachineScaleSetsClient = mockVMSSClient
 	mockVMClient := mockvmclient.NewMockInterface(ctrl)
 
@@ -1084,7 +1084,7 @@ func TestEnableVmssFlexFlag(t *testing.T) {
 	assert.Error(t, err, "vmss - \"test-asg\" with Flexible orchestration detected but 'enbaleVmssFlex' feature flag is turned off")
 
 	// flag set to true
-	provider.azureManager.config.EnableVmssFlex = true
+	provider.azureManager.config.EnableVmssFlexNodes = true
 	err = provider.azureManager.Refresh()
 	assert.NoError(t, err)
 }
diff --git a/cluster-autoscaler/cloudprovider/azure/azure_util.go b/cluster-autoscaler/cloudprovider/azure/azure_util.go
index 9f4a44284ed2..44a87980571c 100644
--- a/cluster-autoscaler/cloudprovider/azure/azure_util.go
+++ b/cluster-autoscaler/cloudprovider/azure/azure_util.go
@@ -636,3 +636,21 @@ func vmPowerStateFromStatuses(statuses []compute.InstanceViewStatus) string {
 	// PowerState is not set if the VM is still creating (or has failed creation)
 	return vmPowerStateUnknown
 }
+
+// strconv.ParseInt, but for int
+func parseInt32(s string, base int) (int, error) {
+	val, err := strconv.ParseInt(s, base, 32)
+	if err != nil {
+		return 0, err
+	}
+	return int(val), nil
+}
+
+// strconv.ParseFloat, but for float32
+func parseFloat32(s string) (float32, error) {
+	val, err := strconv.ParseFloat(s, 32)
+	if err != nil {
+		return 0, err
+	}
+	return float32(val), nil
+}
diff --git a/cluster-autoscaler/go.mod b/cluster-autoscaler/go.mod
index 00839b725d5d..beecafa55307 100644
--- a/cluster-autoscaler/go.mod
+++ b/cluster-autoscaler/go.mod
@@ -2,7 +2,7 @@ module k8s.io/autoscaler/cluster-autoscaler
 
 go 1.22.0
 
-toolchain go1.22.2
+toolchain go1.22.4
 
 require (
 	cloud.google.com/go/compute/metadata v0.2.3
@@ -12,8 +12,8 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.5.2
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v4 v4.9.0-beta.1
 	github.com/Azure/go-autorest/autorest v0.11.29
-	github.com/Azure/go-autorest/autorest/adal v0.9.23
-	github.com/Azure/go-autorest/autorest/azure/auth v0.5.8
+	github.com/Azure/go-autorest/autorest/adal v0.9.24
+	github.com/Azure/go-autorest/autorest/azure/auth v0.5.13
 	github.com/Azure/go-autorest/autorest/date v0.3.0
 	github.com/Azure/go-autorest/autorest/to v0.4.0
 	github.com/Azure/skewer v0.0.14
@@ -55,6 +55,7 @@ require (
 	k8s.io/legacy-cloud-providers v0.0.0
 	k8s.io/utils v0.0.0-20231127182322-b307cd553661
 	sigs.k8s.io/cloud-provider-azure v1.29.4
+	sigs.k8s.io/cloud-provider-azure/pkg/azclient v0.0.13
 	sigs.k8s.io/yaml v1.4.0
 )
 
@@ -72,7 +73,7 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.5.0 // indirect
 	github.com/Azure/go-armbalancer v0.0.2 // indirect
 	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
-	github.com/Azure/go-autorest/autorest/azure/cli v0.4.2 // indirect
+	github.com/Azure/go-autorest/autorest/azure/cli v0.4.6 // indirect
 	github.com/Azure/go-autorest/autorest/mocks v0.4.2 // indirect
 	github.com/Azure/go-autorest/autorest/validation v0.3.1 // indirect
 	github.com/Azure/go-autorest/logger v0.2.1 // indirect
@@ -212,8 +213,7 @@ require (
 	k8s.io/kube-scheduler v0.0.0 // indirect
 	k8s.io/kubectl v0.28.0 // indirect
 	k8s.io/mount-utils v0.26.0-alpha.0 // indirect
-	sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.29.0 // indirect
-	sigs.k8s.io/cloud-provider-azure/pkg/azclient v0.0.13 // indirect
+	sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.30.3 // indirect
 	sigs.k8s.io/cloud-provider-azure/pkg/azclient/configloader v0.0.4 // indirect
 	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect
diff --git a/cluster-autoscaler/go.sum b/cluster-autoscaler/go.sum
index 44095b0edabd..23db6a366402 100644
--- a/cluster-autoscaler/go.sum
+++ b/cluster-autoscaler/go.sum
@@ -90,20 +90,19 @@ github.com/Azure/go-armbalancer v0.0.2/go.mod h1:yTg7MA/8YnfKQc9o97tzAJ7fbdVkod1
 github.com/Azure/go-autorest v14.2.0+incompatible h1:V5VMDjClD3GiElqLWO7mz2MxNAK/vTfRHdAubSIPRgs=
 github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
 github.com/Azure/go-autorest/autorest v0.11.4/go.mod h1:JFgpikqFJ/MleTTxwepExTKnFUKKszPS8UavbQYUMuw=
-github.com/Azure/go-autorest/autorest v0.11.17/go.mod h1:eipySxLmqSyC5s5k1CLupqet0PSENBEDP93LQ9a8QYw=
+github.com/Azure/go-autorest/autorest v0.11.28/go.mod h1:MrkzG3Y3AH668QyF9KRk5neJnGgmhQ6krbhR8Q5eMvA=
 github.com/Azure/go-autorest/autorest v0.11.29 h1:I4+HL/JDvErx2LjyzaVxllw2lRDB5/BT2Bm4g20iqYw=
 github.com/Azure/go-autorest/autorest v0.11.29/go.mod h1:ZtEzC4Jy2JDrZLxvWs8LrBWEBycl1hbT1eknI8MtfAs=
 github.com/Azure/go-autorest/autorest/adal v0.9.0/go.mod h1:/c022QCutn2P7uY+/oQWWNcK9YU+MH96NgK+jErpbcg=
 github.com/Azure/go-autorest/autorest/adal v0.9.2/go.mod h1:/3SMAM86bP6wC9Ev35peQDUeqFZBMH07vvUOmg4z/fE=
-github.com/Azure/go-autorest/autorest/adal v0.9.5/go.mod h1:B7KF7jKIeC9Mct5spmyCB/A8CG/sEz1vwIRGv/bbw7A=
-github.com/Azure/go-autorest/autorest/adal v0.9.11/go.mod h1:nBKAnTomx8gDtl+3ZCJv2v0KACFHWTB2drffI1B68Pk=
+github.com/Azure/go-autorest/autorest/adal v0.9.18/go.mod h1:XVVeme+LZwABT8K5Lc3hA4nAe8LDBVle26gTrguhhPQ=
 github.com/Azure/go-autorest/autorest/adal v0.9.22/go.mod h1:XuAbAEUv2Tta//+voMI038TrJBqjKam0me7qR+L8Cmk=
-github.com/Azure/go-autorest/autorest/adal v0.9.23 h1:Yepx8CvFxwNKpH6ja7RZ+sKX+DWYNldbLiALMC3BTz8=
-github.com/Azure/go-autorest/autorest/adal v0.9.23/go.mod h1:5pcMqFkdPhviJdlEy3kC/v1ZLnQl0MH6XA5YCcMhy4c=
-github.com/Azure/go-autorest/autorest/azure/auth v0.5.8 h1:TzPg6B6fTZ0G1zBf3T54aI7p3cAT6u//TOXGPmFMOXg=
-github.com/Azure/go-autorest/autorest/azure/auth v0.5.8/go.mod h1:kxyKZTSfKh8OVFWPAgOgQ/frrJgeYQJPyR5fLFmXko4=
-github.com/Azure/go-autorest/autorest/azure/cli v0.4.2 h1:dMOmEJfkLKW/7JsokJqkyoYSgmR08hi9KrhjZb+JALY=
-github.com/Azure/go-autorest/autorest/azure/cli v0.4.2/go.mod h1:7qkJkT+j6b+hIpzMOwPChJhTqS8VbsqqgULzMNRugoM=
+github.com/Azure/go-autorest/autorest/adal v0.9.24 h1:BHZfgGsGwdkHDyZdtQRQk1WeUdW0m2WPAwuHZwUi5i4=
+github.com/Azure/go-autorest/autorest/adal v0.9.24/go.mod h1:7T1+g0PYFmACYW5LlG2fcoPiPlFHjClyRGL7dRlP5c8=
+github.com/Azure/go-autorest/autorest/azure/auth v0.5.13 h1:Ov8avRZi2vmrE2JcXw+tu5K/yB41r7xK9GZDiBF7NdM=
+github.com/Azure/go-autorest/autorest/azure/auth v0.5.13/go.mod h1:5BAVfWLWXihP47vYrPuBKKf4cS0bXI+KM9Qx6ETDJYo=
+github.com/Azure/go-autorest/autorest/azure/cli v0.4.6 h1:w77/uPk80ZET2F+AfQExZyEWtn+0Rk/uw17m9fv5Ajc=
+github.com/Azure/go-autorest/autorest/azure/cli v0.4.6/go.mod h1:piCfgPho7BiIDdEQ1+g4VmKyD5y+p/XtSNqE6Hc4QD0=
 github.com/Azure/go-autorest/autorest/date v0.3.0 h1:7gUk1U5M/CQbp9WoqinNzJar+8KY+LPI6wiWrP/myHw=
 github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74=
 github.com/Azure/go-autorest/autorest/mocks v0.4.0/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k=
@@ -221,7 +220,6 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZm
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/digitalocean/godo v1.27.0 h1:78iE9oVvTnAEqhMip2UHFvL01b8LJcydbNUpr0cAmN4=
 github.com/digitalocean/godo v1.27.0/go.mod h1:iJnN9rVu6K5LioLxLimlq0uRI+y/eAQjROUmeU/r0hY=
-github.com/dimchansky/utfbom v1.1.0/go.mod h1:rO41eb7gLfo8SF1jd9F8HplJm1Fewwi4mQvIirEdv+8=
 github.com/dimchansky/utfbom v1.1.1 h1:vV6w1AhK4VMnhBno/TPVCoK9U/LP0PkLCS9tbxHdi/U=
 github.com/dimchansky/utfbom v1.1.1/go.mod h1:SxdoEBH5qIqFocHMyGOXVAybYJdr71b1Q/j0mACtrfE=
 github.com/distribution/reference v0.5.0 h1:/FUIFXtfc/x2gpa5/VGfiGLuOIdYa1t65IKK2OFGvA0=
@@ -258,7 +256,6 @@ github.com/evanphx/json-patch v5.9.0+incompatible h1:fBXyNpNMuTTDdquAq/uisOr2lSh
 github.com/evanphx/json-patch v5.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
-github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k=
 github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
 github.com/frankban/quicktest v1.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss=
 github.com/frankban/quicktest v1.14.0/go.mod h1:NeW+ay9A/U67EYXNFA1nPE8e/tnQv/09mUdL/ijj8og=
@@ -301,6 +298,7 @@ github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zV
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-jwt/jwt/v4 v4.0.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
+github.com/golang-jwt/jwt/v4 v4.2.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
 github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
 github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
@@ -678,11 +676,10 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30=
 golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -723,6 +720,7 @@ golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.15.0 h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8=
 golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -767,6 +765,7 @@ golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w=
 golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -800,6 +799,7 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -862,12 +862,16 @@ golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
 golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
 golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -881,6 +885,7 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -944,6 +949,7 @@ golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ=
 golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1186,8 +1192,8 @@ k8s.io/utils v0.0.0-20231127182322-b307cd553661/go.mod h1:OLgZIPagt7ERELqWJFomSt
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
 rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
-sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.29.0 h1:/U5vjBbQn3RChhv7P11uhYvCSm5G2GaIi5AIGBS6r4c=
-sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.29.0/go.mod h1:z7+wmGM2dfIiLRfrC6jb5kV2Mq/sK1ZP303cxzkV5Y4=
+sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.30.3 h1:2770sDpzrjjsAtVhSeUFseziht227YAWYHLGNM8QPwY=
+sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.30.3/go.mod h1:Ve9uj1L+deCXFrPOk1LpFXqTg7LCFzFso6PA48q/XZw=
 sigs.k8s.io/cloud-provider-azure v1.29.4 h1:lW/mqq9fofs52/T+Crs6JNzzEhz0NjzQUtSXMseh67M=
 sigs.k8s.io/cloud-provider-azure v1.29.4/go.mod h1:73KgMVXVtMqG/JlhRRezonfirvoO2ldsxC6H+1FKEPg=
 sigs.k8s.io/cloud-provider-azure/pkg/azclient v0.0.13 h1:dxpo41/N6m2R//9fmqKgqYZL2k0rQSE1NvQteIQ9pGA=

From f413d4eeb814a960c4ef6b73c65d6527cdd0af34 Mon Sep 17 00:00:00 2001
From: Robin Deeboonchai <rdeeboonchai@microsoft.com>
Date: Mon, 26 Aug 2024 14:23:44 -0700
Subject: [PATCH 2/2] chore: vendor

---
 .../mgmt/2021-02-01/storage/CHANGELOG.md      |    2 -
 .../mgmt/2021-02-01/storage/_meta.json        |   11 -
 .../mgmt/2021-02-01/storage/accounts.go       | 1444 -----
 .../mgmt/2021-02-01/storage/blobcontainers.go | 1437 -----
 .../storage/blobinventorypolicies.go          |  411 --
 .../mgmt/2021-02-01/storage/blobservices.go   |  344 --
 .../storage/mgmt/2021-02-01/storage/client.go |   43 -
 .../2021-02-01/storage/deletedaccounts.go     |  236 -
 .../2021-02-01/storage/encryptionscopes.go    |  469 --
 .../storage/mgmt/2021-02-01/storage/enums.go  |  863 ---
 .../mgmt/2021-02-01/storage/fileservices.go   |  323 --
 .../mgmt/2021-02-01/storage/fileshares.go     |  703 ---
 .../2021-02-01/storage/managementpolicies.go  |  316 -
 .../storage/mgmt/2021-02-01/storage/models.go | 5140 -----------------
 .../storage/objectreplicationpolicies.go      |  417 --
 .../mgmt/2021-02-01/storage/operations.go     |   98 -
 .../storage/privateendpointconnections.go     |  411 --
 .../storage/privatelinkresources.go           |  124 -
 .../storage/mgmt/2021-02-01/storage/queue.go  |  571 --
 .../mgmt/2021-02-01/storage/queueservices.go  |  313 -
 .../storage/mgmt/2021-02-01/storage/skus.go   |  109 -
 .../storage/mgmt/2021-02-01/storage/table.go  |  556 --
 .../mgmt/2021-02-01/storage/tableservices.go  |  313 -
 .../storage/mgmt/2021-02-01/storage/usages.go |  112 -
 .../mgmt/2021-02-01/storage/version.go        |   19 -
 .../Azure/go-autorest/autorest/adal/README.md |    2 +-
 .../go-autorest/autorest/adal/devicetoken.go  |   10 +-
 .../go-autorest/autorest/adal/persist.go      |    3 +-
 .../Azure/go-autorest/autorest/adal/token.go  |    9 +-
 .../go-autorest/autorest/azure/auth/README.md |  152 +
 .../go-autorest/autorest/azure/auth/auth.go   |   27 +-
 .../autorest/azure/auth/go_mod_tidy_hack.go   |    1 +
 .../autorest/azure/cli/go_mod_tidy_hack.go    |    1 +
 .../go-autorest/autorest/azure/cli/token.go   |  104 +-
 cluster-autoscaler/vendor/modules.txt         |   15 +-
 .../proto/client/client.pb.go                 |    2 +-
 .../proto/client/client_grpc.pb.go            |    2 +-
 37 files changed, 273 insertions(+), 14840 deletions(-)
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/CHANGELOG.md
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/_meta.json
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/accounts.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobcontainers.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobinventorypolicies.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobservices.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/client.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/deletedaccounts.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/encryptionscopes.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/enums.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileservices.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileshares.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/managementpolicies.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/models.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/objectreplicationpolicies.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/operations.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privateendpointconnections.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privatelinkresources.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queue.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queueservices.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/skus.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/table.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/tableservices.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/usages.go
 delete mode 100644 cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/version.go
 create mode 100644 cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/README.md

diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/CHANGELOG.md b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/CHANGELOG.md
deleted file mode 100644
index 52911e4cc5e4..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/CHANGELOG.md
+++ /dev/null
@@ -1,2 +0,0 @@
-# Change History
-
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/_meta.json b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/_meta.json
deleted file mode 100644
index b6d9ac079390..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/_meta.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "commit": "ea5bc27ee9cadeb67767d774c82095be2420bcad",
-  "readme": "/_/azure-rest-api-specs/specification/storage/resource-manager/readme.md",
-  "tag": "package-2021-02",
-  "use": "@microsoft.azure/autorest.go@2.1.187",
-  "repository_url": "https://github.com/Azure/azure-rest-api-specs.git",
-  "autorest_command": "autorest --use=@microsoft.azure/autorest.go@2.1.187 --tag=package-2021-02 --go-sdk-folder=/_/azure-sdk-for-go --go --verbose --use-onever --version=2.0.4421 --go.license-header=MICROSOFT_MIT_NO_VERSION --enum-prefix /_/azure-rest-api-specs/specification/storage/resource-manager/readme.md",
-  "additional_properties": {
-    "additional_options": "--go --verbose --use-onever --version=2.0.4421 --go.license-header=MICROSOFT_MIT_NO_VERSION --enum-prefix"
-  }
-}
\ No newline at end of file
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/accounts.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/accounts.go
deleted file mode 100644
index aab326ade4c3..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/accounts.go
+++ /dev/null
@@ -1,1444 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// AccountsClient is the the Azure Storage Management API.
-type AccountsClient struct {
-	BaseClient
-}
-
-// NewAccountsClient creates an instance of the AccountsClient client.
-func NewAccountsClient(subscriptionID string) AccountsClient {
-	return NewAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewAccountsClientWithBaseURI creates an instance of the AccountsClient client using a custom endpoint.  Use this
-// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewAccountsClientWithBaseURI(baseURI string, subscriptionID string) AccountsClient {
-	return AccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// CheckNameAvailability checks that the storage account name is valid and is not already in use.
-// Parameters:
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client AccountsClient) CheckNameAvailability(ctx context.Context, accountName AccountCheckNameAvailabilityParameters) (result CheckNameAvailabilityResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.CheckNameAvailability")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName.Name", Name: validation.Null, Rule: true, Chain: nil},
-				{Target: "accountName.Type", Name: validation.Null, Rule: true, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "CheckNameAvailability", err.Error())
-	}
-
-	req, err := client.CheckNameAvailabilityPreparer(ctx, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "CheckNameAvailability", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CheckNameAvailabilitySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "CheckNameAvailability", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CheckNameAvailabilityResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "CheckNameAvailability", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
-func (client AccountsClient) CheckNameAvailabilityPreparer(ctx context.Context, accountName AccountCheckNameAvailabilityParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability", pathParameters),
-		autorest.WithJSON(accountName),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) CheckNameAvailabilityResponder(resp *http.Response) (result CheckNameAvailabilityResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Create asynchronously creates a new storage account with the specified parameters. If an account is already created
-// and a subsequent create request is issued with different properties, the account properties will be updated. If an
-// account is already created and a subsequent create or update request is issued with the exact same set of
-// properties, the request will succeed.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the parameters to provide for the created account.
-func (client AccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, parameters AccountCreateParameters) (result AccountsCreateFuture, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Create")
-		defer func() {
-			sc := -1
-			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
-				sc = result.FutureAPI.Response().StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.Sku", Name: validation.Null, Rule: true, Chain: nil},
-				{Target: "parameters.Location", Name: validation.Null, Rule: true, Chain: nil},
-				{Target: "parameters.AccountPropertiesCreateParameters", Name: validation.Null, Rule: false,
-					Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.SasPolicy", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.SasPolicy.SasExpirationPeriod", Name: validation.Null, Rule: true, Chain: nil},
-							{Target: "parameters.AccountPropertiesCreateParameters.SasPolicy.ExpirationAction", Name: validation.Null, Rule: true, Chain: nil},
-						}},
-						{Target: "parameters.AccountPropertiesCreateParameters.KeyPolicy", Name: validation.Null, Rule: false,
-							Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.KeyPolicy.KeyExpirationPeriodInDays", Name: validation.Null, Rule: true, Chain: nil}}},
-						{Target: "parameters.AccountPropertiesCreateParameters.CustomDomain", Name: validation.Null, Rule: false,
-							Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.CustomDomain.Name", Name: validation.Null, Rule: true, Chain: nil}}},
-						{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication", Name: validation.Null, Rule: false,
-							Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties", Name: validation.Null, Rule: false,
-								Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties.DomainName", Name: validation.Null, Rule: true, Chain: nil},
-									{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties.NetBiosDomainName", Name: validation.Null, Rule: true, Chain: nil},
-									{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties.ForestName", Name: validation.Null, Rule: true, Chain: nil},
-									{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties.DomainGUID", Name: validation.Null, Rule: true, Chain: nil},
-									{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties.DomainSid", Name: validation.Null, Rule: true, Chain: nil},
-									{Target: "parameters.AccountPropertiesCreateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties.AzureStorageSid", Name: validation.Null, Rule: true, Chain: nil},
-								}},
-							}},
-					}}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "Create", err.Error())
-	}
-
-	req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Create", nil, "Failure preparing request")
-		return
-	}
-
-	result, err = client.CreateSender(req)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Create", result.Response(), "Failure sending request")
-		return
-	}
-
-	return
-}
-
-// CreatePreparer prepares the Create request.
-func (client AccountsClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters AccountCreateParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateSender sends the Create request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) CreateSender(req *http.Request) (future AccountsCreateFuture, err error) {
-	var resp *http.Response
-	future.FutureAPI = &azure.Future{}
-	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
-	if err != nil {
-		return
-	}
-	var azf azure.Future
-	azf, err = azure.NewFutureFromResponse(resp)
-	future.FutureAPI = &azf
-	future.Result = future.result
-	return
-}
-
-// CreateResponder handles the response to the Create request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) CreateResponder(resp *http.Response) (result Account, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes a storage account in Microsoft Azure.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client AccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client AccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Failover failover request can be triggered for a storage account in case of availability issues. The failover occurs
-// from the storage account's primary cluster to secondary cluster for RA-GRS accounts. The secondary cluster will
-// become primary after failover.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client AccountsClient) Failover(ctx context.Context, resourceGroupName string, accountName string) (result AccountsFailoverFuture, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Failover")
-		defer func() {
-			sc := -1
-			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
-				sc = result.FutureAPI.Response().StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "Failover", err.Error())
-	}
-
-	req, err := client.FailoverPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Failover", nil, "Failure preparing request")
-		return
-	}
-
-	result, err = client.FailoverSender(req)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Failover", result.Response(), "Failure sending request")
-		return
-	}
-
-	return
-}
-
-// FailoverPreparer prepares the Failover request.
-func (client AccountsClient) FailoverPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/failover", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// FailoverSender sends the Failover request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) FailoverSender(req *http.Request) (future AccountsFailoverFuture, err error) {
-	var resp *http.Response
-	future.FutureAPI = &azure.Future{}
-	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
-	if err != nil {
-		return
-	}
-	var azf azure.Future
-	azf, err = azure.NewFutureFromResponse(resp)
-	future.FutureAPI = &azf
-	future.Result = future.result
-	return
-}
-
-// FailoverResponder handles the response to the Failover request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) FailoverResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// GetProperties returns the properties for the specified storage account including but not limited to name, SKU name,
-// location, and account status. The ListKeys operation should be used to retrieve storage keys.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// expand - may be used to expand the properties within account's properties. By default, data is not included
-// when fetching properties. Currently we only support geoReplicationStats and blobRestoreStatus.
-func (client AccountsClient) GetProperties(ctx context.Context, resourceGroupName string, accountName string, expand AccountExpand) (result Account, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.GetProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "GetProperties", err.Error())
-	}
-
-	req, err := client.GetPropertiesPreparer(ctx, resourceGroupName, accountName, expand)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "GetProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetPropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "GetProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetPropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "GetProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPropertiesPreparer prepares the GetProperties request.
-func (client AccountsClient) GetPropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string, expand AccountExpand) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(string(expand)) > 0 {
-		queryParameters["$expand"] = autorest.Encode("query", expand)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetPropertiesSender sends the GetProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) GetPropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetPropertiesResponder handles the response to the GetProperties request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) GetPropertiesResponder(resp *http.Response) (result Account, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List lists all the storage accounts available under the subscription. Note that storage keys are not returned; use
-// the ListKeys operation for this.
-func (client AccountsClient) List(ctx context.Context) (result AccountListResultPage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List")
-		defer func() {
-			sc := -1
-			if result.alr.Response.Response != nil {
-				sc = result.alr.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.alr.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.alr, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.alr.hasNextLink() && result.alr.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client AccountsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/storageAccounts", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) ListResponder(resp *http.Response) (result AccountListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client AccountsClient) listNextResults(ctx context.Context, lastResults AccountListResult) (result AccountListResult, err error) {
-	req, err := lastResults.accountListResultPreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.AccountsClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.AccountsClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client AccountsClient) ListComplete(ctx context.Context) (result AccountListResultIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx)
-	return
-}
-
-// ListAccountSAS list SAS credentials of a storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the parameters to provide to list SAS credentials for the storage account.
-func (client AccountsClient) ListAccountSAS(ctx context.Context, resourceGroupName string, accountName string, parameters AccountSasParameters) (result ListAccountSasResponse, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListAccountSAS")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.SharedAccessExpiryTime", Name: validation.Null, Rule: true, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "ListAccountSAS", err.Error())
-	}
-
-	req, err := client.ListAccountSASPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListAccountSAS", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListAccountSASSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListAccountSAS", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListAccountSASResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListAccountSAS", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListAccountSASPreparer prepares the ListAccountSAS request.
-func (client AccountsClient) ListAccountSASPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters AccountSasParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/ListAccountSas", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListAccountSASSender sends the ListAccountSAS request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) ListAccountSASSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListAccountSASResponder handles the response to the ListAccountSAS request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) ListAccountSASResponder(resp *http.Response) (result ListAccountSasResponse, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// ListByResourceGroup lists all the storage accounts available under the given resource group. Note that storage keys
-// are not returned; use the ListKeys operation for this.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-func (client AccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result AccountListResultPage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup")
-		defer func() {
-			sc := -1
-			if result.alr.Response.Response != nil {
-				sc = result.alr.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "ListByResourceGroup", err.Error())
-	}
-
-	result.fn = client.listByResourceGroupNextResults
-	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListByResourceGroup", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListByResourceGroupSender(req)
-	if err != nil {
-		result.alr.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListByResourceGroup", resp, "Failure sending request")
-		return
-	}
-
-	result.alr, err = client.ListByResourceGroupResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListByResourceGroup", resp, "Failure responding to request")
-		return
-	}
-	if result.alr.hasNextLink() && result.alr.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
-func (client AccountsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) ListByResourceGroupResponder(resp *http.Response) (result AccountListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listByResourceGroupNextResults retrieves the next set of results, if any.
-func (client AccountsClient) listByResourceGroupNextResults(ctx context.Context, lastResults AccountListResult) (result AccountListResult, err error) {
-	req, err := lastResults.accountListResultPreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.AccountsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListByResourceGroupSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.AccountsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListByResourceGroupResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
-func (client AccountsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result AccountListResultIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
-	return
-}
-
-// ListKeys lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// expand - specifies type of the key to be listed. Possible value is kerb.
-func (client AccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string, expand ListKeyExpand) (result AccountListKeysResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListKeys")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "ListKeys", err.Error())
-	}
-
-	req, err := client.ListKeysPreparer(ctx, resourceGroupName, accountName, expand)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListKeys", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListKeysSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListKeys", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListKeysResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListKeys", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListKeysPreparer prepares the ListKeys request.
-func (client AccountsClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, accountName string, expand ListKeyExpand) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(string(expand)) > 0 {
-		queryParameters["$expand"] = autorest.Encode("query", expand)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/listKeys", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListKeysSender sends the ListKeys request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) ListKeysSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListKeysResponder handles the response to the ListKeys request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) ListKeysResponder(resp *http.Response) (result AccountListKeysResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// ListServiceSAS list service SAS credentials of a specific resource.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the parameters to provide to list service SAS credentials.
-func (client AccountsClient) ListServiceSAS(ctx context.Context, resourceGroupName string, accountName string, parameters ServiceSasParameters) (result ListServiceSasResponse, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListServiceSAS")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.CanonicalizedResource", Name: validation.Null, Rule: true, Chain: nil},
-				{Target: "parameters.Identifier", Name: validation.Null, Rule: false,
-					Chain: []validation.Constraint{{Target: "parameters.Identifier", Name: validation.MaxLength, Rule: 64, Chain: nil}}}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "ListServiceSAS", err.Error())
-	}
-
-	req, err := client.ListServiceSASPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListServiceSAS", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListServiceSASSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListServiceSAS", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListServiceSASResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListServiceSAS", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListServiceSASPreparer prepares the ListServiceSAS request.
-func (client AccountsClient) ListServiceSASPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters ServiceSasParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/ListServiceSas", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListServiceSASSender sends the ListServiceSAS request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) ListServiceSASSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListServiceSASResponder handles the response to the ListServiceSAS request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) ListServiceSASResponder(resp *http.Response) (result ListServiceSasResponse, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// RegenerateKey regenerates one of the access keys or Kerberos keys for the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// regenerateKey - specifies name of the key which should be regenerated -- key1, key2, kerb1, kerb2.
-func (client AccountsClient) RegenerateKey(ctx context.Context, resourceGroupName string, accountName string, regenerateKey AccountRegenerateKeyParameters) (result AccountListKeysResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.RegenerateKey")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: regenerateKey,
-			Constraints: []validation.Constraint{{Target: "regenerateKey.KeyName", Name: validation.Null, Rule: true, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "RegenerateKey", err.Error())
-	}
-
-	req, err := client.RegenerateKeyPreparer(ctx, resourceGroupName, accountName, regenerateKey)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RegenerateKey", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.RegenerateKeySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RegenerateKey", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.RegenerateKeyResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RegenerateKey", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// RegenerateKeyPreparer prepares the RegenerateKey request.
-func (client AccountsClient) RegenerateKeyPreparer(ctx context.Context, resourceGroupName string, accountName string, regenerateKey AccountRegenerateKeyParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/regenerateKey", pathParameters),
-		autorest.WithJSON(regenerateKey),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// RegenerateKeySender sends the RegenerateKey request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) RegenerateKeySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// RegenerateKeyResponder handles the response to the RegenerateKey request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) RegenerateKeyResponder(resp *http.Response) (result AccountListKeysResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// RestoreBlobRanges restore blobs in the specified blob ranges
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the parameters to provide for restore blob ranges.
-func (client AccountsClient) RestoreBlobRanges(ctx context.Context, resourceGroupName string, accountName string, parameters BlobRestoreParameters) (result AccountsRestoreBlobRangesFuture, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.RestoreBlobRanges")
-		defer func() {
-			sc := -1
-			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
-				sc = result.FutureAPI.Response().StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.TimeToRestore", Name: validation.Null, Rule: true, Chain: nil},
-				{Target: "parameters.BlobRanges", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "RestoreBlobRanges", err.Error())
-	}
-
-	req, err := client.RestoreBlobRangesPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RestoreBlobRanges", nil, "Failure preparing request")
-		return
-	}
-
-	result, err = client.RestoreBlobRangesSender(req)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RestoreBlobRanges", result.Response(), "Failure sending request")
-		return
-	}
-
-	return
-}
-
-// RestoreBlobRangesPreparer prepares the RestoreBlobRanges request.
-func (client AccountsClient) RestoreBlobRangesPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters BlobRestoreParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/restoreBlobRanges", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// RestoreBlobRangesSender sends the RestoreBlobRanges request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) RestoreBlobRangesSender(req *http.Request) (future AccountsRestoreBlobRangesFuture, err error) {
-	var resp *http.Response
-	future.FutureAPI = &azure.Future{}
-	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
-	if err != nil {
-		return
-	}
-	var azf azure.Future
-	azf, err = azure.NewFutureFromResponse(resp)
-	future.FutureAPI = &azf
-	future.Result = future.result
-	return
-}
-
-// RestoreBlobRangesResponder handles the response to the RestoreBlobRanges request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) RestoreBlobRangesResponder(resp *http.Response) (result BlobRestoreStatus, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// RevokeUserDelegationKeys revoke user delegation keys.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client AccountsClient) RevokeUserDelegationKeys(ctx context.Context, resourceGroupName string, accountName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.RevokeUserDelegationKeys")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "RevokeUserDelegationKeys", err.Error())
-	}
-
-	req, err := client.RevokeUserDelegationKeysPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RevokeUserDelegationKeys", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.RevokeUserDelegationKeysSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RevokeUserDelegationKeys", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.RevokeUserDelegationKeysResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RevokeUserDelegationKeys", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// RevokeUserDelegationKeysPreparer prepares the RevokeUserDelegationKeys request.
-func (client AccountsClient) RevokeUserDelegationKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/revokeUserDelegationKeys", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// RevokeUserDelegationKeysSender sends the RevokeUserDelegationKeys request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) RevokeUserDelegationKeysSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// RevokeUserDelegationKeysResponder handles the response to the RevokeUserDelegationKeys request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) RevokeUserDelegationKeysResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Update the update operation can be used to update the SKU, encryption, access tier, or tags for a storage account.
-// It can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
-// the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
-// must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
-// call does not change the storage keys for the account. If you want to change the storage account keys, use the
-// regenerate keys operation. The location and name of the storage account cannot be changed after creation.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the parameters to provide for the updated account.
-func (client AccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, parameters AccountUpdateParameters) (result Account, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Update")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.AccountsClient", "Update", err.Error())
-	}
-
-	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Update", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.UpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Update", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.UpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Update", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// UpdatePreparer prepares the Update request.
-func (client AccountsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters AccountUpdateParameters) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPatch(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// UpdateSender sends the Update request. The method will close the
-// http.Response Body if it receives an error.
-func (client AccountsClient) UpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// UpdateResponder handles the response to the Update request. The method always
-// closes the http.Response Body.
-func (client AccountsClient) UpdateResponder(resp *http.Response) (result Account, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobcontainers.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobcontainers.go
deleted file mode 100644
index 000b65a67996..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobcontainers.go
+++ /dev/null
@@ -1,1437 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// BlobContainersClient is the the Azure Storage Management API.
-type BlobContainersClient struct {
-	BaseClient
-}
-
-// NewBlobContainersClient creates an instance of the BlobContainersClient client.
-func NewBlobContainersClient(subscriptionID string) BlobContainersClient {
-	return NewBlobContainersClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewBlobContainersClientWithBaseURI creates an instance of the BlobContainersClient client using a custom endpoint.
-// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewBlobContainersClientWithBaseURI(baseURI string, subscriptionID string) BlobContainersClient {
-	return BlobContainersClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// ClearLegalHold clears legal hold tags. Clearing the same or non-existent tag results in an idempotent operation.
-// ClearLegalHold clears out only the specified tags in the request.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// legalHold - the LegalHold property that will be clear from a blob container.
-func (client BlobContainersClient) ClearLegalHold(ctx context.Context, resourceGroupName string, accountName string, containerName string, legalHold LegalHold) (result LegalHold, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.ClearLegalHold")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: legalHold,
-			Constraints: []validation.Constraint{{Target: "legalHold.Tags", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "ClearLegalHold", err.Error())
-	}
-
-	req, err := client.ClearLegalHoldPreparer(ctx, resourceGroupName, accountName, containerName, legalHold)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "ClearLegalHold", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ClearLegalHoldSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "ClearLegalHold", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ClearLegalHoldResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "ClearLegalHold", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ClearLegalHoldPreparer prepares the ClearLegalHold request.
-func (client BlobContainersClient) ClearLegalHoldPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, legalHold LegalHold) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	legalHold.HasLegalHold = nil
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/clearLegalHold", pathParameters),
-		autorest.WithJSON(legalHold),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ClearLegalHoldSender sends the ClearLegalHold request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) ClearLegalHoldSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ClearLegalHoldResponder handles the response to the ClearLegalHold request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) ClearLegalHoldResponder(resp *http.Response) (result LegalHold, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Create creates a new container under the specified account as described by request body. The container resource
-// includes metadata and properties for that container. It does not include a list of the blobs contained by the
-// container.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// blobContainer - properties of the blob container to create.
-func (client BlobContainersClient) Create(ctx context.Context, resourceGroupName string, accountName string, containerName string, blobContainer BlobContainer) (result BlobContainer, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.Create")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "Create", err.Error())
-	}
-
-	req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, containerName, blobContainer)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Create", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Create", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Create", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreatePreparer prepares the Create request.
-func (client BlobContainersClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, blobContainer BlobContainer) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}", pathParameters),
-		autorest.WithJSON(blobContainer),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateSender sends the Create request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) CreateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateResponder handles the response to the Create request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) CreateResponder(resp *http.Response) (result BlobContainer, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// CreateOrUpdateImmutabilityPolicy creates or updates an unlocked immutability policy. ETag in If-Match is honored if
-// given but not required for this operation.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// parameters - the ImmutabilityPolicy Properties that will be created or updated to a blob container.
-// ifMatch - the entity state (ETag) version of the immutability policy to update. A value of "*" can be used
-// to apply the operation only if the immutability policy already exists. If omitted, this operation will
-// always be applied.
-func (client BlobContainersClient) CreateOrUpdateImmutabilityPolicy(ctx context.Context, resourceGroupName string, accountName string, containerName string, parameters *ImmutabilityPolicy, ifMatch string) (result ImmutabilityPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.CreateOrUpdateImmutabilityPolicy")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "parameters.ImmutabilityPolicyProperty", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "CreateOrUpdateImmutabilityPolicy", err.Error())
-	}
-
-	req, err := client.CreateOrUpdateImmutabilityPolicyPreparer(ctx, resourceGroupName, accountName, containerName, parameters, ifMatch)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "CreateOrUpdateImmutabilityPolicy", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateOrUpdateImmutabilityPolicySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "CreateOrUpdateImmutabilityPolicy", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateOrUpdateImmutabilityPolicyResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "CreateOrUpdateImmutabilityPolicy", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreateOrUpdateImmutabilityPolicyPreparer prepares the CreateOrUpdateImmutabilityPolicy request.
-func (client BlobContainersClient) CreateOrUpdateImmutabilityPolicyPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, parameters *ImmutabilityPolicy, ifMatch string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":            autorest.Encode("path", accountName),
-		"containerName":          autorest.Encode("path", containerName),
-		"immutabilityPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":      autorest.Encode("path", resourceGroupName),
-		"subscriptionId":         autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/immutabilityPolicies/{immutabilityPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	if parameters != nil {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithJSON(parameters))
-	}
-	if len(ifMatch) > 0 {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
-	}
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateOrUpdateImmutabilityPolicySender sends the CreateOrUpdateImmutabilityPolicy request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) CreateOrUpdateImmutabilityPolicySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateOrUpdateImmutabilityPolicyResponder handles the response to the CreateOrUpdateImmutabilityPolicy request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) CreateOrUpdateImmutabilityPolicyResponder(resp *http.Response) (result ImmutabilityPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes specified container under its account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-func (client BlobContainersClient) Delete(ctx context.Context, resourceGroupName string, accountName string, containerName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, containerName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client BlobContainersClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// DeleteImmutabilityPolicy aborts an unlocked immutability policy. The response of delete has
-// immutabilityPeriodSinceCreationInDays set to 0. ETag in If-Match is required for this operation. Deleting a locked
-// immutability policy is not allowed, the only way is to delete the container after deleting all expired blobs inside
-// the policy locked container.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// ifMatch - the entity state (ETag) version of the immutability policy to update. A value of "*" can be used
-// to apply the operation only if the immutability policy already exists. If omitted, this operation will
-// always be applied.
-func (client BlobContainersClient) DeleteImmutabilityPolicy(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string) (result ImmutabilityPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.DeleteImmutabilityPolicy")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "DeleteImmutabilityPolicy", err.Error())
-	}
-
-	req, err := client.DeleteImmutabilityPolicyPreparer(ctx, resourceGroupName, accountName, containerName, ifMatch)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "DeleteImmutabilityPolicy", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteImmutabilityPolicySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "DeleteImmutabilityPolicy", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteImmutabilityPolicyResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "DeleteImmutabilityPolicy", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeleteImmutabilityPolicyPreparer prepares the DeleteImmutabilityPolicy request.
-func (client BlobContainersClient) DeleteImmutabilityPolicyPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":            autorest.Encode("path", accountName),
-		"containerName":          autorest.Encode("path", containerName),
-		"immutabilityPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":      autorest.Encode("path", resourceGroupName),
-		"subscriptionId":         autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/immutabilityPolicies/{immutabilityPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters),
-		autorest.WithHeader("If-Match", autorest.String(ifMatch)))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteImmutabilityPolicySender sends the DeleteImmutabilityPolicy request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) DeleteImmutabilityPolicySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteImmutabilityPolicyResponder handles the response to the DeleteImmutabilityPolicy request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) DeleteImmutabilityPolicyResponder(resp *http.Response) (result ImmutabilityPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// ExtendImmutabilityPolicy extends the immutabilityPeriodSinceCreationInDays of a locked immutabilityPolicy. The only
-// action allowed on a Locked policy will be this action. ETag in If-Match is required for this operation.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// ifMatch - the entity state (ETag) version of the immutability policy to update. A value of "*" can be used
-// to apply the operation only if the immutability policy already exists. If omitted, this operation will
-// always be applied.
-// parameters - the ImmutabilityPolicy Properties that will be extended for a blob container.
-func (client BlobContainersClient) ExtendImmutabilityPolicy(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string, parameters *ImmutabilityPolicy) (result ImmutabilityPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.ExtendImmutabilityPolicy")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "parameters.ImmutabilityPolicyProperty", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "ExtendImmutabilityPolicy", err.Error())
-	}
-
-	req, err := client.ExtendImmutabilityPolicyPreparer(ctx, resourceGroupName, accountName, containerName, ifMatch, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "ExtendImmutabilityPolicy", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ExtendImmutabilityPolicySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "ExtendImmutabilityPolicy", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ExtendImmutabilityPolicyResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "ExtendImmutabilityPolicy", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ExtendImmutabilityPolicyPreparer prepares the ExtendImmutabilityPolicy request.
-func (client BlobContainersClient) ExtendImmutabilityPolicyPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string, parameters *ImmutabilityPolicy) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/immutabilityPolicies/default/extend", pathParameters),
-		autorest.WithQueryParameters(queryParameters),
-		autorest.WithHeader("If-Match", autorest.String(ifMatch)))
-	if parameters != nil {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithJSON(parameters))
-	}
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ExtendImmutabilityPolicySender sends the ExtendImmutabilityPolicy request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) ExtendImmutabilityPolicySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ExtendImmutabilityPolicyResponder handles the response to the ExtendImmutabilityPolicy request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) ExtendImmutabilityPolicyResponder(resp *http.Response) (result ImmutabilityPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Get gets properties of a specified container.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-func (client BlobContainersClient) Get(ctx context.Context, resourceGroupName string, accountName string, containerName string) (result BlobContainer, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, containerName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client BlobContainersClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) GetResponder(resp *http.Response) (result BlobContainer, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// GetImmutabilityPolicy gets the existing immutability policy along with the corresponding ETag in response headers
-// and body.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// ifMatch - the entity state (ETag) version of the immutability policy to update. A value of "*" can be used
-// to apply the operation only if the immutability policy already exists. If omitted, this operation will
-// always be applied.
-func (client BlobContainersClient) GetImmutabilityPolicy(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string) (result ImmutabilityPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.GetImmutabilityPolicy")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "GetImmutabilityPolicy", err.Error())
-	}
-
-	req, err := client.GetImmutabilityPolicyPreparer(ctx, resourceGroupName, accountName, containerName, ifMatch)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "GetImmutabilityPolicy", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetImmutabilityPolicySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "GetImmutabilityPolicy", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetImmutabilityPolicyResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "GetImmutabilityPolicy", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetImmutabilityPolicyPreparer prepares the GetImmutabilityPolicy request.
-func (client BlobContainersClient) GetImmutabilityPolicyPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":            autorest.Encode("path", accountName),
-		"containerName":          autorest.Encode("path", containerName),
-		"immutabilityPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":      autorest.Encode("path", resourceGroupName),
-		"subscriptionId":         autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/immutabilityPolicies/{immutabilityPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	if len(ifMatch) > 0 {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
-	}
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetImmutabilityPolicySender sends the GetImmutabilityPolicy request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) GetImmutabilityPolicySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetImmutabilityPolicyResponder handles the response to the GetImmutabilityPolicy request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) GetImmutabilityPolicyResponder(resp *http.Response) (result ImmutabilityPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Lease the Lease Container operation establishes and manages a lock on a container for delete operations. The lock
-// duration can be 15 to 60 seconds, or can be infinite.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// parameters - lease Container request body.
-func (client BlobContainersClient) Lease(ctx context.Context, resourceGroupName string, accountName string, containerName string, parameters *LeaseContainerRequest) (result LeaseContainerResponse, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.Lease")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "Lease", err.Error())
-	}
-
-	req, err := client.LeasePreparer(ctx, resourceGroupName, accountName, containerName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Lease", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.LeaseSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Lease", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.LeaseResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Lease", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// LeasePreparer prepares the Lease request.
-func (client BlobContainersClient) LeasePreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, parameters *LeaseContainerRequest) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/lease", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	if parameters != nil {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithJSON(parameters))
-	}
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// LeaseSender sends the Lease request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) LeaseSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// LeaseResponder handles the response to the Lease request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) LeaseResponder(resp *http.Response) (result LeaseContainerResponse, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List lists all containers and does not support a prefix like data plane. Also SRP today does not return continuation
-// token.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// maxpagesize - optional. Specified maximum number of containers that can be included in the list.
-// filter - optional. When specified, only container names starting with the filter will be listed.
-// include - optional, used to include the properties for soft deleted blob containers.
-func (client BlobContainersClient) List(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string, include ListContainersInclude) (result ListContainerItemsPage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.List")
-		defer func() {
-			sc := -1
-			if result.lci.Response.Response != nil {
-				sc = result.lci.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName, maxpagesize, filter, include)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.lci.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.lci, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.lci.hasNextLink() && result.lci.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client BlobContainersClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string, include ListContainersInclude) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(maxpagesize) > 0 {
-		queryParameters["$maxpagesize"] = autorest.Encode("query", maxpagesize)
-	}
-	if len(filter) > 0 {
-		queryParameters["$filter"] = autorest.Encode("query", filter)
-	}
-	if len(string(include)) > 0 {
-		queryParameters["$include"] = autorest.Encode("query", include)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) ListResponder(resp *http.Response) (result ListContainerItems, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client BlobContainersClient) listNextResults(ctx context.Context, lastResults ListContainerItems) (result ListContainerItems, err error) {
-	req, err := lastResults.listContainerItemsPreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.BlobContainersClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.BlobContainersClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client BlobContainersClient) ListComplete(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string, include ListContainersInclude) (result ListContainerItemsIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx, resourceGroupName, accountName, maxpagesize, filter, include)
-	return
-}
-
-// LockImmutabilityPolicy sets the ImmutabilityPolicy to Locked state. The only action allowed on a Locked policy is
-// ExtendImmutabilityPolicy action. ETag in If-Match is required for this operation.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// ifMatch - the entity state (ETag) version of the immutability policy to update. A value of "*" can be used
-// to apply the operation only if the immutability policy already exists. If omitted, this operation will
-// always be applied.
-func (client BlobContainersClient) LockImmutabilityPolicy(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string) (result ImmutabilityPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.LockImmutabilityPolicy")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "LockImmutabilityPolicy", err.Error())
-	}
-
-	req, err := client.LockImmutabilityPolicyPreparer(ctx, resourceGroupName, accountName, containerName, ifMatch)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "LockImmutabilityPolicy", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.LockImmutabilityPolicySender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "LockImmutabilityPolicy", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.LockImmutabilityPolicyResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "LockImmutabilityPolicy", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// LockImmutabilityPolicyPreparer prepares the LockImmutabilityPolicy request.
-func (client BlobContainersClient) LockImmutabilityPolicyPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, ifMatch string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/immutabilityPolicies/default/lock", pathParameters),
-		autorest.WithQueryParameters(queryParameters),
-		autorest.WithHeader("If-Match", autorest.String(ifMatch)))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// LockImmutabilityPolicySender sends the LockImmutabilityPolicy request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) LockImmutabilityPolicySender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// LockImmutabilityPolicyResponder handles the response to the LockImmutabilityPolicy request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) LockImmutabilityPolicyResponder(resp *http.Response) (result ImmutabilityPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// SetLegalHold sets legal hold tags. Setting the same tag results in an idempotent operation. SetLegalHold follows an
-// append pattern and does not clear out the existing tags that are not specified in the request.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// legalHold - the LegalHold property that will be set to a blob container.
-func (client BlobContainersClient) SetLegalHold(ctx context.Context, resourceGroupName string, accountName string, containerName string, legalHold LegalHold) (result LegalHold, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.SetLegalHold")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: legalHold,
-			Constraints: []validation.Constraint{{Target: "legalHold.Tags", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "SetLegalHold", err.Error())
-	}
-
-	req, err := client.SetLegalHoldPreparer(ctx, resourceGroupName, accountName, containerName, legalHold)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "SetLegalHold", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.SetLegalHoldSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "SetLegalHold", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.SetLegalHoldResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "SetLegalHold", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// SetLegalHoldPreparer prepares the SetLegalHold request.
-func (client BlobContainersClient) SetLegalHoldPreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, legalHold LegalHold) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	legalHold.HasLegalHold = nil
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}/setLegalHold", pathParameters),
-		autorest.WithJSON(legalHold),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// SetLegalHoldSender sends the SetLegalHold request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) SetLegalHoldSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// SetLegalHoldResponder handles the response to the SetLegalHold request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) SetLegalHoldResponder(resp *http.Response) (result LegalHold, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Update updates container properties as specified in request body. Properties not mentioned in the request will be
-// unchanged. Update fails if the specified container doesn't already exist.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// containerName - the name of the blob container within the specified storage account. Blob container names
-// must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every
-// dash (-) character must be immediately preceded and followed by a letter or number.
-// blobContainer - properties to update for the blob container.
-func (client BlobContainersClient) Update(ctx context.Context, resourceGroupName string, accountName string, containerName string, blobContainer BlobContainer) (result BlobContainer, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobContainersClient.Update")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: containerName,
-			Constraints: []validation.Constraint{{Target: "containerName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "containerName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobContainersClient", "Update", err.Error())
-	}
-
-	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, containerName, blobContainer)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Update", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.UpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Update", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.UpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobContainersClient", "Update", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// UpdatePreparer prepares the Update request.
-func (client BlobContainersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, containerName string, blobContainer BlobContainer) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"containerName":     autorest.Encode("path", containerName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPatch(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/default/containers/{containerName}", pathParameters),
-		autorest.WithJSON(blobContainer),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// UpdateSender sends the Update request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobContainersClient) UpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// UpdateResponder handles the response to the Update request. The method always
-// closes the http.Response Body.
-func (client BlobContainersClient) UpdateResponder(resp *http.Response) (result BlobContainer, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobinventorypolicies.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobinventorypolicies.go
deleted file mode 100644
index 1b331244726d..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobinventorypolicies.go
+++ /dev/null
@@ -1,411 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// BlobInventoryPoliciesClient is the the Azure Storage Management API.
-type BlobInventoryPoliciesClient struct {
-	BaseClient
-}
-
-// NewBlobInventoryPoliciesClient creates an instance of the BlobInventoryPoliciesClient client.
-func NewBlobInventoryPoliciesClient(subscriptionID string) BlobInventoryPoliciesClient {
-	return NewBlobInventoryPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewBlobInventoryPoliciesClientWithBaseURI creates an instance of the BlobInventoryPoliciesClient client using a
-// custom endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds,
-// Azure stack).
-func NewBlobInventoryPoliciesClientWithBaseURI(baseURI string, subscriptionID string) BlobInventoryPoliciesClient {
-	return BlobInventoryPoliciesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// CreateOrUpdate sets the blob inventory policy to the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// properties - the blob inventory policy set to a storage account.
-func (client BlobInventoryPoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, properties BlobInventoryPolicy) (result BlobInventoryPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobInventoryPoliciesClient.CreateOrUpdate")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: properties,
-			Constraints: []validation.Constraint{{Target: "properties.BlobInventoryPolicyProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "properties.BlobInventoryPolicyProperties.Policy", Name: validation.Null, Rule: true,
-					Chain: []validation.Constraint{{Target: "properties.BlobInventoryPolicyProperties.Policy.Enabled", Name: validation.Null, Rule: true, Chain: nil},
-						{Target: "properties.BlobInventoryPolicyProperties.Policy.Destination", Name: validation.Null, Rule: true, Chain: nil},
-						{Target: "properties.BlobInventoryPolicyProperties.Policy.Type", Name: validation.Null, Rule: true, Chain: nil},
-						{Target: "properties.BlobInventoryPolicyProperties.Policy.Rules", Name: validation.Null, Rule: true, Chain: nil},
-					}},
-				}}}}}); err != nil {
-		return result, validation.NewError("storage.BlobInventoryPoliciesClient", "CreateOrUpdate", err.Error())
-	}
-
-	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, properties)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "CreateOrUpdate", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateOrUpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "CreateOrUpdate", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateOrUpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "CreateOrUpdate", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
-func (client BlobInventoryPoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, properties BlobInventoryPolicy) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":             autorest.Encode("path", accountName),
-		"blobInventoryPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
-		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/inventoryPolicies/{blobInventoryPolicyName}", pathParameters),
-		autorest.WithJSON(properties),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobInventoryPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
-// closes the http.Response Body.
-func (client BlobInventoryPoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result BlobInventoryPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes the blob inventory policy associated with the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client BlobInventoryPoliciesClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobInventoryPoliciesClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobInventoryPoliciesClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client BlobInventoryPoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":             autorest.Encode("path", accountName),
-		"blobInventoryPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
-		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/inventoryPolicies/{blobInventoryPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobInventoryPoliciesClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client BlobInventoryPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get gets the blob inventory policy associated with the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client BlobInventoryPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result BlobInventoryPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobInventoryPoliciesClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobInventoryPoliciesClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client BlobInventoryPoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":             autorest.Encode("path", accountName),
-		"blobInventoryPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
-		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/inventoryPolicies/{blobInventoryPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobInventoryPoliciesClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client BlobInventoryPoliciesClient) GetResponder(resp *http.Response) (result BlobInventoryPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List gets the blob inventory policy associated with the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client BlobInventoryPoliciesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result ListBlobInventoryPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobInventoryPoliciesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobInventoryPoliciesClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobInventoryPoliciesClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client BlobInventoryPoliciesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/inventoryPolicies", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobInventoryPoliciesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client BlobInventoryPoliciesClient) ListResponder(resp *http.Response) (result ListBlobInventoryPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobservices.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobservices.go
deleted file mode 100644
index 3f3af97acc86..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/blobservices.go
+++ /dev/null
@@ -1,344 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// BlobServicesClient is the the Azure Storage Management API.
-type BlobServicesClient struct {
-	BaseClient
-}
-
-// NewBlobServicesClient creates an instance of the BlobServicesClient client.
-func NewBlobServicesClient(subscriptionID string) BlobServicesClient {
-	return NewBlobServicesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewBlobServicesClientWithBaseURI creates an instance of the BlobServicesClient client using a custom endpoint.  Use
-// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewBlobServicesClientWithBaseURI(baseURI string, subscriptionID string) BlobServicesClient {
-	return BlobServicesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// GetServiceProperties gets the properties of a storage account’s Blob service, including properties for Storage
-// Analytics and CORS (Cross-Origin Resource Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client BlobServicesClient) GetServiceProperties(ctx context.Context, resourceGroupName string, accountName string) (result BlobServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobServicesClient.GetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobServicesClient", "GetServiceProperties", err.Error())
-	}
-
-	req, err := client.GetServicePropertiesPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "GetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "GetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "GetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetServicePropertiesPreparer prepares the GetServiceProperties request.
-func (client BlobServicesClient) GetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"BlobServicesName":  autorest.Encode("path", "default"),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/{BlobServicesName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetServicePropertiesSender sends the GetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobServicesClient) GetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetServicePropertiesResponder handles the response to the GetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client BlobServicesClient) GetServicePropertiesResponder(resp *http.Response) (result BlobServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List list blob services of storage account. It returns a collection of one object named default.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client BlobServicesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result BlobServiceItems, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobServicesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.BlobServicesClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client BlobServicesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobServicesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client BlobServicesClient) ListResponder(resp *http.Response) (result BlobServiceItems, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// SetServiceProperties sets the properties of a storage account’s Blob service, including properties for Storage
-// Analytics and CORS (Cross-Origin Resource Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the properties of a storage account’s Blob service, including properties for Storage Analytics
-// and CORS (Cross-Origin Resource Sharing) rules.
-func (client BlobServicesClient) SetServiceProperties(ctx context.Context, resourceGroupName string, accountName string, parameters BlobServiceProperties) (result BlobServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/BlobServicesClient.SetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.DeleteRetentionPolicy", Name: validation.Null, Rule: false,
-					Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.DeleteRetentionPolicy.Days", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.DeleteRetentionPolicy.Days", Name: validation.InclusiveMaximum, Rule: int64(365), Chain: nil},
-							{Target: "parameters.BlobServicePropertiesProperties.DeleteRetentionPolicy.Days", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
-						}},
-					}},
-					{Target: "parameters.BlobServicePropertiesProperties.ChangeFeed", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.ChangeFeed.RetentionInDays", Name: validation.Null, Rule: false,
-							Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.ChangeFeed.RetentionInDays", Name: validation.InclusiveMaximum, Rule: int64(146000), Chain: nil},
-								{Target: "parameters.BlobServicePropertiesProperties.ChangeFeed.RetentionInDays", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
-							}},
-						}},
-					{Target: "parameters.BlobServicePropertiesProperties.RestorePolicy", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.RestorePolicy.Enabled", Name: validation.Null, Rule: true, Chain: nil},
-							{Target: "parameters.BlobServicePropertiesProperties.RestorePolicy.Days", Name: validation.Null, Rule: false,
-								Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.RestorePolicy.Days", Name: validation.InclusiveMaximum, Rule: int64(365), Chain: nil},
-									{Target: "parameters.BlobServicePropertiesProperties.RestorePolicy.Days", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
-								}},
-						}},
-					{Target: "parameters.BlobServicePropertiesProperties.ContainerDeleteRetentionPolicy", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.ContainerDeleteRetentionPolicy.Days", Name: validation.Null, Rule: false,
-							Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.ContainerDeleteRetentionPolicy.Days", Name: validation.InclusiveMaximum, Rule: int64(365), Chain: nil},
-								{Target: "parameters.BlobServicePropertiesProperties.ContainerDeleteRetentionPolicy.Days", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
-							}},
-						}},
-					{Target: "parameters.BlobServicePropertiesProperties.LastAccessTimeTrackingPolicy", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.BlobServicePropertiesProperties.LastAccessTimeTrackingPolicy.Enable", Name: validation.Null, Rule: true, Chain: nil}}},
-				}}}}}); err != nil {
-		return result, validation.NewError("storage.BlobServicesClient", "SetServiceProperties", err.Error())
-	}
-
-	req, err := client.SetServicePropertiesPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "SetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.SetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "SetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.SetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.BlobServicesClient", "SetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// SetServicePropertiesPreparer prepares the SetServiceProperties request.
-func (client BlobServicesClient) SetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters BlobServiceProperties) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"BlobServicesName":  autorest.Encode("path", "default"),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	parameters.Sku = nil
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/blobServices/{BlobServicesName}", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client BlobServicesClient) SetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client BlobServicesClient) SetServicePropertiesResponder(resp *http.Response) (result BlobServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/client.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/client.go
deleted file mode 100644
index 71aa87b9192e..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/client.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Deprecated: Please note, this package has been deprecated. A replacement package is available [github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage). We strongly encourage you to upgrade to continue receiving updates. See [Migration Guide](https://aka.ms/azsdk/golang/t2/migration) for guidance on upgrading. Refer to our [deprecation policy](https://azure.github.io/azure-sdk/policies_support.html) for more details.
-//
-// Package storage implements the Azure ARM Storage service API version 2021-02-01.
-//
-// The Azure Storage Management API.
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"github.com/Azure/go-autorest/autorest"
-)
-
-const (
-	// DefaultBaseURI is the default URI used for the service Storage
-	DefaultBaseURI = "https://management.azure.com"
-)
-
-// BaseClient is the base client for Storage.
-type BaseClient struct {
-	autorest.Client
-	BaseURI        string
-	SubscriptionID string
-}
-
-// New creates an instance of the BaseClient client.
-func New(subscriptionID string) BaseClient {
-	return NewWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint.  Use this when interacting with
-// an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
-	return BaseClient{
-		Client:         autorest.NewClientWithUserAgent(UserAgent()),
-		BaseURI:        baseURI,
-		SubscriptionID: subscriptionID,
-	}
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/deletedaccounts.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/deletedaccounts.go
deleted file mode 100644
index 109ae05dc96b..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/deletedaccounts.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// DeletedAccountsClient is the the Azure Storage Management API.
-type DeletedAccountsClient struct {
-	BaseClient
-}
-
-// NewDeletedAccountsClient creates an instance of the DeletedAccountsClient client.
-func NewDeletedAccountsClient(subscriptionID string) DeletedAccountsClient {
-	return NewDeletedAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewDeletedAccountsClientWithBaseURI creates an instance of the DeletedAccountsClient client using a custom endpoint.
-// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewDeletedAccountsClientWithBaseURI(baseURI string, subscriptionID string) DeletedAccountsClient {
-	return DeletedAccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// Get get properties of specified deleted account resource.
-// Parameters:
-// deletedAccountName - name of the deleted storage account.
-// location - the location of the deleted storage account.
-func (client DeletedAccountsClient) Get(ctx context.Context, deletedAccountName string, location string) (result DeletedAccount, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/DeletedAccountsClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: deletedAccountName,
-			Constraints: []validation.Constraint{{Target: "deletedAccountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "deletedAccountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.DeletedAccountsClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, deletedAccountName, location)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client DeletedAccountsClient) GetPreparer(ctx context.Context, deletedAccountName string, location string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"deletedAccountName": autorest.Encode("path", deletedAccountName),
-		"location":           autorest.Encode("path", location),
-		"subscriptionId":     autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/locations/{location}/deletedAccounts/{deletedAccountName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client DeletedAccountsClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client DeletedAccountsClient) GetResponder(resp *http.Response) (result DeletedAccount, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List lists deleted accounts under the subscription.
-func (client DeletedAccountsClient) List(ctx context.Context) (result DeletedAccountListResultPage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/DeletedAccountsClient.List")
-		defer func() {
-			sc := -1
-			if result.dalr.Response.Response != nil {
-				sc = result.dalr.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.DeletedAccountsClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.dalr.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.dalr, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.dalr.hasNextLink() && result.dalr.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client DeletedAccountsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/deletedAccounts", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client DeletedAccountsClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client DeletedAccountsClient) ListResponder(resp *http.Response) (result DeletedAccountListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client DeletedAccountsClient) listNextResults(ctx context.Context, lastResults DeletedAccountListResult) (result DeletedAccountListResult, err error) {
-	req, err := lastResults.deletedAccountListResultPreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.DeletedAccountsClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client DeletedAccountsClient) ListComplete(ctx context.Context) (result DeletedAccountListResultIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/DeletedAccountsClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx)
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/encryptionscopes.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/encryptionscopes.go
deleted file mode 100644
index 3235434fc63e..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/encryptionscopes.go
+++ /dev/null
@@ -1,469 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// EncryptionScopesClient is the the Azure Storage Management API.
-type EncryptionScopesClient struct {
-	BaseClient
-}
-
-// NewEncryptionScopesClient creates an instance of the EncryptionScopesClient client.
-func NewEncryptionScopesClient(subscriptionID string) EncryptionScopesClient {
-	return NewEncryptionScopesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewEncryptionScopesClientWithBaseURI creates an instance of the EncryptionScopesClient client using a custom
-// endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
-// stack).
-func NewEncryptionScopesClientWithBaseURI(baseURI string, subscriptionID string) EncryptionScopesClient {
-	return EncryptionScopesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// Get returns the properties for the specified encryption scope.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// encryptionScopeName - the name of the encryption scope within the specified storage account. Encryption
-// scope names must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-)
-// only. Every dash (-) character must be immediately preceded and followed by a letter or number.
-func (client EncryptionScopesClient) Get(ctx context.Context, resourceGroupName string, accountName string, encryptionScopeName string) (result EncryptionScope, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopesClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: encryptionScopeName,
-			Constraints: []validation.Constraint{{Target: "encryptionScopeName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "encryptionScopeName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.EncryptionScopesClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, encryptionScopeName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client EncryptionScopesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, encryptionScopeName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":         autorest.Encode("path", accountName),
-		"encryptionScopeName": autorest.Encode("path", encryptionScopeName),
-		"resourceGroupName":   autorest.Encode("path", resourceGroupName),
-		"subscriptionId":      autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/encryptionScopes/{encryptionScopeName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client EncryptionScopesClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client EncryptionScopesClient) GetResponder(resp *http.Response) (result EncryptionScope, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List lists all the encryption scopes available under the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client EncryptionScopesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result EncryptionScopeListResultPage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopesClient.List")
-		defer func() {
-			sc := -1
-			if result.eslr.Response.Response != nil {
-				sc = result.eslr.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.EncryptionScopesClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.eslr.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.eslr, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.eslr.hasNextLink() && result.eslr.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client EncryptionScopesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/encryptionScopes", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client EncryptionScopesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client EncryptionScopesClient) ListResponder(resp *http.Response) (result EncryptionScopeListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client EncryptionScopesClient) listNextResults(ctx context.Context, lastResults EncryptionScopeListResult) (result EncryptionScopeListResult, err error) {
-	req, err := lastResults.encryptionScopeListResultPreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client EncryptionScopesClient) ListComplete(ctx context.Context, resourceGroupName string, accountName string) (result EncryptionScopeListResultIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx, resourceGroupName, accountName)
-	return
-}
-
-// Patch update encryption scope properties as specified in the request body. Update fails if the specified encryption
-// scope does not already exist.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// encryptionScopeName - the name of the encryption scope within the specified storage account. Encryption
-// scope names must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-)
-// only. Every dash (-) character must be immediately preceded and followed by a letter or number.
-// encryptionScope - encryption scope properties to be used for the update.
-func (client EncryptionScopesClient) Patch(ctx context.Context, resourceGroupName string, accountName string, encryptionScopeName string, encryptionScope EncryptionScope) (result EncryptionScope, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopesClient.Patch")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: encryptionScopeName,
-			Constraints: []validation.Constraint{{Target: "encryptionScopeName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "encryptionScopeName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.EncryptionScopesClient", "Patch", err.Error())
-	}
-
-	req, err := client.PatchPreparer(ctx, resourceGroupName, accountName, encryptionScopeName, encryptionScope)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Patch", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.PatchSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Patch", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.PatchResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Patch", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// PatchPreparer prepares the Patch request.
-func (client EncryptionScopesClient) PatchPreparer(ctx context.Context, resourceGroupName string, accountName string, encryptionScopeName string, encryptionScope EncryptionScope) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":         autorest.Encode("path", accountName),
-		"encryptionScopeName": autorest.Encode("path", encryptionScopeName),
-		"resourceGroupName":   autorest.Encode("path", resourceGroupName),
-		"subscriptionId":      autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPatch(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/encryptionScopes/{encryptionScopeName}", pathParameters),
-		autorest.WithJSON(encryptionScope),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// PatchSender sends the Patch request. The method will close the
-// http.Response Body if it receives an error.
-func (client EncryptionScopesClient) PatchSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// PatchResponder handles the response to the Patch request. The method always
-// closes the http.Response Body.
-func (client EncryptionScopesClient) PatchResponder(resp *http.Response) (result EncryptionScope, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Put synchronously creates or updates an encryption scope under the specified storage account. If an encryption scope
-// is already created and a subsequent request is issued with different properties, the encryption scope properties
-// will be updated per the specified request.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// encryptionScopeName - the name of the encryption scope within the specified storage account. Encryption
-// scope names must be between 3 and 63 characters in length and use numbers, lower-case letters and dash (-)
-// only. Every dash (-) character must be immediately preceded and followed by a letter or number.
-// encryptionScope - encryption scope properties to be used for the create or update.
-func (client EncryptionScopesClient) Put(ctx context.Context, resourceGroupName string, accountName string, encryptionScopeName string, encryptionScope EncryptionScope) (result EncryptionScope, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopesClient.Put")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: encryptionScopeName,
-			Constraints: []validation.Constraint{{Target: "encryptionScopeName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "encryptionScopeName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.EncryptionScopesClient", "Put", err.Error())
-	}
-
-	req, err := client.PutPreparer(ctx, resourceGroupName, accountName, encryptionScopeName, encryptionScope)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Put", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.PutSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Put", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.PutResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.EncryptionScopesClient", "Put", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// PutPreparer prepares the Put request.
-func (client EncryptionScopesClient) PutPreparer(ctx context.Context, resourceGroupName string, accountName string, encryptionScopeName string, encryptionScope EncryptionScope) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":         autorest.Encode("path", accountName),
-		"encryptionScopeName": autorest.Encode("path", encryptionScopeName),
-		"resourceGroupName":   autorest.Encode("path", resourceGroupName),
-		"subscriptionId":      autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/encryptionScopes/{encryptionScopeName}", pathParameters),
-		autorest.WithJSON(encryptionScope),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// PutSender sends the Put request. The method will close the
-// http.Response Body if it receives an error.
-func (client EncryptionScopesClient) PutSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// PutResponder handles the response to the Put request. The method always
-// closes the http.Response Body.
-func (client EncryptionScopesClient) PutResponder(resp *http.Response) (result EncryptionScope, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/enums.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/enums.go
deleted file mode 100644
index 65368dba60af..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/enums.go
+++ /dev/null
@@ -1,863 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-// AccessTier enumerates the values for access tier.
-type AccessTier string
-
-const (
-	// AccessTierCool ...
-	AccessTierCool AccessTier = "Cool"
-	// AccessTierHot ...
-	AccessTierHot AccessTier = "Hot"
-)
-
-// PossibleAccessTierValues returns an array of possible values for the AccessTier const type.
-func PossibleAccessTierValues() []AccessTier {
-	return []AccessTier{AccessTierCool, AccessTierHot}
-}
-
-// AccountExpand enumerates the values for account expand.
-type AccountExpand string
-
-const (
-	// AccountExpandBlobRestoreStatus ...
-	AccountExpandBlobRestoreStatus AccountExpand = "blobRestoreStatus"
-	// AccountExpandGeoReplicationStats ...
-	AccountExpandGeoReplicationStats AccountExpand = "geoReplicationStats"
-)
-
-// PossibleAccountExpandValues returns an array of possible values for the AccountExpand const type.
-func PossibleAccountExpandValues() []AccountExpand {
-	return []AccountExpand{AccountExpandBlobRestoreStatus, AccountExpandGeoReplicationStats}
-}
-
-// AccountStatus enumerates the values for account status.
-type AccountStatus string
-
-const (
-	// AccountStatusAvailable ...
-	AccountStatusAvailable AccountStatus = "available"
-	// AccountStatusUnavailable ...
-	AccountStatusUnavailable AccountStatus = "unavailable"
-)
-
-// PossibleAccountStatusValues returns an array of possible values for the AccountStatus const type.
-func PossibleAccountStatusValues() []AccountStatus {
-	return []AccountStatus{AccountStatusAvailable, AccountStatusUnavailable}
-}
-
-// Action enumerates the values for action.
-type Action string
-
-const (
-	// ActionAllow ...
-	ActionAllow Action = "Allow"
-)
-
-// PossibleActionValues returns an array of possible values for the Action const type.
-func PossibleActionValues() []Action {
-	return []Action{ActionAllow}
-}
-
-// Action1 enumerates the values for action 1.
-type Action1 string
-
-const (
-	// Action1Acquire ...
-	Action1Acquire Action1 = "Acquire"
-	// Action1Break ...
-	Action1Break Action1 = "Break"
-	// Action1Change ...
-	Action1Change Action1 = "Change"
-	// Action1Release ...
-	Action1Release Action1 = "Release"
-	// Action1Renew ...
-	Action1Renew Action1 = "Renew"
-)
-
-// PossibleAction1Values returns an array of possible values for the Action1 const type.
-func PossibleAction1Values() []Action1 {
-	return []Action1{Action1Acquire, Action1Break, Action1Change, Action1Release, Action1Renew}
-}
-
-// BlobRestoreProgressStatus enumerates the values for blob restore progress status.
-type BlobRestoreProgressStatus string
-
-const (
-	// BlobRestoreProgressStatusComplete ...
-	BlobRestoreProgressStatusComplete BlobRestoreProgressStatus = "Complete"
-	// BlobRestoreProgressStatusFailed ...
-	BlobRestoreProgressStatusFailed BlobRestoreProgressStatus = "Failed"
-	// BlobRestoreProgressStatusInProgress ...
-	BlobRestoreProgressStatusInProgress BlobRestoreProgressStatus = "InProgress"
-)
-
-// PossibleBlobRestoreProgressStatusValues returns an array of possible values for the BlobRestoreProgressStatus const type.
-func PossibleBlobRestoreProgressStatusValues() []BlobRestoreProgressStatus {
-	return []BlobRestoreProgressStatus{BlobRestoreProgressStatusComplete, BlobRestoreProgressStatusFailed, BlobRestoreProgressStatusInProgress}
-}
-
-// Bypass enumerates the values for bypass.
-type Bypass string
-
-const (
-	// BypassAzureServices ...
-	BypassAzureServices Bypass = "AzureServices"
-	// BypassLogging ...
-	BypassLogging Bypass = "Logging"
-	// BypassMetrics ...
-	BypassMetrics Bypass = "Metrics"
-	// BypassNone ...
-	BypassNone Bypass = "None"
-)
-
-// PossibleBypassValues returns an array of possible values for the Bypass const type.
-func PossibleBypassValues() []Bypass {
-	return []Bypass{BypassAzureServices, BypassLogging, BypassMetrics, BypassNone}
-}
-
-// CreatedByType enumerates the values for created by type.
-type CreatedByType string
-
-const (
-	// CreatedByTypeApplication ...
-	CreatedByTypeApplication CreatedByType = "Application"
-	// CreatedByTypeKey ...
-	CreatedByTypeKey CreatedByType = "Key"
-	// CreatedByTypeManagedIdentity ...
-	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
-	// CreatedByTypeUser ...
-	CreatedByTypeUser CreatedByType = "User"
-)
-
-// PossibleCreatedByTypeValues returns an array of possible values for the CreatedByType const type.
-func PossibleCreatedByTypeValues() []CreatedByType {
-	return []CreatedByType{CreatedByTypeApplication, CreatedByTypeKey, CreatedByTypeManagedIdentity, CreatedByTypeUser}
-}
-
-// DefaultAction enumerates the values for default action.
-type DefaultAction string
-
-const (
-	// DefaultActionAllow ...
-	DefaultActionAllow DefaultAction = "Allow"
-	// DefaultActionDeny ...
-	DefaultActionDeny DefaultAction = "Deny"
-)
-
-// PossibleDefaultActionValues returns an array of possible values for the DefaultAction const type.
-func PossibleDefaultActionValues() []DefaultAction {
-	return []DefaultAction{DefaultActionAllow, DefaultActionDeny}
-}
-
-// DirectoryServiceOptions enumerates the values for directory service options.
-type DirectoryServiceOptions string
-
-const (
-	// DirectoryServiceOptionsAADDS ...
-	DirectoryServiceOptionsAADDS DirectoryServiceOptions = "AADDS"
-	// DirectoryServiceOptionsAD ...
-	DirectoryServiceOptionsAD DirectoryServiceOptions = "AD"
-	// DirectoryServiceOptionsNone ...
-	DirectoryServiceOptionsNone DirectoryServiceOptions = "None"
-)
-
-// PossibleDirectoryServiceOptionsValues returns an array of possible values for the DirectoryServiceOptions const type.
-func PossibleDirectoryServiceOptionsValues() []DirectoryServiceOptions {
-	return []DirectoryServiceOptions{DirectoryServiceOptionsAADDS, DirectoryServiceOptionsAD, DirectoryServiceOptionsNone}
-}
-
-// EnabledProtocols enumerates the values for enabled protocols.
-type EnabledProtocols string
-
-const (
-	// EnabledProtocolsNFS ...
-	EnabledProtocolsNFS EnabledProtocols = "NFS"
-	// EnabledProtocolsSMB ...
-	EnabledProtocolsSMB EnabledProtocols = "SMB"
-)
-
-// PossibleEnabledProtocolsValues returns an array of possible values for the EnabledProtocols const type.
-func PossibleEnabledProtocolsValues() []EnabledProtocols {
-	return []EnabledProtocols{EnabledProtocolsNFS, EnabledProtocolsSMB}
-}
-
-// EncryptionScopeSource enumerates the values for encryption scope source.
-type EncryptionScopeSource string
-
-const (
-	// EncryptionScopeSourceMicrosoftKeyVault ...
-	EncryptionScopeSourceMicrosoftKeyVault EncryptionScopeSource = "Microsoft.KeyVault"
-	// EncryptionScopeSourceMicrosoftStorage ...
-	EncryptionScopeSourceMicrosoftStorage EncryptionScopeSource = "Microsoft.Storage"
-)
-
-// PossibleEncryptionScopeSourceValues returns an array of possible values for the EncryptionScopeSource const type.
-func PossibleEncryptionScopeSourceValues() []EncryptionScopeSource {
-	return []EncryptionScopeSource{EncryptionScopeSourceMicrosoftKeyVault, EncryptionScopeSourceMicrosoftStorage}
-}
-
-// EncryptionScopeState enumerates the values for encryption scope state.
-type EncryptionScopeState string
-
-const (
-	// EncryptionScopeStateDisabled ...
-	EncryptionScopeStateDisabled EncryptionScopeState = "Disabled"
-	// EncryptionScopeStateEnabled ...
-	EncryptionScopeStateEnabled EncryptionScopeState = "Enabled"
-)
-
-// PossibleEncryptionScopeStateValues returns an array of possible values for the EncryptionScopeState const type.
-func PossibleEncryptionScopeStateValues() []EncryptionScopeState {
-	return []EncryptionScopeState{EncryptionScopeStateDisabled, EncryptionScopeStateEnabled}
-}
-
-// ExtendedLocationTypes enumerates the values for extended location types.
-type ExtendedLocationTypes string
-
-const (
-	// ExtendedLocationTypesEdgeZone ...
-	ExtendedLocationTypesEdgeZone ExtendedLocationTypes = "EdgeZone"
-)
-
-// PossibleExtendedLocationTypesValues returns an array of possible values for the ExtendedLocationTypes const type.
-func PossibleExtendedLocationTypesValues() []ExtendedLocationTypes {
-	return []ExtendedLocationTypes{ExtendedLocationTypesEdgeZone}
-}
-
-// GeoReplicationStatus enumerates the values for geo replication status.
-type GeoReplicationStatus string
-
-const (
-	// GeoReplicationStatusBootstrap ...
-	GeoReplicationStatusBootstrap GeoReplicationStatus = "Bootstrap"
-	// GeoReplicationStatusLive ...
-	GeoReplicationStatusLive GeoReplicationStatus = "Live"
-	// GeoReplicationStatusUnavailable ...
-	GeoReplicationStatusUnavailable GeoReplicationStatus = "Unavailable"
-)
-
-// PossibleGeoReplicationStatusValues returns an array of possible values for the GeoReplicationStatus const type.
-func PossibleGeoReplicationStatusValues() []GeoReplicationStatus {
-	return []GeoReplicationStatus{GeoReplicationStatusBootstrap, GeoReplicationStatusLive, GeoReplicationStatusUnavailable}
-}
-
-// GetShareExpand enumerates the values for get share expand.
-type GetShareExpand string
-
-const (
-	// GetShareExpandStats ...
-	GetShareExpandStats GetShareExpand = "stats"
-)
-
-// PossibleGetShareExpandValues returns an array of possible values for the GetShareExpand const type.
-func PossibleGetShareExpandValues() []GetShareExpand {
-	return []GetShareExpand{GetShareExpandStats}
-}
-
-// HTTPProtocol enumerates the values for http protocol.
-type HTTPProtocol string
-
-const (
-	// HTTPProtocolHTTPS ...
-	HTTPProtocolHTTPS HTTPProtocol = "https"
-	// HTTPProtocolHttpshttp ...
-	HTTPProtocolHttpshttp HTTPProtocol = "https,http"
-)
-
-// PossibleHTTPProtocolValues returns an array of possible values for the HTTPProtocol const type.
-func PossibleHTTPProtocolValues() []HTTPProtocol {
-	return []HTTPProtocol{HTTPProtocolHTTPS, HTTPProtocolHttpshttp}
-}
-
-// IdentityType enumerates the values for identity type.
-type IdentityType string
-
-const (
-	// IdentityTypeNone ...
-	IdentityTypeNone IdentityType = "None"
-	// IdentityTypeSystemAssigned ...
-	IdentityTypeSystemAssigned IdentityType = "SystemAssigned"
-	// IdentityTypeSystemAssignedUserAssigned ...
-	IdentityTypeSystemAssignedUserAssigned IdentityType = "SystemAssigned,UserAssigned"
-	// IdentityTypeUserAssigned ...
-	IdentityTypeUserAssigned IdentityType = "UserAssigned"
-)
-
-// PossibleIdentityTypeValues returns an array of possible values for the IdentityType const type.
-func PossibleIdentityTypeValues() []IdentityType {
-	return []IdentityType{IdentityTypeNone, IdentityTypeSystemAssigned, IdentityTypeSystemAssignedUserAssigned, IdentityTypeUserAssigned}
-}
-
-// ImmutabilityPolicyState enumerates the values for immutability policy state.
-type ImmutabilityPolicyState string
-
-const (
-	// ImmutabilityPolicyStateLocked ...
-	ImmutabilityPolicyStateLocked ImmutabilityPolicyState = "Locked"
-	// ImmutabilityPolicyStateUnlocked ...
-	ImmutabilityPolicyStateUnlocked ImmutabilityPolicyState = "Unlocked"
-)
-
-// PossibleImmutabilityPolicyStateValues returns an array of possible values for the ImmutabilityPolicyState const type.
-func PossibleImmutabilityPolicyStateValues() []ImmutabilityPolicyState {
-	return []ImmutabilityPolicyState{ImmutabilityPolicyStateLocked, ImmutabilityPolicyStateUnlocked}
-}
-
-// ImmutabilityPolicyUpdateType enumerates the values for immutability policy update type.
-type ImmutabilityPolicyUpdateType string
-
-const (
-	// ImmutabilityPolicyUpdateTypeExtend ...
-	ImmutabilityPolicyUpdateTypeExtend ImmutabilityPolicyUpdateType = "extend"
-	// ImmutabilityPolicyUpdateTypeLock ...
-	ImmutabilityPolicyUpdateTypeLock ImmutabilityPolicyUpdateType = "lock"
-	// ImmutabilityPolicyUpdateTypePut ...
-	ImmutabilityPolicyUpdateTypePut ImmutabilityPolicyUpdateType = "put"
-)
-
-// PossibleImmutabilityPolicyUpdateTypeValues returns an array of possible values for the ImmutabilityPolicyUpdateType const type.
-func PossibleImmutabilityPolicyUpdateTypeValues() []ImmutabilityPolicyUpdateType {
-	return []ImmutabilityPolicyUpdateType{ImmutabilityPolicyUpdateTypeExtend, ImmutabilityPolicyUpdateTypeLock, ImmutabilityPolicyUpdateTypePut}
-}
-
-// KeyPermission enumerates the values for key permission.
-type KeyPermission string
-
-const (
-	// KeyPermissionFull ...
-	KeyPermissionFull KeyPermission = "Full"
-	// KeyPermissionRead ...
-	KeyPermissionRead KeyPermission = "Read"
-)
-
-// PossibleKeyPermissionValues returns an array of possible values for the KeyPermission const type.
-func PossibleKeyPermissionValues() []KeyPermission {
-	return []KeyPermission{KeyPermissionFull, KeyPermissionRead}
-}
-
-// KeySource enumerates the values for key source.
-type KeySource string
-
-const (
-	// KeySourceMicrosoftKeyvault ...
-	KeySourceMicrosoftKeyvault KeySource = "Microsoft.Keyvault"
-	// KeySourceMicrosoftStorage ...
-	KeySourceMicrosoftStorage KeySource = "Microsoft.Storage"
-)
-
-// PossibleKeySourceValues returns an array of possible values for the KeySource const type.
-func PossibleKeySourceValues() []KeySource {
-	return []KeySource{KeySourceMicrosoftKeyvault, KeySourceMicrosoftStorage}
-}
-
-// KeyType enumerates the values for key type.
-type KeyType string
-
-const (
-	// KeyTypeAccount ...
-	KeyTypeAccount KeyType = "Account"
-	// KeyTypeService ...
-	KeyTypeService KeyType = "Service"
-)
-
-// PossibleKeyTypeValues returns an array of possible values for the KeyType const type.
-func PossibleKeyTypeValues() []KeyType {
-	return []KeyType{KeyTypeAccount, KeyTypeService}
-}
-
-// Kind enumerates the values for kind.
-type Kind string
-
-const (
-	// KindBlobStorage ...
-	KindBlobStorage Kind = "BlobStorage"
-	// KindBlockBlobStorage ...
-	KindBlockBlobStorage Kind = "BlockBlobStorage"
-	// KindFileStorage ...
-	KindFileStorage Kind = "FileStorage"
-	// KindStorage ...
-	KindStorage Kind = "Storage"
-	// KindStorageV2 ...
-	KindStorageV2 Kind = "StorageV2"
-)
-
-// PossibleKindValues returns an array of possible values for the Kind const type.
-func PossibleKindValues() []Kind {
-	return []Kind{KindBlobStorage, KindBlockBlobStorage, KindFileStorage, KindStorage, KindStorageV2}
-}
-
-// LargeFileSharesState enumerates the values for large file shares state.
-type LargeFileSharesState string
-
-const (
-	// LargeFileSharesStateDisabled ...
-	LargeFileSharesStateDisabled LargeFileSharesState = "Disabled"
-	// LargeFileSharesStateEnabled ...
-	LargeFileSharesStateEnabled LargeFileSharesState = "Enabled"
-)
-
-// PossibleLargeFileSharesStateValues returns an array of possible values for the LargeFileSharesState const type.
-func PossibleLargeFileSharesStateValues() []LargeFileSharesState {
-	return []LargeFileSharesState{LargeFileSharesStateDisabled, LargeFileSharesStateEnabled}
-}
-
-// LeaseDuration enumerates the values for lease duration.
-type LeaseDuration string
-
-const (
-	// LeaseDurationFixed ...
-	LeaseDurationFixed LeaseDuration = "Fixed"
-	// LeaseDurationInfinite ...
-	LeaseDurationInfinite LeaseDuration = "Infinite"
-)
-
-// PossibleLeaseDurationValues returns an array of possible values for the LeaseDuration const type.
-func PossibleLeaseDurationValues() []LeaseDuration {
-	return []LeaseDuration{LeaseDurationFixed, LeaseDurationInfinite}
-}
-
-// LeaseState enumerates the values for lease state.
-type LeaseState string
-
-const (
-	// LeaseStateAvailable ...
-	LeaseStateAvailable LeaseState = "Available"
-	// LeaseStateBreaking ...
-	LeaseStateBreaking LeaseState = "Breaking"
-	// LeaseStateBroken ...
-	LeaseStateBroken LeaseState = "Broken"
-	// LeaseStateExpired ...
-	LeaseStateExpired LeaseState = "Expired"
-	// LeaseStateLeased ...
-	LeaseStateLeased LeaseState = "Leased"
-)
-
-// PossibleLeaseStateValues returns an array of possible values for the LeaseState const type.
-func PossibleLeaseStateValues() []LeaseState {
-	return []LeaseState{LeaseStateAvailable, LeaseStateBreaking, LeaseStateBroken, LeaseStateExpired, LeaseStateLeased}
-}
-
-// LeaseStatus enumerates the values for lease status.
-type LeaseStatus string
-
-const (
-	// LeaseStatusLocked ...
-	LeaseStatusLocked LeaseStatus = "Locked"
-	// LeaseStatusUnlocked ...
-	LeaseStatusUnlocked LeaseStatus = "Unlocked"
-)
-
-// PossibleLeaseStatusValues returns an array of possible values for the LeaseStatus const type.
-func PossibleLeaseStatusValues() []LeaseStatus {
-	return []LeaseStatus{LeaseStatusLocked, LeaseStatusUnlocked}
-}
-
-// ListContainersInclude enumerates the values for list containers include.
-type ListContainersInclude string
-
-const (
-	// ListContainersIncludeDeleted ...
-	ListContainersIncludeDeleted ListContainersInclude = "deleted"
-)
-
-// PossibleListContainersIncludeValues returns an array of possible values for the ListContainersInclude const type.
-func PossibleListContainersIncludeValues() []ListContainersInclude {
-	return []ListContainersInclude{ListContainersIncludeDeleted}
-}
-
-// ListKeyExpand enumerates the values for list key expand.
-type ListKeyExpand string
-
-const (
-	// ListKeyExpandKerb ...
-	ListKeyExpandKerb ListKeyExpand = "kerb"
-)
-
-// PossibleListKeyExpandValues returns an array of possible values for the ListKeyExpand const type.
-func PossibleListKeyExpandValues() []ListKeyExpand {
-	return []ListKeyExpand{ListKeyExpandKerb}
-}
-
-// ListSharesExpand enumerates the values for list shares expand.
-type ListSharesExpand string
-
-const (
-	// ListSharesExpandDeleted ...
-	ListSharesExpandDeleted ListSharesExpand = "deleted"
-	// ListSharesExpandSnapshots ...
-	ListSharesExpandSnapshots ListSharesExpand = "snapshots"
-)
-
-// PossibleListSharesExpandValues returns an array of possible values for the ListSharesExpand const type.
-func PossibleListSharesExpandValues() []ListSharesExpand {
-	return []ListSharesExpand{ListSharesExpandDeleted, ListSharesExpandSnapshots}
-}
-
-// MinimumTLSVersion enumerates the values for minimum tls version.
-type MinimumTLSVersion string
-
-const (
-	// MinimumTLSVersionTLS10 ...
-	MinimumTLSVersionTLS10 MinimumTLSVersion = "TLS1_0"
-	// MinimumTLSVersionTLS11 ...
-	MinimumTLSVersionTLS11 MinimumTLSVersion = "TLS1_1"
-	// MinimumTLSVersionTLS12 ...
-	MinimumTLSVersionTLS12 MinimumTLSVersion = "TLS1_2"
-)
-
-// PossibleMinimumTLSVersionValues returns an array of possible values for the MinimumTLSVersion const type.
-func PossibleMinimumTLSVersionValues() []MinimumTLSVersion {
-	return []MinimumTLSVersion{MinimumTLSVersionTLS10, MinimumTLSVersionTLS11, MinimumTLSVersionTLS12}
-}
-
-// Name enumerates the values for name.
-type Name string
-
-const (
-	// NameAccessTimeTracking ...
-	NameAccessTimeTracking Name = "AccessTimeTracking"
-)
-
-// PossibleNameValues returns an array of possible values for the Name const type.
-func PossibleNameValues() []Name {
-	return []Name{NameAccessTimeTracking}
-}
-
-// Permissions enumerates the values for permissions.
-type Permissions string
-
-const (
-	// PermissionsA ...
-	PermissionsA Permissions = "a"
-	// PermissionsC ...
-	PermissionsC Permissions = "c"
-	// PermissionsD ...
-	PermissionsD Permissions = "d"
-	// PermissionsL ...
-	PermissionsL Permissions = "l"
-	// PermissionsP ...
-	PermissionsP Permissions = "p"
-	// PermissionsR ...
-	PermissionsR Permissions = "r"
-	// PermissionsU ...
-	PermissionsU Permissions = "u"
-	// PermissionsW ...
-	PermissionsW Permissions = "w"
-)
-
-// PossiblePermissionsValues returns an array of possible values for the Permissions const type.
-func PossiblePermissionsValues() []Permissions {
-	return []Permissions{PermissionsA, PermissionsC, PermissionsD, PermissionsL, PermissionsP, PermissionsR, PermissionsU, PermissionsW}
-}
-
-// PrivateEndpointConnectionProvisioningState enumerates the values for private endpoint connection
-// provisioning state.
-type PrivateEndpointConnectionProvisioningState string
-
-const (
-	// PrivateEndpointConnectionProvisioningStateCreating ...
-	PrivateEndpointConnectionProvisioningStateCreating PrivateEndpointConnectionProvisioningState = "Creating"
-	// PrivateEndpointConnectionProvisioningStateDeleting ...
-	PrivateEndpointConnectionProvisioningStateDeleting PrivateEndpointConnectionProvisioningState = "Deleting"
-	// PrivateEndpointConnectionProvisioningStateFailed ...
-	PrivateEndpointConnectionProvisioningStateFailed PrivateEndpointConnectionProvisioningState = "Failed"
-	// PrivateEndpointConnectionProvisioningStateSucceeded ...
-	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
-)
-
-// PossiblePrivateEndpointConnectionProvisioningStateValues returns an array of possible values for the PrivateEndpointConnectionProvisioningState const type.
-func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState {
-	return []PrivateEndpointConnectionProvisioningState{PrivateEndpointConnectionProvisioningStateCreating, PrivateEndpointConnectionProvisioningStateDeleting, PrivateEndpointConnectionProvisioningStateFailed, PrivateEndpointConnectionProvisioningStateSucceeded}
-}
-
-// PrivateEndpointServiceConnectionStatus enumerates the values for private endpoint service connection status.
-type PrivateEndpointServiceConnectionStatus string
-
-const (
-	// PrivateEndpointServiceConnectionStatusApproved ...
-	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
-	// PrivateEndpointServiceConnectionStatusPending ...
-	PrivateEndpointServiceConnectionStatusPending PrivateEndpointServiceConnectionStatus = "Pending"
-	// PrivateEndpointServiceConnectionStatusRejected ...
-	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
-)
-
-// PossiblePrivateEndpointServiceConnectionStatusValues returns an array of possible values for the PrivateEndpointServiceConnectionStatus const type.
-func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus {
-	return []PrivateEndpointServiceConnectionStatus{PrivateEndpointServiceConnectionStatusApproved, PrivateEndpointServiceConnectionStatusPending, PrivateEndpointServiceConnectionStatusRejected}
-}
-
-// ProvisioningState enumerates the values for provisioning state.
-type ProvisioningState string
-
-const (
-	// ProvisioningStateCreating ...
-	ProvisioningStateCreating ProvisioningState = "Creating"
-	// ProvisioningStateResolvingDNS ...
-	ProvisioningStateResolvingDNS ProvisioningState = "ResolvingDNS"
-	// ProvisioningStateSucceeded ...
-	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
-)
-
-// PossibleProvisioningStateValues returns an array of possible values for the ProvisioningState const type.
-func PossibleProvisioningStateValues() []ProvisioningState {
-	return []ProvisioningState{ProvisioningStateCreating, ProvisioningStateResolvingDNS, ProvisioningStateSucceeded}
-}
-
-// PublicAccess enumerates the values for public access.
-type PublicAccess string
-
-const (
-	// PublicAccessBlob ...
-	PublicAccessBlob PublicAccess = "Blob"
-	// PublicAccessContainer ...
-	PublicAccessContainer PublicAccess = "Container"
-	// PublicAccessNone ...
-	PublicAccessNone PublicAccess = "None"
-)
-
-// PossiblePublicAccessValues returns an array of possible values for the PublicAccess const type.
-func PossiblePublicAccessValues() []PublicAccess {
-	return []PublicAccess{PublicAccessBlob, PublicAccessContainer, PublicAccessNone}
-}
-
-// PutSharesExpand enumerates the values for put shares expand.
-type PutSharesExpand string
-
-const (
-	// PutSharesExpandSnapshots ...
-	PutSharesExpandSnapshots PutSharesExpand = "snapshots"
-)
-
-// PossiblePutSharesExpandValues returns an array of possible values for the PutSharesExpand const type.
-func PossiblePutSharesExpandValues() []PutSharesExpand {
-	return []PutSharesExpand{PutSharesExpandSnapshots}
-}
-
-// Reason enumerates the values for reason.
-type Reason string
-
-const (
-	// ReasonAccountNameInvalid ...
-	ReasonAccountNameInvalid Reason = "AccountNameInvalid"
-	// ReasonAlreadyExists ...
-	ReasonAlreadyExists Reason = "AlreadyExists"
-)
-
-// PossibleReasonValues returns an array of possible values for the Reason const type.
-func PossibleReasonValues() []Reason {
-	return []Reason{ReasonAccountNameInvalid, ReasonAlreadyExists}
-}
-
-// ReasonCode enumerates the values for reason code.
-type ReasonCode string
-
-const (
-	// ReasonCodeNotAvailableForSubscription ...
-	ReasonCodeNotAvailableForSubscription ReasonCode = "NotAvailableForSubscription"
-	// ReasonCodeQuotaID ...
-	ReasonCodeQuotaID ReasonCode = "QuotaId"
-)
-
-// PossibleReasonCodeValues returns an array of possible values for the ReasonCode const type.
-func PossibleReasonCodeValues() []ReasonCode {
-	return []ReasonCode{ReasonCodeNotAvailableForSubscription, ReasonCodeQuotaID}
-}
-
-// RootSquashType enumerates the values for root squash type.
-type RootSquashType string
-
-const (
-	// RootSquashTypeAllSquash ...
-	RootSquashTypeAllSquash RootSquashType = "AllSquash"
-	// RootSquashTypeNoRootSquash ...
-	RootSquashTypeNoRootSquash RootSquashType = "NoRootSquash"
-	// RootSquashTypeRootSquash ...
-	RootSquashTypeRootSquash RootSquashType = "RootSquash"
-)
-
-// PossibleRootSquashTypeValues returns an array of possible values for the RootSquashType const type.
-func PossibleRootSquashTypeValues() []RootSquashType {
-	return []RootSquashType{RootSquashTypeAllSquash, RootSquashTypeNoRootSquash, RootSquashTypeRootSquash}
-}
-
-// RoutingChoice enumerates the values for routing choice.
-type RoutingChoice string
-
-const (
-	// RoutingChoiceInternetRouting ...
-	RoutingChoiceInternetRouting RoutingChoice = "InternetRouting"
-	// RoutingChoiceMicrosoftRouting ...
-	RoutingChoiceMicrosoftRouting RoutingChoice = "MicrosoftRouting"
-)
-
-// PossibleRoutingChoiceValues returns an array of possible values for the RoutingChoice const type.
-func PossibleRoutingChoiceValues() []RoutingChoice {
-	return []RoutingChoice{RoutingChoiceInternetRouting, RoutingChoiceMicrosoftRouting}
-}
-
-// Services enumerates the values for services.
-type Services string
-
-const (
-	// ServicesB ...
-	ServicesB Services = "b"
-	// ServicesF ...
-	ServicesF Services = "f"
-	// ServicesQ ...
-	ServicesQ Services = "q"
-	// ServicesT ...
-	ServicesT Services = "t"
-)
-
-// PossibleServicesValues returns an array of possible values for the Services const type.
-func PossibleServicesValues() []Services {
-	return []Services{ServicesB, ServicesF, ServicesQ, ServicesT}
-}
-
-// ShareAccessTier enumerates the values for share access tier.
-type ShareAccessTier string
-
-const (
-	// ShareAccessTierCool ...
-	ShareAccessTierCool ShareAccessTier = "Cool"
-	// ShareAccessTierHot ...
-	ShareAccessTierHot ShareAccessTier = "Hot"
-	// ShareAccessTierPremium ...
-	ShareAccessTierPremium ShareAccessTier = "Premium"
-	// ShareAccessTierTransactionOptimized ...
-	ShareAccessTierTransactionOptimized ShareAccessTier = "TransactionOptimized"
-)
-
-// PossibleShareAccessTierValues returns an array of possible values for the ShareAccessTier const type.
-func PossibleShareAccessTierValues() []ShareAccessTier {
-	return []ShareAccessTier{ShareAccessTierCool, ShareAccessTierHot, ShareAccessTierPremium, ShareAccessTierTransactionOptimized}
-}
-
-// SignedResource enumerates the values for signed resource.
-type SignedResource string
-
-const (
-	// SignedResourceB ...
-	SignedResourceB SignedResource = "b"
-	// SignedResourceC ...
-	SignedResourceC SignedResource = "c"
-	// SignedResourceF ...
-	SignedResourceF SignedResource = "f"
-	// SignedResourceS ...
-	SignedResourceS SignedResource = "s"
-)
-
-// PossibleSignedResourceValues returns an array of possible values for the SignedResource const type.
-func PossibleSignedResourceValues() []SignedResource {
-	return []SignedResource{SignedResourceB, SignedResourceC, SignedResourceF, SignedResourceS}
-}
-
-// SignedResourceTypes enumerates the values for signed resource types.
-type SignedResourceTypes string
-
-const (
-	// SignedResourceTypesC ...
-	SignedResourceTypesC SignedResourceTypes = "c"
-	// SignedResourceTypesO ...
-	SignedResourceTypesO SignedResourceTypes = "o"
-	// SignedResourceTypesS ...
-	SignedResourceTypesS SignedResourceTypes = "s"
-)
-
-// PossibleSignedResourceTypesValues returns an array of possible values for the SignedResourceTypes const type.
-func PossibleSignedResourceTypesValues() []SignedResourceTypes {
-	return []SignedResourceTypes{SignedResourceTypesC, SignedResourceTypesO, SignedResourceTypesS}
-}
-
-// SkuName enumerates the values for sku name.
-type SkuName string
-
-const (
-	// SkuNamePremiumLRS ...
-	SkuNamePremiumLRS SkuName = "Premium_LRS"
-	// SkuNamePremiumZRS ...
-	SkuNamePremiumZRS SkuName = "Premium_ZRS"
-	// SkuNameStandardGRS ...
-	SkuNameStandardGRS SkuName = "Standard_GRS"
-	// SkuNameStandardGZRS ...
-	SkuNameStandardGZRS SkuName = "Standard_GZRS"
-	// SkuNameStandardLRS ...
-	SkuNameStandardLRS SkuName = "Standard_LRS"
-	// SkuNameStandardRAGRS ...
-	SkuNameStandardRAGRS SkuName = "Standard_RAGRS"
-	// SkuNameStandardRAGZRS ...
-	SkuNameStandardRAGZRS SkuName = "Standard_RAGZRS"
-	// SkuNameStandardZRS ...
-	SkuNameStandardZRS SkuName = "Standard_ZRS"
-)
-
-// PossibleSkuNameValues returns an array of possible values for the SkuName const type.
-func PossibleSkuNameValues() []SkuName {
-	return []SkuName{SkuNamePremiumLRS, SkuNamePremiumZRS, SkuNameStandardGRS, SkuNameStandardGZRS, SkuNameStandardLRS, SkuNameStandardRAGRS, SkuNameStandardRAGZRS, SkuNameStandardZRS}
-}
-
-// SkuTier enumerates the values for sku tier.
-type SkuTier string
-
-const (
-	// SkuTierPremium ...
-	SkuTierPremium SkuTier = "Premium"
-	// SkuTierStandard ...
-	SkuTierStandard SkuTier = "Standard"
-)
-
-// PossibleSkuTierValues returns an array of possible values for the SkuTier const type.
-func PossibleSkuTierValues() []SkuTier {
-	return []SkuTier{SkuTierPremium, SkuTierStandard}
-}
-
-// State enumerates the values for state.
-type State string
-
-const (
-	// StateDeprovisioning ...
-	StateDeprovisioning State = "deprovisioning"
-	// StateFailed ...
-	StateFailed State = "failed"
-	// StateNetworkSourceDeleted ...
-	StateNetworkSourceDeleted State = "networkSourceDeleted"
-	// StateProvisioning ...
-	StateProvisioning State = "provisioning"
-	// StateSucceeded ...
-	StateSucceeded State = "succeeded"
-)
-
-// PossibleStateValues returns an array of possible values for the State const type.
-func PossibleStateValues() []State {
-	return []State{StateDeprovisioning, StateFailed, StateNetworkSourceDeleted, StateProvisioning, StateSucceeded}
-}
-
-// UsageUnit enumerates the values for usage unit.
-type UsageUnit string
-
-const (
-	// UsageUnitBytes ...
-	UsageUnitBytes UsageUnit = "Bytes"
-	// UsageUnitBytesPerSecond ...
-	UsageUnitBytesPerSecond UsageUnit = "BytesPerSecond"
-	// UsageUnitCount ...
-	UsageUnitCount UsageUnit = "Count"
-	// UsageUnitCountsPerSecond ...
-	UsageUnitCountsPerSecond UsageUnit = "CountsPerSecond"
-	// UsageUnitPercent ...
-	UsageUnitPercent UsageUnit = "Percent"
-	// UsageUnitSeconds ...
-	UsageUnitSeconds UsageUnit = "Seconds"
-)
-
-// PossibleUsageUnitValues returns an array of possible values for the UsageUnit const type.
-func PossibleUsageUnitValues() []UsageUnit {
-	return []UsageUnit{UsageUnitBytes, UsageUnitBytesPerSecond, UsageUnitCount, UsageUnitCountsPerSecond, UsageUnitPercent, UsageUnitSeconds}
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileservices.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileservices.go
deleted file mode 100644
index 3c6351539a2c..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileservices.go
+++ /dev/null
@@ -1,323 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// FileServicesClient is the the Azure Storage Management API.
-type FileServicesClient struct {
-	BaseClient
-}
-
-// NewFileServicesClient creates an instance of the FileServicesClient client.
-func NewFileServicesClient(subscriptionID string) FileServicesClient {
-	return NewFileServicesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewFileServicesClientWithBaseURI creates an instance of the FileServicesClient client using a custom endpoint.  Use
-// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewFileServicesClientWithBaseURI(baseURI string, subscriptionID string) FileServicesClient {
-	return FileServicesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// GetServiceProperties gets the properties of file services in storage accounts, including CORS (Cross-Origin Resource
-// Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client FileServicesClient) GetServiceProperties(ctx context.Context, resourceGroupName string, accountName string) (result FileServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileServicesClient.GetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileServicesClient", "GetServiceProperties", err.Error())
-	}
-
-	req, err := client.GetServicePropertiesPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "GetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "GetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "GetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetServicePropertiesPreparer prepares the GetServiceProperties request.
-func (client FileServicesClient) GetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"FileServicesName":  autorest.Encode("path", "default"),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/{FileServicesName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetServicePropertiesSender sends the GetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileServicesClient) GetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetServicePropertiesResponder handles the response to the GetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client FileServicesClient) GetServicePropertiesResponder(resp *http.Response) (result FileServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List list all file services in storage accounts
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client FileServicesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result FileServiceItems, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileServicesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileServicesClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client FileServicesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileServicesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client FileServicesClient) ListResponder(resp *http.Response) (result FileServiceItems, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// SetServiceProperties sets the properties of file services in storage accounts, including CORS (Cross-Origin Resource
-// Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the properties of file services in storage accounts, including CORS (Cross-Origin Resource
-// Sharing) rules.
-func (client FileServicesClient) SetServiceProperties(ctx context.Context, resourceGroupName string, accountName string, parameters FileServiceProperties) (result FileServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileServicesClient.SetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: parameters,
-			Constraints: []validation.Constraint{{Target: "parameters.FileServicePropertiesProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "parameters.FileServicePropertiesProperties.ShareDeleteRetentionPolicy", Name: validation.Null, Rule: false,
-					Chain: []validation.Constraint{{Target: "parameters.FileServicePropertiesProperties.ShareDeleteRetentionPolicy.Days", Name: validation.Null, Rule: false,
-						Chain: []validation.Constraint{{Target: "parameters.FileServicePropertiesProperties.ShareDeleteRetentionPolicy.Days", Name: validation.InclusiveMaximum, Rule: int64(365), Chain: nil},
-							{Target: "parameters.FileServicePropertiesProperties.ShareDeleteRetentionPolicy.Days", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
-						}},
-					}},
-				}}}}}); err != nil {
-		return result, validation.NewError("storage.FileServicesClient", "SetServiceProperties", err.Error())
-	}
-
-	req, err := client.SetServicePropertiesPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "SetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.SetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "SetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.SetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileServicesClient", "SetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// SetServicePropertiesPreparer prepares the SetServiceProperties request.
-func (client FileServicesClient) SetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters FileServiceProperties) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"FileServicesName":  autorest.Encode("path", "default"),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	parameters.Sku = nil
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/{FileServicesName}", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileServicesClient) SetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client FileServicesClient) SetServicePropertiesResponder(resp *http.Response) (result FileServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileshares.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileshares.go
deleted file mode 100644
index 6ccc4bfb14f1..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/fileshares.go
+++ /dev/null
@@ -1,703 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// FileSharesClient is the the Azure Storage Management API.
-type FileSharesClient struct {
-	BaseClient
-}
-
-// NewFileSharesClient creates an instance of the FileSharesClient client.
-func NewFileSharesClient(subscriptionID string) FileSharesClient {
-	return NewFileSharesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewFileSharesClientWithBaseURI creates an instance of the FileSharesClient client using a custom endpoint.  Use this
-// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewFileSharesClientWithBaseURI(baseURI string, subscriptionID string) FileSharesClient {
-	return FileSharesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// Create creates a new share under the specified account as described by request body. The share resource includes
-// metadata and properties for that share. It does not include a list of the files contained by the share.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// shareName - the name of the file share within the specified storage account. File share names must be
-// between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every dash (-)
-// character must be immediately preceded and followed by a letter or number.
-// fileShare - properties of the file share to create.
-// expand - optional, used to create a snapshot.
-func (client FileSharesClient) Create(ctx context.Context, resourceGroupName string, accountName string, shareName string, fileShare FileShare, expand PutSharesExpand) (result FileShare, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.Create")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: shareName,
-			Constraints: []validation.Constraint{{Target: "shareName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "shareName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: fileShare,
-			Constraints: []validation.Constraint{{Target: "fileShare.FileShareProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "fileShare.FileShareProperties.ShareQuota", Name: validation.Null, Rule: false,
-					Chain: []validation.Constraint{{Target: "fileShare.FileShareProperties.ShareQuota", Name: validation.InclusiveMaximum, Rule: int64(102400), Chain: nil},
-						{Target: "fileShare.FileShareProperties.ShareQuota", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
-					}},
-				}}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileSharesClient", "Create", err.Error())
-	}
-
-	req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, shareName, fileShare, expand)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Create", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Create", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Create", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreatePreparer prepares the Create request.
-func (client FileSharesClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, shareName string, fileShare FileShare, expand PutSharesExpand) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"shareName":         autorest.Encode("path", shareName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(string(expand)) > 0 {
-		queryParameters["$expand"] = autorest.Encode("query", expand)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/default/shares/{shareName}", pathParameters),
-		autorest.WithJSON(fileShare),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateSender sends the Create request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileSharesClient) CreateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateResponder handles the response to the Create request. The method always
-// closes the http.Response Body.
-func (client FileSharesClient) CreateResponder(resp *http.Response) (result FileShare, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes specified share under its account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// shareName - the name of the file share within the specified storage account. File share names must be
-// between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every dash (-)
-// character must be immediately preceded and followed by a letter or number.
-// xMsSnapshot - optional, used to delete a snapshot.
-func (client FileSharesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, shareName string, xMsSnapshot string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: shareName,
-			Constraints: []validation.Constraint{{Target: "shareName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "shareName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileSharesClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, shareName, xMsSnapshot)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client FileSharesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, shareName string, xMsSnapshot string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"shareName":         autorest.Encode("path", shareName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/default/shares/{shareName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	if len(xMsSnapshot) > 0 {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithHeader("x-ms-snapshot", autorest.String(xMsSnapshot)))
-	}
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileSharesClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client FileSharesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get gets properties of a specified share.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// shareName - the name of the file share within the specified storage account. File share names must be
-// between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every dash (-)
-// character must be immediately preceded and followed by a letter or number.
-// expand - optional, used to expand the properties within share's properties.
-// xMsSnapshot - optional, used to retrieve properties of a snapshot.
-func (client FileSharesClient) Get(ctx context.Context, resourceGroupName string, accountName string, shareName string, expand GetShareExpand, xMsSnapshot string) (result FileShare, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: shareName,
-			Constraints: []validation.Constraint{{Target: "shareName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "shareName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileSharesClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, shareName, expand, xMsSnapshot)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client FileSharesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, shareName string, expand GetShareExpand, xMsSnapshot string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"shareName":         autorest.Encode("path", shareName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(string(expand)) > 0 {
-		queryParameters["$expand"] = autorest.Encode("query", expand)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/default/shares/{shareName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	if len(xMsSnapshot) > 0 {
-		preparer = autorest.DecoratePreparer(preparer,
-			autorest.WithHeader("x-ms-snapshot", autorest.String(xMsSnapshot)))
-	}
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileSharesClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client FileSharesClient) GetResponder(resp *http.Response) (result FileShare, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List lists all shares.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// maxpagesize - optional. Specified maximum number of shares that can be included in the list.
-// filter - optional. When specified, only share names starting with the filter will be listed.
-// expand - optional, used to expand the properties within share's properties.
-func (client FileSharesClient) List(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string, expand ListSharesExpand) (result FileShareItemsPage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.List")
-		defer func() {
-			sc := -1
-			if result.fsi.Response.Response != nil {
-				sc = result.fsi.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileSharesClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName, maxpagesize, filter, expand)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.fsi.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.fsi, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.fsi.hasNextLink() && result.fsi.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client FileSharesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string, expand ListSharesExpand) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(maxpagesize) > 0 {
-		queryParameters["$maxpagesize"] = autorest.Encode("query", maxpagesize)
-	}
-	if len(filter) > 0 {
-		queryParameters["$filter"] = autorest.Encode("query", filter)
-	}
-	if len(string(expand)) > 0 {
-		queryParameters["$expand"] = autorest.Encode("query", expand)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/default/shares", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileSharesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client FileSharesClient) ListResponder(resp *http.Response) (result FileShareItems, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client FileSharesClient) listNextResults(ctx context.Context, lastResults FileShareItems) (result FileShareItems, err error) {
-	req, err := lastResults.fileShareItemsPreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.FileSharesClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.FileSharesClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client FileSharesClient) ListComplete(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string, expand ListSharesExpand) (result FileShareItemsIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx, resourceGroupName, accountName, maxpagesize, filter, expand)
-	return
-}
-
-// Restore restore a file share within a valid retention days if share soft delete is enabled
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// shareName - the name of the file share within the specified storage account. File share names must be
-// between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every dash (-)
-// character must be immediately preceded and followed by a letter or number.
-func (client FileSharesClient) Restore(ctx context.Context, resourceGroupName string, accountName string, shareName string, deletedShare DeletedShare) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.Restore")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: shareName,
-			Constraints: []validation.Constraint{{Target: "shareName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "shareName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: deletedShare,
-			Constraints: []validation.Constraint{{Target: "deletedShare.DeletedShareName", Name: validation.Null, Rule: true, Chain: nil},
-				{Target: "deletedShare.DeletedShareVersion", Name: validation.Null, Rule: true, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileSharesClient", "Restore", err.Error())
-	}
-
-	req, err := client.RestorePreparer(ctx, resourceGroupName, accountName, shareName, deletedShare)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Restore", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.RestoreSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Restore", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.RestoreResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Restore", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// RestorePreparer prepares the Restore request.
-func (client FileSharesClient) RestorePreparer(ctx context.Context, resourceGroupName string, accountName string, shareName string, deletedShare DeletedShare) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"shareName":         autorest.Encode("path", shareName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPost(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/default/shares/{shareName}/restore", pathParameters),
-		autorest.WithJSON(deletedShare),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// RestoreSender sends the Restore request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileSharesClient) RestoreSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// RestoreResponder handles the response to the Restore request. The method always
-// closes the http.Response Body.
-func (client FileSharesClient) RestoreResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Update updates share properties as specified in request body. Properties not mentioned in the request will not be
-// changed. Update fails if the specified share does not already exist.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// shareName - the name of the file share within the specified storage account. File share names must be
-// between 3 and 63 characters in length and use numbers, lower-case letters and dash (-) only. Every dash (-)
-// character must be immediately preceded and followed by a letter or number.
-// fileShare - properties to update for the file share.
-func (client FileSharesClient) Update(ctx context.Context, resourceGroupName string, accountName string, shareName string, fileShare FileShare) (result FileShare, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileSharesClient.Update")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: shareName,
-			Constraints: []validation.Constraint{{Target: "shareName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "shareName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.FileSharesClient", "Update", err.Error())
-	}
-
-	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, shareName, fileShare)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Update", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.UpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Update", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.UpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.FileSharesClient", "Update", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// UpdatePreparer prepares the Update request.
-func (client FileSharesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, shareName string, fileShare FileShare) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"shareName":         autorest.Encode("path", shareName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPatch(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/fileServices/default/shares/{shareName}", pathParameters),
-		autorest.WithJSON(fileShare),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// UpdateSender sends the Update request. The method will close the
-// http.Response Body if it receives an error.
-func (client FileSharesClient) UpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// UpdateResponder handles the response to the Update request. The method always
-// closes the http.Response Body.
-func (client FileSharesClient) UpdateResponder(resp *http.Response) (result FileShare, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/managementpolicies.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/managementpolicies.go
deleted file mode 100644
index 77e126a8a379..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/managementpolicies.go
+++ /dev/null
@@ -1,316 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// ManagementPoliciesClient is the the Azure Storage Management API.
-type ManagementPoliciesClient struct {
-	BaseClient
-}
-
-// NewManagementPoliciesClient creates an instance of the ManagementPoliciesClient client.
-func NewManagementPoliciesClient(subscriptionID string) ManagementPoliciesClient {
-	return NewManagementPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewManagementPoliciesClientWithBaseURI creates an instance of the ManagementPoliciesClient client using a custom
-// endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
-// stack).
-func NewManagementPoliciesClientWithBaseURI(baseURI string, subscriptionID string) ManagementPoliciesClient {
-	return ManagementPoliciesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// CreateOrUpdate sets the managementpolicy to the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// properties - the ManagementPolicy set to a storage account.
-func (client ManagementPoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, properties ManagementPolicy) (result ManagementPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementPoliciesClient.CreateOrUpdate")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: properties,
-			Constraints: []validation.Constraint{{Target: "properties.ManagementPolicyProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "properties.ManagementPolicyProperties.Policy", Name: validation.Null, Rule: true,
-					Chain: []validation.Constraint{{Target: "properties.ManagementPolicyProperties.Policy.Rules", Name: validation.Null, Rule: true, Chain: nil}}},
-				}}}}}); err != nil {
-		return result, validation.NewError("storage.ManagementPoliciesClient", "CreateOrUpdate", err.Error())
-	}
-
-	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, properties)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "CreateOrUpdate", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateOrUpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "CreateOrUpdate", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateOrUpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "CreateOrUpdate", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
-func (client ManagementPoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, properties ManagementPolicy) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":          autorest.Encode("path", accountName),
-		"managementPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
-		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/managementPolicies/{managementPolicyName}", pathParameters),
-		autorest.WithJSON(properties),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
-// http.Response Body if it receives an error.
-func (client ManagementPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
-// closes the http.Response Body.
-func (client ManagementPoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result ManagementPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes the managementpolicy associated with the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client ManagementPoliciesClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementPoliciesClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.ManagementPoliciesClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client ManagementPoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":          autorest.Encode("path", accountName),
-		"managementPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
-		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/managementPolicies/{managementPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client ManagementPoliciesClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client ManagementPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get gets the managementpolicy associated with the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client ManagementPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result ManagementPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementPoliciesClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.ManagementPoliciesClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ManagementPoliciesClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client ManagementPoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":          autorest.Encode("path", accountName),
-		"managementPolicyName": autorest.Encode("path", "default"),
-		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
-		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/managementPolicies/{managementPolicyName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client ManagementPoliciesClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client ManagementPoliciesClient) GetResponder(resp *http.Response) (result ManagementPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/models.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/models.go
deleted file mode 100644
index 1a7663011e13..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/models.go
+++ /dev/null
@@ -1,5140 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"encoding/json"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/date"
-	"github.com/Azure/go-autorest/autorest/to"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// The package's fully qualified name.
-const fqdn = "github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage"
-
-// Account the storage account.
-type Account struct {
-	autorest.Response `json:"-"`
-	// Sku - READ-ONLY; Gets the SKU.
-	Sku *Sku `json:"sku,omitempty"`
-	// Kind - READ-ONLY; Gets the Kind. Possible values include: 'KindStorage', 'KindStorageV2', 'KindBlobStorage', 'KindFileStorage', 'KindBlockBlobStorage'
-	Kind Kind `json:"kind,omitempty"`
-	// Identity - The identity of the resource.
-	Identity *Identity `json:"identity,omitempty"`
-	// ExtendedLocation - The extendedLocation of the resource.
-	ExtendedLocation *ExtendedLocation `json:"extendedLocation,omitempty"`
-	// AccountProperties - Properties of the storage account.
-	*AccountProperties `json:"properties,omitempty"`
-	// Tags - Resource tags.
-	Tags map[string]*string `json:"tags"`
-	// Location - The geo-location where the resource lives
-	Location *string `json:"location,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Account.
-func (a Account) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if a.Identity != nil {
-		objectMap["identity"] = a.Identity
-	}
-	if a.ExtendedLocation != nil {
-		objectMap["extendedLocation"] = a.ExtendedLocation
-	}
-	if a.AccountProperties != nil {
-		objectMap["properties"] = a.AccountProperties
-	}
-	if a.Tags != nil {
-		objectMap["tags"] = a.Tags
-	}
-	if a.Location != nil {
-		objectMap["location"] = a.Location
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for Account struct.
-func (a *Account) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "sku":
-			if v != nil {
-				var sku Sku
-				err = json.Unmarshal(*v, &sku)
-				if err != nil {
-					return err
-				}
-				a.Sku = &sku
-			}
-		case "kind":
-			if v != nil {
-				var kind Kind
-				err = json.Unmarshal(*v, &kind)
-				if err != nil {
-					return err
-				}
-				a.Kind = kind
-			}
-		case "identity":
-			if v != nil {
-				var identity Identity
-				err = json.Unmarshal(*v, &identity)
-				if err != nil {
-					return err
-				}
-				a.Identity = &identity
-			}
-		case "extendedLocation":
-			if v != nil {
-				var extendedLocation ExtendedLocation
-				err = json.Unmarshal(*v, &extendedLocation)
-				if err != nil {
-					return err
-				}
-				a.ExtendedLocation = &extendedLocation
-			}
-		case "properties":
-			if v != nil {
-				var accountProperties AccountProperties
-				err = json.Unmarshal(*v, &accountProperties)
-				if err != nil {
-					return err
-				}
-				a.AccountProperties = &accountProperties
-			}
-		case "tags":
-			if v != nil {
-				var tags map[string]*string
-				err = json.Unmarshal(*v, &tags)
-				if err != nil {
-					return err
-				}
-				a.Tags = tags
-			}
-		case "location":
-			if v != nil {
-				var location string
-				err = json.Unmarshal(*v, &location)
-				if err != nil {
-					return err
-				}
-				a.Location = &location
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				a.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				a.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				a.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// AccountCheckNameAvailabilityParameters the parameters used to check the availability of the storage
-// account name.
-type AccountCheckNameAvailabilityParameters struct {
-	// Name - The storage account name.
-	Name *string `json:"name,omitempty"`
-	// Type - The type of resource, Microsoft.Storage/storageAccounts
-	Type *string `json:"type,omitempty"`
-}
-
-// AccountCreateParameters the parameters used when creating a storage account.
-type AccountCreateParameters struct {
-	// Sku - Required. Gets or sets the SKU name.
-	Sku *Sku `json:"sku,omitempty"`
-	// Kind - Required. Indicates the type of storage account. Possible values include: 'KindStorage', 'KindStorageV2', 'KindBlobStorage', 'KindFileStorage', 'KindBlockBlobStorage'
-	Kind Kind `json:"kind,omitempty"`
-	// Location - Required. Gets or sets the location of the resource. This will be one of the supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.). The geo region of a resource cannot be changed once it is created, but if an identical geo region is specified on update, the request will succeed.
-	Location *string `json:"location,omitempty"`
-	// ExtendedLocation - Optional. Set the extended location of the resource. If not set, the storage account will be created in Azure main region. Otherwise it will be created in the specified extended location
-	ExtendedLocation *ExtendedLocation `json:"extendedLocation,omitempty"`
-	// Tags - Gets or sets a list of key value pairs that describe the resource. These tags can be used for viewing and grouping this resource (across resource groups). A maximum of 15 tags can be provided for a resource. Each tag must have a key with a length no greater than 128 characters and a value with a length no greater than 256 characters.
-	Tags map[string]*string `json:"tags"`
-	// Identity - The identity of the resource.
-	Identity *Identity `json:"identity,omitempty"`
-	// AccountPropertiesCreateParameters - The parameters used to create the storage account.
-	*AccountPropertiesCreateParameters `json:"properties,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountCreateParameters.
-func (acp AccountCreateParameters) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if acp.Sku != nil {
-		objectMap["sku"] = acp.Sku
-	}
-	if acp.Kind != "" {
-		objectMap["kind"] = acp.Kind
-	}
-	if acp.Location != nil {
-		objectMap["location"] = acp.Location
-	}
-	if acp.ExtendedLocation != nil {
-		objectMap["extendedLocation"] = acp.ExtendedLocation
-	}
-	if acp.Tags != nil {
-		objectMap["tags"] = acp.Tags
-	}
-	if acp.Identity != nil {
-		objectMap["identity"] = acp.Identity
-	}
-	if acp.AccountPropertiesCreateParameters != nil {
-		objectMap["properties"] = acp.AccountPropertiesCreateParameters
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for AccountCreateParameters struct.
-func (acp *AccountCreateParameters) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "sku":
-			if v != nil {
-				var sku Sku
-				err = json.Unmarshal(*v, &sku)
-				if err != nil {
-					return err
-				}
-				acp.Sku = &sku
-			}
-		case "kind":
-			if v != nil {
-				var kind Kind
-				err = json.Unmarshal(*v, &kind)
-				if err != nil {
-					return err
-				}
-				acp.Kind = kind
-			}
-		case "location":
-			if v != nil {
-				var location string
-				err = json.Unmarshal(*v, &location)
-				if err != nil {
-					return err
-				}
-				acp.Location = &location
-			}
-		case "extendedLocation":
-			if v != nil {
-				var extendedLocation ExtendedLocation
-				err = json.Unmarshal(*v, &extendedLocation)
-				if err != nil {
-					return err
-				}
-				acp.ExtendedLocation = &extendedLocation
-			}
-		case "tags":
-			if v != nil {
-				var tags map[string]*string
-				err = json.Unmarshal(*v, &tags)
-				if err != nil {
-					return err
-				}
-				acp.Tags = tags
-			}
-		case "identity":
-			if v != nil {
-				var identity Identity
-				err = json.Unmarshal(*v, &identity)
-				if err != nil {
-					return err
-				}
-				acp.Identity = &identity
-			}
-		case "properties":
-			if v != nil {
-				var accountPropertiesCreateParameters AccountPropertiesCreateParameters
-				err = json.Unmarshal(*v, &accountPropertiesCreateParameters)
-				if err != nil {
-					return err
-				}
-				acp.AccountPropertiesCreateParameters = &accountPropertiesCreateParameters
-			}
-		}
-	}
-
-	return nil
-}
-
-// AccountInternetEndpoints the URIs that are used to perform a retrieval of a public blob, file, web or
-// dfs object via a internet routing endpoint.
-type AccountInternetEndpoints struct {
-	// Blob - READ-ONLY; Gets the blob endpoint.
-	Blob *string `json:"blob,omitempty"`
-	// File - READ-ONLY; Gets the file endpoint.
-	File *string `json:"file,omitempty"`
-	// Web - READ-ONLY; Gets the web endpoint.
-	Web *string `json:"web,omitempty"`
-	// Dfs - READ-ONLY; Gets the dfs endpoint.
-	Dfs *string `json:"dfs,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountInternetEndpoints.
-func (aie AccountInternetEndpoints) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// AccountKey an access key for the storage account.
-type AccountKey struct {
-	// KeyName - READ-ONLY; Name of the key.
-	KeyName *string `json:"keyName,omitempty"`
-	// Value - READ-ONLY; Base 64-encoded value of the key.
-	Value *string `json:"value,omitempty"`
-	// Permissions - READ-ONLY; Permissions for the key -- read-only or full permissions. Possible values include: 'KeyPermissionRead', 'KeyPermissionFull'
-	Permissions KeyPermission `json:"permissions,omitempty"`
-	// CreationTime - READ-ONLY; Creation time of the key, in round trip date format.
-	CreationTime *date.Time `json:"creationTime,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountKey.
-func (ak AccountKey) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// AccountListKeysResult the response from the ListKeys operation.
-type AccountListKeysResult struct {
-	autorest.Response `json:"-"`
-	// Keys - READ-ONLY; Gets the list of storage account keys and their properties for the specified storage account.
-	Keys *[]AccountKey `json:"keys,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountListKeysResult.
-func (alkr AccountListKeysResult) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// AccountListResult the response from the List Storage Accounts operation.
-type AccountListResult struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; Gets the list of storage accounts and their properties.
-	Value *[]Account `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to query next page of storage accounts. Returned when total number of requested storage accounts exceed maximum page size.
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountListResult.
-func (alr AccountListResult) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// AccountListResultIterator provides access to a complete listing of Account values.
-type AccountListResultIterator struct {
-	i    int
-	page AccountListResultPage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *AccountListResultIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountListResultIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *AccountListResultIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter AccountListResultIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter AccountListResultIterator) Response() AccountListResult {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter AccountListResultIterator) Value() Account {
-	if !iter.page.NotDone() {
-		return Account{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the AccountListResultIterator type.
-func NewAccountListResultIterator(page AccountListResultPage) AccountListResultIterator {
-	return AccountListResultIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (alr AccountListResult) IsEmpty() bool {
-	return alr.Value == nil || len(*alr.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (alr AccountListResult) hasNextLink() bool {
-	return alr.NextLink != nil && len(*alr.NextLink) != 0
-}
-
-// accountListResultPreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (alr AccountListResult) accountListResultPreparer(ctx context.Context) (*http.Request, error) {
-	if !alr.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(alr.NextLink)))
-}
-
-// AccountListResultPage contains a page of Account values.
-type AccountListResultPage struct {
-	fn  func(context.Context, AccountListResult) (AccountListResult, error)
-	alr AccountListResult
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *AccountListResultPage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/AccountListResultPage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.alr)
-		if err != nil {
-			return err
-		}
-		page.alr = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *AccountListResultPage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page AccountListResultPage) NotDone() bool {
-	return !page.alr.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page AccountListResultPage) Response() AccountListResult {
-	return page.alr
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page AccountListResultPage) Values() []Account {
-	if page.alr.IsEmpty() {
-		return nil
-	}
-	return *page.alr.Value
-}
-
-// Creates a new instance of the AccountListResultPage type.
-func NewAccountListResultPage(cur AccountListResult, getNextPage func(context.Context, AccountListResult) (AccountListResult, error)) AccountListResultPage {
-	return AccountListResultPage{
-		fn:  getNextPage,
-		alr: cur,
-	}
-}
-
-// AccountMicrosoftEndpoints the URIs that are used to perform a retrieval of a public blob, queue, table,
-// web or dfs object via a microsoft routing endpoint.
-type AccountMicrosoftEndpoints struct {
-	// Blob - READ-ONLY; Gets the blob endpoint.
-	Blob *string `json:"blob,omitempty"`
-	// Queue - READ-ONLY; Gets the queue endpoint.
-	Queue *string `json:"queue,omitempty"`
-	// Table - READ-ONLY; Gets the table endpoint.
-	Table *string `json:"table,omitempty"`
-	// File - READ-ONLY; Gets the file endpoint.
-	File *string `json:"file,omitempty"`
-	// Web - READ-ONLY; Gets the web endpoint.
-	Web *string `json:"web,omitempty"`
-	// Dfs - READ-ONLY; Gets the dfs endpoint.
-	Dfs *string `json:"dfs,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountMicrosoftEndpoints.
-func (ame AccountMicrosoftEndpoints) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// AccountProperties properties of the storage account.
-type AccountProperties struct {
-	// ProvisioningState - READ-ONLY; Gets the status of the storage account at the time the operation was called. Possible values include: 'ProvisioningStateCreating', 'ProvisioningStateResolvingDNS', 'ProvisioningStateSucceeded'
-	ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
-	// PrimaryEndpoints - READ-ONLY; Gets the URLs that are used to perform a retrieval of a public blob, queue, or table object. Note that Standard_ZRS and Premium_LRS accounts only return the blob endpoint.
-	PrimaryEndpoints *Endpoints `json:"primaryEndpoints,omitempty"`
-	// PrimaryLocation - READ-ONLY; Gets the location of the primary data center for the storage account.
-	PrimaryLocation *string `json:"primaryLocation,omitempty"`
-	// StatusOfPrimary - READ-ONLY; Gets the status indicating whether the primary location of the storage account is available or unavailable. Possible values include: 'AccountStatusAvailable', 'AccountStatusUnavailable'
-	StatusOfPrimary AccountStatus `json:"statusOfPrimary,omitempty"`
-	// LastGeoFailoverTime - READ-ONLY; Gets the timestamp of the most recent instance of a failover to the secondary location. Only the most recent timestamp is retained. This element is not returned if there has never been a failover instance. Only available if the accountType is Standard_GRS or Standard_RAGRS.
-	LastGeoFailoverTime *date.Time `json:"lastGeoFailoverTime,omitempty"`
-	// SecondaryLocation - READ-ONLY; Gets the location of the geo-replicated secondary for the storage account. Only available if the accountType is Standard_GRS or Standard_RAGRS.
-	SecondaryLocation *string `json:"secondaryLocation,omitempty"`
-	// StatusOfSecondary - READ-ONLY; Gets the status indicating whether the secondary location of the storage account is available or unavailable. Only available if the SKU name is Standard_GRS or Standard_RAGRS. Possible values include: 'AccountStatusAvailable', 'AccountStatusUnavailable'
-	StatusOfSecondary AccountStatus `json:"statusOfSecondary,omitempty"`
-	// CreationTime - READ-ONLY; Gets the creation date and time of the storage account in UTC.
-	CreationTime *date.Time `json:"creationTime,omitempty"`
-	// CustomDomain - READ-ONLY; Gets the custom domain the user assigned to this storage account.
-	CustomDomain *CustomDomain `json:"customDomain,omitempty"`
-	// SasPolicy - READ-ONLY; SasPolicy assigned to the storage account.
-	SasPolicy *SasPolicy `json:"sasPolicy,omitempty"`
-	// KeyPolicy - READ-ONLY; KeyPolicy assigned to the storage account.
-	KeyPolicy *KeyPolicy `json:"keyPolicy,omitempty"`
-	// KeyCreationTime - READ-ONLY; Storage account keys creation time.
-	KeyCreationTime *KeyCreationTime `json:"keyCreationTime,omitempty"`
-	// SecondaryEndpoints - READ-ONLY; Gets the URLs that are used to perform a retrieval of a public blob, queue, or table object from the secondary location of the storage account. Only available if the SKU name is Standard_RAGRS.
-	SecondaryEndpoints *Endpoints `json:"secondaryEndpoints,omitempty"`
-	// Encryption - READ-ONLY; Gets the encryption settings on the account. If unspecified, the account is unencrypted.
-	Encryption *Encryption `json:"encryption,omitempty"`
-	// AccessTier - READ-ONLY; Required for storage accounts where kind = BlobStorage. The access tier used for billing. Possible values include: 'AccessTierHot', 'AccessTierCool'
-	AccessTier AccessTier `json:"accessTier,omitempty"`
-	// AzureFilesIdentityBasedAuthentication - Provides the identity based authentication settings for Azure Files.
-	AzureFilesIdentityBasedAuthentication *AzureFilesIdentityBasedAuthentication `json:"azureFilesIdentityBasedAuthentication,omitempty"`
-	// EnableHTTPSTrafficOnly - Allows https traffic only to storage service if sets to true.
-	EnableHTTPSTrafficOnly *bool `json:"supportsHttpsTrafficOnly,omitempty"`
-	// NetworkRuleSet - READ-ONLY; Network rule set
-	NetworkRuleSet *NetworkRuleSet `json:"networkAcls,omitempty"`
-	// IsHnsEnabled - Account HierarchicalNamespace enabled if sets to true.
-	IsHnsEnabled *bool `json:"isHnsEnabled,omitempty"`
-	// GeoReplicationStats - READ-ONLY; Geo Replication Stats
-	GeoReplicationStats *GeoReplicationStats `json:"geoReplicationStats,omitempty"`
-	// FailoverInProgress - READ-ONLY; If the failover is in progress, the value will be true, otherwise, it will be null.
-	FailoverInProgress *bool `json:"failoverInProgress,omitempty"`
-	// LargeFileSharesState - Allow large file shares if sets to Enabled. It cannot be disabled once it is enabled. Possible values include: 'LargeFileSharesStateDisabled', 'LargeFileSharesStateEnabled'
-	LargeFileSharesState LargeFileSharesState `json:"largeFileSharesState,omitempty"`
-	// PrivateEndpointConnections - READ-ONLY; List of private endpoint connection associated with the specified storage account
-	PrivateEndpointConnections *[]PrivateEndpointConnection `json:"privateEndpointConnections,omitempty"`
-	// RoutingPreference - Maintains information about the network routing choice opted by the user for data transfer
-	RoutingPreference *RoutingPreference `json:"routingPreference,omitempty"`
-	// BlobRestoreStatus - READ-ONLY; Blob restore status
-	BlobRestoreStatus *BlobRestoreStatus `json:"blobRestoreStatus,omitempty"`
-	// AllowBlobPublicAccess - Allow or disallow public access to all blobs or containers in the storage account. The default interpretation is true for this property.
-	AllowBlobPublicAccess *bool `json:"allowBlobPublicAccess,omitempty"`
-	// MinimumTLSVersion - Set the minimum TLS version to be permitted on requests to storage. The default interpretation is TLS 1.0 for this property. Possible values include: 'MinimumTLSVersionTLS10', 'MinimumTLSVersionTLS11', 'MinimumTLSVersionTLS12'
-	MinimumTLSVersion MinimumTLSVersion `json:"minimumTlsVersion,omitempty"`
-	// AllowSharedKeyAccess - Indicates whether the storage account permits requests to be authorized with the account access key via Shared Key. If false, then all requests, including shared access signatures, must be authorized with Azure Active Directory (Azure AD). The default value is null, which is equivalent to true.
-	AllowSharedKeyAccess *bool `json:"allowSharedKeyAccess,omitempty"`
-	// EnableNfsV3 - NFS 3.0 protocol support enabled if set to true.
-	EnableNfsV3 *bool `json:"isNfsV3Enabled,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountProperties.
-func (ap AccountProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if ap.AzureFilesIdentityBasedAuthentication != nil {
-		objectMap["azureFilesIdentityBasedAuthentication"] = ap.AzureFilesIdentityBasedAuthentication
-	}
-	if ap.EnableHTTPSTrafficOnly != nil {
-		objectMap["supportsHttpsTrafficOnly"] = ap.EnableHTTPSTrafficOnly
-	}
-	if ap.IsHnsEnabled != nil {
-		objectMap["isHnsEnabled"] = ap.IsHnsEnabled
-	}
-	if ap.LargeFileSharesState != "" {
-		objectMap["largeFileSharesState"] = ap.LargeFileSharesState
-	}
-	if ap.RoutingPreference != nil {
-		objectMap["routingPreference"] = ap.RoutingPreference
-	}
-	if ap.AllowBlobPublicAccess != nil {
-		objectMap["allowBlobPublicAccess"] = ap.AllowBlobPublicAccess
-	}
-	if ap.MinimumTLSVersion != "" {
-		objectMap["minimumTlsVersion"] = ap.MinimumTLSVersion
-	}
-	if ap.AllowSharedKeyAccess != nil {
-		objectMap["allowSharedKeyAccess"] = ap.AllowSharedKeyAccess
-	}
-	if ap.EnableNfsV3 != nil {
-		objectMap["isNfsV3Enabled"] = ap.EnableNfsV3
-	}
-	return json.Marshal(objectMap)
-}
-
-// AccountPropertiesCreateParameters the parameters used to create the storage account.
-type AccountPropertiesCreateParameters struct {
-	// SasPolicy - SasPolicy assigned to the storage account.
-	SasPolicy *SasPolicy `json:"sasPolicy,omitempty"`
-	// KeyPolicy - KeyPolicy assigned to the storage account.
-	KeyPolicy *KeyPolicy `json:"keyPolicy,omitempty"`
-	// CustomDomain - User domain assigned to the storage account. Name is the CNAME source. Only one custom domain is supported per storage account at this time. To clear the existing custom domain, use an empty string for the custom domain name property.
-	CustomDomain *CustomDomain `json:"customDomain,omitempty"`
-	// Encryption - Not applicable. Azure Storage encryption is enabled for all storage accounts and cannot be disabled.
-	Encryption *Encryption `json:"encryption,omitempty"`
-	// NetworkRuleSet - Network rule set
-	NetworkRuleSet *NetworkRuleSet `json:"networkAcls,omitempty"`
-	// AccessTier - Required for storage accounts where kind = BlobStorage. The access tier used for billing. Possible values include: 'AccessTierHot', 'AccessTierCool'
-	AccessTier AccessTier `json:"accessTier,omitempty"`
-	// AzureFilesIdentityBasedAuthentication - Provides the identity based authentication settings for Azure Files.
-	AzureFilesIdentityBasedAuthentication *AzureFilesIdentityBasedAuthentication `json:"azureFilesIdentityBasedAuthentication,omitempty"`
-	// EnableHTTPSTrafficOnly - Allows https traffic only to storage service if sets to true. The default value is true since API version 2019-04-01.
-	EnableHTTPSTrafficOnly *bool `json:"supportsHttpsTrafficOnly,omitempty"`
-	// IsHnsEnabled - Account HierarchicalNamespace enabled if sets to true.
-	IsHnsEnabled *bool `json:"isHnsEnabled,omitempty"`
-	// LargeFileSharesState - Allow large file shares if sets to Enabled. It cannot be disabled once it is enabled. Possible values include: 'LargeFileSharesStateDisabled', 'LargeFileSharesStateEnabled'
-	LargeFileSharesState LargeFileSharesState `json:"largeFileSharesState,omitempty"`
-	// RoutingPreference - Maintains information about the network routing choice opted by the user for data transfer
-	RoutingPreference *RoutingPreference `json:"routingPreference,omitempty"`
-	// AllowBlobPublicAccess - Allow or disallow public access to all blobs or containers in the storage account. The default interpretation is true for this property.
-	AllowBlobPublicAccess *bool `json:"allowBlobPublicAccess,omitempty"`
-	// MinimumTLSVersion - Set the minimum TLS version to be permitted on requests to storage. The default interpretation is TLS 1.0 for this property. Possible values include: 'MinimumTLSVersionTLS10', 'MinimumTLSVersionTLS11', 'MinimumTLSVersionTLS12'
-	MinimumTLSVersion MinimumTLSVersion `json:"minimumTlsVersion,omitempty"`
-	// AllowSharedKeyAccess - Indicates whether the storage account permits requests to be authorized with the account access key via Shared Key. If false, then all requests, including shared access signatures, must be authorized with Azure Active Directory (Azure AD). The default value is null, which is equivalent to true.
-	AllowSharedKeyAccess *bool `json:"allowSharedKeyAccess,omitempty"`
-	// EnableNfsV3 - NFS 3.0 protocol support enabled if set to true.
-	EnableNfsV3 *bool `json:"isNfsV3Enabled,omitempty"`
-}
-
-// AccountPropertiesUpdateParameters the parameters used when updating a storage account.
-type AccountPropertiesUpdateParameters struct {
-	// CustomDomain - Custom domain assigned to the storage account by the user. Name is the CNAME source. Only one custom domain is supported per storage account at this time. To clear the existing custom domain, use an empty string for the custom domain name property.
-	CustomDomain *CustomDomain `json:"customDomain,omitempty"`
-	// Encryption - Provides the encryption settings on the account. The default setting is unencrypted.
-	Encryption *Encryption `json:"encryption,omitempty"`
-	// SasPolicy - SasPolicy assigned to the storage account.
-	SasPolicy *SasPolicy `json:"sasPolicy,omitempty"`
-	// KeyPolicy - KeyPolicy assigned to the storage account.
-	KeyPolicy *KeyPolicy `json:"keyPolicy,omitempty"`
-	// AccessTier - Required for storage accounts where kind = BlobStorage. The access tier used for billing. Possible values include: 'AccessTierHot', 'AccessTierCool'
-	AccessTier AccessTier `json:"accessTier,omitempty"`
-	// AzureFilesIdentityBasedAuthentication - Provides the identity based authentication settings for Azure Files.
-	AzureFilesIdentityBasedAuthentication *AzureFilesIdentityBasedAuthentication `json:"azureFilesIdentityBasedAuthentication,omitempty"`
-	// EnableHTTPSTrafficOnly - Allows https traffic only to storage service if sets to true.
-	EnableHTTPSTrafficOnly *bool `json:"supportsHttpsTrafficOnly,omitempty"`
-	// NetworkRuleSet - Network rule set
-	NetworkRuleSet *NetworkRuleSet `json:"networkAcls,omitempty"`
-	// LargeFileSharesState - Allow large file shares if sets to Enabled. It cannot be disabled once it is enabled. Possible values include: 'LargeFileSharesStateDisabled', 'LargeFileSharesStateEnabled'
-	LargeFileSharesState LargeFileSharesState `json:"largeFileSharesState,omitempty"`
-	// RoutingPreference - Maintains information about the network routing choice opted by the user for data transfer
-	RoutingPreference *RoutingPreference `json:"routingPreference,omitempty"`
-	// AllowBlobPublicAccess - Allow or disallow public access to all blobs or containers in the storage account. The default interpretation is true for this property.
-	AllowBlobPublicAccess *bool `json:"allowBlobPublicAccess,omitempty"`
-	// MinimumTLSVersion - Set the minimum TLS version to be permitted on requests to storage. The default interpretation is TLS 1.0 for this property. Possible values include: 'MinimumTLSVersionTLS10', 'MinimumTLSVersionTLS11', 'MinimumTLSVersionTLS12'
-	MinimumTLSVersion MinimumTLSVersion `json:"minimumTlsVersion,omitempty"`
-	// AllowSharedKeyAccess - Indicates whether the storage account permits requests to be authorized with the account access key via Shared Key. If false, then all requests, including shared access signatures, must be authorized with Azure Active Directory (Azure AD). The default value is null, which is equivalent to true.
-	AllowSharedKeyAccess *bool `json:"allowSharedKeyAccess,omitempty"`
-}
-
-// AccountRegenerateKeyParameters the parameters used to regenerate the storage account key.
-type AccountRegenerateKeyParameters struct {
-	// KeyName - The name of storage keys that want to be regenerated, possible values are key1, key2, kerb1, kerb2.
-	KeyName *string `json:"keyName,omitempty"`
-}
-
-// AccountSasParameters the parameters to list SAS credentials of a storage account.
-type AccountSasParameters struct {
-	// Services - The signed services accessible with the account SAS. Possible values include: Blob (b), Queue (q), Table (t), File (f). Possible values include: 'ServicesB', 'ServicesQ', 'ServicesT', 'ServicesF'
-	Services Services `json:"signedServices,omitempty"`
-	// ResourceTypes - The signed resource types that are accessible with the account SAS. Service (s): Access to service-level APIs; Container (c): Access to container-level APIs; Object (o): Access to object-level APIs for blobs, queue messages, table entities, and files. Possible values include: 'SignedResourceTypesS', 'SignedResourceTypesC', 'SignedResourceTypesO'
-	ResourceTypes SignedResourceTypes `json:"signedResourceTypes,omitempty"`
-	// Permissions - The signed permissions for the account SAS. Possible values include: Read (r), Write (w), Delete (d), List (l), Add (a), Create (c), Update (u) and Process (p). Possible values include: 'PermissionsR', 'PermissionsD', 'PermissionsW', 'PermissionsL', 'PermissionsA', 'PermissionsC', 'PermissionsU', 'PermissionsP'
-	Permissions Permissions `json:"signedPermission,omitempty"`
-	// IPAddressOrRange - An IP address or a range of IP addresses from which to accept requests.
-	IPAddressOrRange *string `json:"signedIp,omitempty"`
-	// Protocols - The protocol permitted for a request made with the account SAS. Possible values include: 'HTTPProtocolHttpshttp', 'HTTPProtocolHTTPS'
-	Protocols HTTPProtocol `json:"signedProtocol,omitempty"`
-	// SharedAccessStartTime - The time at which the SAS becomes valid.
-	SharedAccessStartTime *date.Time `json:"signedStart,omitempty"`
-	// SharedAccessExpiryTime - The time at which the shared access signature becomes invalid.
-	SharedAccessExpiryTime *date.Time `json:"signedExpiry,omitempty"`
-	// KeyToSign - The key to sign the account SAS token with.
-	KeyToSign *string `json:"keyToSign,omitempty"`
-}
-
-// AccountsCreateFuture an abstraction for monitoring and retrieving the results of a long-running
-// operation.
-type AccountsCreateFuture struct {
-	azure.FutureAPI
-	// Result returns the result of the asynchronous operation.
-	// If the operation has not completed it will return an error.
-	Result func(AccountsClient) (Account, error)
-}
-
-// UnmarshalJSON is the custom unmarshaller for CreateFuture.
-func (future *AccountsCreateFuture) UnmarshalJSON(body []byte) error {
-	var azFuture azure.Future
-	if err := json.Unmarshal(body, &azFuture); err != nil {
-		return err
-	}
-	future.FutureAPI = &azFuture
-	future.Result = future.result
-	return nil
-}
-
-// result is the default implementation for AccountsCreateFuture.Result.
-func (future *AccountsCreateFuture) result(client AccountsClient) (a Account, err error) {
-	var done bool
-	done, err = future.DoneWithContext(context.Background(), client)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsCreateFuture", "Result", future.Response(), "Polling failure")
-		return
-	}
-	if !done {
-		a.Response.Response = future.Response()
-		err = azure.NewAsyncOpIncompleteError("storage.AccountsCreateFuture")
-		return
-	}
-	sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
-	if a.Response.Response, err = future.GetResult(sender); err == nil && a.Response.Response.StatusCode != http.StatusNoContent {
-		a, err = client.CreateResponder(a.Response.Response)
-		if err != nil {
-			err = autorest.NewErrorWithError(err, "storage.AccountsCreateFuture", "Result", a.Response.Response, "Failure responding to request")
-		}
-	}
-	return
-}
-
-// AccountsFailoverFuture an abstraction for monitoring and retrieving the results of a long-running
-// operation.
-type AccountsFailoverFuture struct {
-	azure.FutureAPI
-	// Result returns the result of the asynchronous operation.
-	// If the operation has not completed it will return an error.
-	Result func(AccountsClient) (autorest.Response, error)
-}
-
-// UnmarshalJSON is the custom unmarshaller for CreateFuture.
-func (future *AccountsFailoverFuture) UnmarshalJSON(body []byte) error {
-	var azFuture azure.Future
-	if err := json.Unmarshal(body, &azFuture); err != nil {
-		return err
-	}
-	future.FutureAPI = &azFuture
-	future.Result = future.result
-	return nil
-}
-
-// result is the default implementation for AccountsFailoverFuture.Result.
-func (future *AccountsFailoverFuture) result(client AccountsClient) (ar autorest.Response, err error) {
-	var done bool
-	done, err = future.DoneWithContext(context.Background(), client)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsFailoverFuture", "Result", future.Response(), "Polling failure")
-		return
-	}
-	if !done {
-		ar.Response = future.Response()
-		err = azure.NewAsyncOpIncompleteError("storage.AccountsFailoverFuture")
-		return
-	}
-	ar.Response = future.Response()
-	return
-}
-
-// AccountsRestoreBlobRangesFuture an abstraction for monitoring and retrieving the results of a
-// long-running operation.
-type AccountsRestoreBlobRangesFuture struct {
-	azure.FutureAPI
-	// Result returns the result of the asynchronous operation.
-	// If the operation has not completed it will return an error.
-	Result func(AccountsClient) (BlobRestoreStatus, error)
-}
-
-// UnmarshalJSON is the custom unmarshaller for CreateFuture.
-func (future *AccountsRestoreBlobRangesFuture) UnmarshalJSON(body []byte) error {
-	var azFuture azure.Future
-	if err := json.Unmarshal(body, &azFuture); err != nil {
-		return err
-	}
-	future.FutureAPI = &azFuture
-	future.Result = future.result
-	return nil
-}
-
-// result is the default implementation for AccountsRestoreBlobRangesFuture.Result.
-func (future *AccountsRestoreBlobRangesFuture) result(client AccountsClient) (brs BlobRestoreStatus, err error) {
-	var done bool
-	done, err = future.DoneWithContext(context.Background(), client)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.AccountsRestoreBlobRangesFuture", "Result", future.Response(), "Polling failure")
-		return
-	}
-	if !done {
-		brs.Response.Response = future.Response()
-		err = azure.NewAsyncOpIncompleteError("storage.AccountsRestoreBlobRangesFuture")
-		return
-	}
-	sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
-	if brs.Response.Response, err = future.GetResult(sender); err == nil && brs.Response.Response.StatusCode != http.StatusNoContent {
-		brs, err = client.RestoreBlobRangesResponder(brs.Response.Response)
-		if err != nil {
-			err = autorest.NewErrorWithError(err, "storage.AccountsRestoreBlobRangesFuture", "Result", brs.Response.Response, "Failure responding to request")
-		}
-	}
-	return
-}
-
-// AccountUpdateParameters the parameters that can be provided when updating the storage account
-// properties.
-type AccountUpdateParameters struct {
-	// Sku - Gets or sets the SKU name. Note that the SKU name cannot be updated to Standard_ZRS, Premium_LRS or Premium_ZRS, nor can accounts of those SKU names be updated to any other value.
-	Sku *Sku `json:"sku,omitempty"`
-	// Tags - Gets or sets a list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups). A maximum of 15 tags can be provided for a resource. Each tag must have a key no greater in length than 128 characters and a value no greater in length than 256 characters.
-	Tags map[string]*string `json:"tags"`
-	// Identity - The identity of the resource.
-	Identity *Identity `json:"identity,omitempty"`
-	// AccountPropertiesUpdateParameters - The parameters used when updating a storage account.
-	*AccountPropertiesUpdateParameters `json:"properties,omitempty"`
-	// Kind - Optional. Indicates the type of storage account. Currently only StorageV2 value supported by server. Possible values include: 'KindStorage', 'KindStorageV2', 'KindBlobStorage', 'KindFileStorage', 'KindBlockBlobStorage'
-	Kind Kind `json:"kind,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AccountUpdateParameters.
-func (aup AccountUpdateParameters) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if aup.Sku != nil {
-		objectMap["sku"] = aup.Sku
-	}
-	if aup.Tags != nil {
-		objectMap["tags"] = aup.Tags
-	}
-	if aup.Identity != nil {
-		objectMap["identity"] = aup.Identity
-	}
-	if aup.AccountPropertiesUpdateParameters != nil {
-		objectMap["properties"] = aup.AccountPropertiesUpdateParameters
-	}
-	if aup.Kind != "" {
-		objectMap["kind"] = aup.Kind
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for AccountUpdateParameters struct.
-func (aup *AccountUpdateParameters) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "sku":
-			if v != nil {
-				var sku Sku
-				err = json.Unmarshal(*v, &sku)
-				if err != nil {
-					return err
-				}
-				aup.Sku = &sku
-			}
-		case "tags":
-			if v != nil {
-				var tags map[string]*string
-				err = json.Unmarshal(*v, &tags)
-				if err != nil {
-					return err
-				}
-				aup.Tags = tags
-			}
-		case "identity":
-			if v != nil {
-				var identity Identity
-				err = json.Unmarshal(*v, &identity)
-				if err != nil {
-					return err
-				}
-				aup.Identity = &identity
-			}
-		case "properties":
-			if v != nil {
-				var accountPropertiesUpdateParameters AccountPropertiesUpdateParameters
-				err = json.Unmarshal(*v, &accountPropertiesUpdateParameters)
-				if err != nil {
-					return err
-				}
-				aup.AccountPropertiesUpdateParameters = &accountPropertiesUpdateParameters
-			}
-		case "kind":
-			if v != nil {
-				var kind Kind
-				err = json.Unmarshal(*v, &kind)
-				if err != nil {
-					return err
-				}
-				aup.Kind = kind
-			}
-		}
-	}
-
-	return nil
-}
-
-// ActiveDirectoryProperties settings properties for Active Directory (AD).
-type ActiveDirectoryProperties struct {
-	// DomainName - Specifies the primary domain that the AD DNS server is authoritative for.
-	DomainName *string `json:"domainName,omitempty"`
-	// NetBiosDomainName - Specifies the NetBIOS domain name.
-	NetBiosDomainName *string `json:"netBiosDomainName,omitempty"`
-	// ForestName - Specifies the Active Directory forest to get.
-	ForestName *string `json:"forestName,omitempty"`
-	// DomainGUID - Specifies the domain GUID.
-	DomainGUID *string `json:"domainGuid,omitempty"`
-	// DomainSid - Specifies the security identifier (SID).
-	DomainSid *string `json:"domainSid,omitempty"`
-	// AzureStorageSid - Specifies the security identifier (SID) for Azure Storage.
-	AzureStorageSid *string `json:"azureStorageSid,omitempty"`
-}
-
-// AzureEntityResource the resource model definition for an Azure Resource Manager resource with an etag.
-type AzureEntityResource struct {
-	// Etag - READ-ONLY; Resource Etag.
-	Etag *string `json:"etag,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for AzureEntityResource.
-func (aer AzureEntityResource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// AzureFilesIdentityBasedAuthentication settings for Azure Files identity based authentication.
-type AzureFilesIdentityBasedAuthentication struct {
-	// DirectoryServiceOptions - Indicates the directory service used. Possible values include: 'DirectoryServiceOptionsNone', 'DirectoryServiceOptionsAADDS', 'DirectoryServiceOptionsAD'
-	DirectoryServiceOptions DirectoryServiceOptions `json:"directoryServiceOptions,omitempty"`
-	// ActiveDirectoryProperties - Required if choose AD.
-	ActiveDirectoryProperties *ActiveDirectoryProperties `json:"activeDirectoryProperties,omitempty"`
-}
-
-// BlobContainer properties of the blob container, including Id, resource name, resource type, Etag.
-type BlobContainer struct {
-	autorest.Response `json:"-"`
-	// ContainerProperties - Properties of the blob container.
-	*ContainerProperties `json:"properties,omitempty"`
-	// Etag - READ-ONLY; Resource Etag.
-	Etag *string `json:"etag,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for BlobContainer.
-func (bc BlobContainer) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if bc.ContainerProperties != nil {
-		objectMap["properties"] = bc.ContainerProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for BlobContainer struct.
-func (bc *BlobContainer) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var containerProperties ContainerProperties
-				err = json.Unmarshal(*v, &containerProperties)
-				if err != nil {
-					return err
-				}
-				bc.ContainerProperties = &containerProperties
-			}
-		case "etag":
-			if v != nil {
-				var etag string
-				err = json.Unmarshal(*v, &etag)
-				if err != nil {
-					return err
-				}
-				bc.Etag = &etag
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				bc.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				bc.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				bc.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// BlobInventoryPolicy the storage account blob inventory policy.
-type BlobInventoryPolicy struct {
-	autorest.Response `json:"-"`
-	// BlobInventoryPolicyProperties - Returns the storage account blob inventory policy rules.
-	*BlobInventoryPolicyProperties `json:"properties,omitempty"`
-	SystemData                     *SystemData `json:"systemData,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for BlobInventoryPolicy.
-func (bip BlobInventoryPolicy) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if bip.BlobInventoryPolicyProperties != nil {
-		objectMap["properties"] = bip.BlobInventoryPolicyProperties
-	}
-	if bip.SystemData != nil {
-		objectMap["systemData"] = bip.SystemData
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for BlobInventoryPolicy struct.
-func (bip *BlobInventoryPolicy) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var blobInventoryPolicyProperties BlobInventoryPolicyProperties
-				err = json.Unmarshal(*v, &blobInventoryPolicyProperties)
-				if err != nil {
-					return err
-				}
-				bip.BlobInventoryPolicyProperties = &blobInventoryPolicyProperties
-			}
-		case "systemData":
-			if v != nil {
-				var systemData SystemData
-				err = json.Unmarshal(*v, &systemData)
-				if err != nil {
-					return err
-				}
-				bip.SystemData = &systemData
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				bip.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				bip.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				bip.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// BlobInventoryPolicyDefinition an object that defines the blob inventory rule. Each definition consists
-// of a set of filters.
-type BlobInventoryPolicyDefinition struct {
-	// Filters - An object that defines the filter set.
-	Filters *BlobInventoryPolicyFilter `json:"filters,omitempty"`
-}
-
-// BlobInventoryPolicyFilter an object that defines the blob inventory rule filter conditions.
-type BlobInventoryPolicyFilter struct {
-	// PrefixMatch - An array of strings for blob prefixes to be matched.
-	PrefixMatch *[]string `json:"prefixMatch,omitempty"`
-	// BlobTypes - An array of predefined enum values. Valid values include blockBlob, appendBlob, pageBlob. Hns accounts does not support pageBlobs.
-	BlobTypes *[]string `json:"blobTypes,omitempty"`
-	// IncludeBlobVersions - Includes blob versions in blob inventory when value set to true.
-	IncludeBlobVersions *bool `json:"includeBlobVersions,omitempty"`
-	// IncludeSnapshots - Includes blob snapshots in blob inventory when value set to true.
-	IncludeSnapshots *bool `json:"includeSnapshots,omitempty"`
-}
-
-// BlobInventoryPolicyProperties the storage account blob inventory policy properties.
-type BlobInventoryPolicyProperties struct {
-	// LastModifiedTime - READ-ONLY; Returns the last modified date and time of the blob inventory policy.
-	LastModifiedTime *date.Time `json:"lastModifiedTime,omitempty"`
-	// Policy - The storage account blob inventory policy object. It is composed of policy rules.
-	Policy *BlobInventoryPolicySchema `json:"policy,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for BlobInventoryPolicyProperties.
-func (bipp BlobInventoryPolicyProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if bipp.Policy != nil {
-		objectMap["policy"] = bipp.Policy
-	}
-	return json.Marshal(objectMap)
-}
-
-// BlobInventoryPolicyRule an object that wraps the blob inventory rule. Each rule is uniquely defined by
-// name.
-type BlobInventoryPolicyRule struct {
-	// Enabled - Rule is enabled when set to true.
-	Enabled *bool `json:"enabled,omitempty"`
-	// Name - A rule name can contain any combination of alpha numeric characters. Rule name is case-sensitive. It must be unique within a policy.
-	Name *string `json:"name,omitempty"`
-	// Definition - An object that defines the blob inventory policy rule.
-	Definition *BlobInventoryPolicyDefinition `json:"definition,omitempty"`
-}
-
-// BlobInventoryPolicySchema the storage account blob inventory policy rules.
-type BlobInventoryPolicySchema struct {
-	// Enabled - Policy is enabled if set to true.
-	Enabled *bool `json:"enabled,omitempty"`
-	// Destination - Container name where blob inventory files are stored. Must be pre-created.
-	Destination *string `json:"destination,omitempty"`
-	// Type - The valid value is Inventory
-	Type *string `json:"type,omitempty"`
-	// Rules - The storage account blob inventory policy rules. The rule is applied when it is enabled.
-	Rules *[]BlobInventoryPolicyRule `json:"rules,omitempty"`
-}
-
-// BlobRestoreParameters blob restore parameters
-type BlobRestoreParameters struct {
-	// TimeToRestore - Restore blob to the specified time.
-	TimeToRestore *date.Time `json:"timeToRestore,omitempty"`
-	// BlobRanges - Blob ranges to restore.
-	BlobRanges *[]BlobRestoreRange `json:"blobRanges,omitempty"`
-}
-
-// BlobRestoreRange blob range
-type BlobRestoreRange struct {
-	// StartRange - Blob start range. This is inclusive. Empty means account start.
-	StartRange *string `json:"startRange,omitempty"`
-	// EndRange - Blob end range. This is exclusive. Empty means account end.
-	EndRange *string `json:"endRange,omitempty"`
-}
-
-// BlobRestoreStatus blob restore status.
-type BlobRestoreStatus struct {
-	autorest.Response `json:"-"`
-	// Status - READ-ONLY; The status of blob restore progress. Possible values are: - InProgress: Indicates that blob restore is ongoing. - Complete: Indicates that blob restore has been completed successfully. - Failed: Indicates that blob restore is failed. Possible values include: 'BlobRestoreProgressStatusInProgress', 'BlobRestoreProgressStatusComplete', 'BlobRestoreProgressStatusFailed'
-	Status BlobRestoreProgressStatus `json:"status,omitempty"`
-	// FailureReason - READ-ONLY; Failure reason when blob restore is failed.
-	FailureReason *string `json:"failureReason,omitempty"`
-	// RestoreID - READ-ONLY; Id for tracking blob restore request.
-	RestoreID *string `json:"restoreId,omitempty"`
-	// Parameters - READ-ONLY; Blob restore request parameters.
-	Parameters *BlobRestoreParameters `json:"parameters,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for BlobRestoreStatus.
-func (brs BlobRestoreStatus) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// BlobServiceItems ...
-type BlobServiceItems struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of blob services returned.
-	Value *[]BlobServiceProperties `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for BlobServiceItems.
-func (bsi BlobServiceItems) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// BlobServiceProperties the properties of a storage account’s Blob service.
-type BlobServiceProperties struct {
-	autorest.Response `json:"-"`
-	// BlobServicePropertiesProperties - The properties of a storage account’s Blob service.
-	*BlobServicePropertiesProperties `json:"properties,omitempty"`
-	// Sku - READ-ONLY; Sku name and tier.
-	Sku *Sku `json:"sku,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for BlobServiceProperties.
-func (bsp BlobServiceProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if bsp.BlobServicePropertiesProperties != nil {
-		objectMap["properties"] = bsp.BlobServicePropertiesProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for BlobServiceProperties struct.
-func (bsp *BlobServiceProperties) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var blobServiceProperties BlobServicePropertiesProperties
-				err = json.Unmarshal(*v, &blobServiceProperties)
-				if err != nil {
-					return err
-				}
-				bsp.BlobServicePropertiesProperties = &blobServiceProperties
-			}
-		case "sku":
-			if v != nil {
-				var sku Sku
-				err = json.Unmarshal(*v, &sku)
-				if err != nil {
-					return err
-				}
-				bsp.Sku = &sku
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				bsp.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				bsp.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				bsp.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// BlobServicePropertiesProperties the properties of a storage account’s Blob service.
-type BlobServicePropertiesProperties struct {
-	// Cors - Specifies CORS rules for the Blob service. You can include up to five CorsRule elements in the request. If no CorsRule elements are included in the request body, all CORS rules will be deleted, and CORS will be disabled for the Blob service.
-	Cors *CorsRules `json:"cors,omitempty"`
-	// DefaultServiceVersion - DefaultServiceVersion indicates the default version to use for requests to the Blob service if an incoming request’s version is not specified. Possible values include version 2008-10-27 and all more recent versions.
-	DefaultServiceVersion *string `json:"defaultServiceVersion,omitempty"`
-	// DeleteRetentionPolicy - The blob service properties for blob soft delete.
-	DeleteRetentionPolicy *DeleteRetentionPolicy `json:"deleteRetentionPolicy,omitempty"`
-	// IsVersioningEnabled - Versioning is enabled if set to true.
-	IsVersioningEnabled *bool `json:"isVersioningEnabled,omitempty"`
-	// AutomaticSnapshotPolicyEnabled - Deprecated in favor of isVersioningEnabled property.
-	AutomaticSnapshotPolicyEnabled *bool `json:"automaticSnapshotPolicyEnabled,omitempty"`
-	// ChangeFeed - The blob service properties for change feed events.
-	ChangeFeed *ChangeFeed `json:"changeFeed,omitempty"`
-	// RestorePolicy - The blob service properties for blob restore policy.
-	RestorePolicy *RestorePolicyProperties `json:"restorePolicy,omitempty"`
-	// ContainerDeleteRetentionPolicy - The blob service properties for container soft delete.
-	ContainerDeleteRetentionPolicy *DeleteRetentionPolicy `json:"containerDeleteRetentionPolicy,omitempty"`
-	// LastAccessTimeTrackingPolicy - The blob service property to configure last access time based tracking policy.
-	LastAccessTimeTrackingPolicy *LastAccessTimeTrackingPolicy `json:"lastAccessTimeTrackingPolicy,omitempty"`
-}
-
-// ChangeFeed the blob service properties for change feed events.
-type ChangeFeed struct {
-	// Enabled - Indicates whether change feed event logging is enabled for the Blob service.
-	Enabled *bool `json:"enabled,omitempty"`
-	// RetentionInDays - Indicates the duration of changeFeed retention in days. Minimum value is 1 day and maximum value is 146000 days (400 years). A null value indicates an infinite retention of the change feed.
-	RetentionInDays *int32 `json:"retentionInDays,omitempty"`
-}
-
-// CheckNameAvailabilityResult the CheckNameAvailability operation response.
-type CheckNameAvailabilityResult struct {
-	autorest.Response `json:"-"`
-	// NameAvailable - READ-ONLY; Gets a boolean value that indicates whether the name is available for you to use. If true, the name is available. If false, the name has already been taken or is invalid and cannot be used.
-	NameAvailable *bool `json:"nameAvailable,omitempty"`
-	// Reason - READ-ONLY; Gets the reason that a storage account name could not be used. The Reason element is only returned if NameAvailable is false. Possible values include: 'ReasonAccountNameInvalid', 'ReasonAlreadyExists'
-	Reason Reason `json:"reason,omitempty"`
-	// Message - READ-ONLY; Gets an error message explaining the Reason value in more detail.
-	Message *string `json:"message,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for CheckNameAvailabilityResult.
-func (cnar CheckNameAvailabilityResult) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// CloudError an error response from the Storage service.
-type CloudError struct {
-	Error *CloudErrorBody `json:"error,omitempty"`
-}
-
-// CloudErrorBody an error response from the Storage service.
-type CloudErrorBody struct {
-	// Code - An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
-	Code *string `json:"code,omitempty"`
-	// Message - A message describing the error, intended to be suitable for display in a user interface.
-	Message *string `json:"message,omitempty"`
-	// Target - The target of the particular error. For example, the name of the property in error.
-	Target *string `json:"target,omitempty"`
-	// Details - A list of additional details about the error.
-	Details *[]CloudErrorBody `json:"details,omitempty"`
-}
-
-// ContainerProperties the properties of a container.
-type ContainerProperties struct {
-	// Version - READ-ONLY; The version of the deleted blob container.
-	Version *string `json:"version,omitempty"`
-	// Deleted - READ-ONLY; Indicates whether the blob container was deleted.
-	Deleted *bool `json:"deleted,omitempty"`
-	// DeletedTime - READ-ONLY; Blob container deletion time.
-	DeletedTime *date.Time `json:"deletedTime,omitempty"`
-	// RemainingRetentionDays - READ-ONLY; Remaining retention days for soft deleted blob container.
-	RemainingRetentionDays *int32 `json:"remainingRetentionDays,omitempty"`
-	// DefaultEncryptionScope - Default the container to use specified encryption scope for all writes.
-	DefaultEncryptionScope *string `json:"defaultEncryptionScope,omitempty"`
-	// DenyEncryptionScopeOverride - Block override of encryption scope from the container default.
-	DenyEncryptionScopeOverride *bool `json:"denyEncryptionScopeOverride,omitempty"`
-	// PublicAccess - Specifies whether data in the container may be accessed publicly and the level of access. Possible values include: 'PublicAccessContainer', 'PublicAccessBlob', 'PublicAccessNone'
-	PublicAccess PublicAccess `json:"publicAccess,omitempty"`
-	// LastModifiedTime - READ-ONLY; Returns the date and time the container was last modified.
-	LastModifiedTime *date.Time `json:"lastModifiedTime,omitempty"`
-	// LeaseStatus - READ-ONLY; The lease status of the container. Possible values include: 'LeaseStatusLocked', 'LeaseStatusUnlocked'
-	LeaseStatus LeaseStatus `json:"leaseStatus,omitempty"`
-	// LeaseState - READ-ONLY; Lease state of the container. Possible values include: 'LeaseStateAvailable', 'LeaseStateLeased', 'LeaseStateExpired', 'LeaseStateBreaking', 'LeaseStateBroken'
-	LeaseState LeaseState `json:"leaseState,omitempty"`
-	// LeaseDuration - READ-ONLY; Specifies whether the lease on a container is of infinite or fixed duration, only when the container is leased. Possible values include: 'LeaseDurationInfinite', 'LeaseDurationFixed'
-	LeaseDuration LeaseDuration `json:"leaseDuration,omitempty"`
-	// Metadata - A name-value pair to associate with the container as metadata.
-	Metadata map[string]*string `json:"metadata"`
-	// ImmutabilityPolicy - READ-ONLY; The ImmutabilityPolicy property of the container.
-	ImmutabilityPolicy *ImmutabilityPolicyProperties `json:"immutabilityPolicy,omitempty"`
-	// LegalHold - READ-ONLY; The LegalHold property of the container.
-	LegalHold *LegalHoldProperties `json:"legalHold,omitempty"`
-	// HasLegalHold - READ-ONLY; The hasLegalHold public property is set to true by SRP if there are at least one existing tag. The hasLegalHold public property is set to false by SRP if all existing legal hold tags are cleared out. There can be a maximum of 1000 blob containers with hasLegalHold=true for a given account.
-	HasLegalHold *bool `json:"hasLegalHold,omitempty"`
-	// HasImmutabilityPolicy - READ-ONLY; The hasImmutabilityPolicy public property is set to true by SRP if ImmutabilityPolicy has been created for this container. The hasImmutabilityPolicy public property is set to false by SRP if ImmutabilityPolicy has not been created for this container.
-	HasImmutabilityPolicy *bool `json:"hasImmutabilityPolicy,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ContainerProperties.
-func (cp ContainerProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if cp.DefaultEncryptionScope != nil {
-		objectMap["defaultEncryptionScope"] = cp.DefaultEncryptionScope
-	}
-	if cp.DenyEncryptionScopeOverride != nil {
-		objectMap["denyEncryptionScopeOverride"] = cp.DenyEncryptionScopeOverride
-	}
-	if cp.PublicAccess != "" {
-		objectMap["publicAccess"] = cp.PublicAccess
-	}
-	if cp.Metadata != nil {
-		objectMap["metadata"] = cp.Metadata
-	}
-	return json.Marshal(objectMap)
-}
-
-// CorsRule specifies a CORS rule for the Blob service.
-type CorsRule struct {
-	// AllowedOrigins - Required if CorsRule element is present. A list of origin domains that will be allowed via CORS, or "*" to allow all domains
-	AllowedOrigins *[]string `json:"allowedOrigins,omitempty"`
-	// AllowedMethods - Required if CorsRule element is present. A list of HTTP methods that are allowed to be executed by the origin.
-	AllowedMethods *[]string `json:"allowedMethods,omitempty"`
-	// MaxAgeInSeconds - Required if CorsRule element is present. The number of seconds that the client/browser should cache a preflight response.
-	MaxAgeInSeconds *int32 `json:"maxAgeInSeconds,omitempty"`
-	// ExposedHeaders - Required if CorsRule element is present. A list of response headers to expose to CORS clients.
-	ExposedHeaders *[]string `json:"exposedHeaders,omitempty"`
-	// AllowedHeaders - Required if CorsRule element is present. A list of headers allowed to be part of the cross-origin request.
-	AllowedHeaders *[]string `json:"allowedHeaders,omitempty"`
-}
-
-// CorsRules sets the CORS rules. You can include up to five CorsRule elements in the request.
-type CorsRules struct {
-	// CorsRules - The List of CORS rules. You can include up to five CorsRule elements in the request.
-	CorsRules *[]CorsRule `json:"corsRules,omitempty"`
-}
-
-// CustomDomain the custom domain assigned to this storage account. This can be set via Update.
-type CustomDomain struct {
-	// Name - Gets or sets the custom domain name assigned to the storage account. Name is the CNAME source.
-	Name *string `json:"name,omitempty"`
-	// UseSubDomainName - Indicates whether indirect CName validation is enabled. Default value is false. This should only be set on updates.
-	UseSubDomainName *bool `json:"useSubDomainName,omitempty"`
-}
-
-// DateAfterCreation object to define the number of days after creation.
-type DateAfterCreation struct {
-	// DaysAfterCreationGreaterThan - Value indicating the age in days after creation
-	DaysAfterCreationGreaterThan *float64 `json:"daysAfterCreationGreaterThan,omitempty"`
-}
-
-// DateAfterModification object to define the number of days after object last modification Or last access.
-// Properties daysAfterModificationGreaterThan and daysAfterLastAccessTimeGreaterThan are mutually
-// exclusive.
-type DateAfterModification struct {
-	// DaysAfterModificationGreaterThan - Value indicating the age in days after last modification
-	DaysAfterModificationGreaterThan *float64 `json:"daysAfterModificationGreaterThan,omitempty"`
-	// DaysAfterLastAccessTimeGreaterThan - Value indicating the age in days after last blob access. This property can only be used in conjunction with last access time tracking policy
-	DaysAfterLastAccessTimeGreaterThan *float64 `json:"daysAfterLastAccessTimeGreaterThan,omitempty"`
-}
-
-// DeletedAccount deleted storage account
-type DeletedAccount struct {
-	autorest.Response `json:"-"`
-	// DeletedAccountProperties - Properties of the deleted account.
-	*DeletedAccountProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for DeletedAccount.
-func (da DeletedAccount) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if da.DeletedAccountProperties != nil {
-		objectMap["properties"] = da.DeletedAccountProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for DeletedAccount struct.
-func (da *DeletedAccount) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var deletedAccountProperties DeletedAccountProperties
-				err = json.Unmarshal(*v, &deletedAccountProperties)
-				if err != nil {
-					return err
-				}
-				da.DeletedAccountProperties = &deletedAccountProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				da.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				da.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				da.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// DeletedAccountListResult the response from the List Deleted Accounts operation.
-type DeletedAccountListResult struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; Gets the list of deleted accounts and their properties.
-	Value *[]DeletedAccount `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to query next page of deleted accounts. Returned when total number of requested deleted accounts exceed maximum page size.
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for DeletedAccountListResult.
-func (dalr DeletedAccountListResult) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// DeletedAccountListResultIterator provides access to a complete listing of DeletedAccount values.
-type DeletedAccountListResultIterator struct {
-	i    int
-	page DeletedAccountListResultPage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *DeletedAccountListResultIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/DeletedAccountListResultIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *DeletedAccountListResultIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter DeletedAccountListResultIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter DeletedAccountListResultIterator) Response() DeletedAccountListResult {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter DeletedAccountListResultIterator) Value() DeletedAccount {
-	if !iter.page.NotDone() {
-		return DeletedAccount{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the DeletedAccountListResultIterator type.
-func NewDeletedAccountListResultIterator(page DeletedAccountListResultPage) DeletedAccountListResultIterator {
-	return DeletedAccountListResultIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (dalr DeletedAccountListResult) IsEmpty() bool {
-	return dalr.Value == nil || len(*dalr.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (dalr DeletedAccountListResult) hasNextLink() bool {
-	return dalr.NextLink != nil && len(*dalr.NextLink) != 0
-}
-
-// deletedAccountListResultPreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (dalr DeletedAccountListResult) deletedAccountListResultPreparer(ctx context.Context) (*http.Request, error) {
-	if !dalr.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(dalr.NextLink)))
-}
-
-// DeletedAccountListResultPage contains a page of DeletedAccount values.
-type DeletedAccountListResultPage struct {
-	fn   func(context.Context, DeletedAccountListResult) (DeletedAccountListResult, error)
-	dalr DeletedAccountListResult
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *DeletedAccountListResultPage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/DeletedAccountListResultPage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.dalr)
-		if err != nil {
-			return err
-		}
-		page.dalr = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *DeletedAccountListResultPage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page DeletedAccountListResultPage) NotDone() bool {
-	return !page.dalr.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page DeletedAccountListResultPage) Response() DeletedAccountListResult {
-	return page.dalr
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page DeletedAccountListResultPage) Values() []DeletedAccount {
-	if page.dalr.IsEmpty() {
-		return nil
-	}
-	return *page.dalr.Value
-}
-
-// Creates a new instance of the DeletedAccountListResultPage type.
-func NewDeletedAccountListResultPage(cur DeletedAccountListResult, getNextPage func(context.Context, DeletedAccountListResult) (DeletedAccountListResult, error)) DeletedAccountListResultPage {
-	return DeletedAccountListResultPage{
-		fn:   getNextPage,
-		dalr: cur,
-	}
-}
-
-// DeletedAccountProperties attributes of a deleted storage account.
-type DeletedAccountProperties struct {
-	// StorageAccountResourceID - READ-ONLY; Full resource id of the original storage account.
-	StorageAccountResourceID *string `json:"storageAccountResourceId,omitempty"`
-	// Location - READ-ONLY; Location of the deleted account.
-	Location *string `json:"location,omitempty"`
-	// RestoreReference - READ-ONLY; Can be used to attempt recovering this deleted account via PutStorageAccount API.
-	RestoreReference *string `json:"restoreReference,omitempty"`
-	// CreationTime - READ-ONLY; Creation time of the deleted account.
-	CreationTime *string `json:"creationTime,omitempty"`
-	// DeletionTime - READ-ONLY; Deletion time of the deleted account.
-	DeletionTime *string `json:"deletionTime,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for DeletedAccountProperties.
-func (dap DeletedAccountProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// DeletedShare the deleted share to be restored.
-type DeletedShare struct {
-	// DeletedShareName - Required. Identify the name of the deleted share that will be restored.
-	DeletedShareName *string `json:"deletedShareName,omitempty"`
-	// DeletedShareVersion - Required. Identify the version of the deleted share that will be restored.
-	DeletedShareVersion *string `json:"deletedShareVersion,omitempty"`
-}
-
-// DeleteRetentionPolicy the service properties for soft delete.
-type DeleteRetentionPolicy struct {
-	// Enabled - Indicates whether DeleteRetentionPolicy is enabled.
-	Enabled *bool `json:"enabled,omitempty"`
-	// Days - Indicates the number of days that the deleted item should be retained. The minimum specified value can be 1 and the maximum value can be 365.
-	Days *int32 `json:"days,omitempty"`
-}
-
-// Dimension dimension of blobs, possibly be blob type or access tier.
-type Dimension struct {
-	// Name - Display name of dimension.
-	Name *string `json:"name,omitempty"`
-	// DisplayName - Display name of dimension.
-	DisplayName *string `json:"displayName,omitempty"`
-}
-
-// Encryption the encryption settings on the storage account.
-type Encryption struct {
-	// Services - List of services which support encryption.
-	Services *EncryptionServices `json:"services,omitempty"`
-	// KeySource - The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.Storage, Microsoft.Keyvault. Possible values include: 'KeySourceMicrosoftStorage', 'KeySourceMicrosoftKeyvault'
-	KeySource KeySource `json:"keySource,omitempty"`
-	// RequireInfrastructureEncryption - A boolean indicating whether or not the service applies a secondary layer of encryption with platform managed keys for data at rest.
-	RequireInfrastructureEncryption *bool `json:"requireInfrastructureEncryption,omitempty"`
-	// KeyVaultProperties - Properties provided by key vault.
-	KeyVaultProperties *KeyVaultProperties `json:"keyvaultproperties,omitempty"`
-	// EncryptionIdentity - The identity to be used with service-side encryption at rest.
-	EncryptionIdentity *EncryptionIdentity `json:"identity,omitempty"`
-}
-
-// EncryptionIdentity encryption identity for the storage account.
-type EncryptionIdentity struct {
-	// EncryptionUserAssignedIdentity - Resource identifier of the UserAssigned identity to be associated with server-side encryption on the storage account.
-	EncryptionUserAssignedIdentity *string `json:"userAssignedIdentity,omitempty"`
-}
-
-// EncryptionScope the Encryption Scope resource.
-type EncryptionScope struct {
-	autorest.Response `json:"-"`
-	// EncryptionScopeProperties - Properties of the encryption scope.
-	*EncryptionScopeProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for EncryptionScope.
-func (es EncryptionScope) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if es.EncryptionScopeProperties != nil {
-		objectMap["properties"] = es.EncryptionScopeProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for EncryptionScope struct.
-func (es *EncryptionScope) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var encryptionScopeProperties EncryptionScopeProperties
-				err = json.Unmarshal(*v, &encryptionScopeProperties)
-				if err != nil {
-					return err
-				}
-				es.EncryptionScopeProperties = &encryptionScopeProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				es.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				es.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				es.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// EncryptionScopeKeyVaultProperties the key vault properties for the encryption scope. This is a required
-// field if encryption scope 'source' attribute is set to 'Microsoft.KeyVault'.
-type EncryptionScopeKeyVaultProperties struct {
-	// KeyURI - The object identifier for a key vault key object. When applied, the encryption scope will use the key referenced by the identifier to enable customer-managed key support on this encryption scope.
-	KeyURI *string `json:"keyUri,omitempty"`
-	// CurrentVersionedKeyIdentifier - READ-ONLY; The object identifier of the current versioned Key Vault Key in use.
-	CurrentVersionedKeyIdentifier *string `json:"currentVersionedKeyIdentifier,omitempty"`
-	// LastKeyRotationTimestamp - READ-ONLY; Timestamp of last rotation of the Key Vault Key.
-	LastKeyRotationTimestamp *date.Time `json:"lastKeyRotationTimestamp,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for EncryptionScopeKeyVaultProperties.
-func (eskvp EncryptionScopeKeyVaultProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if eskvp.KeyURI != nil {
-		objectMap["keyUri"] = eskvp.KeyURI
-	}
-	return json.Marshal(objectMap)
-}
-
-// EncryptionScopeListResult list of encryption scopes requested, and if paging is required, a URL to the
-// next page of encryption scopes.
-type EncryptionScopeListResult struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of encryption scopes requested.
-	Value *[]EncryptionScope `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to query next page of encryption scopes. Returned when total number of requested encryption scopes exceeds the maximum page size.
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for EncryptionScopeListResult.
-func (eslr EncryptionScopeListResult) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// EncryptionScopeListResultIterator provides access to a complete listing of EncryptionScope values.
-type EncryptionScopeListResultIterator struct {
-	i    int
-	page EncryptionScopeListResultPage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *EncryptionScopeListResultIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopeListResultIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *EncryptionScopeListResultIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter EncryptionScopeListResultIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter EncryptionScopeListResultIterator) Response() EncryptionScopeListResult {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter EncryptionScopeListResultIterator) Value() EncryptionScope {
-	if !iter.page.NotDone() {
-		return EncryptionScope{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the EncryptionScopeListResultIterator type.
-func NewEncryptionScopeListResultIterator(page EncryptionScopeListResultPage) EncryptionScopeListResultIterator {
-	return EncryptionScopeListResultIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (eslr EncryptionScopeListResult) IsEmpty() bool {
-	return eslr.Value == nil || len(*eslr.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (eslr EncryptionScopeListResult) hasNextLink() bool {
-	return eslr.NextLink != nil && len(*eslr.NextLink) != 0
-}
-
-// encryptionScopeListResultPreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (eslr EncryptionScopeListResult) encryptionScopeListResultPreparer(ctx context.Context) (*http.Request, error) {
-	if !eslr.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(eslr.NextLink)))
-}
-
-// EncryptionScopeListResultPage contains a page of EncryptionScope values.
-type EncryptionScopeListResultPage struct {
-	fn   func(context.Context, EncryptionScopeListResult) (EncryptionScopeListResult, error)
-	eslr EncryptionScopeListResult
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *EncryptionScopeListResultPage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/EncryptionScopeListResultPage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.eslr)
-		if err != nil {
-			return err
-		}
-		page.eslr = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *EncryptionScopeListResultPage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page EncryptionScopeListResultPage) NotDone() bool {
-	return !page.eslr.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page EncryptionScopeListResultPage) Response() EncryptionScopeListResult {
-	return page.eslr
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page EncryptionScopeListResultPage) Values() []EncryptionScope {
-	if page.eslr.IsEmpty() {
-		return nil
-	}
-	return *page.eslr.Value
-}
-
-// Creates a new instance of the EncryptionScopeListResultPage type.
-func NewEncryptionScopeListResultPage(cur EncryptionScopeListResult, getNextPage func(context.Context, EncryptionScopeListResult) (EncryptionScopeListResult, error)) EncryptionScopeListResultPage {
-	return EncryptionScopeListResultPage{
-		fn:   getNextPage,
-		eslr: cur,
-	}
-}
-
-// EncryptionScopeProperties properties of the encryption scope.
-type EncryptionScopeProperties struct {
-	// Source - The provider for the encryption scope. Possible values (case-insensitive):  Microsoft.Storage, Microsoft.KeyVault. Possible values include: 'EncryptionScopeSourceMicrosoftStorage', 'EncryptionScopeSourceMicrosoftKeyVault'
-	Source EncryptionScopeSource `json:"source,omitempty"`
-	// State - The state of the encryption scope. Possible values (case-insensitive):  Enabled, Disabled. Possible values include: 'EncryptionScopeStateEnabled', 'EncryptionScopeStateDisabled'
-	State EncryptionScopeState `json:"state,omitempty"`
-	// CreationTime - READ-ONLY; Gets the creation date and time of the encryption scope in UTC.
-	CreationTime *date.Time `json:"creationTime,omitempty"`
-	// LastModifiedTime - READ-ONLY; Gets the last modification date and time of the encryption scope in UTC.
-	LastModifiedTime *date.Time `json:"lastModifiedTime,omitempty"`
-	// KeyVaultProperties - The key vault properties for the encryption scope. This is a required field if encryption scope 'source' attribute is set to 'Microsoft.KeyVault'.
-	KeyVaultProperties *EncryptionScopeKeyVaultProperties `json:"keyVaultProperties,omitempty"`
-	// RequireInfrastructureEncryption - A boolean indicating whether or not the service applies a secondary layer of encryption with platform managed keys for data at rest.
-	RequireInfrastructureEncryption *bool `json:"requireInfrastructureEncryption,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for EncryptionScopeProperties.
-func (esp EncryptionScopeProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if esp.Source != "" {
-		objectMap["source"] = esp.Source
-	}
-	if esp.State != "" {
-		objectMap["state"] = esp.State
-	}
-	if esp.KeyVaultProperties != nil {
-		objectMap["keyVaultProperties"] = esp.KeyVaultProperties
-	}
-	if esp.RequireInfrastructureEncryption != nil {
-		objectMap["requireInfrastructureEncryption"] = esp.RequireInfrastructureEncryption
-	}
-	return json.Marshal(objectMap)
-}
-
-// EncryptionService a service that allows server-side encryption to be used.
-type EncryptionService struct {
-	// Enabled - A boolean indicating whether or not the service encrypts the data as it is stored.
-	Enabled *bool `json:"enabled,omitempty"`
-	// LastEnabledTime - READ-ONLY; Gets a rough estimate of the date/time when the encryption was last enabled by the user. Only returned when encryption is enabled. There might be some unencrypted blobs which were written after this time, as it is just a rough estimate.
-	LastEnabledTime *date.Time `json:"lastEnabledTime,omitempty"`
-	// KeyType - Encryption key type to be used for the encryption service. 'Account' key type implies that an account-scoped encryption key will be used. 'Service' key type implies that a default service key is used. Possible values include: 'KeyTypeService', 'KeyTypeAccount'
-	KeyType KeyType `json:"keyType,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for EncryptionService.
-func (es EncryptionService) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if es.Enabled != nil {
-		objectMap["enabled"] = es.Enabled
-	}
-	if es.KeyType != "" {
-		objectMap["keyType"] = es.KeyType
-	}
-	return json.Marshal(objectMap)
-}
-
-// EncryptionServices a list of services that support encryption.
-type EncryptionServices struct {
-	// Blob - The encryption function of the blob storage service.
-	Blob *EncryptionService `json:"blob,omitempty"`
-	// File - The encryption function of the file storage service.
-	File *EncryptionService `json:"file,omitempty"`
-	// Table - The encryption function of the table storage service.
-	Table *EncryptionService `json:"table,omitempty"`
-	// Queue - The encryption function of the queue storage service.
-	Queue *EncryptionService `json:"queue,omitempty"`
-}
-
-// Endpoints the URIs that are used to perform a retrieval of a public blob, queue, table, web or dfs
-// object.
-type Endpoints struct {
-	// Blob - READ-ONLY; Gets the blob endpoint.
-	Blob *string `json:"blob,omitempty"`
-	// Queue - READ-ONLY; Gets the queue endpoint.
-	Queue *string `json:"queue,omitempty"`
-	// Table - READ-ONLY; Gets the table endpoint.
-	Table *string `json:"table,omitempty"`
-	// File - READ-ONLY; Gets the file endpoint.
-	File *string `json:"file,omitempty"`
-	// Web - READ-ONLY; Gets the web endpoint.
-	Web *string `json:"web,omitempty"`
-	// Dfs - READ-ONLY; Gets the dfs endpoint.
-	Dfs *string `json:"dfs,omitempty"`
-	// MicrosoftEndpoints - Gets the microsoft routing storage endpoints.
-	MicrosoftEndpoints *AccountMicrosoftEndpoints `json:"microsoftEndpoints,omitempty"`
-	// InternetEndpoints - Gets the internet routing storage endpoints
-	InternetEndpoints *AccountInternetEndpoints `json:"internetEndpoints,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Endpoints.
-func (e Endpoints) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if e.MicrosoftEndpoints != nil {
-		objectMap["microsoftEndpoints"] = e.MicrosoftEndpoints
-	}
-	if e.InternetEndpoints != nil {
-		objectMap["internetEndpoints"] = e.InternetEndpoints
-	}
-	return json.Marshal(objectMap)
-}
-
-// ErrorResponse an error response from the storage resource provider.
-type ErrorResponse struct {
-	// Error - Azure Storage Resource Provider error response body.
-	Error *ErrorResponseBody `json:"error,omitempty"`
-}
-
-// ErrorResponseBody error response body contract.
-type ErrorResponseBody struct {
-	// Code - An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
-	Code *string `json:"code,omitempty"`
-	// Message - A message describing the error, intended to be suitable for display in a user interface.
-	Message *string `json:"message,omitempty"`
-}
-
-// ExtendedLocation the complex type of the extended location.
-type ExtendedLocation struct {
-	// Name - The name of the extended location.
-	Name *string `json:"name,omitempty"`
-	// Type - The type of the extended location. Possible values include: 'ExtendedLocationTypesEdgeZone'
-	Type ExtendedLocationTypes `json:"type,omitempty"`
-}
-
-// FileServiceItems ...
-type FileServiceItems struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of file services returned.
-	Value *[]FileServiceProperties `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for FileServiceItems.
-func (fsi FileServiceItems) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// FileServiceProperties the properties of File services in storage account.
-type FileServiceProperties struct {
-	autorest.Response `json:"-"`
-	// FileServicePropertiesProperties - The properties of File services in storage account.
-	*FileServicePropertiesProperties `json:"properties,omitempty"`
-	// Sku - READ-ONLY; Sku name and tier.
-	Sku *Sku `json:"sku,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for FileServiceProperties.
-func (fsp FileServiceProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if fsp.FileServicePropertiesProperties != nil {
-		objectMap["properties"] = fsp.FileServicePropertiesProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for FileServiceProperties struct.
-func (fsp *FileServiceProperties) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var fileServiceProperties FileServicePropertiesProperties
-				err = json.Unmarshal(*v, &fileServiceProperties)
-				if err != nil {
-					return err
-				}
-				fsp.FileServicePropertiesProperties = &fileServiceProperties
-			}
-		case "sku":
-			if v != nil {
-				var sku Sku
-				err = json.Unmarshal(*v, &sku)
-				if err != nil {
-					return err
-				}
-				fsp.Sku = &sku
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				fsp.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				fsp.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				fsp.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// FileServicePropertiesProperties the properties of File services in storage account.
-type FileServicePropertiesProperties struct {
-	// Cors - Specifies CORS rules for the File service. You can include up to five CorsRule elements in the request. If no CorsRule elements are included in the request body, all CORS rules will be deleted, and CORS will be disabled for the File service.
-	Cors *CorsRules `json:"cors,omitempty"`
-	// ShareDeleteRetentionPolicy - The file service properties for share soft delete.
-	ShareDeleteRetentionPolicy *DeleteRetentionPolicy `json:"shareDeleteRetentionPolicy,omitempty"`
-	// ProtocolSettings - Protocol settings for file service
-	ProtocolSettings *ProtocolSettings `json:"protocolSettings,omitempty"`
-}
-
-// FileShare properties of the file share, including Id, resource name, resource type, Etag.
-type FileShare struct {
-	autorest.Response `json:"-"`
-	// FileShareProperties - Properties of the file share.
-	*FileShareProperties `json:"properties,omitempty"`
-	// Etag - READ-ONLY; Resource Etag.
-	Etag *string `json:"etag,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for FileShare.
-func (fs FileShare) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if fs.FileShareProperties != nil {
-		objectMap["properties"] = fs.FileShareProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for FileShare struct.
-func (fs *FileShare) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var fileShareProperties FileShareProperties
-				err = json.Unmarshal(*v, &fileShareProperties)
-				if err != nil {
-					return err
-				}
-				fs.FileShareProperties = &fileShareProperties
-			}
-		case "etag":
-			if v != nil {
-				var etag string
-				err = json.Unmarshal(*v, &etag)
-				if err != nil {
-					return err
-				}
-				fs.Etag = &etag
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				fs.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				fs.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				fs.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// FileShareItem the file share properties be listed out.
-type FileShareItem struct {
-	// FileShareProperties - The file share properties be listed out.
-	*FileShareProperties `json:"properties,omitempty"`
-	// Etag - READ-ONLY; Resource Etag.
-	Etag *string `json:"etag,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for FileShareItem.
-func (fsi FileShareItem) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if fsi.FileShareProperties != nil {
-		objectMap["properties"] = fsi.FileShareProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for FileShareItem struct.
-func (fsi *FileShareItem) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var fileShareProperties FileShareProperties
-				err = json.Unmarshal(*v, &fileShareProperties)
-				if err != nil {
-					return err
-				}
-				fsi.FileShareProperties = &fileShareProperties
-			}
-		case "etag":
-			if v != nil {
-				var etag string
-				err = json.Unmarshal(*v, &etag)
-				if err != nil {
-					return err
-				}
-				fsi.Etag = &etag
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				fsi.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				fsi.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				fsi.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// FileShareItems response schema. Contains list of shares returned, and if paging is requested or
-// required, a URL to next page of shares.
-type FileShareItems struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of file shares returned.
-	Value *[]FileShareItem `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to query next page of shares. Returned when total number of requested shares exceed maximum page size.
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for FileShareItems.
-func (fsi FileShareItems) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// FileShareItemsIterator provides access to a complete listing of FileShareItem values.
-type FileShareItemsIterator struct {
-	i    int
-	page FileShareItemsPage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *FileShareItemsIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileShareItemsIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *FileShareItemsIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter FileShareItemsIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter FileShareItemsIterator) Response() FileShareItems {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter FileShareItemsIterator) Value() FileShareItem {
-	if !iter.page.NotDone() {
-		return FileShareItem{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the FileShareItemsIterator type.
-func NewFileShareItemsIterator(page FileShareItemsPage) FileShareItemsIterator {
-	return FileShareItemsIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (fsi FileShareItems) IsEmpty() bool {
-	return fsi.Value == nil || len(*fsi.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (fsi FileShareItems) hasNextLink() bool {
-	return fsi.NextLink != nil && len(*fsi.NextLink) != 0
-}
-
-// fileShareItemsPreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (fsi FileShareItems) fileShareItemsPreparer(ctx context.Context) (*http.Request, error) {
-	if !fsi.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(fsi.NextLink)))
-}
-
-// FileShareItemsPage contains a page of FileShareItem values.
-type FileShareItemsPage struct {
-	fn  func(context.Context, FileShareItems) (FileShareItems, error)
-	fsi FileShareItems
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *FileShareItemsPage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/FileShareItemsPage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.fsi)
-		if err != nil {
-			return err
-		}
-		page.fsi = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *FileShareItemsPage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page FileShareItemsPage) NotDone() bool {
-	return !page.fsi.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page FileShareItemsPage) Response() FileShareItems {
-	return page.fsi
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page FileShareItemsPage) Values() []FileShareItem {
-	if page.fsi.IsEmpty() {
-		return nil
-	}
-	return *page.fsi.Value
-}
-
-// Creates a new instance of the FileShareItemsPage type.
-func NewFileShareItemsPage(cur FileShareItems, getNextPage func(context.Context, FileShareItems) (FileShareItems, error)) FileShareItemsPage {
-	return FileShareItemsPage{
-		fn:  getNextPage,
-		fsi: cur,
-	}
-}
-
-// FileShareProperties the properties of the file share.
-type FileShareProperties struct {
-	// LastModifiedTime - READ-ONLY; Returns the date and time the share was last modified.
-	LastModifiedTime *date.Time `json:"lastModifiedTime,omitempty"`
-	// Metadata - A name-value pair to associate with the share as metadata.
-	Metadata map[string]*string `json:"metadata"`
-	// ShareQuota - The maximum size of the share, in gigabytes. Must be greater than 0, and less than or equal to 5TB (5120). For Large File Shares, the maximum size is 102400.
-	ShareQuota *int32 `json:"shareQuota,omitempty"`
-	// EnabledProtocols - The authentication protocol that is used for the file share. Can only be specified when creating a share. Possible values include: 'EnabledProtocolsSMB', 'EnabledProtocolsNFS'
-	EnabledProtocols EnabledProtocols `json:"enabledProtocols,omitempty"`
-	// RootSquash - The property is for NFS share only. The default is NoRootSquash. Possible values include: 'RootSquashTypeNoRootSquash', 'RootSquashTypeRootSquash', 'RootSquashTypeAllSquash'
-	RootSquash RootSquashType `json:"rootSquash,omitempty"`
-	// Version - READ-ONLY; The version of the share.
-	Version *string `json:"version,omitempty"`
-	// Deleted - READ-ONLY; Indicates whether the share was deleted.
-	Deleted *bool `json:"deleted,omitempty"`
-	// DeletedTime - READ-ONLY; The deleted time if the share was deleted.
-	DeletedTime *date.Time `json:"deletedTime,omitempty"`
-	// RemainingRetentionDays - READ-ONLY; Remaining retention days for share that was soft deleted.
-	RemainingRetentionDays *int32 `json:"remainingRetentionDays,omitempty"`
-	// AccessTier - Access tier for specific share. GpV2 account can choose between TransactionOptimized (default), Hot, and Cool. FileStorage account can choose Premium. Possible values include: 'ShareAccessTierTransactionOptimized', 'ShareAccessTierHot', 'ShareAccessTierCool', 'ShareAccessTierPremium'
-	AccessTier ShareAccessTier `json:"accessTier,omitempty"`
-	// AccessTierChangeTime - READ-ONLY; Indicates the last modification time for share access tier.
-	AccessTierChangeTime *date.Time `json:"accessTierChangeTime,omitempty"`
-	// AccessTierStatus - READ-ONLY; Indicates if there is a pending transition for access tier.
-	AccessTierStatus *string `json:"accessTierStatus,omitempty"`
-	// ShareUsageBytes - READ-ONLY; The approximate size of the data stored on the share. Note that this value may not include all recently created or recently resized files.
-	ShareUsageBytes *int64 `json:"shareUsageBytes,omitempty"`
-	// SnapshotTime - READ-ONLY; Creation time of share snapshot returned in the response of list shares with expand param "snapshots".
-	SnapshotTime *date.Time `json:"snapshotTime,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for FileShareProperties.
-func (fsp FileShareProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if fsp.Metadata != nil {
-		objectMap["metadata"] = fsp.Metadata
-	}
-	if fsp.ShareQuota != nil {
-		objectMap["shareQuota"] = fsp.ShareQuota
-	}
-	if fsp.EnabledProtocols != "" {
-		objectMap["enabledProtocols"] = fsp.EnabledProtocols
-	}
-	if fsp.RootSquash != "" {
-		objectMap["rootSquash"] = fsp.RootSquash
-	}
-	if fsp.AccessTier != "" {
-		objectMap["accessTier"] = fsp.AccessTier
-	}
-	return json.Marshal(objectMap)
-}
-
-// GeoReplicationStats statistics related to replication for storage account's Blob, Table, Queue and File
-// services. It is only available when geo-redundant replication is enabled for the storage account.
-type GeoReplicationStats struct {
-	// Status - READ-ONLY; The status of the secondary location. Possible values are: - Live: Indicates that the secondary location is active and operational. - Bootstrap: Indicates initial synchronization from the primary location to the secondary location is in progress.This typically occurs when replication is first enabled. - Unavailable: Indicates that the secondary location is temporarily unavailable. Possible values include: 'GeoReplicationStatusLive', 'GeoReplicationStatusBootstrap', 'GeoReplicationStatusUnavailable'
-	Status GeoReplicationStatus `json:"status,omitempty"`
-	// LastSyncTime - READ-ONLY; All primary writes preceding this UTC date/time value are guaranteed to be available for read operations. Primary writes following this point in time may or may not be available for reads. Element may be default value if value of LastSyncTime is not available, this can happen if secondary is offline or we are in bootstrap.
-	LastSyncTime *date.Time `json:"lastSyncTime,omitempty"`
-	// CanFailover - READ-ONLY; A boolean flag which indicates whether or not account failover is supported for the account.
-	CanFailover *bool `json:"canFailover,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for GeoReplicationStats.
-func (grs GeoReplicationStats) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// Identity identity for the resource.
-type Identity struct {
-	// PrincipalID - READ-ONLY; The principal ID of resource identity.
-	PrincipalID *string `json:"principalId,omitempty"`
-	// TenantID - READ-ONLY; The tenant ID of resource.
-	TenantID *string `json:"tenantId,omitempty"`
-	// Type - The identity type. Possible values include: 'IdentityTypeNone', 'IdentityTypeSystemAssigned', 'IdentityTypeUserAssigned', 'IdentityTypeSystemAssignedUserAssigned'
-	Type IdentityType `json:"type,omitempty"`
-	// UserAssignedIdentities - Gets or sets a list of key value pairs that describe the set of User Assigned identities that will be used with this storage account. The key is the ARM resource identifier of the identity. Only 1 User Assigned identity is permitted here.
-	UserAssignedIdentities map[string]*UserAssignedIdentity `json:"userAssignedIdentities"`
-}
-
-// MarshalJSON is the custom marshaler for Identity.
-func (i Identity) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if i.Type != "" {
-		objectMap["type"] = i.Type
-	}
-	if i.UserAssignedIdentities != nil {
-		objectMap["userAssignedIdentities"] = i.UserAssignedIdentities
-	}
-	return json.Marshal(objectMap)
-}
-
-// ImmutabilityPolicy the ImmutabilityPolicy property of a blob container, including Id, resource name,
-// resource type, Etag.
-type ImmutabilityPolicy struct {
-	autorest.Response `json:"-"`
-	// ImmutabilityPolicyProperty - The properties of an ImmutabilityPolicy of a blob container.
-	*ImmutabilityPolicyProperty `json:"properties,omitempty"`
-	// Etag - READ-ONLY; Resource Etag.
-	Etag *string `json:"etag,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ImmutabilityPolicy.
-func (IP ImmutabilityPolicy) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if IP.ImmutabilityPolicyProperty != nil {
-		objectMap["properties"] = IP.ImmutabilityPolicyProperty
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for ImmutabilityPolicy struct.
-func (IP *ImmutabilityPolicy) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var immutabilityPolicyProperty ImmutabilityPolicyProperty
-				err = json.Unmarshal(*v, &immutabilityPolicyProperty)
-				if err != nil {
-					return err
-				}
-				IP.ImmutabilityPolicyProperty = &immutabilityPolicyProperty
-			}
-		case "etag":
-			if v != nil {
-				var etag string
-				err = json.Unmarshal(*v, &etag)
-				if err != nil {
-					return err
-				}
-				IP.Etag = &etag
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				IP.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				IP.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				IP.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// ImmutabilityPolicyProperties the properties of an ImmutabilityPolicy of a blob container.
-type ImmutabilityPolicyProperties struct {
-	// ImmutabilityPolicyProperty - The properties of an ImmutabilityPolicy of a blob container.
-	*ImmutabilityPolicyProperty `json:"properties,omitempty"`
-	// Etag - READ-ONLY; ImmutabilityPolicy Etag.
-	Etag *string `json:"etag,omitempty"`
-	// UpdateHistory - READ-ONLY; The ImmutabilityPolicy update history of the blob container.
-	UpdateHistory *[]UpdateHistoryProperty `json:"updateHistory,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ImmutabilityPolicyProperties.
-func (ipp ImmutabilityPolicyProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if ipp.ImmutabilityPolicyProperty != nil {
-		objectMap["properties"] = ipp.ImmutabilityPolicyProperty
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for ImmutabilityPolicyProperties struct.
-func (ipp *ImmutabilityPolicyProperties) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var immutabilityPolicyProperty ImmutabilityPolicyProperty
-				err = json.Unmarshal(*v, &immutabilityPolicyProperty)
-				if err != nil {
-					return err
-				}
-				ipp.ImmutabilityPolicyProperty = &immutabilityPolicyProperty
-			}
-		case "etag":
-			if v != nil {
-				var etag string
-				err = json.Unmarshal(*v, &etag)
-				if err != nil {
-					return err
-				}
-				ipp.Etag = &etag
-			}
-		case "updateHistory":
-			if v != nil {
-				var updateHistory []UpdateHistoryProperty
-				err = json.Unmarshal(*v, &updateHistory)
-				if err != nil {
-					return err
-				}
-				ipp.UpdateHistory = &updateHistory
-			}
-		}
-	}
-
-	return nil
-}
-
-// ImmutabilityPolicyProperty the properties of an ImmutabilityPolicy of a blob container.
-type ImmutabilityPolicyProperty struct {
-	// ImmutabilityPeriodSinceCreationInDays - The immutability period for the blobs in the container since the policy creation, in days.
-	ImmutabilityPeriodSinceCreationInDays *int32 `json:"immutabilityPeriodSinceCreationInDays,omitempty"`
-	// State - READ-ONLY; The ImmutabilityPolicy state of a blob container, possible values include: Locked and Unlocked. Possible values include: 'ImmutabilityPolicyStateLocked', 'ImmutabilityPolicyStateUnlocked'
-	State ImmutabilityPolicyState `json:"state,omitempty"`
-	// AllowProtectedAppendWrites - This property can only be changed for unlocked time-based retention policies. When enabled, new blocks can be written to an append blob while maintaining immutability protection and compliance. Only new blocks can be added and any existing blocks cannot be modified or deleted. This property cannot be changed with ExtendImmutabilityPolicy API
-	AllowProtectedAppendWrites *bool `json:"allowProtectedAppendWrites,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ImmutabilityPolicyProperty.
-func (ipp ImmutabilityPolicyProperty) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if ipp.ImmutabilityPeriodSinceCreationInDays != nil {
-		objectMap["immutabilityPeriodSinceCreationInDays"] = ipp.ImmutabilityPeriodSinceCreationInDays
-	}
-	if ipp.AllowProtectedAppendWrites != nil {
-		objectMap["allowProtectedAppendWrites"] = ipp.AllowProtectedAppendWrites
-	}
-	return json.Marshal(objectMap)
-}
-
-// IPRule IP rule with specific IP or IP range in CIDR format.
-type IPRule struct {
-	// IPAddressOrRange - Specifies the IP or IP range in CIDR format. Only IPV4 address is allowed.
-	IPAddressOrRange *string `json:"value,omitempty"`
-	// Action - The action of IP ACL rule. Possible values include: 'ActionAllow'
-	Action Action `json:"action,omitempty"`
-}
-
-// KeyCreationTime storage account keys creation time.
-type KeyCreationTime struct {
-	Key1 *date.Time `json:"key1,omitempty"`
-	Key2 *date.Time `json:"key2,omitempty"`
-}
-
-// KeyPolicy keyPolicy assigned to the storage account.
-type KeyPolicy struct {
-	// KeyExpirationPeriodInDays - The key expiration period in days.
-	KeyExpirationPeriodInDays *int32 `json:"keyExpirationPeriodInDays,omitempty"`
-}
-
-// KeyVaultProperties properties of key vault.
-type KeyVaultProperties struct {
-	// KeyName - The name of KeyVault key.
-	KeyName *string `json:"keyname,omitempty"`
-	// KeyVersion - The version of KeyVault key.
-	KeyVersion *string `json:"keyversion,omitempty"`
-	// KeyVaultURI - The Uri of KeyVault.
-	KeyVaultURI *string `json:"keyvaulturi,omitempty"`
-	// CurrentVersionedKeyIdentifier - READ-ONLY; The object identifier of the current versioned Key Vault Key in use.
-	CurrentVersionedKeyIdentifier *string `json:"currentVersionedKeyIdentifier,omitempty"`
-	// LastKeyRotationTimestamp - READ-ONLY; Timestamp of last rotation of the Key Vault Key.
-	LastKeyRotationTimestamp *date.Time `json:"lastKeyRotationTimestamp,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for KeyVaultProperties.
-func (kvp KeyVaultProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if kvp.KeyName != nil {
-		objectMap["keyname"] = kvp.KeyName
-	}
-	if kvp.KeyVersion != nil {
-		objectMap["keyversion"] = kvp.KeyVersion
-	}
-	if kvp.KeyVaultURI != nil {
-		objectMap["keyvaulturi"] = kvp.KeyVaultURI
-	}
-	return json.Marshal(objectMap)
-}
-
-// LastAccessTimeTrackingPolicy the blob service properties for Last access time based tracking policy.
-type LastAccessTimeTrackingPolicy struct {
-	// Enable - When set to true last access time based tracking is enabled.
-	Enable *bool `json:"enable,omitempty"`
-	// Name - Name of the policy. The valid value is AccessTimeTracking. This field is currently read only. Possible values include: 'NameAccessTimeTracking'
-	Name Name `json:"name,omitempty"`
-	// TrackingGranularityInDays - The field specifies blob object tracking granularity in days, typically how often the blob object should be tracked.This field is currently read only with value as 1
-	TrackingGranularityInDays *int32 `json:"trackingGranularityInDays,omitempty"`
-	// BlobType - An array of predefined supported blob types. Only blockBlob is the supported value. This field is currently read only
-	BlobType *[]string `json:"blobType,omitempty"`
-}
-
-// LeaseContainerRequest lease Container request schema.
-type LeaseContainerRequest struct {
-	// Action - Specifies the lease action. Can be one of the available actions. Possible values include: 'Action1Acquire', 'Action1Renew', 'Action1Change', 'Action1Release', 'Action1Break'
-	Action Action1 `json:"action,omitempty"`
-	// LeaseID - Identifies the lease. Can be specified in any valid GUID string format.
-	LeaseID *string `json:"leaseId,omitempty"`
-	// BreakPeriod - Optional. For a break action, proposed duration the lease should continue before it is broken, in seconds, between 0 and 60.
-	BreakPeriod *int32 `json:"breakPeriod,omitempty"`
-	// LeaseDuration - Required for acquire. Specifies the duration of the lease, in seconds, or negative one (-1) for a lease that never expires.
-	LeaseDuration *int32 `json:"leaseDuration,omitempty"`
-	// ProposedLeaseID - Optional for acquire, required for change. Proposed lease ID, in a GUID string format.
-	ProposedLeaseID *string `json:"proposedLeaseId,omitempty"`
-}
-
-// LeaseContainerResponse lease Container response schema.
-type LeaseContainerResponse struct {
-	autorest.Response `json:"-"`
-	// LeaseID - Returned unique lease ID that must be included with any request to delete the container, or to renew, change, or release the lease.
-	LeaseID *string `json:"leaseId,omitempty"`
-	// LeaseTimeSeconds - Approximate time remaining in the lease period, in seconds.
-	LeaseTimeSeconds *string `json:"leaseTimeSeconds,omitempty"`
-}
-
-// LegalHold the LegalHold property of a blob container.
-type LegalHold struct {
-	autorest.Response `json:"-"`
-	// HasLegalHold - READ-ONLY; The hasLegalHold public property is set to true by SRP if there are at least one existing tag. The hasLegalHold public property is set to false by SRP if all existing legal hold tags are cleared out. There can be a maximum of 1000 blob containers with hasLegalHold=true for a given account.
-	HasLegalHold *bool `json:"hasLegalHold,omitempty"`
-	// Tags - Each tag should be 3 to 23 alphanumeric characters and is normalized to lower case at SRP.
-	Tags *[]string `json:"tags,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for LegalHold.
-func (lh LegalHold) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if lh.Tags != nil {
-		objectMap["tags"] = lh.Tags
-	}
-	return json.Marshal(objectMap)
-}
-
-// LegalHoldProperties the LegalHold property of a blob container.
-type LegalHoldProperties struct {
-	// HasLegalHold - READ-ONLY; The hasLegalHold public property is set to true by SRP if there are at least one existing tag. The hasLegalHold public property is set to false by SRP if all existing legal hold tags are cleared out. There can be a maximum of 1000 blob containers with hasLegalHold=true for a given account.
-	HasLegalHold *bool `json:"hasLegalHold,omitempty"`
-	// Tags - The list of LegalHold tags of a blob container.
-	Tags *[]TagProperty `json:"tags,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for LegalHoldProperties.
-func (lhp LegalHoldProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if lhp.Tags != nil {
-		objectMap["tags"] = lhp.Tags
-	}
-	return json.Marshal(objectMap)
-}
-
-// ListAccountSasResponse the List SAS credentials operation response.
-type ListAccountSasResponse struct {
-	autorest.Response `json:"-"`
-	// AccountSasToken - READ-ONLY; List SAS credentials of storage account.
-	AccountSasToken *string `json:"accountSasToken,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListAccountSasResponse.
-func (lasr ListAccountSasResponse) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListBlobInventoryPolicy list of blob inventory policies returned.
-type ListBlobInventoryPolicy struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of blob inventory policies.
-	Value *[]BlobInventoryPolicy `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListBlobInventoryPolicy.
-func (lbip ListBlobInventoryPolicy) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListContainerItem the blob container properties be listed out.
-type ListContainerItem struct {
-	// ContainerProperties - The blob container properties be listed out.
-	*ContainerProperties `json:"properties,omitempty"`
-	// Etag - READ-ONLY; Resource Etag.
-	Etag *string `json:"etag,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListContainerItem.
-func (lci ListContainerItem) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if lci.ContainerProperties != nil {
-		objectMap["properties"] = lci.ContainerProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for ListContainerItem struct.
-func (lci *ListContainerItem) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var containerProperties ContainerProperties
-				err = json.Unmarshal(*v, &containerProperties)
-				if err != nil {
-					return err
-				}
-				lci.ContainerProperties = &containerProperties
-			}
-		case "etag":
-			if v != nil {
-				var etag string
-				err = json.Unmarshal(*v, &etag)
-				if err != nil {
-					return err
-				}
-				lci.Etag = &etag
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				lci.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				lci.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				lci.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// ListContainerItems response schema. Contains list of blobs returned, and if paging is requested or
-// required, a URL to next page of containers.
-type ListContainerItems struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of blobs containers returned.
-	Value *[]ListContainerItem `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to query next page of containers. Returned when total number of requested containers exceed maximum page size.
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListContainerItems.
-func (lci ListContainerItems) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListContainerItemsIterator provides access to a complete listing of ListContainerItem values.
-type ListContainerItemsIterator struct {
-	i    int
-	page ListContainerItemsPage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *ListContainerItemsIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ListContainerItemsIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *ListContainerItemsIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter ListContainerItemsIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter ListContainerItemsIterator) Response() ListContainerItems {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter ListContainerItemsIterator) Value() ListContainerItem {
-	if !iter.page.NotDone() {
-		return ListContainerItem{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the ListContainerItemsIterator type.
-func NewListContainerItemsIterator(page ListContainerItemsPage) ListContainerItemsIterator {
-	return ListContainerItemsIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (lci ListContainerItems) IsEmpty() bool {
-	return lci.Value == nil || len(*lci.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (lci ListContainerItems) hasNextLink() bool {
-	return lci.NextLink != nil && len(*lci.NextLink) != 0
-}
-
-// listContainerItemsPreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (lci ListContainerItems) listContainerItemsPreparer(ctx context.Context) (*http.Request, error) {
-	if !lci.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(lci.NextLink)))
-}
-
-// ListContainerItemsPage contains a page of ListContainerItem values.
-type ListContainerItemsPage struct {
-	fn  func(context.Context, ListContainerItems) (ListContainerItems, error)
-	lci ListContainerItems
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *ListContainerItemsPage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ListContainerItemsPage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.lci)
-		if err != nil {
-			return err
-		}
-		page.lci = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *ListContainerItemsPage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page ListContainerItemsPage) NotDone() bool {
-	return !page.lci.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page ListContainerItemsPage) Response() ListContainerItems {
-	return page.lci
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page ListContainerItemsPage) Values() []ListContainerItem {
-	if page.lci.IsEmpty() {
-		return nil
-	}
-	return *page.lci.Value
-}
-
-// Creates a new instance of the ListContainerItemsPage type.
-func NewListContainerItemsPage(cur ListContainerItems, getNextPage func(context.Context, ListContainerItems) (ListContainerItems, error)) ListContainerItemsPage {
-	return ListContainerItemsPage{
-		fn:  getNextPage,
-		lci: cur,
-	}
-}
-
-// ListQueue ...
-type ListQueue struct {
-	// ListQueueProperties - List Queue resource properties.
-	*ListQueueProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListQueue.
-func (lq ListQueue) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if lq.ListQueueProperties != nil {
-		objectMap["properties"] = lq.ListQueueProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for ListQueue struct.
-func (lq *ListQueue) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var queueProperties ListQueueProperties
-				err = json.Unmarshal(*v, &queueProperties)
-				if err != nil {
-					return err
-				}
-				lq.ListQueueProperties = &queueProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				lq.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				lq.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				lq.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// ListQueueProperties ...
-type ListQueueProperties struct {
-	// Metadata - A name-value pair that represents queue metadata.
-	Metadata map[string]*string `json:"metadata"`
-}
-
-// MarshalJSON is the custom marshaler for ListQueueProperties.
-func (lqp ListQueueProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if lqp.Metadata != nil {
-		objectMap["metadata"] = lqp.Metadata
-	}
-	return json.Marshal(objectMap)
-}
-
-// ListQueueResource response schema. Contains list of queues returned
-type ListQueueResource struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of queues returned.
-	Value *[]ListQueue `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to list next page of queues
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListQueueResource.
-func (lqr ListQueueResource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListQueueResourceIterator provides access to a complete listing of ListQueue values.
-type ListQueueResourceIterator struct {
-	i    int
-	page ListQueueResourcePage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *ListQueueResourceIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ListQueueResourceIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *ListQueueResourceIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter ListQueueResourceIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter ListQueueResourceIterator) Response() ListQueueResource {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter ListQueueResourceIterator) Value() ListQueue {
-	if !iter.page.NotDone() {
-		return ListQueue{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the ListQueueResourceIterator type.
-func NewListQueueResourceIterator(page ListQueueResourcePage) ListQueueResourceIterator {
-	return ListQueueResourceIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (lqr ListQueueResource) IsEmpty() bool {
-	return lqr.Value == nil || len(*lqr.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (lqr ListQueueResource) hasNextLink() bool {
-	return lqr.NextLink != nil && len(*lqr.NextLink) != 0
-}
-
-// listQueueResourcePreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (lqr ListQueueResource) listQueueResourcePreparer(ctx context.Context) (*http.Request, error) {
-	if !lqr.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(lqr.NextLink)))
-}
-
-// ListQueueResourcePage contains a page of ListQueue values.
-type ListQueueResourcePage struct {
-	fn  func(context.Context, ListQueueResource) (ListQueueResource, error)
-	lqr ListQueueResource
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *ListQueueResourcePage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ListQueueResourcePage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.lqr)
-		if err != nil {
-			return err
-		}
-		page.lqr = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *ListQueueResourcePage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page ListQueueResourcePage) NotDone() bool {
-	return !page.lqr.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page ListQueueResourcePage) Response() ListQueueResource {
-	return page.lqr
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page ListQueueResourcePage) Values() []ListQueue {
-	if page.lqr.IsEmpty() {
-		return nil
-	}
-	return *page.lqr.Value
-}
-
-// Creates a new instance of the ListQueueResourcePage type.
-func NewListQueueResourcePage(cur ListQueueResource, getNextPage func(context.Context, ListQueueResource) (ListQueueResource, error)) ListQueueResourcePage {
-	return ListQueueResourcePage{
-		fn:  getNextPage,
-		lqr: cur,
-	}
-}
-
-// ListQueueServices ...
-type ListQueueServices struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of queue services returned.
-	Value *[]QueueServiceProperties `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListQueueServices.
-func (lqs ListQueueServices) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListServiceSasResponse the List service SAS credentials operation response.
-type ListServiceSasResponse struct {
-	autorest.Response `json:"-"`
-	// ServiceSasToken - READ-ONLY; List service SAS credentials of specific resource.
-	ServiceSasToken *string `json:"serviceSasToken,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListServiceSasResponse.
-func (lssr ListServiceSasResponse) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListTableResource response schema. Contains list of tables returned
-type ListTableResource struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of tables returned.
-	Value *[]Table `json:"value,omitempty"`
-	// NextLink - READ-ONLY; Request URL that can be used to query next page of tables
-	NextLink *string `json:"nextLink,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListTableResource.
-func (ltr ListTableResource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ListTableResourceIterator provides access to a complete listing of Table values.
-type ListTableResourceIterator struct {
-	i    int
-	page ListTableResourcePage
-}
-
-// NextWithContext advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *ListTableResourceIterator) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ListTableResourceIterator.NextWithContext")
-		defer func() {
-			sc := -1
-			if iter.Response().Response.Response != nil {
-				sc = iter.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	iter.i++
-	if iter.i < len(iter.page.Values()) {
-		return nil
-	}
-	err = iter.page.NextWithContext(ctx)
-	if err != nil {
-		iter.i--
-		return err
-	}
-	iter.i = 0
-	return nil
-}
-
-// Next advances to the next value.  If there was an error making
-// the request the iterator does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (iter *ListTableResourceIterator) Next() error {
-	return iter.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter ListTableResourceIterator) NotDone() bool {
-	return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter ListTableResourceIterator) Response() ListTableResource {
-	return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter ListTableResourceIterator) Value() Table {
-	if !iter.page.NotDone() {
-		return Table{}
-	}
-	return iter.page.Values()[iter.i]
-}
-
-// Creates a new instance of the ListTableResourceIterator type.
-func NewListTableResourceIterator(page ListTableResourcePage) ListTableResourceIterator {
-	return ListTableResourceIterator{page: page}
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (ltr ListTableResource) IsEmpty() bool {
-	return ltr.Value == nil || len(*ltr.Value) == 0
-}
-
-// hasNextLink returns true if the NextLink is not empty.
-func (ltr ListTableResource) hasNextLink() bool {
-	return ltr.NextLink != nil && len(*ltr.NextLink) != 0
-}
-
-// listTableResourcePreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (ltr ListTableResource) listTableResourcePreparer(ctx context.Context) (*http.Request, error) {
-	if !ltr.hasNextLink() {
-		return nil, nil
-	}
-	return autorest.Prepare((&http.Request{}).WithContext(ctx),
-		autorest.AsJSON(),
-		autorest.AsGet(),
-		autorest.WithBaseURL(to.String(ltr.NextLink)))
-}
-
-// ListTableResourcePage contains a page of Table values.
-type ListTableResourcePage struct {
-	fn  func(context.Context, ListTableResource) (ListTableResource, error)
-	ltr ListTableResource
-}
-
-// NextWithContext advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *ListTableResourcePage) NextWithContext(ctx context.Context) (err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ListTableResourcePage.NextWithContext")
-		defer func() {
-			sc := -1
-			if page.Response().Response.Response != nil {
-				sc = page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	for {
-		next, err := page.fn(ctx, page.ltr)
-		if err != nil {
-			return err
-		}
-		page.ltr = next
-		if !next.hasNextLink() || !next.IsEmpty() {
-			break
-		}
-	}
-	return nil
-}
-
-// Next advances to the next page of values.  If there was an error making
-// the request the page does not advance and the error is returned.
-// Deprecated: Use NextWithContext() instead.
-func (page *ListTableResourcePage) Next() error {
-	return page.NextWithContext(context.Background())
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page ListTableResourcePage) NotDone() bool {
-	return !page.ltr.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page ListTableResourcePage) Response() ListTableResource {
-	return page.ltr
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page ListTableResourcePage) Values() []Table {
-	if page.ltr.IsEmpty() {
-		return nil
-	}
-	return *page.ltr.Value
-}
-
-// Creates a new instance of the ListTableResourcePage type.
-func NewListTableResourcePage(cur ListTableResource, getNextPage func(context.Context, ListTableResource) (ListTableResource, error)) ListTableResourcePage {
-	return ListTableResourcePage{
-		fn:  getNextPage,
-		ltr: cur,
-	}
-}
-
-// ListTableServices ...
-type ListTableServices struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; List of table services returned.
-	Value *[]TableServiceProperties `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ListTableServices.
-func (lts ListTableServices) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ManagementPolicy the Get Storage Account ManagementPolicies operation response.
-type ManagementPolicy struct {
-	autorest.Response `json:"-"`
-	// ManagementPolicyProperties - Returns the Storage Account Data Policies Rules.
-	*ManagementPolicyProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ManagementPolicy.
-func (mp ManagementPolicy) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if mp.ManagementPolicyProperties != nil {
-		objectMap["properties"] = mp.ManagementPolicyProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for ManagementPolicy struct.
-func (mp *ManagementPolicy) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var managementPolicyProperties ManagementPolicyProperties
-				err = json.Unmarshal(*v, &managementPolicyProperties)
-				if err != nil {
-					return err
-				}
-				mp.ManagementPolicyProperties = &managementPolicyProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				mp.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				mp.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				mp.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// ManagementPolicyAction actions are applied to the filtered blobs when the execution condition is met.
-type ManagementPolicyAction struct {
-	// BaseBlob - The management policy action for base blob
-	BaseBlob *ManagementPolicyBaseBlob `json:"baseBlob,omitempty"`
-	// Snapshot - The management policy action for snapshot
-	Snapshot *ManagementPolicySnapShot `json:"snapshot,omitempty"`
-	// Version - The management policy action for version
-	Version *ManagementPolicyVersion `json:"version,omitempty"`
-}
-
-// ManagementPolicyBaseBlob management policy action for base blob.
-type ManagementPolicyBaseBlob struct {
-	// TierToCool - The function to tier blobs to cool storage. Support blobs currently at Hot tier
-	TierToCool *DateAfterModification `json:"tierToCool,omitempty"`
-	// TierToArchive - The function to tier blobs to archive storage. Support blobs currently at Hot or Cool tier
-	TierToArchive *DateAfterModification `json:"tierToArchive,omitempty"`
-	// Delete - The function to delete the blob
-	Delete *DateAfterModification `json:"delete,omitempty"`
-	// EnableAutoTierToHotFromCool - This property enables auto tiering of a blob from cool to hot on a blob access. This property requires tierToCool.daysAfterLastAccessTimeGreaterThan.
-	EnableAutoTierToHotFromCool *bool `json:"enableAutoTierToHotFromCool,omitempty"`
-}
-
-// ManagementPolicyDefinition an object that defines the Lifecycle rule. Each definition is made up with a
-// filters set and an actions set.
-type ManagementPolicyDefinition struct {
-	// Actions - An object that defines the action set.
-	Actions *ManagementPolicyAction `json:"actions,omitempty"`
-	// Filters - An object that defines the filter set.
-	Filters *ManagementPolicyFilter `json:"filters,omitempty"`
-}
-
-// ManagementPolicyFilter filters limit rule actions to a subset of blobs within the storage account. If
-// multiple filters are defined, a logical AND is performed on all filters.
-type ManagementPolicyFilter struct {
-	// PrefixMatch - An array of strings for prefixes to be match.
-	PrefixMatch *[]string `json:"prefixMatch,omitempty"`
-	// BlobTypes - An array of predefined enum values. Currently blockBlob supports all tiering and delete actions. Only delete actions are supported for appendBlob.
-	BlobTypes *[]string `json:"blobTypes,omitempty"`
-	// BlobIndexMatch - An array of blob index tag based filters, there can be at most 10 tag filters
-	BlobIndexMatch *[]TagFilter `json:"blobIndexMatch,omitempty"`
-}
-
-// ManagementPolicyProperties the Storage Account ManagementPolicy properties.
-type ManagementPolicyProperties struct {
-	// LastModifiedTime - READ-ONLY; Returns the date and time the ManagementPolicies was last modified.
-	LastModifiedTime *date.Time `json:"lastModifiedTime,omitempty"`
-	// Policy - The Storage Account ManagementPolicy, in JSON format. See more details in: https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.
-	Policy *ManagementPolicySchema `json:"policy,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ManagementPolicyProperties.
-func (mpp ManagementPolicyProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if mpp.Policy != nil {
-		objectMap["policy"] = mpp.Policy
-	}
-	return json.Marshal(objectMap)
-}
-
-// ManagementPolicyRule an object that wraps the Lifecycle rule. Each rule is uniquely defined by name.
-type ManagementPolicyRule struct {
-	// Enabled - Rule is enabled if set to true.
-	Enabled *bool `json:"enabled,omitempty"`
-	// Name - A rule name can contain any combination of alpha numeric characters. Rule name is case-sensitive. It must be unique within a policy.
-	Name *string `json:"name,omitempty"`
-	// Type - The valid value is Lifecycle
-	Type *string `json:"type,omitempty"`
-	// Definition - An object that defines the Lifecycle rule.
-	Definition *ManagementPolicyDefinition `json:"definition,omitempty"`
-}
-
-// ManagementPolicySchema the Storage Account ManagementPolicies Rules. See more details in:
-// https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.
-type ManagementPolicySchema struct {
-	// Rules - The Storage Account ManagementPolicies Rules. See more details in: https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.
-	Rules *[]ManagementPolicyRule `json:"rules,omitempty"`
-}
-
-// ManagementPolicySnapShot management policy action for snapshot.
-type ManagementPolicySnapShot struct {
-	// TierToCool - The function to tier blob snapshot to cool storage. Support blob snapshot currently at Hot tier
-	TierToCool *DateAfterCreation `json:"tierToCool,omitempty"`
-	// TierToArchive - The function to tier blob snapshot to archive storage. Support blob snapshot currently at Hot or Cool tier
-	TierToArchive *DateAfterCreation `json:"tierToArchive,omitempty"`
-	// Delete - The function to delete the blob snapshot
-	Delete *DateAfterCreation `json:"delete,omitempty"`
-}
-
-// ManagementPolicyVersion management policy action for blob version.
-type ManagementPolicyVersion struct {
-	// TierToCool - The function to tier blob version to cool storage. Support blob version currently at Hot tier
-	TierToCool *DateAfterCreation `json:"tierToCool,omitempty"`
-	// TierToArchive - The function to tier blob version to archive storage. Support blob version currently at Hot or Cool tier
-	TierToArchive *DateAfterCreation `json:"tierToArchive,omitempty"`
-	// Delete - The function to delete the blob version
-	Delete *DateAfterCreation `json:"delete,omitempty"`
-}
-
-// MetricSpecification metric specification of operation.
-type MetricSpecification struct {
-	// Name - Name of metric specification.
-	Name *string `json:"name,omitempty"`
-	// DisplayName - Display name of metric specification.
-	DisplayName *string `json:"displayName,omitempty"`
-	// DisplayDescription - Display description of metric specification.
-	DisplayDescription *string `json:"displayDescription,omitempty"`
-	// Unit - Unit could be Bytes or Count.
-	Unit *string `json:"unit,omitempty"`
-	// Dimensions - Dimensions of blobs, including blob type and access tier.
-	Dimensions *[]Dimension `json:"dimensions,omitempty"`
-	// AggregationType - Aggregation type could be Average.
-	AggregationType *string `json:"aggregationType,omitempty"`
-	// FillGapWithZero - The property to decide fill gap with zero or not.
-	FillGapWithZero *bool `json:"fillGapWithZero,omitempty"`
-	// Category - The category this metric specification belong to, could be Capacity.
-	Category *string `json:"category,omitempty"`
-	// ResourceIDDimensionNameOverride - Account Resource Id.
-	ResourceIDDimensionNameOverride *string `json:"resourceIdDimensionNameOverride,omitempty"`
-}
-
-// Multichannel multichannel setting. Applies to Premium FileStorage only.
-type Multichannel struct {
-	// Enabled - Indicates whether multichannel is enabled
-	Enabled *bool `json:"enabled,omitempty"`
-}
-
-// NetworkRuleSet network rule set
-type NetworkRuleSet struct {
-	// Bypass - Specifies whether traffic is bypassed for Logging/Metrics/AzureServices. Possible values are any combination of Logging|Metrics|AzureServices (For example, "Logging, Metrics"), or None to bypass none of those traffics. Possible values include: 'BypassNone', 'BypassLogging', 'BypassMetrics', 'BypassAzureServices'
-	Bypass Bypass `json:"bypass,omitempty"`
-	// ResourceAccessRules - Sets the resource access rules
-	ResourceAccessRules *[]ResourceAccessRule `json:"resourceAccessRules,omitempty"`
-	// VirtualNetworkRules - Sets the virtual network rules
-	VirtualNetworkRules *[]VirtualNetworkRule `json:"virtualNetworkRules,omitempty"`
-	// IPRules - Sets the IP ACL rules
-	IPRules *[]IPRule `json:"ipRules,omitempty"`
-	// DefaultAction - Specifies the default action of allow or deny when no other rules match. Possible values include: 'DefaultActionAllow', 'DefaultActionDeny'
-	DefaultAction DefaultAction `json:"defaultAction,omitempty"`
-}
-
-// ObjectReplicationPolicies list storage account object replication policies.
-type ObjectReplicationPolicies struct {
-	autorest.Response `json:"-"`
-	// Value - The replication policy between two storage accounts.
-	Value *[]ObjectReplicationPolicy `json:"value,omitempty"`
-}
-
-// ObjectReplicationPolicy the replication policy between two storage accounts. Multiple rules can be
-// defined in one policy.
-type ObjectReplicationPolicy struct {
-	autorest.Response `json:"-"`
-	// ObjectReplicationPolicyProperties - Returns the Storage Account Object Replication Policy.
-	*ObjectReplicationPolicyProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ObjectReplicationPolicy.
-func (orp ObjectReplicationPolicy) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if orp.ObjectReplicationPolicyProperties != nil {
-		objectMap["properties"] = orp.ObjectReplicationPolicyProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for ObjectReplicationPolicy struct.
-func (orp *ObjectReplicationPolicy) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var objectReplicationPolicyProperties ObjectReplicationPolicyProperties
-				err = json.Unmarshal(*v, &objectReplicationPolicyProperties)
-				if err != nil {
-					return err
-				}
-				orp.ObjectReplicationPolicyProperties = &objectReplicationPolicyProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				orp.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				orp.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				orp.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// ObjectReplicationPolicyFilter filters limit replication to a subset of blobs within the storage account.
-// A logical OR is performed on values in the filter. If multiple filters are defined, a logical AND is
-// performed on all filters.
-type ObjectReplicationPolicyFilter struct {
-	// PrefixMatch - Optional. Filters the results to replicate only blobs whose names begin with the specified prefix.
-	PrefixMatch *[]string `json:"prefixMatch,omitempty"`
-	// MinCreationTime - Blobs created after the time will be replicated to the destination. It must be in datetime format 'yyyy-MM-ddTHH:mm:ssZ'. Example: 2020-02-19T16:05:00Z
-	MinCreationTime *string `json:"minCreationTime,omitempty"`
-}
-
-// ObjectReplicationPolicyProperties the Storage Account ObjectReplicationPolicy properties.
-type ObjectReplicationPolicyProperties struct {
-	// PolicyID - READ-ONLY; A unique id for object replication policy.
-	PolicyID *string `json:"policyId,omitempty"`
-	// EnabledTime - READ-ONLY; Indicates when the policy is enabled on the source account.
-	EnabledTime *date.Time `json:"enabledTime,omitempty"`
-	// SourceAccount - Required. Source account name.
-	SourceAccount *string `json:"sourceAccount,omitempty"`
-	// DestinationAccount - Required. Destination account name.
-	DestinationAccount *string `json:"destinationAccount,omitempty"`
-	// Rules - The storage account object replication rules.
-	Rules *[]ObjectReplicationPolicyRule `json:"rules,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ObjectReplicationPolicyProperties.
-func (orpp ObjectReplicationPolicyProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if orpp.SourceAccount != nil {
-		objectMap["sourceAccount"] = orpp.SourceAccount
-	}
-	if orpp.DestinationAccount != nil {
-		objectMap["destinationAccount"] = orpp.DestinationAccount
-	}
-	if orpp.Rules != nil {
-		objectMap["rules"] = orpp.Rules
-	}
-	return json.Marshal(objectMap)
-}
-
-// ObjectReplicationPolicyRule the replication policy rule between two containers.
-type ObjectReplicationPolicyRule struct {
-	// RuleID - Rule Id is auto-generated for each new rule on destination account. It is required for put policy on source account.
-	RuleID *string `json:"ruleId,omitempty"`
-	// SourceContainer - Required. Source container name.
-	SourceContainer *string `json:"sourceContainer,omitempty"`
-	// DestinationContainer - Required. Destination container name.
-	DestinationContainer *string `json:"destinationContainer,omitempty"`
-	// Filters - Optional. An object that defines the filter set.
-	Filters *ObjectReplicationPolicyFilter `json:"filters,omitempty"`
-}
-
-// Operation storage REST API operation definition.
-type Operation struct {
-	// Name - Operation name: {provider}/{resource}/{operation}
-	Name *string `json:"name,omitempty"`
-	// Display - Display metadata associated with the operation.
-	Display *OperationDisplay `json:"display,omitempty"`
-	// Origin - The origin of operations.
-	Origin *string `json:"origin,omitempty"`
-	// OperationProperties - Properties of operation, include metric specifications.
-	*OperationProperties `json:"properties,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Operation.
-func (o Operation) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if o.Name != nil {
-		objectMap["name"] = o.Name
-	}
-	if o.Display != nil {
-		objectMap["display"] = o.Display
-	}
-	if o.Origin != nil {
-		objectMap["origin"] = o.Origin
-	}
-	if o.OperationProperties != nil {
-		objectMap["properties"] = o.OperationProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for Operation struct.
-func (o *Operation) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				o.Name = &name
-			}
-		case "display":
-			if v != nil {
-				var display OperationDisplay
-				err = json.Unmarshal(*v, &display)
-				if err != nil {
-					return err
-				}
-				o.Display = &display
-			}
-		case "origin":
-			if v != nil {
-				var origin string
-				err = json.Unmarshal(*v, &origin)
-				if err != nil {
-					return err
-				}
-				o.Origin = &origin
-			}
-		case "properties":
-			if v != nil {
-				var operationProperties OperationProperties
-				err = json.Unmarshal(*v, &operationProperties)
-				if err != nil {
-					return err
-				}
-				o.OperationProperties = &operationProperties
-			}
-		}
-	}
-
-	return nil
-}
-
-// OperationDisplay display metadata associated with the operation.
-type OperationDisplay struct {
-	// Provider - Service provider: Microsoft Storage.
-	Provider *string `json:"provider,omitempty"`
-	// Resource - Resource on which the operation is performed etc.
-	Resource *string `json:"resource,omitempty"`
-	// Operation - Type of operation: get, read, delete, etc.
-	Operation *string `json:"operation,omitempty"`
-	// Description - Description of the operation.
-	Description *string `json:"description,omitempty"`
-}
-
-// OperationListResult result of the request to list Storage operations. It contains a list of operations
-// and a URL link to get the next set of results.
-type OperationListResult struct {
-	autorest.Response `json:"-"`
-	// Value - List of Storage operations supported by the Storage resource provider.
-	Value *[]Operation `json:"value,omitempty"`
-}
-
-// OperationProperties properties of operation, include metric specifications.
-type OperationProperties struct {
-	// ServiceSpecification - One property of operation, include metric specifications.
-	ServiceSpecification *ServiceSpecification `json:"serviceSpecification,omitempty"`
-}
-
-// PrivateEndpoint the Private Endpoint resource.
-type PrivateEndpoint struct {
-	// ID - READ-ONLY; The ARM identifier for Private Endpoint
-	ID *string `json:"id,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for PrivateEndpoint.
-func (peVar PrivateEndpoint) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// PrivateEndpointConnection the Private Endpoint Connection resource.
-type PrivateEndpointConnection struct {
-	autorest.Response `json:"-"`
-	// PrivateEndpointConnectionProperties - Resource properties.
-	*PrivateEndpointConnectionProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for PrivateEndpointConnection.
-func (pec PrivateEndpointConnection) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if pec.PrivateEndpointConnectionProperties != nil {
-		objectMap["properties"] = pec.PrivateEndpointConnectionProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for PrivateEndpointConnection struct.
-func (pec *PrivateEndpointConnection) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var privateEndpointConnectionProperties PrivateEndpointConnectionProperties
-				err = json.Unmarshal(*v, &privateEndpointConnectionProperties)
-				if err != nil {
-					return err
-				}
-				pec.PrivateEndpointConnectionProperties = &privateEndpointConnectionProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				pec.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				pec.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				pec.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// PrivateEndpointConnectionListResult list of private endpoint connection associated with the specified
-// storage account
-type PrivateEndpointConnectionListResult struct {
-	autorest.Response `json:"-"`
-	// Value - Array of private endpoint connections
-	Value *[]PrivateEndpointConnection `json:"value,omitempty"`
-}
-
-// PrivateEndpointConnectionProperties properties of the PrivateEndpointConnectProperties.
-type PrivateEndpointConnectionProperties struct {
-	// PrivateEndpoint - The resource of private end point.
-	PrivateEndpoint *PrivateEndpoint `json:"privateEndpoint,omitempty"`
-	// PrivateLinkServiceConnectionState - A collection of information about the state of the connection between service consumer and provider.
-	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"privateLinkServiceConnectionState,omitempty"`
-	// ProvisioningState - The provisioning state of the private endpoint connection resource. Possible values include: 'PrivateEndpointConnectionProvisioningStateSucceeded', 'PrivateEndpointConnectionProvisioningStateCreating', 'PrivateEndpointConnectionProvisioningStateDeleting', 'PrivateEndpointConnectionProvisioningStateFailed'
-	ProvisioningState PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty"`
-}
-
-// PrivateLinkResource a private link resource
-type PrivateLinkResource struct {
-	// PrivateLinkResourceProperties - Resource properties.
-	*PrivateLinkResourceProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for PrivateLinkResource.
-func (plr PrivateLinkResource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if plr.PrivateLinkResourceProperties != nil {
-		objectMap["properties"] = plr.PrivateLinkResourceProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for PrivateLinkResource struct.
-func (plr *PrivateLinkResource) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var privateLinkResourceProperties PrivateLinkResourceProperties
-				err = json.Unmarshal(*v, &privateLinkResourceProperties)
-				if err != nil {
-					return err
-				}
-				plr.PrivateLinkResourceProperties = &privateLinkResourceProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				plr.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				plr.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				plr.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// PrivateLinkResourceListResult a list of private link resources
-type PrivateLinkResourceListResult struct {
-	autorest.Response `json:"-"`
-	// Value - Array of private link resources
-	Value *[]PrivateLinkResource `json:"value,omitempty"`
-}
-
-// PrivateLinkResourceProperties properties of a private link resource.
-type PrivateLinkResourceProperties struct {
-	// GroupID - READ-ONLY; The private link resource group id.
-	GroupID *string `json:"groupId,omitempty"`
-	// RequiredMembers - READ-ONLY; The private link resource required member names.
-	RequiredMembers *[]string `json:"requiredMembers,omitempty"`
-	// RequiredZoneNames - The private link resource Private link DNS zone name.
-	RequiredZoneNames *[]string `json:"requiredZoneNames,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for PrivateLinkResourceProperties.
-func (plrp PrivateLinkResourceProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if plrp.RequiredZoneNames != nil {
-		objectMap["requiredZoneNames"] = plrp.RequiredZoneNames
-	}
-	return json.Marshal(objectMap)
-}
-
-// PrivateLinkServiceConnectionState a collection of information about the state of the connection between
-// service consumer and provider.
-type PrivateLinkServiceConnectionState struct {
-	// Status - Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service. Possible values include: 'PrivateEndpointServiceConnectionStatusPending', 'PrivateEndpointServiceConnectionStatusApproved', 'PrivateEndpointServiceConnectionStatusRejected'
-	Status PrivateEndpointServiceConnectionStatus `json:"status,omitempty"`
-	// Description - The reason for approval/rejection of the connection.
-	Description *string `json:"description,omitempty"`
-	// ActionRequired - A message indicating if changes on the service provider require any updates on the consumer.
-	ActionRequired *string `json:"actionRequired,omitempty"`
-}
-
-// ProtocolSettings protocol settings for file service
-type ProtocolSettings struct {
-	// Smb - Setting for SMB protocol
-	Smb *SmbSetting `json:"smb,omitempty"`
-}
-
-// ProxyResource the resource model definition for a Azure Resource Manager proxy resource. It will not
-// have tags and a location
-type ProxyResource struct {
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for ProxyResource.
-func (pr ProxyResource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// Queue ...
-type Queue struct {
-	autorest.Response `json:"-"`
-	// QueueProperties - Queue resource properties.
-	*QueueProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Queue.
-func (q Queue) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if q.QueueProperties != nil {
-		objectMap["properties"] = q.QueueProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for Queue struct.
-func (q *Queue) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var queueProperties QueueProperties
-				err = json.Unmarshal(*v, &queueProperties)
-				if err != nil {
-					return err
-				}
-				q.QueueProperties = &queueProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				q.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				q.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				q.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// QueueProperties ...
-type QueueProperties struct {
-	// Metadata - A name-value pair that represents queue metadata.
-	Metadata map[string]*string `json:"metadata"`
-	// ApproximateMessageCount - READ-ONLY; Integer indicating an approximate number of messages in the queue. This number is not lower than the actual number of messages in the queue, but could be higher.
-	ApproximateMessageCount *int32 `json:"approximateMessageCount,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for QueueProperties.
-func (qp QueueProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if qp.Metadata != nil {
-		objectMap["metadata"] = qp.Metadata
-	}
-	return json.Marshal(objectMap)
-}
-
-// QueueServiceProperties the properties of a storage account’s Queue service.
-type QueueServiceProperties struct {
-	autorest.Response `json:"-"`
-	// QueueServicePropertiesProperties - The properties of a storage account’s Queue service.
-	*QueueServicePropertiesProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for QueueServiceProperties.
-func (qsp QueueServiceProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if qsp.QueueServicePropertiesProperties != nil {
-		objectMap["properties"] = qsp.QueueServicePropertiesProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for QueueServiceProperties struct.
-func (qsp *QueueServiceProperties) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var queueServiceProperties QueueServicePropertiesProperties
-				err = json.Unmarshal(*v, &queueServiceProperties)
-				if err != nil {
-					return err
-				}
-				qsp.QueueServicePropertiesProperties = &queueServiceProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				qsp.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				qsp.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				qsp.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// QueueServicePropertiesProperties the properties of a storage account’s Queue service.
-type QueueServicePropertiesProperties struct {
-	// Cors - Specifies CORS rules for the Queue service. You can include up to five CorsRule elements in the request. If no CorsRule elements are included in the request body, all CORS rules will be deleted, and CORS will be disabled for the Queue service.
-	Cors *CorsRules `json:"cors,omitempty"`
-}
-
-// Resource common fields that are returned in the response for all Azure Resource Manager resources
-type Resource struct {
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Resource.
-func (r Resource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// ResourceAccessRule resource Access Rule.
-type ResourceAccessRule struct {
-	// TenantID - Tenant Id
-	TenantID *string `json:"tenantId,omitempty"`
-	// ResourceID - Resource Id
-	ResourceID *string `json:"resourceId,omitempty"`
-}
-
-// RestorePolicyProperties the blob service properties for blob restore policy
-type RestorePolicyProperties struct {
-	// Enabled - Blob restore is enabled if set to true.
-	Enabled *bool `json:"enabled,omitempty"`
-	// Days - how long this blob can be restored. It should be great than zero and less than DeleteRetentionPolicy.days.
-	Days *int32 `json:"days,omitempty"`
-	// LastEnabledTime - READ-ONLY; Deprecated in favor of minRestoreTime property.
-	LastEnabledTime *date.Time `json:"lastEnabledTime,omitempty"`
-	// MinRestoreTime - READ-ONLY; Returns the minimum date and time that the restore can be started.
-	MinRestoreTime *date.Time `json:"minRestoreTime,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for RestorePolicyProperties.
-func (rpp RestorePolicyProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if rpp.Enabled != nil {
-		objectMap["enabled"] = rpp.Enabled
-	}
-	if rpp.Days != nil {
-		objectMap["days"] = rpp.Days
-	}
-	return json.Marshal(objectMap)
-}
-
-// Restriction the restriction because of which SKU cannot be used.
-type Restriction struct {
-	// Type - READ-ONLY; The type of restrictions. As of now only possible value for this is location.
-	Type *string `json:"type,omitempty"`
-	// Values - READ-ONLY; The value of restrictions. If the restriction type is set to location. This would be different locations where the SKU is restricted.
-	Values *[]string `json:"values,omitempty"`
-	// ReasonCode - The reason for the restriction. As of now this can be "QuotaId" or "NotAvailableForSubscription". Quota Id is set when the SKU has requiredQuotas parameter as the subscription does not belong to that quota. The "NotAvailableForSubscription" is related to capacity at DC. Possible values include: 'ReasonCodeQuotaID', 'ReasonCodeNotAvailableForSubscription'
-	ReasonCode ReasonCode `json:"reasonCode,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Restriction.
-func (r Restriction) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if r.ReasonCode != "" {
-		objectMap["reasonCode"] = r.ReasonCode
-	}
-	return json.Marshal(objectMap)
-}
-
-// RoutingPreference routing preference defines the type of network, either microsoft or internet routing
-// to be used to deliver the user data, the default option is microsoft routing
-type RoutingPreference struct {
-	// RoutingChoice - Routing Choice defines the kind of network routing opted by the user. Possible values include: 'RoutingChoiceMicrosoftRouting', 'RoutingChoiceInternetRouting'
-	RoutingChoice RoutingChoice `json:"routingChoice,omitempty"`
-	// PublishMicrosoftEndpoints - A boolean flag which indicates whether microsoft routing storage endpoints are to be published
-	PublishMicrosoftEndpoints *bool `json:"publishMicrosoftEndpoints,omitempty"`
-	// PublishInternetEndpoints - A boolean flag which indicates whether internet routing storage endpoints are to be published
-	PublishInternetEndpoints *bool `json:"publishInternetEndpoints,omitempty"`
-}
-
-// SasPolicy sasPolicy assigned to the storage account.
-type SasPolicy struct {
-	// SasExpirationPeriod - The SAS expiration period, DD.HH:MM:SS.
-	SasExpirationPeriod *string `json:"sasExpirationPeriod,omitempty"`
-	// ExpirationAction - The SAS expiration action. Can only be Log.
-	ExpirationAction *string `json:"expirationAction,omitempty"`
-}
-
-// ServiceSasParameters the parameters to list service SAS credentials of a specific resource.
-type ServiceSasParameters struct {
-	// CanonicalizedResource - The canonical path to the signed resource.
-	CanonicalizedResource *string `json:"canonicalizedResource,omitempty"`
-	// Resource - The signed services accessible with the service SAS. Possible values include: Blob (b), Container (c), File (f), Share (s). Possible values include: 'SignedResourceB', 'SignedResourceC', 'SignedResourceF', 'SignedResourceS'
-	Resource SignedResource `json:"signedResource,omitempty"`
-	// Permissions - The signed permissions for the service SAS. Possible values include: Read (r), Write (w), Delete (d), List (l), Add (a), Create (c), Update (u) and Process (p). Possible values include: 'PermissionsR', 'PermissionsD', 'PermissionsW', 'PermissionsL', 'PermissionsA', 'PermissionsC', 'PermissionsU', 'PermissionsP'
-	Permissions Permissions `json:"signedPermission,omitempty"`
-	// IPAddressOrRange - An IP address or a range of IP addresses from which to accept requests.
-	IPAddressOrRange *string `json:"signedIp,omitempty"`
-	// Protocols - The protocol permitted for a request made with the account SAS. Possible values include: 'HTTPProtocolHttpshttp', 'HTTPProtocolHTTPS'
-	Protocols HTTPProtocol `json:"signedProtocol,omitempty"`
-	// SharedAccessStartTime - The time at which the SAS becomes valid.
-	SharedAccessStartTime *date.Time `json:"signedStart,omitempty"`
-	// SharedAccessExpiryTime - The time at which the shared access signature becomes invalid.
-	SharedAccessExpiryTime *date.Time `json:"signedExpiry,omitempty"`
-	// Identifier - A unique value up to 64 characters in length that correlates to an access policy specified for the container, queue, or table.
-	Identifier *string `json:"signedIdentifier,omitempty"`
-	// PartitionKeyStart - The start of partition key.
-	PartitionKeyStart *string `json:"startPk,omitempty"`
-	// PartitionKeyEnd - The end of partition key.
-	PartitionKeyEnd *string `json:"endPk,omitempty"`
-	// RowKeyStart - The start of row key.
-	RowKeyStart *string `json:"startRk,omitempty"`
-	// RowKeyEnd - The end of row key.
-	RowKeyEnd *string `json:"endRk,omitempty"`
-	// KeyToSign - The key to sign the account SAS token with.
-	KeyToSign *string `json:"keyToSign,omitempty"`
-	// CacheControl - The response header override for cache control.
-	CacheControl *string `json:"rscc,omitempty"`
-	// ContentDisposition - The response header override for content disposition.
-	ContentDisposition *string `json:"rscd,omitempty"`
-	// ContentEncoding - The response header override for content encoding.
-	ContentEncoding *string `json:"rsce,omitempty"`
-	// ContentLanguage - The response header override for content language.
-	ContentLanguage *string `json:"rscl,omitempty"`
-	// ContentType - The response header override for content type.
-	ContentType *string `json:"rsct,omitempty"`
-}
-
-// ServiceSpecification one property of operation, include metric specifications.
-type ServiceSpecification struct {
-	// MetricSpecifications - Metric specifications of operation.
-	MetricSpecifications *[]MetricSpecification `json:"metricSpecifications,omitempty"`
-}
-
-// Sku the SKU of the storage account.
-type Sku struct {
-	// Name - Possible values include: 'SkuNameStandardLRS', 'SkuNameStandardGRS', 'SkuNameStandardRAGRS', 'SkuNameStandardZRS', 'SkuNamePremiumLRS', 'SkuNamePremiumZRS', 'SkuNameStandardGZRS', 'SkuNameStandardRAGZRS'
-	Name SkuName `json:"name,omitempty"`
-	// Tier - Possible values include: 'SkuTierStandard', 'SkuTierPremium'
-	Tier SkuTier `json:"tier,omitempty"`
-}
-
-// SKUCapability the capability information in the specified SKU, including file encryption, network ACLs,
-// change notification, etc.
-type SKUCapability struct {
-	// Name - READ-ONLY; The name of capability, The capability information in the specified SKU, including file encryption, network ACLs, change notification, etc.
-	Name *string `json:"name,omitempty"`
-	// Value - READ-ONLY; A string value to indicate states of given capability. Possibly 'true' or 'false'.
-	Value *string `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for SKUCapability.
-func (sc SKUCapability) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// SkuInformation storage SKU and its properties
-type SkuInformation struct {
-	// Name - Possible values include: 'SkuNameStandardLRS', 'SkuNameStandardGRS', 'SkuNameStandardRAGRS', 'SkuNameStandardZRS', 'SkuNamePremiumLRS', 'SkuNamePremiumZRS', 'SkuNameStandardGZRS', 'SkuNameStandardRAGZRS'
-	Name SkuName `json:"name,omitempty"`
-	// Tier - Possible values include: 'SkuTierStandard', 'SkuTierPremium'
-	Tier SkuTier `json:"tier,omitempty"`
-	// ResourceType - READ-ONLY; The type of the resource, usually it is 'storageAccounts'.
-	ResourceType *string `json:"resourceType,omitempty"`
-	// Kind - READ-ONLY; Indicates the type of storage account. Possible values include: 'KindStorage', 'KindStorageV2', 'KindBlobStorage', 'KindFileStorage', 'KindBlockBlobStorage'
-	Kind Kind `json:"kind,omitempty"`
-	// Locations - READ-ONLY; The set of locations that the SKU is available. This will be supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.).
-	Locations *[]string `json:"locations,omitempty"`
-	// Capabilities - READ-ONLY; The capability information in the specified SKU, including file encryption, network ACLs, change notification, etc.
-	Capabilities *[]SKUCapability `json:"capabilities,omitempty"`
-	// Restrictions - The restrictions because of which SKU cannot be used. This is empty if there are no restrictions.
-	Restrictions *[]Restriction `json:"restrictions,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for SkuInformation.
-func (si SkuInformation) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if si.Name != "" {
-		objectMap["name"] = si.Name
-	}
-	if si.Tier != "" {
-		objectMap["tier"] = si.Tier
-	}
-	if si.Restrictions != nil {
-		objectMap["restrictions"] = si.Restrictions
-	}
-	return json.Marshal(objectMap)
-}
-
-// SkuListResult the response from the List Storage SKUs operation.
-type SkuListResult struct {
-	autorest.Response `json:"-"`
-	// Value - READ-ONLY; Get the list result of storage SKUs and their properties.
-	Value *[]SkuInformation `json:"value,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for SkuListResult.
-func (slr SkuListResult) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// SmbSetting setting for SMB protocol
-type SmbSetting struct {
-	// Multichannel - Multichannel setting. Applies to Premium FileStorage only.
-	Multichannel *Multichannel `json:"multichannel,omitempty"`
-	// Versions - SMB protocol versions supported by server. Valid values are SMB2.1, SMB3.0, SMB3.1.1. Should be passed as a string with delimiter ';'.
-	Versions *string `json:"versions,omitempty"`
-	// AuthenticationMethods - SMB authentication methods supported by server. Valid values are NTLMv2, Kerberos. Should be passed as a string with delimiter ';'.
-	AuthenticationMethods *string `json:"authenticationMethods,omitempty"`
-	// KerberosTicketEncryption - Kerberos ticket encryption supported by server. Valid values are RC4-HMAC, AES-256. Should be passed as a string with delimiter ';'
-	KerberosTicketEncryption *string `json:"kerberosTicketEncryption,omitempty"`
-	// ChannelEncryption - SMB channel encryption supported by server. Valid values are AES-128-CCM, AES-128-GCM, AES-256-GCM. Should be passed as a string with delimiter ';'.
-	ChannelEncryption *string `json:"channelEncryption,omitempty"`
-}
-
-// SystemData metadata pertaining to creation and last modification of the resource.
-type SystemData struct {
-	// CreatedBy - The identity that created the resource.
-	CreatedBy *string `json:"createdBy,omitempty"`
-	// CreatedByType - The type of identity that created the resource. Possible values include: 'CreatedByTypeUser', 'CreatedByTypeApplication', 'CreatedByTypeManagedIdentity', 'CreatedByTypeKey'
-	CreatedByType CreatedByType `json:"createdByType,omitempty"`
-	// CreatedAt - The timestamp of resource creation (UTC).
-	CreatedAt *date.Time `json:"createdAt,omitempty"`
-	// LastModifiedBy - The identity that last modified the resource.
-	LastModifiedBy *string `json:"lastModifiedBy,omitempty"`
-	// LastModifiedByType - The type of identity that last modified the resource. Possible values include: 'CreatedByTypeUser', 'CreatedByTypeApplication', 'CreatedByTypeManagedIdentity', 'CreatedByTypeKey'
-	LastModifiedByType CreatedByType `json:"lastModifiedByType,omitempty"`
-	// LastModifiedAt - The timestamp of resource last modification (UTC)
-	LastModifiedAt *date.Time `json:"lastModifiedAt,omitempty"`
-}
-
-// Table properties of the table, including Id, resource name, resource type.
-type Table struct {
-	autorest.Response `json:"-"`
-	// TableProperties - Table resource properties.
-	*TableProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Table.
-func (t Table) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if t.TableProperties != nil {
-		objectMap["properties"] = t.TableProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for Table struct.
-func (t *Table) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var tableProperties TableProperties
-				err = json.Unmarshal(*v, &tableProperties)
-				if err != nil {
-					return err
-				}
-				t.TableProperties = &tableProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				t.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				t.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				t.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// TableProperties ...
-type TableProperties struct {
-	// TableName - READ-ONLY; Table name under the specified account
-	TableName *string `json:"tableName,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for TableProperties.
-func (tp TableProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// TableServiceProperties the properties of a storage account’s Table service.
-type TableServiceProperties struct {
-	autorest.Response `json:"-"`
-	// TableServicePropertiesProperties - The properties of a storage account’s Table service.
-	*TableServicePropertiesProperties `json:"properties,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for TableServiceProperties.
-func (tsp TableServiceProperties) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if tsp.TableServicePropertiesProperties != nil {
-		objectMap["properties"] = tsp.TableServicePropertiesProperties
-	}
-	return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for TableServiceProperties struct.
-func (tsp *TableServiceProperties) UnmarshalJSON(body []byte) error {
-	var m map[string]*json.RawMessage
-	err := json.Unmarshal(body, &m)
-	if err != nil {
-		return err
-	}
-	for k, v := range m {
-		switch k {
-		case "properties":
-			if v != nil {
-				var tableServiceProperties TableServicePropertiesProperties
-				err = json.Unmarshal(*v, &tableServiceProperties)
-				if err != nil {
-					return err
-				}
-				tsp.TableServicePropertiesProperties = &tableServiceProperties
-			}
-		case "id":
-			if v != nil {
-				var ID string
-				err = json.Unmarshal(*v, &ID)
-				if err != nil {
-					return err
-				}
-				tsp.ID = &ID
-			}
-		case "name":
-			if v != nil {
-				var name string
-				err = json.Unmarshal(*v, &name)
-				if err != nil {
-					return err
-				}
-				tsp.Name = &name
-			}
-		case "type":
-			if v != nil {
-				var typeVar string
-				err = json.Unmarshal(*v, &typeVar)
-				if err != nil {
-					return err
-				}
-				tsp.Type = &typeVar
-			}
-		}
-	}
-
-	return nil
-}
-
-// TableServicePropertiesProperties the properties of a storage account’s Table service.
-type TableServicePropertiesProperties struct {
-	// Cors - Specifies CORS rules for the Table service. You can include up to five CorsRule elements in the request. If no CorsRule elements are included in the request body, all CORS rules will be deleted, and CORS will be disabled for the Table service.
-	Cors *CorsRules `json:"cors,omitempty"`
-}
-
-// TagFilter blob index tag based filtering for blob objects
-type TagFilter struct {
-	// Name - This is the filter tag name, it can have 1 - 128 characters
-	Name *string `json:"name,omitempty"`
-	// Op - This is the comparison operator which is used for object comparison and filtering. Only == (equality operator) is currently supported
-	Op *string `json:"op,omitempty"`
-	// Value - This is the filter tag value field used for tag based filtering, it can have 0 - 256 characters
-	Value *string `json:"value,omitempty"`
-}
-
-// TagProperty a tag of the LegalHold of a blob container.
-type TagProperty struct {
-	// Tag - READ-ONLY; The tag value.
-	Tag *string `json:"tag,omitempty"`
-	// Timestamp - READ-ONLY; Returns the date and time the tag was added.
-	Timestamp *date.Time `json:"timestamp,omitempty"`
-	// ObjectIdentifier - READ-ONLY; Returns the Object ID of the user who added the tag.
-	ObjectIdentifier *string `json:"objectIdentifier,omitempty"`
-	// TenantID - READ-ONLY; Returns the Tenant ID that issued the token for the user who added the tag.
-	TenantID *string `json:"tenantId,omitempty"`
-	// Upn - READ-ONLY; Returns the User Principal Name of the user who added the tag.
-	Upn *string `json:"upn,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for TagProperty.
-func (tp TagProperty) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// TrackedResource the resource model definition for an Azure Resource Manager tracked top level resource
-// which has 'tags' and a 'location'
-type TrackedResource struct {
-	// Tags - Resource tags.
-	Tags map[string]*string `json:"tags"`
-	// Location - The geo-location where the resource lives
-	Location *string `json:"location,omitempty"`
-	// ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
-	ID *string `json:"id,omitempty"`
-	// Name - READ-ONLY; The name of the resource
-	Name *string `json:"name,omitempty"`
-	// Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-	Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for TrackedResource.
-func (tr TrackedResource) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	if tr.Tags != nil {
-		objectMap["tags"] = tr.Tags
-	}
-	if tr.Location != nil {
-		objectMap["location"] = tr.Location
-	}
-	return json.Marshal(objectMap)
-}
-
-// UpdateHistoryProperty an update history of the ImmutabilityPolicy of a blob container.
-type UpdateHistoryProperty struct {
-	// Update - READ-ONLY; The ImmutabilityPolicy update type of a blob container, possible values include: put, lock and extend. Possible values include: 'ImmutabilityPolicyUpdateTypePut', 'ImmutabilityPolicyUpdateTypeLock', 'ImmutabilityPolicyUpdateTypeExtend'
-	Update ImmutabilityPolicyUpdateType `json:"update,omitempty"`
-	// ImmutabilityPeriodSinceCreationInDays - READ-ONLY; The immutability period for the blobs in the container since the policy creation, in days.
-	ImmutabilityPeriodSinceCreationInDays *int32 `json:"immutabilityPeriodSinceCreationInDays,omitempty"`
-	// Timestamp - READ-ONLY; Returns the date and time the ImmutabilityPolicy was updated.
-	Timestamp *date.Time `json:"timestamp,omitempty"`
-	// ObjectIdentifier - READ-ONLY; Returns the Object ID of the user who updated the ImmutabilityPolicy.
-	ObjectIdentifier *string `json:"objectIdentifier,omitempty"`
-	// TenantID - READ-ONLY; Returns the Tenant ID that issued the token for the user who updated the ImmutabilityPolicy.
-	TenantID *string `json:"tenantId,omitempty"`
-	// Upn - READ-ONLY; Returns the User Principal Name of the user who updated the ImmutabilityPolicy.
-	Upn *string `json:"upn,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for UpdateHistoryProperty.
-func (uhp UpdateHistoryProperty) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// Usage describes Storage Resource Usage.
-type Usage struct {
-	// Unit - READ-ONLY; Gets the unit of measurement. Possible values include: 'UsageUnitCount', 'UsageUnitBytes', 'UsageUnitSeconds', 'UsageUnitPercent', 'UsageUnitCountsPerSecond', 'UsageUnitBytesPerSecond'
-	Unit UsageUnit `json:"unit,omitempty"`
-	// CurrentValue - READ-ONLY; Gets the current count of the allocated resources in the subscription.
-	CurrentValue *int32 `json:"currentValue,omitempty"`
-	// Limit - READ-ONLY; Gets the maximum count of the resources that can be allocated in the subscription.
-	Limit *int32 `json:"limit,omitempty"`
-	// Name - READ-ONLY; Gets the name of the type of usage.
-	Name *UsageName `json:"name,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Usage.
-func (u Usage) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// UsageListResult the response from the List Usages operation.
-type UsageListResult struct {
-	autorest.Response `json:"-"`
-	// Value - Gets or sets the list of Storage Resource Usages.
-	Value *[]Usage `json:"value,omitempty"`
-}
-
-// UsageName the usage names that can be used; currently limited to StorageAccount.
-type UsageName struct {
-	// Value - READ-ONLY; Gets a string describing the resource name.
-	Value *string `json:"value,omitempty"`
-	// LocalizedValue - READ-ONLY; Gets a localized string describing the resource name.
-	LocalizedValue *string `json:"localizedValue,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for UsageName.
-func (un UsageName) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// UserAssignedIdentity userAssignedIdentity for the resource.
-type UserAssignedIdentity struct {
-	// PrincipalID - READ-ONLY; The principal ID of the identity.
-	PrincipalID *string `json:"principalId,omitempty"`
-	// ClientID - READ-ONLY; The client ID of the identity.
-	ClientID *string `json:"clientId,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for UserAssignedIdentity.
-func (uai UserAssignedIdentity) MarshalJSON() ([]byte, error) {
-	objectMap := make(map[string]interface{})
-	return json.Marshal(objectMap)
-}
-
-// VirtualNetworkRule virtual Network rule.
-type VirtualNetworkRule struct {
-	// VirtualNetworkResourceID - Resource ID of a subnet, for example: /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{vnetName}/subnets/{subnetName}.
-	VirtualNetworkResourceID *string `json:"id,omitempty"`
-	// Action - The action of virtual network rule. Possible values include: 'ActionAllow'
-	Action Action `json:"action,omitempty"`
-	// State - Gets the state of virtual network rule. Possible values include: 'StateProvisioning', 'StateDeprovisioning', 'StateSucceeded', 'StateFailed', 'StateNetworkSourceDeleted'
-	State State `json:"state,omitempty"`
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/objectreplicationpolicies.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/objectreplicationpolicies.go
deleted file mode 100644
index a4a9b9d476f8..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/objectreplicationpolicies.go
+++ /dev/null
@@ -1,417 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// ObjectReplicationPoliciesClient is the the Azure Storage Management API.
-type ObjectReplicationPoliciesClient struct {
-	BaseClient
-}
-
-// NewObjectReplicationPoliciesClient creates an instance of the ObjectReplicationPoliciesClient client.
-func NewObjectReplicationPoliciesClient(subscriptionID string) ObjectReplicationPoliciesClient {
-	return NewObjectReplicationPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewObjectReplicationPoliciesClientWithBaseURI creates an instance of the ObjectReplicationPoliciesClient client
-// using a custom endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
-// clouds, Azure stack).
-func NewObjectReplicationPoliciesClientWithBaseURI(baseURI string, subscriptionID string) ObjectReplicationPoliciesClient {
-	return ObjectReplicationPoliciesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// CreateOrUpdate create or update the object replication policy of the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// objectReplicationPolicyID - the ID of object replication policy or 'default' if the policy ID is unknown.
-// properties - the object replication policy set to a storage account. A unique policy ID will be created if
-// absent.
-func (client ObjectReplicationPoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, objectReplicationPolicyID string, properties ObjectReplicationPolicy) (result ObjectReplicationPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ObjectReplicationPoliciesClient.CreateOrUpdate")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: objectReplicationPolicyID,
-			Constraints: []validation.Constraint{{Target: "objectReplicationPolicyID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: properties,
-			Constraints: []validation.Constraint{{Target: "properties.ObjectReplicationPolicyProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "properties.ObjectReplicationPolicyProperties.SourceAccount", Name: validation.Null, Rule: true, Chain: nil},
-					{Target: "properties.ObjectReplicationPolicyProperties.DestinationAccount", Name: validation.Null, Rule: true, Chain: nil},
-				}}}}}); err != nil {
-		return result, validation.NewError("storage.ObjectReplicationPoliciesClient", "CreateOrUpdate", err.Error())
-	}
-
-	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, objectReplicationPolicyID, properties)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "CreateOrUpdate", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateOrUpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "CreateOrUpdate", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateOrUpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "CreateOrUpdate", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
-func (client ObjectReplicationPoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, objectReplicationPolicyID string, properties ObjectReplicationPolicy) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":               autorest.Encode("path", accountName),
-		"objectReplicationPolicyId": autorest.Encode("path", objectReplicationPolicyID),
-		"resourceGroupName":         autorest.Encode("path", resourceGroupName),
-		"subscriptionId":            autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/objectReplicationPolicies/{objectReplicationPolicyId}", pathParameters),
-		autorest.WithJSON(properties),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
-// http.Response Body if it receives an error.
-func (client ObjectReplicationPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
-// closes the http.Response Body.
-func (client ObjectReplicationPoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result ObjectReplicationPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes the object replication policy associated with the specified storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// objectReplicationPolicyID - the ID of object replication policy or 'default' if the policy ID is unknown.
-func (client ObjectReplicationPoliciesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, objectReplicationPolicyID string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ObjectReplicationPoliciesClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: objectReplicationPolicyID,
-			Constraints: []validation.Constraint{{Target: "objectReplicationPolicyID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.ObjectReplicationPoliciesClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, objectReplicationPolicyID)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client ObjectReplicationPoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, objectReplicationPolicyID string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":               autorest.Encode("path", accountName),
-		"objectReplicationPolicyId": autorest.Encode("path", objectReplicationPolicyID),
-		"resourceGroupName":         autorest.Encode("path", resourceGroupName),
-		"subscriptionId":            autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/objectReplicationPolicies/{objectReplicationPolicyId}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client ObjectReplicationPoliciesClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client ObjectReplicationPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get get the object replication policy of the storage account by policy ID.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// objectReplicationPolicyID - the ID of object replication policy or 'default' if the policy ID is unknown.
-func (client ObjectReplicationPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, objectReplicationPolicyID string) (result ObjectReplicationPolicy, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ObjectReplicationPoliciesClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: objectReplicationPolicyID,
-			Constraints: []validation.Constraint{{Target: "objectReplicationPolicyID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.ObjectReplicationPoliciesClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, objectReplicationPolicyID)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client ObjectReplicationPoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, objectReplicationPolicyID string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":               autorest.Encode("path", accountName),
-		"objectReplicationPolicyId": autorest.Encode("path", objectReplicationPolicyID),
-		"resourceGroupName":         autorest.Encode("path", resourceGroupName),
-		"subscriptionId":            autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/objectReplicationPolicies/{objectReplicationPolicyId}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client ObjectReplicationPoliciesClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client ObjectReplicationPoliciesClient) GetResponder(resp *http.Response) (result ObjectReplicationPolicy, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List list the object replication policies associated with the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client ObjectReplicationPoliciesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result ObjectReplicationPolicies, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/ObjectReplicationPoliciesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.ObjectReplicationPoliciesClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.ObjectReplicationPoliciesClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client ObjectReplicationPoliciesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/objectReplicationPolicies", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client ObjectReplicationPoliciesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client ObjectReplicationPoliciesClient) ListResponder(resp *http.Response) (result ObjectReplicationPolicies, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/operations.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/operations.go
deleted file mode 100644
index d21dc1ca69e7..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/operations.go
+++ /dev/null
@@ -1,98 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// OperationsClient is the the Azure Storage Management API.
-type OperationsClient struct {
-	BaseClient
-}
-
-// NewOperationsClient creates an instance of the OperationsClient client.
-func NewOperationsClient(subscriptionID string) OperationsClient {
-	return NewOperationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewOperationsClientWithBaseURI creates an instance of the OperationsClient client using a custom endpoint.  Use this
-// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
-	return OperationsClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// List lists all of the available Storage Rest API operations.
-func (client OperationsClient) List(ctx context.Context) (result OperationListResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	req, err := client.ListPreparer(ctx)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.OperationsClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.OperationsClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.OperationsClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPath("/providers/Microsoft.Storage/operations"),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client OperationsClient) ListResponder(resp *http.Response) (result OperationListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privateendpointconnections.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privateendpointconnections.go
deleted file mode 100644
index 7bb24a1cd68e..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privateendpointconnections.go
+++ /dev/null
@@ -1,411 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// PrivateEndpointConnectionsClient is the the Azure Storage Management API.
-type PrivateEndpointConnectionsClient struct {
-	BaseClient
-}
-
-// NewPrivateEndpointConnectionsClient creates an instance of the PrivateEndpointConnectionsClient client.
-func NewPrivateEndpointConnectionsClient(subscriptionID string) PrivateEndpointConnectionsClient {
-	return NewPrivateEndpointConnectionsClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewPrivateEndpointConnectionsClientWithBaseURI creates an instance of the PrivateEndpointConnectionsClient client
-// using a custom endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
-// clouds, Azure stack).
-func NewPrivateEndpointConnectionsClientWithBaseURI(baseURI string, subscriptionID string) PrivateEndpointConnectionsClient {
-	return PrivateEndpointConnectionsClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// Delete deletes the specified private endpoint connection associated with the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// privateEndpointConnectionName - the name of the private endpoint connection associated with the Azure
-// resource
-func (client PrivateEndpointConnectionsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, privateEndpointConnectionName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.PrivateEndpointConnectionsClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, privateEndpointConnectionName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client PrivateEndpointConnectionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, privateEndpointConnectionName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":                   autorest.Encode("path", accountName),
-		"privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName),
-		"resourceGroupName":             autorest.Encode("path", resourceGroupName),
-		"subscriptionId":                autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client PrivateEndpointConnectionsClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client PrivateEndpointConnectionsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get gets the specified private endpoint connection associated with the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// privateEndpointConnectionName - the name of the private endpoint connection associated with the Azure
-// resource
-func (client PrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, accountName string, privateEndpointConnectionName string) (result PrivateEndpointConnection, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.PrivateEndpointConnectionsClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, privateEndpointConnectionName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client PrivateEndpointConnectionsClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, privateEndpointConnectionName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":                   autorest.Encode("path", accountName),
-		"privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName),
-		"resourceGroupName":             autorest.Encode("path", resourceGroupName),
-		"subscriptionId":                autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client PrivateEndpointConnectionsClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client PrivateEndpointConnectionsClient) GetResponder(resp *http.Response) (result PrivateEndpointConnection, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List list all the private endpoint connections associated with the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client PrivateEndpointConnectionsClient) List(ctx context.Context, resourceGroupName string, accountName string) (result PrivateEndpointConnectionListResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.PrivateEndpointConnectionsClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client PrivateEndpointConnectionsClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/privateEndpointConnections", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client PrivateEndpointConnectionsClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client PrivateEndpointConnectionsClient) ListResponder(resp *http.Response) (result PrivateEndpointConnectionListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Put update the state of specified private endpoint connection associated with the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// privateEndpointConnectionName - the name of the private endpoint connection associated with the Azure
-// resource
-// properties - the private endpoint connection properties.
-func (client PrivateEndpointConnectionsClient) Put(ctx context.Context, resourceGroupName string, accountName string, privateEndpointConnectionName string, properties PrivateEndpointConnection) (result PrivateEndpointConnection, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.Put")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: properties,
-			Constraints: []validation.Constraint{{Target: "properties.PrivateEndpointConnectionProperties", Name: validation.Null, Rule: false,
-				Chain: []validation.Constraint{{Target: "properties.PrivateEndpointConnectionProperties.PrivateLinkServiceConnectionState", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
-		return result, validation.NewError("storage.PrivateEndpointConnectionsClient", "Put", err.Error())
-	}
-
-	req, err := client.PutPreparer(ctx, resourceGroupName, accountName, privateEndpointConnectionName, properties)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Put", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.PutSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Put", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.PutResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateEndpointConnectionsClient", "Put", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// PutPreparer prepares the Put request.
-func (client PrivateEndpointConnectionsClient) PutPreparer(ctx context.Context, resourceGroupName string, accountName string, privateEndpointConnectionName string, properties PrivateEndpointConnection) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":                   autorest.Encode("path", accountName),
-		"privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName),
-		"resourceGroupName":             autorest.Encode("path", resourceGroupName),
-		"subscriptionId":                autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters),
-		autorest.WithJSON(properties),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// PutSender sends the Put request. The method will close the
-// http.Response Body if it receives an error.
-func (client PrivateEndpointConnectionsClient) PutSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// PutResponder handles the response to the Put request. The method always
-// closes the http.Response Body.
-func (client PrivateEndpointConnectionsClient) PutResponder(resp *http.Response) (result PrivateEndpointConnection, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privatelinkresources.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privatelinkresources.go
deleted file mode 100644
index 2aab58432d4e..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/privatelinkresources.go
+++ /dev/null
@@ -1,124 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// PrivateLinkResourcesClient is the the Azure Storage Management API.
-type PrivateLinkResourcesClient struct {
-	BaseClient
-}
-
-// NewPrivateLinkResourcesClient creates an instance of the PrivateLinkResourcesClient client.
-func NewPrivateLinkResourcesClient(subscriptionID string) PrivateLinkResourcesClient {
-	return NewPrivateLinkResourcesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewPrivateLinkResourcesClientWithBaseURI creates an instance of the PrivateLinkResourcesClient client using a custom
-// endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
-// stack).
-func NewPrivateLinkResourcesClientWithBaseURI(baseURI string, subscriptionID string) PrivateLinkResourcesClient {
-	return PrivateLinkResourcesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// ListByStorageAccount gets the private link resources that need to be created for a storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client PrivateLinkResourcesClient) ListByStorageAccount(ctx context.Context, resourceGroupName string, accountName string) (result PrivateLinkResourceListResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/PrivateLinkResourcesClient.ListByStorageAccount")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.PrivateLinkResourcesClient", "ListByStorageAccount", err.Error())
-	}
-
-	req, err := client.ListByStorageAccountPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateLinkResourcesClient", "ListByStorageAccount", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListByStorageAccountSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.PrivateLinkResourcesClient", "ListByStorageAccount", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListByStorageAccountResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.PrivateLinkResourcesClient", "ListByStorageAccount", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListByStorageAccountPreparer prepares the ListByStorageAccount request.
-func (client PrivateLinkResourcesClient) ListByStorageAccountPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/privateLinkResources", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListByStorageAccountSender sends the ListByStorageAccount request. The method will close the
-// http.Response Body if it receives an error.
-func (client PrivateLinkResourcesClient) ListByStorageAccountSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListByStorageAccountResponder handles the response to the ListByStorageAccount request. The method always
-// closes the http.Response Body.
-func (client PrivateLinkResourcesClient) ListByStorageAccountResponder(resp *http.Response) (result PrivateLinkResourceListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queue.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queue.go
deleted file mode 100644
index 4a02d3cd77d9..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queue.go
+++ /dev/null
@@ -1,571 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// QueueClient is the the Azure Storage Management API.
-type QueueClient struct {
-	BaseClient
-}
-
-// NewQueueClient creates an instance of the QueueClient client.
-func NewQueueClient(subscriptionID string) QueueClient {
-	return NewQueueClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewQueueClientWithBaseURI creates an instance of the QueueClient client using a custom endpoint.  Use this when
-// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewQueueClientWithBaseURI(baseURI string, subscriptionID string) QueueClient {
-	return QueueClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// Create creates a new queue with the specified queue name, under the specified account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// queueName - a queue name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of lowercase alphanumeric and dash(-) characters only, it should begin and end with an
-// alphanumeric character and it cannot have two consecutive dash(-) characters.
-// queue - queue properties and metadata to be created with
-func (client QueueClient) Create(ctx context.Context, resourceGroupName string, accountName string, queueName string, queue Queue) (result Queue, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueClient.Create")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: queueName,
-			Constraints: []validation.Constraint{{Target: "queueName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "queueName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueClient", "Create", err.Error())
-	}
-
-	req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, queueName, queue)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Create", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Create", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Create", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreatePreparer prepares the Create request.
-func (client QueueClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, queueName string, queue Queue) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"queueName":         autorest.Encode("path", queueName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/default/queues/{queueName}", pathParameters),
-		autorest.WithJSON(queue),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateSender sends the Create request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueClient) CreateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateResponder handles the response to the Create request. The method always
-// closes the http.Response Body.
-func (client QueueClient) CreateResponder(resp *http.Response) (result Queue, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes the queue with the specified queue name, under the specified account if it exists.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// queueName - a queue name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of lowercase alphanumeric and dash(-) characters only, it should begin and end with an
-// alphanumeric character and it cannot have two consecutive dash(-) characters.
-func (client QueueClient) Delete(ctx context.Context, resourceGroupName string, accountName string, queueName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: queueName,
-			Constraints: []validation.Constraint{{Target: "queueName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "queueName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, queueName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client QueueClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, queueName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"queueName":         autorest.Encode("path", queueName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/default/queues/{queueName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client QueueClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get gets the queue with the specified queue name, under the specified account if it exists.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// queueName - a queue name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of lowercase alphanumeric and dash(-) characters only, it should begin and end with an
-// alphanumeric character and it cannot have two consecutive dash(-) characters.
-func (client QueueClient) Get(ctx context.Context, resourceGroupName string, accountName string, queueName string) (result Queue, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: queueName,
-			Constraints: []validation.Constraint{{Target: "queueName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "queueName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, queueName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client QueueClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, queueName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"queueName":         autorest.Encode("path", queueName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/default/queues/{queueName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client QueueClient) GetResponder(resp *http.Response) (result Queue, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List gets a list of all the queues under the specified storage account
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// maxpagesize - optional, a maximum number of queues that should be included in a list queue response
-// filter - optional, When specified, only the queues with a name starting with the given filter will be
-// listed.
-func (client QueueClient) List(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string) (result ListQueueResourcePage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueClient.List")
-		defer func() {
-			sc := -1
-			if result.lqr.Response.Response != nil {
-				sc = result.lqr.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName, maxpagesize, filter)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.lqr.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.lqr, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.lqr.hasNextLink() && result.lqr.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client QueueClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-	if len(maxpagesize) > 0 {
-		queryParameters["$maxpagesize"] = autorest.Encode("query", maxpagesize)
-	}
-	if len(filter) > 0 {
-		queryParameters["$filter"] = autorest.Encode("query", filter)
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/default/queues", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client QueueClient) ListResponder(resp *http.Response) (result ListQueueResource, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client QueueClient) listNextResults(ctx context.Context, lastResults ListQueueResource) (result ListQueueResource, err error) {
-	req, err := lastResults.listQueueResourcePreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.QueueClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.QueueClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client QueueClient) ListComplete(ctx context.Context, resourceGroupName string, accountName string, maxpagesize string, filter string) (result ListQueueResourceIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx, resourceGroupName, accountName, maxpagesize, filter)
-	return
-}
-
-// Update creates a new queue with the specified queue name, under the specified account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// queueName - a queue name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of lowercase alphanumeric and dash(-) characters only, it should begin and end with an
-// alphanumeric character and it cannot have two consecutive dash(-) characters.
-// queue - queue properties and metadata to be created with
-func (client QueueClient) Update(ctx context.Context, resourceGroupName string, accountName string, queueName string, queue Queue) (result Queue, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueClient.Update")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: queueName,
-			Constraints: []validation.Constraint{{Target: "queueName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "queueName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueClient", "Update", err.Error())
-	}
-
-	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, queueName, queue)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Update", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.UpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Update", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.UpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueClient", "Update", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// UpdatePreparer prepares the Update request.
-func (client QueueClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, queueName string, queue Queue) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"queueName":         autorest.Encode("path", queueName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPatch(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/default/queues/{queueName}", pathParameters),
-		autorest.WithJSON(queue),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// UpdateSender sends the Update request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueClient) UpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// UpdateResponder handles the response to the Update request. The method always
-// closes the http.Response Body.
-func (client QueueClient) UpdateResponder(resp *http.Response) (result Queue, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queueservices.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queueservices.go
deleted file mode 100644
index 3223926b972d..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/queueservices.go
+++ /dev/null
@@ -1,313 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// QueueServicesClient is the the Azure Storage Management API.
-type QueueServicesClient struct {
-	BaseClient
-}
-
-// NewQueueServicesClient creates an instance of the QueueServicesClient client.
-func NewQueueServicesClient(subscriptionID string) QueueServicesClient {
-	return NewQueueServicesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewQueueServicesClientWithBaseURI creates an instance of the QueueServicesClient client using a custom endpoint.
-// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewQueueServicesClientWithBaseURI(baseURI string, subscriptionID string) QueueServicesClient {
-	return QueueServicesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// GetServiceProperties gets the properties of a storage account’s Queue service, including properties for Storage
-// Analytics and CORS (Cross-Origin Resource Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client QueueServicesClient) GetServiceProperties(ctx context.Context, resourceGroupName string, accountName string) (result QueueServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueServicesClient.GetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueServicesClient", "GetServiceProperties", err.Error())
-	}
-
-	req, err := client.GetServicePropertiesPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "GetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "GetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "GetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetServicePropertiesPreparer prepares the GetServiceProperties request.
-func (client QueueServicesClient) GetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"queueServiceName":  autorest.Encode("path", "default"),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/{queueServiceName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetServicePropertiesSender sends the GetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueServicesClient) GetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetServicePropertiesResponder handles the response to the GetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client QueueServicesClient) GetServicePropertiesResponder(resp *http.Response) (result QueueServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List list all queue services for the storage account
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client QueueServicesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result ListQueueServices, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueServicesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueServicesClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client QueueServicesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueServicesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client QueueServicesClient) ListResponder(resp *http.Response) (result ListQueueServices, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// SetServiceProperties sets the properties of a storage account’s Queue service, including properties for Storage
-// Analytics and CORS (Cross-Origin Resource Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the properties of a storage account’s Queue service, only properties for Storage Analytics and
-// CORS (Cross-Origin Resource Sharing) rules can be specified.
-func (client QueueServicesClient) SetServiceProperties(ctx context.Context, resourceGroupName string, accountName string, parameters QueueServiceProperties) (result QueueServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/QueueServicesClient.SetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.QueueServicesClient", "SetServiceProperties", err.Error())
-	}
-
-	req, err := client.SetServicePropertiesPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "SetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.SetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "SetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.SetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.QueueServicesClient", "SetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// SetServicePropertiesPreparer prepares the SetServiceProperties request.
-func (client QueueServicesClient) SetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters QueueServiceProperties) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"queueServiceName":  autorest.Encode("path", "default"),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/queueServices/{queueServiceName}", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client QueueServicesClient) SetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client QueueServicesClient) SetServicePropertiesResponder(resp *http.Response) (result QueueServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/skus.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/skus.go
deleted file mode 100644
index dd77993de20a..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/skus.go
+++ /dev/null
@@ -1,109 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// SkusClient is the the Azure Storage Management API.
-type SkusClient struct {
-	BaseClient
-}
-
-// NewSkusClient creates an instance of the SkusClient client.
-func NewSkusClient(subscriptionID string) SkusClient {
-	return NewSkusClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewSkusClientWithBaseURI creates an instance of the SkusClient client using a custom endpoint.  Use this when
-// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewSkusClientWithBaseURI(baseURI string, subscriptionID string) SkusClient {
-	return SkusClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// List lists the available SKUs supported by Microsoft.Storage for given subscription.
-func (client SkusClient) List(ctx context.Context) (result SkuListResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/SkusClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.SkusClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.SkusClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.SkusClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.SkusClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client SkusClient) ListPreparer(ctx context.Context) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/skus", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client SkusClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client SkusClient) ListResponder(resp *http.Response) (result SkuListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/table.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/table.go
deleted file mode 100644
index 4dd557991563..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/table.go
+++ /dev/null
@@ -1,556 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// TableClient is the the Azure Storage Management API.
-type TableClient struct {
-	BaseClient
-}
-
-// NewTableClient creates an instance of the TableClient client.
-func NewTableClient(subscriptionID string) TableClient {
-	return NewTableClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewTableClientWithBaseURI creates an instance of the TableClient client using a custom endpoint.  Use this when
-// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewTableClientWithBaseURI(baseURI string, subscriptionID string) TableClient {
-	return TableClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// Create creates a new table with the specified table name, under the specified account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// tableName - a table name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of only alphanumeric characters and it cannot begin with a numeric character.
-func (client TableClient) Create(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result Table, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableClient.Create")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: tableName,
-			Constraints: []validation.Constraint{{Target: "tableName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "tableName", Name: validation.MinLength, Rule: 3, Chain: nil},
-				{Target: "tableName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]{2,62}$`, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableClient", "Create", err.Error())
-	}
-
-	req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, tableName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Create", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.CreateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Create", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.CreateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Create", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// CreatePreparer prepares the Create request.
-func (client TableClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-		"tableName":         autorest.Encode("path", tableName),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/default/tables/{tableName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// CreateSender sends the Create request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableClient) CreateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// CreateResponder handles the response to the Create request. The method always
-// closes the http.Response Body.
-func (client TableClient) CreateResponder(resp *http.Response) (result Table, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// Delete deletes the table with the specified table name, under the specified account if it exists.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// tableName - a table name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of only alphanumeric characters and it cannot begin with a numeric character.
-func (client TableClient) Delete(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result autorest.Response, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableClient.Delete")
-		defer func() {
-			sc := -1
-			if result.Response != nil {
-				sc = result.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: tableName,
-			Constraints: []validation.Constraint{{Target: "tableName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "tableName", Name: validation.MinLength, Rule: 3, Chain: nil},
-				{Target: "tableName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]{2,62}$`, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableClient", "Delete", err.Error())
-	}
-
-	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, tableName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Delete", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.DeleteSender(req)
-	if err != nil {
-		result.Response = resp
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Delete", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.DeleteResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Delete", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// DeletePreparer prepares the Delete request.
-func (client TableClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-		"tableName":         autorest.Encode("path", tableName),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsDelete(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/default/tables/{tableName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DeleteSender sends the Delete request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableClient) DeleteSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// DeleteResponder handles the response to the Delete request. The method always
-// closes the http.Response Body.
-func (client TableClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
-		autorest.ByClosing())
-	result.Response = resp
-	return
-}
-
-// Get gets the table with the specified table name, under the specified account if it exists.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// tableName - a table name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of only alphanumeric characters and it cannot begin with a numeric character.
-func (client TableClient) Get(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result Table, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableClient.Get")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: tableName,
-			Constraints: []validation.Constraint{{Target: "tableName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "tableName", Name: validation.MinLength, Rule: 3, Chain: nil},
-				{Target: "tableName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]{2,62}$`, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableClient", "Get", err.Error())
-	}
-
-	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, tableName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Get", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Get", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Get", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetPreparer prepares the Get request.
-func (client TableClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-		"tableName":         autorest.Encode("path", tableName),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/default/tables/{tableName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetSender sends the Get request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableClient) GetSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetResponder handles the response to the Get request. The method always
-// closes the http.Response Body.
-func (client TableClient) GetResponder(resp *http.Response) (result Table, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List gets a list of all the tables under the specified storage account
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client TableClient) List(ctx context.Context, resourceGroupName string, accountName string) (result ListTableResourcePage, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableClient.List")
-		defer func() {
-			sc := -1
-			if result.ltr.Response.Response != nil {
-				sc = result.ltr.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableClient", "List", err.Error())
-	}
-
-	result.fn = client.listNextResults
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.ltr.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result.ltr, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "List", resp, "Failure responding to request")
-		return
-	}
-	if result.ltr.hasNextLink() && result.ltr.IsEmpty() {
-		err = result.NextWithContext(ctx)
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client TableClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/default/tables", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client TableClient) ListResponder(resp *http.Response) (result ListTableResource, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// listNextResults retrieves the next set of results, if any.
-func (client TableClient) listNextResults(ctx context.Context, lastResults ListTableResource) (result ListTableResource, err error) {
-	req, err := lastResults.listTableResourcePreparer(ctx)
-	if err != nil {
-		return result, autorest.NewErrorWithError(err, "storage.TableClient", "listNextResults", nil, "Failure preparing next results request")
-	}
-	if req == nil {
-		return
-	}
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		return result, autorest.NewErrorWithError(err, "storage.TableClient", "listNextResults", resp, "Failure sending next results request")
-	}
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "listNextResults", resp, "Failure responding to next results request")
-	}
-	return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client TableClient) ListComplete(ctx context.Context, resourceGroupName string, accountName string) (result ListTableResourceIterator, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableClient.List")
-		defer func() {
-			sc := -1
-			if result.Response().Response.Response != nil {
-				sc = result.page.Response().Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	result.page, err = client.List(ctx, resourceGroupName, accountName)
-	return
-}
-
-// Update creates a new table with the specified table name, under the specified account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// tableName - a table name must be unique within a storage account and must be between 3 and 63 characters.The
-// name must comprise of only alphanumeric characters and it cannot begin with a numeric character.
-func (client TableClient) Update(ctx context.Context, resourceGroupName string, accountName string, tableName string) (result Table, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableClient.Update")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
-		{TargetValue: tableName,
-			Constraints: []validation.Constraint{{Target: "tableName", Name: validation.MaxLength, Rule: 63, Chain: nil},
-				{Target: "tableName", Name: validation.MinLength, Rule: 3, Chain: nil},
-				{Target: "tableName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]{2,62}$`, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableClient", "Update", err.Error())
-	}
-
-	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, tableName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Update", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.UpdateSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Update", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.UpdateResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableClient", "Update", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// UpdatePreparer prepares the Update request.
-func (client TableClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, tableName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-		"tableName":         autorest.Encode("path", tableName),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsPatch(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/default/tables/{tableName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// UpdateSender sends the Update request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableClient) UpdateSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// UpdateResponder handles the response to the Update request. The method always
-// closes the http.Response Body.
-func (client TableClient) UpdateResponder(resp *http.Response) (result Table, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/tableservices.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/tableservices.go
deleted file mode 100644
index 2a6b66bae40e..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/tableservices.go
+++ /dev/null
@@ -1,313 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// TableServicesClient is the the Azure Storage Management API.
-type TableServicesClient struct {
-	BaseClient
-}
-
-// NewTableServicesClient creates an instance of the TableServicesClient client.
-func NewTableServicesClient(subscriptionID string) TableServicesClient {
-	return NewTableServicesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewTableServicesClientWithBaseURI creates an instance of the TableServicesClient client using a custom endpoint.
-// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewTableServicesClientWithBaseURI(baseURI string, subscriptionID string) TableServicesClient {
-	return TableServicesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// GetServiceProperties gets the properties of a storage account’s Table service, including properties for Storage
-// Analytics and CORS (Cross-Origin Resource Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client TableServicesClient) GetServiceProperties(ctx context.Context, resourceGroupName string, accountName string) (result TableServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableServicesClient.GetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableServicesClient", "GetServiceProperties", err.Error())
-	}
-
-	req, err := client.GetServicePropertiesPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "GetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.GetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "GetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.GetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "GetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// GetServicePropertiesPreparer prepares the GetServiceProperties request.
-func (client TableServicesClient) GetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-		"tableServiceName":  autorest.Encode("path", "default"),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/{tableServiceName}", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// GetServicePropertiesSender sends the GetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableServicesClient) GetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// GetServicePropertiesResponder handles the response to the GetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client TableServicesClient) GetServicePropertiesResponder(resp *http.Response) (result TableServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// List list all table services for the storage account.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-func (client TableServicesClient) List(ctx context.Context, resourceGroupName string, accountName string) (result ListTableServices, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableServicesClient.List")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableServicesClient", "List", err.Error())
-	}
-
-	req, err := client.ListPreparer(ctx, resourceGroupName, accountName)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "List", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "List", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "List", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListPreparer prepares the List request.
-func (client TableServicesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListSender sends the List request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableServicesClient) ListSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListResponder handles the response to the List request. The method always
-// closes the http.Response Body.
-func (client TableServicesClient) ListResponder(resp *http.Response) (result ListTableServices, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
-
-// SetServiceProperties sets the properties of a storage account’s Table service, including properties for Storage
-// Analytics and CORS (Cross-Origin Resource Sharing) rules.
-// Parameters:
-// resourceGroupName - the name of the resource group within the user's subscription. The name is case
-// insensitive.
-// accountName - the name of the storage account within the specified resource group. Storage account names
-// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
-// parameters - the properties of a storage account’s Table service, only properties for Storage Analytics and
-// CORS (Cross-Origin Resource Sharing) rules can be specified.
-func (client TableServicesClient) SetServiceProperties(ctx context.Context, resourceGroupName string, accountName string, parameters TableServiceProperties) (result TableServiceProperties, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/TableServicesClient.SetServiceProperties")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: resourceGroupName,
-			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
-				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
-		{TargetValue: accountName,
-			Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
-				{Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.TableServicesClient", "SetServiceProperties", err.Error())
-	}
-
-	req, err := client.SetServicePropertiesPreparer(ctx, resourceGroupName, accountName, parameters)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "SetServiceProperties", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.SetServicePropertiesSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "SetServiceProperties", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.SetServicePropertiesResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.TableServicesClient", "SetServiceProperties", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// SetServicePropertiesPreparer prepares the SetServiceProperties request.
-func (client TableServicesClient) SetServicePropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters TableServiceProperties) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"accountName":       autorest.Encode("path", accountName),
-		"resourceGroupName": autorest.Encode("path", resourceGroupName),
-		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
-		"tableServiceName":  autorest.Encode("path", "default"),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsContentType("application/json; charset=utf-8"),
-		autorest.AsPut(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/tableServices/{tableServiceName}", pathParameters),
-		autorest.WithJSON(parameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the
-// http.Response Body if it receives an error.
-func (client TableServicesClient) SetServicePropertiesSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always
-// closes the http.Response Body.
-func (client TableServicesClient) SetServicePropertiesResponder(resp *http.Response) (result TableServiceProperties, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/usages.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/usages.go
deleted file mode 100644
index 210c45b38cff..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/usages.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package storage
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-import (
-	"context"
-	"github.com/Azure/go-autorest/autorest"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/validation"
-	"github.com/Azure/go-autorest/tracing"
-	"net/http"
-)
-
-// UsagesClient is the the Azure Storage Management API.
-type UsagesClient struct {
-	BaseClient
-}
-
-// NewUsagesClient creates an instance of the UsagesClient client.
-func NewUsagesClient(subscriptionID string) UsagesClient {
-	return NewUsagesClientWithBaseURI(DefaultBaseURI, subscriptionID)
-}
-
-// NewUsagesClientWithBaseURI creates an instance of the UsagesClient client using a custom endpoint.  Use this when
-// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
-func NewUsagesClientWithBaseURI(baseURI string, subscriptionID string) UsagesClient {
-	return UsagesClient{NewWithBaseURI(baseURI, subscriptionID)}
-}
-
-// ListByLocation gets the current usage count and the limit for the resources of the location under the subscription.
-// Parameters:
-// location - the location of the Azure Storage resource.
-func (client UsagesClient) ListByLocation(ctx context.Context, location string) (result UsageListResult, err error) {
-	if tracing.IsEnabled() {
-		ctx = tracing.StartSpan(ctx, fqdn+"/UsagesClient.ListByLocation")
-		defer func() {
-			sc := -1
-			if result.Response.Response != nil {
-				sc = result.Response.Response.StatusCode
-			}
-			tracing.EndSpan(ctx, sc, err)
-		}()
-	}
-	if err := validation.Validate([]validation.Validation{
-		{TargetValue: client.SubscriptionID,
-			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
-		return result, validation.NewError("storage.UsagesClient", "ListByLocation", err.Error())
-	}
-
-	req, err := client.ListByLocationPreparer(ctx, location)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.UsagesClient", "ListByLocation", nil, "Failure preparing request")
-		return
-	}
-
-	resp, err := client.ListByLocationSender(req)
-	if err != nil {
-		result.Response = autorest.Response{Response: resp}
-		err = autorest.NewErrorWithError(err, "storage.UsagesClient", "ListByLocation", resp, "Failure sending request")
-		return
-	}
-
-	result, err = client.ListByLocationResponder(resp)
-	if err != nil {
-		err = autorest.NewErrorWithError(err, "storage.UsagesClient", "ListByLocation", resp, "Failure responding to request")
-		return
-	}
-
-	return
-}
-
-// ListByLocationPreparer prepares the ListByLocation request.
-func (client UsagesClient) ListByLocationPreparer(ctx context.Context, location string) (*http.Request, error) {
-	pathParameters := map[string]interface{}{
-		"location":       autorest.Encode("path", location),
-		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
-	}
-
-	const APIVersion = "2021-02-01"
-	queryParameters := map[string]interface{}{
-		"api-version": APIVersion,
-	}
-
-	preparer := autorest.CreatePreparer(
-		autorest.AsGet(),
-		autorest.WithBaseURL(client.BaseURI),
-		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/locations/{location}/usages", pathParameters),
-		autorest.WithQueryParameters(queryParameters))
-	return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// ListByLocationSender sends the ListByLocation request. The method will close the
-// http.Response Body if it receives an error.
-func (client UsagesClient) ListByLocationSender(req *http.Request) (*http.Response, error) {
-	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
-}
-
-// ListByLocationResponder handles the response to the ListByLocation request. The method always
-// closes the http.Response Body.
-func (client UsagesClient) ListByLocationResponder(resp *http.Response) (result UsageListResult, err error) {
-	err = autorest.Respond(
-		resp,
-		azure.WithErrorUnlessStatusCode(http.StatusOK),
-		autorest.ByUnmarshallingJSON(&result),
-		autorest.ByClosing())
-	result.Response = autorest.Response{Response: resp}
-	return
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/version.go b/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/version.go
deleted file mode 100644
index de079b92f235..000000000000
--- a/cluster-autoscaler/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage/version.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package storage
-
-import "github.com/Azure/azure-sdk-for-go/version"
-
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License. See License.txt in the project root for license information.
-//
-// Code generated by Microsoft (R) AutoRest Code Generator.
-// Changes may cause incorrect behavior and will be lost if the code is regenerated.
-
-// UserAgent returns the UserAgent string to use when sending http.Requests.
-func UserAgent() string {
-	return "Azure-SDK-For-Go/" + Version() + " storage/2021-02-01"
-}
-
-// Version returns the semantic version (see http://semver.org) of the client.
-func Version() string {
-	return version.Number
-}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/README.md b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/README.md
index b11eb07884b0..97434ea7f770 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/README.md
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/README.md
@@ -160,7 +160,7 @@ if (err == nil) {
 ```Go
 certificatePath := "./example-app.pfx"
 
-certData, err := ioutil.ReadFile(certificatePath)
+certData, err := os.ReadFile(certificatePath)
 if err != nil {
 	return nil, fmt.Errorf("failed to read the certificate file (%s): %v", certificatePath, err)
 }
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go
index 9daa4b58b881..f040e2ac6b45 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/devicetoken.go
@@ -27,7 +27,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
@@ -116,7 +116,7 @@ func InitiateDeviceAuthWithContext(ctx context.Context, sender Sender, oauthConf
 	}
 
 	s := v.Encode()
-	body := ioutil.NopCloser(strings.NewReader(s))
+	body := io.NopCloser(strings.NewReader(s))
 
 	req, err := http.NewRequest(http.MethodPost, oauthConfig.DeviceCodeEndpoint.String(), body)
 	if err != nil {
@@ -131,7 +131,7 @@ func InitiateDeviceAuthWithContext(ctx context.Context, sender Sender, oauthConf
 	}
 	defer resp.Body.Close()
 
-	rb, err := ioutil.ReadAll(resp.Body)
+	rb, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("%s %s: %s", logPrefix, errCodeHandlingFails, err.Error())
 	}
@@ -175,7 +175,7 @@ func CheckForUserCompletionWithContext(ctx context.Context, sender Sender, code
 	}
 
 	s := v.Encode()
-	body := ioutil.NopCloser(strings.NewReader(s))
+	body := io.NopCloser(strings.NewReader(s))
 
 	req, err := http.NewRequest(http.MethodPost, code.OAuthConfig.TokenEndpoint.String(), body)
 	if err != nil {
@@ -190,7 +190,7 @@ func CheckForUserCompletionWithContext(ctx context.Context, sender Sender, code
 	}
 	defer resp.Body.Close()
 
-	rb, err := ioutil.ReadAll(resp.Body)
+	rb, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("%s %s: %s", logPrefix, errTokenHandlingFails, err.Error())
 	}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
index 2a974a39b3cd..fb54a43235ba 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/persist.go
@@ -20,7 +20,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 
@@ -62,7 +61,7 @@ func SaveToken(path string, mode os.FileMode, token Token) error {
 		return fmt.Errorf("failed to create directory (%s) to store token in: %v", dir, err)
 	}
 
-	newFile, err := ioutil.TempFile(dir, "token")
+	newFile, err := os.CreateTemp(dir, "token")
 	if err != nil {
 		return fmt.Errorf("failed to create the temp file to write the token: %v", err)
 	}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/token.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/token.go
index 2a24ab80cf16..67baecd83ffe 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/token.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/adal/token.go
@@ -25,7 +25,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"math"
 	"net/http"
 	"net/url"
@@ -1061,7 +1060,7 @@ func (spt *ServicePrincipalToken) refreshInternal(ctx context.Context, resource
 			} else if msiSecret.clientResourceID != "" {
 				data.Set("msi_res_id", msiSecret.clientResourceID)
 			}
-			req.Body = ioutil.NopCloser(strings.NewReader(data.Encode()))
+			req.Body = io.NopCloser(strings.NewReader(data.Encode()))
 			req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 			break
 		case msiTypeIMDS:
@@ -1096,7 +1095,7 @@ func (spt *ServicePrincipalToken) refreshInternal(ctx context.Context, resource
 		}
 
 		s := v.Encode()
-		body := ioutil.NopCloser(strings.NewReader(s))
+		body := io.NopCloser(strings.NewReader(s))
 		req.ContentLength = int64(len(s))
 		req.Header.Set(contentType, mimeTypeFormPost)
 		req.Body = body
@@ -1113,7 +1112,7 @@ func (spt *ServicePrincipalToken) refreshInternal(ctx context.Context, resource
 
 	logger.Instance.WriteResponse(resp, logger.Filter{Body: authBodyFilter})
 	defer resp.Body.Close()
-	rb, err := ioutil.ReadAll(resp.Body)
+	rb, err := io.ReadAll(resp.Body)
 
 	if resp.StatusCode != http.StatusOK {
 		if err != nil {
@@ -1235,7 +1234,7 @@ func retryForIMDS(sender Sender, req *http.Request, maxAttempts int) (resp *http
 
 	for attempt < maxAttempts {
 		if resp != nil && resp.Body != nil {
-			io.Copy(ioutil.Discard, resp.Body)
+			io.Copy(io.Discard, resp.Body)
 			resp.Body.Close()
 		}
 		resp, err = sender.Do(req)
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/README.md b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/README.md
new file mode 100644
index 000000000000..05bef8a8002d
--- /dev/null
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/README.md
@@ -0,0 +1,152 @@
+# NOTE: This module will go out of support by March 31, 2023.  For authenticating with Azure AD, use module [azidentity](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity) instead.  For help migrating from `auth` to `azidentiy` please consult the [migration guide](https://aka.ms/azsdk/go/identity/migration).  General information about the retirement of this and other legacy modules can be found [here](https://azure.microsoft.com/updates/support-for-azure-sdk-libraries-that-do-not-conform-to-our-current-azure-sdk-guidelines-will-be-retired-as-of-31-march-2023/).
+
+## Authentication
+
+Typical SDK operations must be authenticated and authorized. The `autorest.Authorizer`
+interface allows use of any auth style in requests, such as inserting an OAuth2
+Authorization header and bearer token received from Azure AD.
+
+The SDK itself provides a simple way to get an authorizer which first checks
+for OAuth client credentials in environment variables and then falls back to
+Azure's [Managed Service Identity]() when available, e.g. when on an Azure
+VM. The following snippet from [the previous section](#use) demonstrates
+this helper.
+
+```go
+import "github.com/Azure/go-autorest/autorest/azure/auth"
+
+// create a VirtualNetworks client
+vnetClient := network.NewVirtualNetworksClient("<subscriptionID>")
+
+// create an authorizer from env vars or Azure Managed Service Idenity
+authorizer, err := auth.NewAuthorizerFromEnvironment()
+if err != nil {
+    handle(err)
+}
+
+vnetClient.Authorizer = authorizer
+
+// call the VirtualNetworks CreateOrUpdate API
+vnetClient.CreateOrUpdate(context.Background(),
+// ...
+```
+
+The following environment variables help determine authentication configuration:
+
+- `AZURE_ENVIRONMENT`: Specifies the Azure Environment to use. If not set, it
+  defaults to `AzurePublicCloud`. Not applicable to authentication with Managed
+  Service Identity (MSI).
+- `AZURE_AD_RESOURCE`: Specifies the AAD resource ID to use. If not set, it
+  defaults to `ResourceManagerEndpoint` for operations with Azure Resource
+  Manager. You can also choose an alternate resource programmatically with
+  `auth.NewAuthorizerFromEnvironmentWithResource(resource string)`.
+
+### More Authentication Details
+
+The previous is the first and most recommended of several authentication
+options offered by the SDK because it allows seamless use of both service
+principals and [Azure Managed Service Identity][]. Other options are listed
+below.
+
+> Note: If you need to create a new service principal, run `az ad sp create-for-rbac -n "<app_name>"` in the
+> [azure-cli](https://github.com/Azure/azure-cli). See [these
+> docs](https://docs.microsoft.com/cli/azure/create-an-azure-service-principal-azure-cli?view=azure-cli-latest)
+> for more info. Copy the new principal's ID, secret, and tenant ID for use in
+> your app, or consider the `--sdk-auth` parameter for serialized output.
+
+[azure managed service identity]: https://docs.microsoft.com/azure/active-directory/msi-overview
+
+- The `auth.NewAuthorizerFromEnvironment()` described above creates an authorizer
+  from the first available of the following configuration:
+
+      1. **Client Credentials**: Azure AD Application ID and Secret.
+
+          - `AZURE_TENANT_ID`: Specifies the Tenant to which to authenticate.
+          - `AZURE_CLIENT_ID`: Specifies the app client ID to use.
+          - `AZURE_CLIENT_SECRET`: Specifies the app secret to use.
+
+      2. **Client Certificate**: Azure AD Application ID and X.509 Certificate.
+
+          - `AZURE_TENANT_ID`: Specifies the Tenant to which to authenticate.
+          - `AZURE_CLIENT_ID`: Specifies the app client ID to use.
+          - `AZURE_CERTIFICATE_PATH`: Specifies the certificate Path to use.
+          - `AZURE_CERTIFICATE_PASSWORD`: Specifies the certificate password to use.
+
+      3. **Resource Owner Password**: Azure AD User and Password. This grant type is *not
+         recommended*, use device login instead if you need interactive login.
+
+          - `AZURE_TENANT_ID`: Specifies the Tenant to which to authenticate.
+          - `AZURE_CLIENT_ID`: Specifies the app client ID to use.
+          - `AZURE_USERNAME`: Specifies the username to use.
+          - `AZURE_PASSWORD`: Specifies the password to use.
+
+      4. **Azure Managed Service Identity**: Delegate credential management to the
+         platform. Requires that code is running in Azure, e.g. on a VM. All
+         configuration is handled by Azure. See [Azure Managed Service
+         Identity](https://docs.microsoft.com/azure/active-directory/msi-overview)
+         for more details.
+
+- The `auth.NewAuthorizerFromFile()` method creates an authorizer using
+  credentials from an auth file created by the [Azure CLI][]. Follow these
+  steps to utilize:
+
+  1. Create a service principal and output an auth file using `az ad sp create-for-rbac --sdk-auth > client_credentials.json`.
+  2. Set environment variable `AZURE_AUTH_LOCATION` to the path of the saved
+     output file.
+  3. Use the authorizer returned by `auth.NewAuthorizerFromFile()` in your
+     client as described above.
+
+- The `auth.NewAuthorizerFromCLI()` method creates an authorizer which
+  uses [Azure CLI][] to obtain its credentials.
+  
+  The default audience being requested is `https://management.azure.com` (Azure ARM API).
+  To specify your own audience, export `AZURE_AD_RESOURCE` as an evironment variable.
+  This is read by `auth.NewAuthorizerFromCLI()` and passed to Azure CLI to acquire the access token.
+  
+  For example, to request an access token for Azure Key Vault, export
+  ```
+  AZURE_AD_RESOURCE="https://vault.azure.net"
+  ```
+  
+- `auth.NewAuthorizerFromCLIWithResource(AUDIENCE_URL_OR_APPLICATION_ID)` - this method is self contained and does
+  not require exporting environment variables. For example, to request an access token for Azure Key Vault:
+  ```
+  auth.NewAuthorizerFromCLIWithResource("https://vault.azure.net")
+  ```
+
+  To use `NewAuthorizerFromCLI()` or `NewAuthorizerFromCLIWithResource()`, follow these steps:
+
+  1. Install [Azure CLI v2.0.12](https://docs.microsoft.com/cli/azure/install-azure-cli) or later. Upgrade earlier versions.
+  2. Use `az login` to sign in to Azure.
+
+  If you receive an error, use `az account get-access-token` to verify access.
+
+  If Azure CLI is not installed to the default directory, you may receive an error
+  reporting that `az` cannot be found.  
+  Use the `AzureCLIPath` environment variable to define the Azure CLI installation folder.
+
+  If you are signed in to Azure CLI using multiple accounts or your account has
+  access to multiple subscriptions, you need to specify the specific subscription
+  to be used. To do so, use:
+
+  ```
+  az account set --subscription <subscription-id>
+  ```
+
+  To verify the current account settings, use:
+
+  ```
+  az account list
+  ```
+
+[azure cli]: https://github.com/Azure/azure-cli
+
+- Finally, you can use OAuth's [Device Flow][] by calling
+  `auth.NewDeviceFlowConfig()` and extracting the Authorizer as follows:
+
+  ```go
+  config := auth.NewDeviceFlowConfig(clientID, tenantID)
+  a, err := config.Authorizer()
+  ```
+
+[device flow]: https://oauth.net/2/device-flow/
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
index 85acf1c9bc98..25697b3c854c 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
@@ -16,11 +16,12 @@ package auth
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"os"
 	"strings"
@@ -232,6 +233,9 @@ func (settings EnvironmentSettings) GetAuthorizer() (autorest.Authorizer, error)
 	}
 
 	// 4. MSI
+	if !adal.MSIAvailable(context.Background(), nil) {
+		return nil, errors.New("MSI not available")
+	}
 	logger.Instance.Writeln(logger.LogInfo, "EnvironmentSettings.GetAuthorizer() using MSI authentication")
 	return settings.GetMSI().Authorizer()
 }
@@ -246,6 +250,17 @@ func NewAuthorizerFromFile(resourceBaseURI string) (autorest.Authorizer, error)
 	if err != nil {
 		return nil, err
 	}
+	return settings.GetAuthorizer(resourceBaseURI)
+}
+
+// GetAuthorizer create an Authorizer in the following order.
+// 1. Client credentials
+// 2. Client certificate
+// resourceBaseURI - used to determine the resource type
+func (settings FileSettings) GetAuthorizer(resourceBaseURI string) (autorest.Authorizer, error) {
+	if resourceBaseURI == "" {
+		resourceBaseURI = azure.PublicCloud.ServiceManagementEndpoint
+	}
 	if a, err := settings.ClientCredentialsAuthorizer(resourceBaseURI); err == nil {
 		return a, err
 	}
@@ -310,7 +325,7 @@ func GetSettingsFromFile() (FileSettings, error) {
 		return s, errors.New("environment variable AZURE_AUTH_LOCATION is not set")
 	}
 
-	contents, err := ioutil.ReadFile(fileLocation)
+	contents, err := os.ReadFile(fileLocation)
 	if err != nil {
 		return s, err
 	}
@@ -473,7 +488,7 @@ func decode(b []byte) ([]byte, error) {
 		}
 		return []byte(string(utf16.Decode(u16))), nil
 	}
-	return ioutil.ReadAll(reader)
+	return io.ReadAll(reader)
 }
 
 func (settings FileSettings) getResourceForToken(baseURI string) (string, error) {
@@ -555,7 +570,7 @@ func NewDeviceFlowConfig(clientID string, tenantID string) DeviceFlowConfig {
 	}
 }
 
-//AuthorizerConfig provides an authorizer from the configuration provided.
+// AuthorizerConfig provides an authorizer from the configuration provided.
 type AuthorizerConfig interface {
 	Authorizer() (autorest.Authorizer, error)
 }
@@ -621,7 +636,7 @@ func (ccc ClientCertificateConfig) ServicePrincipalToken() (*adal.ServicePrincip
 	if err != nil {
 		return nil, err
 	}
-	certData, err := ioutil.ReadFile(ccc.CertificatePath)
+	certData, err := os.ReadFile(ccc.CertificatePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read the certificate file (%s): %v", ccc.CertificatePath, err)
 	}
@@ -638,7 +653,7 @@ func (ccc ClientCertificateConfig) MultiTenantServicePrincipalToken() (*adal.Mul
 	if err != nil {
 		return nil, err
 	}
-	certData, err := ioutil.ReadFile(ccc.CertificatePath)
+	certData, err := os.ReadFile(ccc.CertificatePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read the certificate file (%s): %v", ccc.CertificatePath, err)
 	}
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/go_mod_tidy_hack.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/go_mod_tidy_hack.go
index 38e4900ad0fb..f7eb26fd366b 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/go_mod_tidy_hack.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/auth/go_mod_tidy_hack.go
@@ -1,3 +1,4 @@
+//go:build modhack
 // +build modhack
 
 package auth
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/go_mod_tidy_hack.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/go_mod_tidy_hack.go
index 861ce2984e64..50d6f0391a5e 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/go_mod_tidy_hack.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/go_mod_tidy_hack.go
@@ -1,3 +1,4 @@
+//go:build modhack
 // +build modhack
 
 package cli
diff --git a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
index 44ff446f6697..486619111c67 100644
--- a/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
+++ b/cluster-autoscaler/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
@@ -124,24 +124,91 @@ func LoadTokens(path string) ([]Token, error) {
 
 // GetTokenFromCLI gets a token using Azure CLI 2.0 for local development scenarios.
 func GetTokenFromCLI(resource string) (*Token, error) {
-	// This is the path that a developer can set to tell this class what the install path for Azure CLI is.
-	const azureCLIPath = "AzureCLIPath"
+	return GetTokenFromCLIWithParams(GetAccessTokenParams{Resource: resource})
+}
 
-	// The default install paths are used to find Azure CLI. This is for security, so that any path in the calling program's Path environment is not used to execute Azure CLI.
-	azureCLIDefaultPathWindows := fmt.Sprintf("%s\\Microsoft SDKs\\Azure\\CLI2\\wbin; %s\\Microsoft SDKs\\Azure\\CLI2\\wbin", os.Getenv("ProgramFiles(x86)"), os.Getenv("ProgramFiles"))
+// GetAccessTokenParams is the parameter struct of GetTokenFromCLIWithParams
+type GetAccessTokenParams struct {
+	Resource     string
+	ResourceType string
+	Subscription string
+	Tenant       string
+}
 
-	// Default path for non-Windows.
-	const azureCLIDefaultPath = "/bin:/sbin:/usr/bin:/usr/local/bin"
+// GetTokenFromCLIWithParams gets a token using Azure CLI 2.0 for local development scenarios.
+func GetTokenFromCLIWithParams(params GetAccessTokenParams) (*Token, error) {
+	cliCmd := GetAzureCLICommand()
 
-	// Validate resource, since it gets sent as a command line argument to Azure CLI
-	const invalidResourceErrorTemplate = "Resource %s is not in expected format. Only alphanumeric characters, [dot], [colon], [hyphen], and [forward slash] are allowed."
-	match, err := regexp.MatchString("^[0-9a-zA-Z-.:/]+$", resource)
+	cliCmd.Args = append(cliCmd.Args, "account", "get-access-token", "-o", "json")
+	if params.Resource != "" {
+		if err := validateParameter(params.Resource); err != nil {
+			return nil, err
+		}
+		cliCmd.Args = append(cliCmd.Args, "--resource", params.Resource)
+	}
+	if params.ResourceType != "" {
+		if err := validateParameter(params.ResourceType); err != nil {
+			return nil, err
+		}
+		cliCmd.Args = append(cliCmd.Args, "--resource-type", params.ResourceType)
+	}
+	if params.Subscription != "" {
+		if err := validateParameter(params.Subscription); err != nil {
+			return nil, err
+		}
+		cliCmd.Args = append(cliCmd.Args, "--subscription", params.Subscription)
+	}
+	if params.Tenant != "" {
+		if err := validateParameter(params.Tenant); err != nil {
+			return nil, err
+		}
+		cliCmd.Args = append(cliCmd.Args, "--tenant", params.Tenant)
+	}
+
+	var stderr bytes.Buffer
+	cliCmd.Stderr = &stderr
+
+	output, err := cliCmd.Output()
+	if err != nil {
+		if stderr.Len() > 0 {
+			return nil, fmt.Errorf("Invoking Azure CLI failed with the following error: %s", stderr.String())
+		}
+
+		return nil, fmt.Errorf("Invoking Azure CLI failed with the following error: %s", err.Error())
+	}
+
+	tokenResponse := Token{}
+	err = json.Unmarshal(output, &tokenResponse)
 	if err != nil {
 		return nil, err
 	}
+
+	return &tokenResponse, err
+}
+
+func validateParameter(param string) error {
+	// Validate parameters, since it gets sent as a command line argument to Azure CLI
+	const invalidResourceErrorTemplate = "Parameter %s is not in expected format. Only alphanumeric characters, [dot], [colon], [hyphen], and [forward slash] are allowed."
+	match, err := regexp.MatchString("^[0-9a-zA-Z-.:/]+$", param)
+	if err != nil {
+		return err
+	}
 	if !match {
-		return nil, fmt.Errorf(invalidResourceErrorTemplate, resource)
+		return fmt.Errorf(invalidResourceErrorTemplate, param)
 	}
+	return nil
+}
+
+// GetAzureCLICommand can be used to run arbitrary Azure CLI command
+func GetAzureCLICommand() *exec.Cmd {
+	// This is the path that a developer can set to tell this class what the install path for Azure CLI is.
+	const azureCLIPath = "AzureCLIPath"
+
+	// The default install paths are used to find Azure CLI. This is for security, so that any path in the calling program's Path environment is not used to execute Azure CLI.
+	azureCLIDefaultPathWindows := fmt.Sprintf("%s\\Microsoft SDKs\\Azure\\CLI2\\wbin; %s\\Microsoft SDKs\\Azure\\CLI2\\wbin", os.Getenv("ProgramFiles(x86)"), os.Getenv("ProgramFiles"))
+
+	// Default path for non-Windows.
+	const azureCLIDefaultPath = "/bin:/sbin:/usr/bin:/usr/local/bin"
 
 	// Execute Azure CLI to get token
 	var cliCmd *exec.Cmd
@@ -155,21 +222,6 @@ func GetTokenFromCLI(resource string) (*Token, error) {
 		cliCmd.Env = os.Environ()
 		cliCmd.Env = append(cliCmd.Env, fmt.Sprintf("PATH=%s:%s", os.Getenv(azureCLIPath), azureCLIDefaultPath))
 	}
-	cliCmd.Args = append(cliCmd.Args, "account", "get-access-token", "-o", "json", "--resource", resource)
 
-	var stderr bytes.Buffer
-	cliCmd.Stderr = &stderr
-
-	output, err := cliCmd.Output()
-	if err != nil {
-		return nil, fmt.Errorf("Invoking Azure CLI failed with the following error: %s", stderr.String())
-	}
-
-	tokenResponse := Token{}
-	err = json.Unmarshal(output, &tokenResponse)
-	if err != nil {
-		return nil, err
-	}
-
-	return &tokenResponse, err
+	return cliCmd
 }
diff --git a/cluster-autoscaler/vendor/modules.txt b/cluster-autoscaler/vendor/modules.txt
index a0d8c6b92851..1b89d465f8c5 100644
--- a/cluster-autoscaler/vendor/modules.txt
+++ b/cluster-autoscaler/vendor/modules.txt
@@ -11,7 +11,6 @@ github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute
 github.com/Azure/azure-sdk-for-go/services/containerservice/mgmt/2021-10-01/containerservice
 github.com/Azure/azure-sdk-for-go/services/network/mgmt/2022-07-01/network
 github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2017-05-10/resources
-github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage
 github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-09-01/storage
 github.com/Azure/azure-sdk-for-go/storage
 github.com/Azure/azure-sdk-for-go/version
@@ -94,14 +93,14 @@ github.com/Azure/go-autorest
 ## explicit; go 1.15
 github.com/Azure/go-autorest/autorest
 github.com/Azure/go-autorest/autorest/azure
-# github.com/Azure/go-autorest/autorest/adal v0.9.23
+# github.com/Azure/go-autorest/autorest/adal v0.9.24
 ## explicit; go 1.15
 github.com/Azure/go-autorest/autorest/adal
-# github.com/Azure/go-autorest/autorest/azure/auth v0.5.8
-## explicit; go 1.12
+# github.com/Azure/go-autorest/autorest/azure/auth v0.5.13
+## explicit; go 1.15
 github.com/Azure/go-autorest/autorest/azure/auth
-# github.com/Azure/go-autorest/autorest/azure/cli v0.4.2
-## explicit; go 1.12
+# github.com/Azure/go-autorest/autorest/azure/cli v0.4.6
+## explicit; go 1.15
 github.com/Azure/go-autorest/autorest/azure/cli
 # github.com/Azure/go-autorest/autorest/date v0.3.0
 ## explicit; go 1.12
@@ -2235,8 +2234,8 @@ k8s.io/utils/ptr
 k8s.io/utils/strings
 k8s.io/utils/strings/slices
 k8s.io/utils/trace
-# sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.29.0
-## explicit; go 1.20
+# sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.30.3
+## explicit; go 1.21
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client/metrics
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/common/metrics
diff --git a/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go b/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go
index 6af92b448b06..da1e37c18ba3 100644
--- a/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go
+++ b/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client.pb.go
@@ -15,7 +15,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.27.1
-// 	protoc        v3.12.4
+// 	protoc        v3.21.12
 // source: konnectivity-client/proto/client/client.proto
 
 package client
diff --git a/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client_grpc.pb.go b/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client_grpc.pb.go
index b8d07fe55a20..5a0d6a2a844c 100644
--- a/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client_grpc.pb.go
+++ b/cluster-autoscaler/vendor/sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client/client_grpc.pb.go
@@ -16,7 +16,7 @@ limitations under the License.
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.2.0
-// - protoc             v3.12.4
+// - protoc             v3.21.12
 // source: konnectivity-client/proto/client/client.proto
 
 package client