diff --git a/internal/clients/client.go b/internal/clients/client.go
index f1a776d27bfb..bb6f8c2862ed 100644
--- a/internal/clients/client.go
+++ b/internal/clients/client.go
@@ -464,7 +464,9 @@ func (client *Client) Build(ctx context.Context, o *common.ClientOptions) error
 	if client.LogAnalytics, err = loganalytics.NewClient(o); err != nil {
 		return fmt.Errorf("building clients for LogAnalytics: %+v", err)
 	}
-	client.LoadBalancers = loadbalancers.NewClient(o)
+	if client.LoadBalancers, err = loadbalancers.NewClient(o); err != nil {
+		return fmt.Errorf("building clients for LoadBalancers: %+v", err)
+	}
 	if client.Logic, err = logic.NewClient(o); err != nil {
 		return fmt.Errorf("building clients for Logic: %+v", err)
 	}
diff --git a/internal/services/databricks/databricks_workspace_resource.go b/internal/services/databricks/databricks_workspace_resource.go
index f2300185f468..179feb590d68 100644
--- a/internal/services/databricks/databricks_workspace_resource.go
+++ b/internal/services/databricks/databricks_workspace_resource.go
@@ -17,6 +17,7 @@ import (
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/tags"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/databricks/2023-02-01/workspaces"
 	mlworkspace "github.com/hashicorp/go-azure-sdk/resource-manager/machinelearningservices/2023-04-01/workspaces"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/azure"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
@@ -24,8 +25,6 @@ import (
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/databricks/validate"
 	keyVaultParse "github.com/hashicorp/terraform-provider-azurerm/internal/services/keyvault/parse"
 	keyVaultValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/keyvault/validate"
-	loadBalancerParse "github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	loadBalancerValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	resourcesParse "github.com/hashicorp/terraform-provider-azurerm/internal/services/resource/parse"
 	storageValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/storage/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
@@ -160,7 +159,7 @@ func resourceDatabricksWorkspace() *pluginsdk.Resource {
 				Type:         pluginsdk.TypeString,
 				Optional:     true,
 				ForceNew:     true,
-				ValidateFunc: loadBalancerValidate.LoadBalancerBackendAddressPoolID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerBackendAddressPoolID,
 			},
 
 			"custom_parameters": {
@@ -386,13 +385,13 @@ func resourceDatabricksWorkspaceCreateUpdate(d *pluginsdk.ResourceData, meta int
 	expandedTags := tags.Expand(d.Get("tags").(map[string]interface{}))
 
 	if backendPool != "" {
-		backendPoolId, err := loadBalancerParse.LoadBalancerBackendAddressPoolID(backendPool)
+		backendPoolId, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(backendPool)
 		if err != nil {
 			return err
 		}
 
 		// Generate the load balancer ID from the Backend Address Pool Id...
-		lbId := loadBalancerParse.NewLoadBalancerID(backendPoolId.SubscriptionId, backendPoolId.ResourceGroup, backendPoolId.LoadBalancerName)
+		lbId := loadbalancers.NewLoadBalancerID(backendPoolId.SubscriptionId, backendPoolId.ResourceGroupName, backendPoolId.LoadBalancerName)
 
 		backendPoolName = backendPoolId.BackendAddressPoolName
 		loadBalancerId = lbId.ID()
@@ -404,12 +403,13 @@ func resourceDatabricksWorkspaceCreateUpdate(d *pluginsdk.ResourceData, meta int
 		defer locks.UnlockByID(lbId.ID())
 
 		// check to make sure the load balancer exists as referred to by the Backend Address Pool...
-		lb, err := lbClient.Get(ctx, lbId.ResourceGroup, lbId.Name, "")
+		plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: backendPoolId.SubscriptionId, ResourceGroupName: backendPoolId.ResourceGroupName, LoadBalancerName: backendPoolId.LoadBalancerName}
+		lb, err := lbClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 		if err != nil {
-			if utils.ResponseWasNotFound(lb.Response) {
-				return fmt.Errorf("load balancer %q for Backend Address Pool %q was not found", lbId, backendPoolId)
+			if response.WasNotFound(lb.HttpResponse) {
+				return fmt.Errorf("%s was not found", lbId)
 			}
-			return fmt.Errorf("failed to retrieve Load Balancer %q for Backend Address Pool %q: %+v", lbId, backendPoolId, err)
+			return fmt.Errorf("retrieving %s: %+v", lbId, err)
 		}
 	}
 
@@ -829,10 +829,10 @@ func flattenWorkspaceCustomParameters(input *workspaces.WorkspaceCustomParameter
 		parameters["virtual_network_id"] = v.Value
 	}
 
-	lbId, err := loadBalancerParse.LoadBalancerIDInsensitively(loadBalancerId)
+	lbId, err := loadbalancers.ParseLoadBalancerIDInsensitively(loadBalancerId)
 
 	if err == nil {
-		backendId := loadBalancerParse.NewLoadBalancerBackendAddressPoolID(lbId.SubscriptionId, lbId.ResourceGroup, lbId.Name, backendName)
+		backendId := loadbalancers.NewLoadBalancerBackendAddressPoolID(lbId.SubscriptionId, lbId.ResourceGroupName, lbId.LoadBalancerName, backendName)
 		backendAddressPoolId = backendId.ID()
 	}
 
diff --git a/internal/services/loadbalancer/backend_address_pool_address_resource.go b/internal/services/loadbalancer/backend_address_pool_address_resource.go
index 1f37cdf650dc..33def544aaa1 100644
--- a/internal/services/loadbalancer/backend_address_pool_address_resource.go
+++ b/internal/services/loadbalancer/backend_address_pool_address_resource.go
@@ -8,15 +8,15 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/sdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 var (
@@ -77,7 +77,7 @@ func (r BackendAddressPoolAddressResource) Arguments() map[string]*pluginsdk.Sch
 			Type:         pluginsdk.TypeString,
 			Required:     true,
 			ForceNew:     true,
-			ValidateFunc: validate.LoadBalancerBackendAddressPoolID,
+			ValidateFunc: loadbalancers.ValidateLoadBalancerBackendAddressPoolID,
 		},
 
 		"virtual_network_id": {
@@ -100,7 +100,7 @@ func (r BackendAddressPoolAddressResource) Arguments() map[string]*pluginsdk.Sch
 			Type:          pluginsdk.TypeString,
 			Optional:      true,
 			ConflictsWith: []string{"virtual_network_id"},
-			ValidateFunc:  validate.LoadBalancerFrontendIpConfigurationID,
+			ValidateFunc:  loadbalancers.ValidateFrontendIPConfigurationID,
 			Description:   "For global load balancer, user needs to specify the `backend_address_ip_configuration_id` of the added regional load balancers",
 		},
 	}
@@ -123,7 +123,7 @@ func (r BackendAddressPoolAddressResource) ResourceType() string {
 func (r BackendAddressPoolAddressResource) Create() sdk.ResourceFunc {
 	return sdk.ResourceFunc{
 		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
-			client := metadata.Client.LoadBalancers.LoadBalancerBackendAddressPoolsClient
+			lbClient := metadata.Client.LoadBalancers.LoadBalancersClient
 			subscriptionId := metadata.Client.Account.SubscriptionId
 
 			var model BackendAddressPoolAddressModel
@@ -131,7 +131,7 @@ func (r BackendAddressPoolAddressResource) Create() sdk.ResourceFunc {
 				return fmt.Errorf("decoding: %+v", err)
 			}
 
-			poolId, err := parse.LoadBalancerBackendAddressPoolID(model.BackendAddressPoolId)
+			poolId, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(model.BackendAddressPoolId)
 			if err != nil {
 				return err
 			}
@@ -140,80 +140,92 @@ func (r BackendAddressPoolAddressResource) Create() sdk.ResourceFunc {
 			defer locks.UnlockByName(poolId.BackendAddressPoolName, backendAddressPoolResourceName)
 
 			// Backend Addresses can not be created for Basic sku, so we have to check
-			lb, err := metadata.Client.LoadBalancers.LoadBalancersClient.Get(ctx, poolId.ResourceGroup, poolId.LoadBalancerName, "")
+			plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: subscriptionId, ResourceGroupName: poolId.ResourceGroupName, LoadBalancerName: poolId.LoadBalancerName}
+			lb, err := metadata.Client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 			if err != nil {
-				return fmt.Errorf("retrieving Load Balancer %q (Resource Group %q): %+v", poolId.LoadBalancerName, poolId.ResourceGroup, err)
+				return fmt.Errorf("retrieving %s: %+v", plbId, err)
 			}
+
 			isBasicSku := true
-			if lb.Sku != nil && lb.Sku.Name != network.LoadBalancerSkuNameBasic {
-				isBasicSku = false
-			}
-			if isBasicSku {
-				return fmt.Errorf("Backend Addresses are not supported on Basic SKU Load Balancers")
-			}
-			if lb.Sku != nil && lb.Sku.Tier == network.LoadBalancerSkuTierGlobal {
-				if model.FrontendIPConfiguration == "" {
-					return fmt.Errorf("Please set a Regional Backend Address Pool Addresses for the Global load balancer")
+			if lb := lb.Model; lb != nil {
+				if lb.Sku != nil && pointer.From(lb.Sku.Name) != loadbalancers.LoadBalancerSkuNameBasic {
+					isBasicSku = false
+				}
+				if isBasicSku {
+					return fmt.Errorf("Backend Addresses are not supported on Basic SKU Load Balancers")
+				}
+				if lb.Sku != nil && pointer.From(lb.Sku.Tier) == loadbalancers.LoadBalancerSkuTierGlobal {
+					if model.FrontendIPConfiguration == "" {
+						return fmt.Errorf("Please set a Regional Backend Address Pool Addresses for the Global load balancer")
+					}
 				}
-			}
 
-			id := parse.NewBackendAddressPoolAddressID(subscriptionId, poolId.ResourceGroup, poolId.LoadBalancerName, poolId.BackendAddressPoolName, model.Name)
-			pool, err := client.Get(ctx, poolId.ResourceGroup, poolId.LoadBalancerName, poolId.BackendAddressPoolName)
-			if err != nil {
-				return fmt.Errorf("retrieving %s: %+v", *poolId, err)
-			}
-			if pool.BackendAddressPoolPropertiesFormat == nil {
-				return fmt.Errorf("retrieving %s: `properties` was nil", *poolId)
-			}
+				id := parse.NewBackendAddressPoolAddressID(subscriptionId, poolId.ResourceGroupName, poolId.LoadBalancerName, poolId.BackendAddressPoolName, model.Name)
+				pool, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, *poolId)
+				if err != nil {
+					return fmt.Errorf("retrieving %s: %+v", *poolId, err)
+				}
 
-			addresses := make([]network.LoadBalancerBackendAddress, 0)
-			if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses != nil {
-				addresses = *pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses
-			}
+				if pool.Model == nil {
+					return fmt.Errorf("retrieving %s: `model` was nil", *poolId)
+				}
 
-			metadata.Logger.Infof("checking for existing %s..", id)
-			for _, address := range addresses {
-				if address.Name == nil {
-					continue
+				if pool.Model.Properties == nil {
+					return fmt.Errorf("retrieving %s: `properties` was nil", *poolId)
 				}
 
-				if *address.Name == id.AddressName {
-					return metadata.ResourceRequiresImport(r.ResourceType(), id)
+				addresses := make([]loadbalancers.LoadBalancerBackendAddress, 0)
+				if pool.Model.Properties.LoadBalancerBackendAddresses != nil {
+					addresses = *pool.Model.Properties.LoadBalancerBackendAddresses
 				}
-			}
 
-			if lb.Sku.Tier == network.LoadBalancerSkuTierGlobal {
-				addresses = append(addresses, network.LoadBalancerBackendAddress{
-					Name: utils.String(id.AddressName),
-					LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-						LoadBalancerFrontendIPConfiguration: &network.SubResource{
-							ID: utils.String(model.FrontendIPConfiguration),
+				metadata.Logger.Infof("checking for existing %s..", id)
+				for _, address := range addresses {
+					if address.Name == nil {
+						continue
+					}
+
+					if *address.Name == model.Name {
+						return metadata.ResourceRequiresImport(r.ResourceType(), id)
+					}
+				}
+
+				if pointer.From(lb.Sku.Tier) == loadbalancers.LoadBalancerSkuTierGlobal {
+					addresses = append(addresses, loadbalancers.LoadBalancerBackendAddress{
+						Name: pointer.To(model.Name),
+						Properties: &loadbalancers.LoadBalancerBackendAddressPropertiesFormat{
+							LoadBalancerFrontendIPConfiguration: &loadbalancers.SubResource{
+								Id: pointer.To(model.FrontendIPConfiguration),
+							},
 						},
-					},
-				})
-			} else {
-				addresses = append(addresses, network.LoadBalancerBackendAddress{
-					LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-						IPAddress: utils.String(model.IPAddress),
-						VirtualNetwork: &network.SubResource{
-							ID: utils.String(model.VirtualNetworkId),
+					})
+				} else {
+					addresses = append(addresses, loadbalancers.LoadBalancerBackendAddress{
+						Properties: &loadbalancers.LoadBalancerBackendAddressPropertiesFormat{
+							IPAddress: pointer.To(model.IPAddress),
+							VirtualNetwork: &loadbalancers.SubResource{
+								Id: pointer.To(model.VirtualNetworkId),
+							},
 						},
+						Name: pointer.To(model.Name),
+					})
+				}
+
+				backendAddressPool := loadbalancers.BackendAddressPool{
+					Properties: &loadbalancers.BackendAddressPoolPropertiesFormat{
+						LoadBalancerBackendAddresses: &addresses,
 					},
-					Name: utils.String(id.AddressName),
-				})
-			}
-			pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses = &addresses
+				}
+				metadata.Logger.Infof("adding %s..", id)
+				err = lbClient.LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx, *poolId, backendAddressPool)
+				if err != nil {
+					return fmt.Errorf("updating %s: %+v", id, err)
+				}
+				metadata.Logger.Infof("waiting for update %s..", id)
 
-			metadata.Logger.Infof("adding %s..", id)
-			future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName, pool)
-			if err != nil {
-				return fmt.Errorf("updating %s: %+v", id, err)
+				metadata.SetID(id)
 			}
-			metadata.Logger.Infof("waiting for update %s..", id)
-			if err := future.WaitForCompletionRef(ctx, client.Client); err != nil {
-				return fmt.Errorf("waiting for update of %s: %+v", id, err)
-			}
-			metadata.SetID(id)
+
 			return nil
 		},
 		Timeout: 30 * time.Minute,
@@ -223,84 +235,91 @@ func (r BackendAddressPoolAddressResource) Create() sdk.ResourceFunc {
 func (r BackendAddressPoolAddressResource) Read() sdk.ResourceFunc {
 	return sdk.ResourceFunc{
 		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
-			client := metadata.Client.LoadBalancers.LoadBalancerBackendAddressPoolsClient
 			lbClient := metadata.Client.LoadBalancers.LoadBalancersClient
+
 			id, err := parse.BackendAddressPoolAddressID(metadata.ResourceData.Id())
 			if err != nil {
 				return err
 			}
 
-			pool, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+			poolId := loadbalancers.NewLoadBalancerBackendAddressPoolID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+			pool, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, poolId)
 			if err != nil {
-				return fmt.Errorf("retrieving %s: %+v", *id, err)
+				return fmt.Errorf("retrieving %s: %+v", poolId, err)
 			}
-			if pool.BackendAddressPoolPropertiesFormat == nil {
-				return fmt.Errorf("retrieving %s: `properties` was nil", *id)
+			if pool.Model == nil {
+				return fmt.Errorf("retrieving %s: `model` was nil", poolId)
+			}
+			if pool.Model.Properties == nil {
+				return fmt.Errorf("retrieving %s: `properties` was nil", poolId)
 			}
 
-			lb, err := lbClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+			plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+			lb, err := lbClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 			if err != nil {
-				return fmt.Errorf("retrieving Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+				return fmt.Errorf("checking for presence of existing %s: %+v", plbId, err)
 			}
 
-			var backendAddress *network.LoadBalancerBackendAddress
-			if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses != nil {
-				for _, address := range *pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses {
-					if address.Name == nil {
-						continue
-					}
+			var backendAddress *loadbalancers.LoadBalancerBackendAddress
+			if model := pool.Model; model != nil {
+				if pool := model.Properties; pool != nil {
+					for _, address := range *pool.LoadBalancerBackendAddresses {
+						if address.Name == nil {
+							continue
+						}
 
-					if *address.Name == id.AddressName {
-						backendAddress = &address
-						break
+						if *address.Name == id.AddressName {
+							backendAddress = &address
+							break
+						}
 					}
 				}
 			}
+
 			if backendAddress == nil {
 				return metadata.MarkAsGone(id)
 			}
 
-			backendAddressPoolId := parse.NewLoadBalancerBackendAddressPoolID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
 			model := BackendAddressPoolAddressModel{
 				Name:                 id.AddressName,
-				BackendAddressPoolId: backendAddressPoolId.ID(),
+				BackendAddressPoolId: poolId.ID(),
 			}
 
-			if props := backendAddress.LoadBalancerBackendAddressPropertiesFormat; props != nil {
-				if lb.Sku.Tier == network.LoadBalancerSkuTierGlobal {
-					if props.LoadBalancerFrontendIPConfiguration != nil && props.LoadBalancerFrontendIPConfiguration.ID != nil {
-						model.FrontendIPConfiguration = *props.LoadBalancerFrontendIPConfiguration.ID
+			if props := backendAddress.Properties; props != nil {
+				if lb.Model != nil && pointer.From(lb.Model.Sku.Tier) == loadbalancers.LoadBalancerSkuTierGlobal {
+					if props.LoadBalancerFrontendIPConfiguration != nil && props.LoadBalancerFrontendIPConfiguration.Id != nil {
+						model.FrontendIPConfiguration = *props.LoadBalancerFrontendIPConfiguration.Id
 					}
 				} else {
 					if props.IPAddress != nil {
 						model.IPAddress = *props.IPAddress
 					}
 
-					if props.VirtualNetwork != nil && props.VirtualNetwork.ID != nil {
-						model.VirtualNetworkId = *props.VirtualNetwork.ID
+					if props.VirtualNetwork != nil && props.VirtualNetwork.Id != nil {
+						model.VirtualNetworkId = *props.VirtualNetwork.Id
 					}
 				}
-			}
-
-			var inboundNATRulePortMappingList []inboundNATRulePortMapping
-			if rules := backendAddress.LoadBalancerBackendAddressPropertiesFormat.InboundNatRulesPortMapping; rules != nil {
-				for _, rule := range *rules {
-					rulePortMapping := inboundNATRulePortMapping{}
-
-					if rule.InboundNatRuleName != nil {
-						rulePortMapping.Name = *rule.InboundNatRuleName
+				var inboundNATRulePortMappingList []inboundNATRulePortMapping
+				if rules := props.InboundNatRulesPortMapping; rules != nil {
+					for _, rule := range *rules {
+						rulePortMapping := inboundNATRulePortMapping{}
+
+						if rule.InboundNatRuleName != nil {
+							rulePortMapping.Name = *rule.InboundNatRuleName
+						}
+						if rule.FrontendPort != nil {
+							rulePortMapping.FrontendPort = int32(*rule.FrontendPort)
+						}
+
+						if rule.BackendPort != nil {
+							rulePortMapping.BackendPort = int32(*rule.BackendPort)
+						}
+						inboundNATRulePortMappingList = append(inboundNATRulePortMappingList, rulePortMapping)
 					}
-					if rule.FrontendPort != nil {
-						rulePortMapping.FrontendPort = *rule.FrontendPort
-					}
-
-					if rule.BackendPort != nil {
-						rulePortMapping.BackendPort = *rule.BackendPort
-					}
-					inboundNATRulePortMappingList = append(inboundNATRulePortMappingList, rulePortMapping)
+					model.PortMapping = inboundNATRulePortMappingList
 				}
-				model.PortMapping = inboundNATRulePortMappingList
 			}
+
 			return metadata.Encode(&model)
 		},
 		Timeout: 5 * time.Minute,
@@ -310,7 +329,6 @@ func (r BackendAddressPoolAddressResource) Read() sdk.ResourceFunc {
 func (r BackendAddressPoolAddressResource) Delete() sdk.ResourceFunc {
 	return sdk.ResourceFunc{
 		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
-			client := metadata.Client.LoadBalancers.LoadBalancerBackendAddressPoolsClient
 			lbClient := metadata.Client.LoadBalancers.LoadBalancersClient
 			id, err := parse.BackendAddressPoolAddressID(metadata.ResourceData.Id())
 			if err != nil {
@@ -320,34 +338,25 @@ func (r BackendAddressPoolAddressResource) Delete() sdk.ResourceFunc {
 			locks.ByName(id.BackendAddressPoolName, backendAddressPoolResourceName)
 			defer locks.UnlockByName(id.BackendAddressPoolName, backendAddressPoolResourceName)
 
-			pool, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+			poolId := loadbalancers.NewLoadBalancerBackendAddressPoolID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+			pool, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, poolId)
 			if err != nil {
-				return fmt.Errorf("retrieving %s: %+v", *id, err)
+				return fmt.Errorf("retrieving %s: %+v", poolId, err)
 			}
-			if pool.BackendAddressPoolPropertiesFormat == nil {
-				return fmt.Errorf("retrieving %s: `properties` was nil", *id)
+			if pool.Model == nil {
+				return fmt.Errorf("retrieving %s: `model` was nil", poolId)
 			}
 
-			timeout, _ := ctx.Deadline()
-			lbStatus := &pluginsdk.StateChangeConf{
-				Pending:                   []string{string(network.ProvisioningStateUpdating)},
-				Target:                    []string{string(network.ProvisioningStateSucceeded)},
-				MinTimeout:                5 * time.Second,
-				Refresh:                   loadbalacnerProvisioningStatusRefreshFunc(ctx, lbClient, *id),
-				ContinuousTargetOccurence: 10,
-				Timeout:                   time.Until(timeout),
+			if pool.Model.Properties == nil {
+				return fmt.Errorf("retrieving %s: `properties` was nil", poolId)
 			}
 
-			if _, err := lbStatus.WaitForStateContext(ctx); err != nil {
-				return fmt.Errorf("waiting for parent resource loadbalancer status to be ready error: %+v", err)
+			addresses := make([]loadbalancers.LoadBalancerBackendAddress, 0)
+			if pool.Model.Properties.LoadBalancerBackendAddresses != nil {
+				addresses = *pool.Model.Properties.LoadBalancerBackendAddresses
 			}
 
-			addresses := make([]network.LoadBalancerBackendAddress, 0)
-			if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses != nil {
-				addresses = *pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses
-			}
-
-			newAddresses := make([]network.LoadBalancerBackendAddress, 0)
+			newAddresses := make([]loadbalancers.LoadBalancerBackendAddress, 0)
 			for _, address := range addresses {
 				if address.Name == nil {
 					continue
@@ -357,16 +366,19 @@ func (r BackendAddressPoolAddressResource) Delete() sdk.ResourceFunc {
 					newAddresses = append(newAddresses, address)
 				}
 			}
-			pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses = &newAddresses
 
 			metadata.Logger.Infof("removing %s..", *id)
-			future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName, pool)
+			backendAddress := loadbalancers.BackendAddressPool{
+				Properties: &loadbalancers.BackendAddressPoolPropertiesFormat{
+					LoadBalancerBackendAddresses: &newAddresses,
+				},
+			}
+
+			err = lbClient.LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx, poolId, backendAddress)
 			if err != nil {
 				return fmt.Errorf("removing %s: %+v", *id, err)
 			}
-			if err := future.WaitForCompletionRef(ctx, client.Client); err != nil {
-				return fmt.Errorf("waiting for removal of %s: %+v", *id, err)
-			}
+
 			return nil
 		},
 		Timeout: 30 * time.Minute,
@@ -380,7 +392,6 @@ func (r BackendAddressPoolAddressResource) IDValidationFunc() pluginsdk.SchemaVa
 func (r BackendAddressPoolAddressResource) Update() sdk.ResourceFunc {
 	return sdk.ResourceFunc{
 		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
-			client := metadata.Client.LoadBalancers.LoadBalancerBackendAddressPoolsClient
 			lbClient := metadata.Client.LoadBalancers.LoadBalancersClient
 			id, err := parse.BackendAddressPoolAddressID(metadata.ResourceData.Id())
 			if err != nil {
@@ -395,22 +406,27 @@ func (r BackendAddressPoolAddressResource) Update() sdk.ResourceFunc {
 				return fmt.Errorf("decoding: %+v", err)
 			}
 
-			pool, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+			poolId := loadbalancers.NewLoadBalancerBackendAddressPoolID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+			pool, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, poolId)
 			if err != nil {
 				return fmt.Errorf("retrieving %s: %+v", *id, err)
 			}
-			if pool.BackendAddressPoolPropertiesFormat == nil {
+			if pool.Model == nil {
+				return fmt.Errorf("retrieving %s: `model` was nil", *id)
+			}
+			if pool.Model.Properties == nil {
 				return fmt.Errorf("retrieving %s: `properties` was nil", *id)
 			}
 
-			lb, err := lbClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+			plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+			lb, err := lbClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 			if err != nil {
-				return fmt.Errorf("retrieving Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+				return fmt.Errorf("retrieving %s: %+v", plbId, err)
 			}
 
-			addresses := make([]network.LoadBalancerBackendAddress, 0)
-			if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses != nil {
-				addresses = *pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses
+			addresses := make([]loadbalancers.LoadBalancerBackendAddress, 0)
+			if backendAddress := pool.Model.Properties.LoadBalancerBackendAddresses; backendAddress != nil {
+				addresses = *backendAddress
 			}
 			index := -1
 			for i, address := range addresses {
@@ -427,62 +443,39 @@ func (r BackendAddressPoolAddressResource) Update() sdk.ResourceFunc {
 				return fmt.Errorf("%s was not found", *id)
 			}
 
-			if lb.Sku.Tier == network.LoadBalancerSkuTierGlobal {
-				addresses[index] = network.LoadBalancerBackendAddress{
-					Name: utils.String(model.Name),
-					LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-						LoadBalancerFrontendIPConfiguration: &network.SubResource{
-							ID: utils.String(model.FrontendIPConfiguration),
+			if lb.Model != nil && pointer.From(lb.Model.Sku.Tier) == loadbalancers.LoadBalancerSkuTierGlobal {
+				addresses[index] = loadbalancers.LoadBalancerBackendAddress{
+					Name: pointer.To(model.Name),
+					Properties: &loadbalancers.LoadBalancerBackendAddressPropertiesFormat{
+						LoadBalancerFrontendIPConfiguration: &loadbalancers.SubResource{
+							Id: pointer.To(model.FrontendIPConfiguration),
 						},
 					},
 				}
 			} else {
-				addresses[index] = network.LoadBalancerBackendAddress{
-					LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-						IPAddress: utils.String(model.IPAddress),
-						VirtualNetwork: &network.SubResource{
-							ID: utils.String(model.VirtualNetworkId),
+				addresses[index] = loadbalancers.LoadBalancerBackendAddress{
+					Properties: &loadbalancers.LoadBalancerBackendAddressPropertiesFormat{
+						IPAddress: pointer.To(model.IPAddress),
+						VirtualNetwork: &loadbalancers.SubResource{
+							Id: pointer.To(model.VirtualNetworkId),
 						},
 					},
-					Name: utils.String(id.AddressName),
+					Name: pointer.To(id.AddressName),
 				}
 			}
-			pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses = &addresses
-
-			timeout, _ := ctx.Deadline()
-			lbStatus := &pluginsdk.StateChangeConf{
-				Pending:                   []string{string(network.ProvisioningStateUpdating)},
-				Target:                    []string{string(network.ProvisioningStateSucceeded)},
-				MinTimeout:                5 * time.Minute,
-				PollInterval:              10 * time.Second,
-				Refresh:                   loadbalacnerProvisioningStatusRefreshFunc(ctx, lbClient, *id),
-				ContinuousTargetOccurence: 10,
-				Timeout:                   time.Until(timeout),
-			}
 
-			if _, err := lbStatus.WaitForStateContext(ctx); err != nil {
-				return fmt.Errorf("waiting for parent resource loadbalancer status to be ready error: %+v", err)
+			backendAddressPool := loadbalancers.BackendAddressPool{
+				Properties: &loadbalancers.BackendAddressPoolPropertiesFormat{
+					LoadBalancerBackendAddresses: &addresses,
+				},
 			}
 
-			future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName, pool)
+			err = lbClient.LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx, poolId, backendAddressPool)
 			if err != nil {
 				return fmt.Errorf("updating %s: %+v", *id, err)
 			}
-			if err := future.WaitForCompletionRef(ctx, client.Client); err != nil {
-				return fmt.Errorf("waiting for update of %s: %+v", *id, err)
-			}
 			return nil
 		},
 		Timeout: 30 * time.Minute,
 	}
 }
-
-func loadbalacnerProvisioningStatusRefreshFunc(ctx context.Context, client *network.LoadBalancersClient, id parse.BackendAddressPoolAddressId) pluginsdk.StateRefreshFunc {
-	return func() (interface{}, string, error) {
-		lbClient, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
-		if err != nil {
-			return nil, "", fmt.Errorf("retrieving load balancer error： %+v", err)
-		}
-		return lbClient, string(lbClient.ProvisioningState), nil
-	}
-}
diff --git a/internal/services/loadbalancer/backend_address_pool_address_resource_test.go b/internal/services/loadbalancer/backend_address_pool_address_resource_test.go
index 8b2ccc07a98a..c90638298e68 100644
--- a/internal/services/loadbalancer/backend_address_pool_address_resource_test.go
+++ b/internal/services/loadbalancer/backend_address_pool_address_resource_test.go
@@ -8,14 +8,14 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/types"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 var _ types.TestResourceVerifyingRemoved = BackendAddressPoolAddressResourceTests{}
@@ -130,26 +130,31 @@ func (BackendAddressPoolAddressResourceTests) Exists(ctx context.Context, client
 		return nil, err
 	}
 
-	pool, err := client.LoadBalancers.LoadBalancerBackendAddressPoolsClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+	poolId := loadbalancers.NewLoadBalancerBackendAddressPoolID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+	pool, err := client.LoadBalancers.LoadBalancersClient.LoadBalancerBackendAddressPoolsGet(ctx, poolId)
 	if err != nil {
 		return nil, fmt.Errorf("retrieving %s: %+v", *id, err)
 	}
-	if pool.BackendAddressPoolPropertiesFormat == nil {
+	if pool.Model == nil {
+		return nil, fmt.Errorf("retrieving %s: `model` was nil", *id)
+	}
+
+	if pool.Model.Properties == nil {
 		return nil, fmt.Errorf("retrieving %s: `properties` was nil", *id)
 	}
 
-	if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses != nil {
-		for _, address := range *pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses {
+	if backendAddress := pool.Model.Properties.LoadBalancerBackendAddresses; backendAddress != nil {
+		for _, address := range *backendAddress {
 			if address.Name == nil {
 				continue
 			}
 
 			if *address.Name == id.AddressName {
-				return utils.Bool(true), nil
+				return pointer.To(true), nil
 			}
 		}
 	}
-	return utils.Bool(false), nil
+	return pointer.To(false), nil
 }
 
 func (BackendAddressPoolAddressResourceTests) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
@@ -158,19 +163,23 @@ func (BackendAddressPoolAddressResourceTests) Destroy(ctx context.Context, clien
 		return nil, err
 	}
 
-	pool, err := client.LoadBalancers.LoadBalancerBackendAddressPoolsClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+	poolId := loadbalancers.NewLoadBalancerBackendAddressPoolID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+	pool, err := client.LoadBalancers.LoadBalancersClient.LoadBalancerBackendAddressPoolsGet(ctx, poolId)
 	if err != nil {
 		return nil, fmt.Errorf("retrieving %s: %+v", *id, err)
 	}
-	if pool.BackendAddressPoolPropertiesFormat == nil {
+	if pool.Model == nil {
+		return nil, fmt.Errorf("retrieving %s: `model` was nil", *id)
+	}
+	if pool.Model.Properties == nil {
 		return nil, fmt.Errorf("retrieving %s: `properties` was nil", *id)
 	}
 
-	addresses := make([]network.LoadBalancerBackendAddress, 0)
-	if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses != nil {
-		addresses = *pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses
+	addresses := make([]loadbalancers.LoadBalancerBackendAddress, 0)
+	if pool.Model.Properties.LoadBalancerBackendAddresses != nil {
+		addresses = *pool.Model.Properties.LoadBalancerBackendAddresses
 	}
-	newAddresses := make([]network.LoadBalancerBackendAddress, 0)
+	newAddresses := make([]loadbalancers.LoadBalancerBackendAddress, 0)
 	for _, address := range addresses {
 		if address.Name == nil {
 			continue
@@ -180,39 +189,43 @@ func (BackendAddressPoolAddressResourceTests) Destroy(ctx context.Context, clien
 			newAddresses = append(newAddresses, address)
 		}
 	}
-	pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses = &newAddresses
 
-	future, err := client.LoadBalancers.LoadBalancerBackendAddressPoolsClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName, pool)
+	backendAddressPool := loadbalancers.BackendAddressPool{
+		Properties: &loadbalancers.BackendAddressPoolPropertiesFormat{
+			LoadBalancerBackendAddresses: &newAddresses,
+		},
+	}
+	err = client.LoadBalancers.LoadBalancersClient.LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx, poolId, backendAddressPool)
 	if err != nil {
 		return nil, fmt.Errorf("updating %s: %+v", *id, err)
 	}
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancerBackendAddressPoolsClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of %s: %+v", *id, err)
-	}
-	return utils.Bool(true), nil
+
+	return pointer.To(true), nil
 }
 
 // nolint unused - for future use
 func (BackendAddressPoolAddressResourceTests) backendAddressPoolHasAddresses(expected int) acceptance.ClientCheckFunc {
 	return func(ctx context.Context, clients *clients.Client, state *pluginsdk.InstanceState) error {
-		id, err := parse.LoadBalancerBackendAddressPoolID(state.ID)
+		id, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(state.ID)
 		if err != nil {
 			return err
 		}
 
-		client := clients.LoadBalancers.LoadBalancerBackendAddressPoolsClient
-		pool, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+		pool, err := clients.LoadBalancers.LoadBalancersClient.LoadBalancerBackendAddressPoolsGet(ctx, *id)
 		if err != nil {
 			return err
 		}
-		if pool.BackendAddressPoolPropertiesFormat == nil {
+		if pool.Model == nil {
+			return fmt.Errorf("`model` is nil")
+		}
+		if pool.Model.Properties == nil {
 			return fmt.Errorf("`properties` is nil")
 		}
-		if pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses == nil {
+		if pool.Model.Properties.LoadBalancerBackendAddresses == nil {
 			return fmt.Errorf("`properties.loadBalancerBackendAddresses` is nil")
 		}
 
-		actual := len(*pool.BackendAddressPoolPropertiesFormat.LoadBalancerBackendAddresses)
+		actual := len(*pool.Model.Properties.LoadBalancerBackendAddresses)
 		if actual != expected {
 			return fmt.Errorf("expected %d but got %d addresses", expected, actual)
 		}
diff --git a/internal/services/loadbalancer/backend_address_pool_data_source.go b/internal/services/loadbalancer/backend_address_pool_data_source.go
index 35aca69239ec..302752033359 100644
--- a/internal/services/loadbalancer/backend_address_pool_data_source.go
+++ b/internal/services/loadbalancer/backend_address_pool_data_source.go
@@ -7,14 +7,13 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func dataSourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
@@ -34,7 +33,7 @@ func dataSourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 			"loadbalancer_id": {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
-				ValidateFunc: validate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"backend_address": {
@@ -122,90 +121,92 @@ func dataSourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 }
 
 func dataSourceArmLoadBalancerBackendAddressPoolRead(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).LoadBalancers.LoadBalancerBackendAddressPoolsClient
+	lbClient := meta.(*clients.Client).LoadBalancers.LoadBalancersClient
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
 	name := d.Get("name").(string)
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return err
 	}
-	id := parse.NewLoadBalancerBackendAddressPoolID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, name)
+	id := loadbalancers.NewLoadBalancerBackendAddressPoolID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, name)
 
-	resp, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+	resp, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, id)
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
-			return fmt.Errorf("Load Balancer Backend Address Pool %q was not found", id)
+		if response.WasNotFound(resp.HttpResponse) {
+			return fmt.Errorf("%s was not found", id)
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer Backend Address Pool %q: %+v", id, err)
+		return fmt.Errorf("retrieving %s: %+v", id, err)
 	}
 
 	d.SetId(id.ID())
 
-	if props := resp.BackendAddressPoolPropertiesFormat; props != nil {
-		if err := d.Set("backend_address", flattenArmLoadBalancerBackendAddresses(props.LoadBalancerBackendAddresses)); err != nil {
-			return fmt.Errorf("setting `backend_address`: %v", err)
-		}
+	if model := resp.Model; model != nil {
+		if props := model.Properties; props != nil {
+			if err := d.Set("backend_address", flattenArmLoadBalancerBackendAddresses(props.LoadBalancerBackendAddresses)); err != nil {
+				return fmt.Errorf("setting `backend_address`: %v", err)
+			}
 
-		var backendIPConfigurations []interface{}
-		if beipConfigs := props.BackendIPConfigurations; beipConfigs != nil {
-			for _, config := range *beipConfigs {
-				ipConfig := make(map[string]interface{})
-				if id := config.ID; id != nil {
-					ipConfig["id"] = *id
-					backendIPConfigurations = append(backendIPConfigurations, ipConfig)
+			var backendIPConfigurations []interface{}
+			if beipConfigs := props.BackendIPConfigurations; beipConfigs != nil {
+				for _, config := range *beipConfigs {
+					ipConfig := make(map[string]interface{})
+					if id := config.Id; id != nil {
+						ipConfig["id"] = pointer.From(id)
+						backendIPConfigurations = append(backendIPConfigurations, ipConfig)
+					}
 				}
 			}
-		}
-		if err := d.Set("backend_ip_configurations", backendIPConfigurations); err != nil {
-			return fmt.Errorf("setting `backend_ip_configurations`: %v", err)
-		}
+			if err := d.Set("backend_ip_configurations", backendIPConfigurations); err != nil {
+				return fmt.Errorf("setting `backend_ip_configurations`: %v", err)
+			}
 
-		var loadBalancingRules []string
-		if rules := props.LoadBalancingRules; rules != nil {
-			for _, rule := range *rules {
-				if rule.ID == nil {
-					continue
+			var loadBalancingRules []string
+			if rules := props.LoadBalancingRules; rules != nil {
+				for _, rule := range *rules {
+					if rule.Id == nil {
+						continue
+					}
+					loadBalancingRules = append(loadBalancingRules, pointer.From(rule.Id))
 				}
-				loadBalancingRules = append(loadBalancingRules, *rule.ID)
 			}
-		}
-		if err := d.Set("load_balancing_rules", loadBalancingRules); err != nil {
-			return fmt.Errorf("setting `load_balancing_rules`: %v", err)
-		}
+			if err := d.Set("load_balancing_rules", loadBalancingRules); err != nil {
+				return fmt.Errorf("setting `load_balancing_rules`: %v", err)
+			}
 
-		var outboundRules []string
-		if rules := props.OutboundRules; rules != nil {
-			for _, rule := range *rules {
-				if rule.ID == nil {
-					continue
+			var outboundRules []string
+			if rules := props.OutboundRules; rules != nil {
+				for _, rule := range *rules {
+					if rule.Id == nil {
+						continue
+					}
+					outboundRules = append(outboundRules, pointer.From(rule.Id))
 				}
-				outboundRules = append(outboundRules, *rule.ID)
 			}
-		}
-		if err := d.Set("outbound_rules", outboundRules); err != nil {
-			return fmt.Errorf("setting `outbound_rules`: %v", err)
-		}
+			if err := d.Set("outbound_rules", outboundRules); err != nil {
+				return fmt.Errorf("setting `outbound_rules`: %v", err)
+			}
 
-		var inboundNATRules []string
-		if rules := props.InboundNatRules; rules != nil {
-			for _, rule := range *rules {
-				if rule.ID == nil {
-					continue
+			var inboundNATRules []string
+			if rules := props.InboundNatRules; rules != nil {
+				for _, rule := range *rules {
+					if rule.Id == nil {
+						continue
+					}
+					inboundNATRules = append(inboundNATRules, pointer.From(rule.Id))
 				}
-				inboundNATRules = append(inboundNATRules, *rule.ID)
 			}
-		}
-		if err := d.Set("inbound_nat_rules", inboundNATRules); err != nil {
-			return fmt.Errorf("setting `inbound_nat_rules`: %v", err)
+			if err := d.Set("inbound_nat_rules", inboundNATRules); err != nil {
+				return fmt.Errorf("setting `inbound_nat_rules`: %v", err)
+			}
 		}
 	}
 
 	return nil
 }
 
-func flattenArmLoadBalancerBackendAddresses(input *[]network.LoadBalancerBackendAddress) []interface{} {
+func flattenArmLoadBalancerBackendAddresses(input *[]loadbalancers.LoadBalancerBackendAddress) []interface{} {
 	if input == nil {
 		return []interface{}{}
 	}
@@ -223,12 +224,12 @@ func flattenArmLoadBalancerBackendAddresses(input *[]network.LoadBalancerBackend
 			vnetId    string
 		)
 		var inboundNATRulePortMappingList []interface{}
-		if prop := e.LoadBalancerBackendAddressPropertiesFormat; prop != nil {
-			if prop.IPAddress != nil {
-				ipAddress = *prop.IPAddress
-			}
-			if prop.VirtualNetwork != nil && prop.VirtualNetwork.ID != nil {
-				vnetId = *prop.VirtualNetwork.ID
+		if prop := e.Properties; prop != nil {
+
+			ipAddress = pointer.From(prop.IPAddress)
+
+			if prop.VirtualNetwork != nil {
+				vnetId = pointer.From(prop.VirtualNetwork.Id)
 			}
 			if prop.InboundNatRulesPortMapping != nil {
 				rules := prop.InboundNatRulesPortMapping
@@ -236,7 +237,7 @@ func flattenArmLoadBalancerBackendAddresses(input *[]network.LoadBalancerBackend
 					rulePortMapping := make(map[string]interface{})
 
 					if rule.InboundNatRuleName != nil {
-						rulePortMapping["inbound_nat_rule_name"] = *rule.InboundNatRuleName
+						rulePortMapping["inbound_nat_rule_name"] = pointer.From(rule.InboundNatRuleName)
 					}
 					if rule.FrontendPort != nil {
 						rulePortMapping["frontendPort"] = *rule.FrontendPort
diff --git a/internal/services/loadbalancer/backend_address_pool_resource.go b/internal/services/loadbalancer/backend_address_pool_resource.go
index 3dec3a05a04c..2ef0c4f9cacc 100644
--- a/internal/services/loadbalancer/backend_address_pool_resource.go
+++ b/internal/services/loadbalancer/backend_address_pool_resource.go
@@ -8,17 +8,16 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 var backendAddressPoolResourceName = "azurerm_lb_backend_address_pool"
@@ -30,13 +29,13 @@ func resourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 		Read:   resourceArmLoadBalancerBackendAddressPoolRead,
 		Delete: resourceArmLoadBalancerBackendAddressPoolDelete,
 
-		Importer: loadBalancerSubResourceImporter(func(input string) (*parse.LoadBalancerId, error) {
-			id, err := parse.LoadBalancerBackendAddressPoolID(input)
+		Importer: loadBalancerSubResourceImporter(func(input string) (*loadbalancers.LoadBalancerId, error) {
+			id, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(input)
 			if err != nil {
 				return nil, err
 			}
 
-			lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+			lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 			return &lbId, nil
 		}),
 
@@ -59,7 +58,7 @@ func resourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
 				ForceNew:     true,
-				ValidateFunc: validate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"tunnel_interface": {
@@ -77,9 +76,9 @@ func resourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 							Type:     pluginsdk.TypeString,
 							Required: true,
 							ValidateFunc: validation.StringInSlice([]string{
-								string(network.GatewayLoadBalancerTunnelInterfaceTypeNone),
-								string(network.GatewayLoadBalancerTunnelInterfaceTypeInternal),
-								string(network.GatewayLoadBalancerTunnelInterfaceTypeExternal),
+								string(loadbalancers.GatewayLoadBalancerTunnelInterfaceTypeNone),
+								string(loadbalancers.GatewayLoadBalancerTunnelInterfaceTypeInternal),
+								string(loadbalancers.GatewayLoadBalancerTunnelInterfaceTypeExternal),
 							},
 								false,
 							),
@@ -89,9 +88,9 @@ func resourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 							Type:     pluginsdk.TypeString,
 							Required: true,
 							ValidateFunc: validation.StringInSlice([]string{
-								string(network.GatewayLoadBalancerTunnelProtocolNone),
-								string(network.GatewayLoadBalancerTunnelProtocolNative),
-								string(network.GatewayLoadBalancerTunnelProtocolVXLAN),
+								string(loadbalancers.GatewayLoadBalancerTunnelProtocolNone),
+								string(loadbalancers.GatewayLoadBalancerTunnelProtocolNative),
+								string(loadbalancers.GatewayLoadBalancerTunnelProtocolVXLAN),
 							},
 								false,
 							),
@@ -147,28 +146,27 @@ func resourceArmLoadBalancerBackendAddressPool() *pluginsdk.Resource {
 }
 
 func resourceArmLoadBalancerBackendAddressPoolCreateUpdate(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).LoadBalancers.LoadBalancerBackendAddressPoolsClient
 	lbClient := meta.(*clients.Client).LoadBalancers.LoadBalancersClient
 	ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return fmt.Errorf("parsing Load Balancer Name and Group: %+v", err)
 	}
 
 	name := d.Get("name").(string)
-	id := parse.NewLoadBalancerBackendAddressPoolID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, name)
+	id := loadbalancers.NewLoadBalancerBackendAddressPoolID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, name)
 
 	if d.IsNewResource() {
-		existing, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+		existing, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, id)
 		if err != nil {
-			if !utils.ResponseWasNotFound(existing.Response) {
-				return fmt.Errorf("checking for presence of existing Load Balancer Backend Address Pool %q: %+v", id, err)
+			if !response.WasNotFound(existing.HttpResponse) {
+				return fmt.Errorf("checking for presence of existing %s: %+v", id, err)
 			}
 		}
 
-		if !utils.ResponseWasNotFound(existing.Response) {
+		if !response.WasNotFound(existing.HttpResponse) {
 			return tf.ImportAsExistsError("azurerm_lb_backend_address_pool", id.ID())
 		}
 	}
@@ -179,15 +177,16 @@ func resourceArmLoadBalancerBackendAddressPoolCreateUpdate(d *pluginsdk.Resource
 	locks.ByID(loadBalancerId.ID())
 	defer locks.UnlockByID(loadBalancerId.ID())
 
-	lb, err := lbClient.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: loadBalancerId.SubscriptionId, ResourceGroupName: loadBalancerId.ResourceGroupName, LoadBalancerName: loadBalancerId.LoadBalancerName}
+	lb, err := lbClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
-			return fmt.Errorf("Load Balancer %q for Backend Address Pool %q was not found", loadBalancerId, id)
+		if response.WasNotFound(lb.HttpResponse) {
+			return fmt.Errorf("%s was not found", *loadBalancerId)
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q for Backend Address Pool %q: %+v", loadBalancerId, id, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	param := network.BackendAddressPool{
+	param := loadbalancers.BackendAddressPool{
 		Name: &id.BackendAddressPoolName,
 	}
 
@@ -197,172 +196,167 @@ func resourceArmLoadBalancerBackendAddressPoolCreateUpdate(d *pluginsdk.Resource
 	// - Standard sku: interact with BAP endpoint for CUD
 	// Particularly, the BAP endpoint can be used for R for bot cases.
 	// See: https://github.com/Azure/azure-rest-api-specs/issues/11234 for details.
-	sku := lb.Sku
+	if lb.Model == nil {
+		return fmt.Errorf("retrieving %s: `model` was nil", *loadBalancerId)
+	}
+	sku := lb.Model.Sku
 	if sku == nil {
-		return fmt.Errorf("nil or empty `sku` for Load Balancer %q for Backend Address Pool %q was not found", loadBalancerId, id)
+		return fmt.Errorf("nil or empty `sku` for Load Balancer %q for Backend Address Pool %q was not found", *loadBalancerId, id)
 	}
 
-	if len(d.Get("tunnel_interface").([]interface{})) != 0 && sku.Name != network.LoadBalancerSkuNameGateway {
+	if len(d.Get("tunnel_interface").([]interface{})) != 0 && *sku.Name != loadbalancers.LoadBalancerSkuNameGateway {
 		return fmt.Errorf("only the Gateway (sku) Load Balancer allows IP based Backend Address Pool configuration,"+
-			"whilst %q is of sku %s", id, sku.Name)
+			"whilst %q is of sku %s", id, *sku.Name)
 	}
-	if len(d.Get("tunnel_interface").([]interface{})) == 0 && sku.Name == network.LoadBalancerSkuNameGateway {
-		return fmt.Errorf("`tunnel_interface` is required for %q when sku is set to %s", id, sku.Name)
+	if len(d.Get("tunnel_interface").([]interface{})) == 0 && *sku.Name == loadbalancers.LoadBalancerSkuNameGateway {
+		return fmt.Errorf("`tunnel_interface` is required for %q when sku is set to %s", id, *sku.Name)
 	}
 
 	if v, ok := d.GetOk("virtual_network_id"); ok {
-		param.BackendAddressPoolPropertiesFormat = &network.BackendAddressPoolPropertiesFormat{
-			VirtualNetwork: &network.SubResource{
-				ID: utils.String(v.(string)),
+		param.Properties = &loadbalancers.BackendAddressPoolPropertiesFormat{
+			VirtualNetwork: &loadbalancers.SubResource{
+				Id: pointer.To(v.(string)),
 			}}
 	}
 
-	switch sku.Name {
-	case network.LoadBalancerSkuNameBasic:
-		if !d.IsNewResource() && d.HasChange("virtual_network_id") {
-			return fmt.Errorf("updating the virtual_network_id of Backend Address Pool %q is not allowed for basic (sku) Load Balancer", id)
-		}
+	if properties := lb.Model.Properties; properties != nil {
+		switch *sku.Name {
+		case loadbalancers.LoadBalancerSkuNameBasic:
+			if !d.IsNewResource() && d.HasChange("virtual_network_id") {
+				return fmt.Errorf("updating the virtual_network_id of Backend Address Pool %q is not allowed for basic (sku) Load Balancer", id)
+			}
 
-		// Insert this BAP and update the LB since the dedicated BAP endpoint doesn't work for the Basic sku.
-		backendAddressPools := append(*lb.LoadBalancerPropertiesFormat.BackendAddressPools, param)
-		_, existingPoolIndex, exists := FindLoadBalancerBackEndAddressPoolByName(&lb, id.BackendAddressPoolName)
-		if exists {
-			// this pool is being updated/reapplied remove the old copy from the slice
-			backendAddressPools = append(backendAddressPools[:existingPoolIndex], backendAddressPools[existingPoolIndex+1:]...)
-		}
+			// Insert this BAP and update the LB since the dedicated BAP endpoint doesn't work for the Basic sku.
+			backendAddressPools := append(*properties.BackendAddressPools, param)
+			_, existingPoolIndex, exists := FindLoadBalancerBackEndAddressPoolByName(lb.Model, id.BackendAddressPoolName)
+			if exists {
+				// this pool is being updated/reapplied remove the old copy from the slice
+				backendAddressPools = append(backendAddressPools[:existingPoolIndex], backendAddressPools[existingPoolIndex+1:]...)
+			}
 
-		lb.LoadBalancerPropertiesFormat.BackendAddressPools = &backendAddressPools
+			properties.BackendAddressPools = &backendAddressPools
 
-		future, err := lbClient.CreateOrUpdate(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, lb)
-		if err != nil {
-			return fmt.Errorf("updating Load Balancer %q for Backend Address Pool %q: %+v", loadBalancerId, id, err)
-		}
-
-		if err = future.WaitForCompletionRef(ctx, lbClient.Client); err != nil {
-			return fmt.Errorf("waiting for update of Load Balancer %q for Backend Address Pool %q: %+v", loadBalancerId, id, err)
-		}
-	case network.LoadBalancerSkuNameStandard:
-		if param.BackendAddressPoolPropertiesFormat == nil {
-			param.BackendAddressPoolPropertiesFormat = &network.BackendAddressPoolPropertiesFormat{
-				// NOTE: Backend Addresses are managed using `azurerm_lb_backend_pool_address`
+			err := lbClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
+			if err != nil {
+				return fmt.Errorf("updating %s: %+v", *loadBalancerId, err)
+			}
+		case loadbalancers.LoadBalancerSkuNameStandard:
+			if param.Properties == nil {
+				param.Properties = &loadbalancers.BackendAddressPoolPropertiesFormat{
+					// NOTE: Backend Addresses are managed using `azurerm_lb_backend_pool_address`
+				}
 			}
-		}
-
-		future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName, param)
-		if err != nil {
-			return fmt.Errorf("creating/updating Load Balancer Backend Address Pool %q: %+v", id, err)
-		}
 
-		if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-			return fmt.Errorf("waiting for Creating/Updating of Load Balancer Backend Address Pool %q: %+v", id, err)
-		}
-	case network.LoadBalancerSkuNameGateway:
-		if param.BackendAddressPoolPropertiesFormat == nil {
-			param.BackendAddressPoolPropertiesFormat = &network.BackendAddressPoolPropertiesFormat{}
-		}
-		param.BackendAddressPoolPropertiesFormat.TunnelInterfaces = expandGatewayLoadBalancerTunnelInterfaces(d.Get("tunnel_interface").([]interface{}))
+			err := lbClient.LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx, id, param)
+			if err != nil {
+				return fmt.Errorf("creating/updating Load Balancer Backend Address Pool %q: %+v", id, err)
+			}
+		case loadbalancers.LoadBalancerSkuNameGateway:
+			if param.Properties == nil {
+				param.Properties = &loadbalancers.BackendAddressPoolPropertiesFormat{}
+			}
+			param.Properties.TunnelInterfaces = expandGatewayLoadBalancerTunnelInterfaces(d.Get("tunnel_interface").([]interface{}))
 
-		future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName, param)
-		if err != nil {
-			return fmt.Errorf("creating/updating %q: %+v", id, err)
+			err := lbClient.LoadBalancerBackendAddressPoolsCreateOrUpdateThenPoll(ctx, id, param)
+			if err != nil {
+				return fmt.Errorf("creating/updating %q: %+v", id, err)
+			}
 		}
 
-		if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-			return fmt.Errorf("waiting for Creating/Updating of %q: %+v", id, err)
-		}
+		d.SetId(id.ID())
 	}
 
-	d.SetId(id.ID())
-
 	return resourceArmLoadBalancerBackendAddressPoolRead(d, meta)
 }
 
 func resourceArmLoadBalancerBackendAddressPoolRead(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).LoadBalancers.LoadBalancerBackendAddressPoolsClient
+	lbClient := meta.(*clients.Client).LoadBalancers.LoadBalancersClient
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerBackendAddressPoolID(d.Id())
+	id, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 
-	resp, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+	resp, err := lbClient.LoadBalancerBackendAddressPoolsGet(ctx, *id)
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
+		if response.WasNotFound(resp.HttpResponse) {
 			d.SetId("")
-			log.Printf("[INFO] Load Balancer Backend Address Pool %q not found - removing from state", id)
+			log.Printf("[INFO] %s was not found - removing from state", *id)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer Backend Address Pool %q: %+v", id, err)
+		return fmt.Errorf("retrieving %s: %+v", *id, err)
 	}
 
 	d.Set("name", id.BackendAddressPoolName)
 	d.Set("loadbalancer_id", lbId.ID())
 
-	if props := resp.BackendAddressPoolPropertiesFormat; props != nil {
-		if err := d.Set("tunnel_interface", flattenGatewayLoadBalancerTunnelInterfaces(props.TunnelInterfaces)); err != nil {
-			return fmt.Errorf("setting `tunnel_interface`: %v", err)
-		}
+	if model := resp.Model; model != nil {
+		if properties := model.Properties; properties != nil {
+			if err := d.Set("tunnel_interface", flattenGatewayLoadBalancerTunnelInterfaces(properties.TunnelInterfaces)); err != nil {
+				return fmt.Errorf("setting `tunnel_interface`: %v", err)
+			}
 
-		var backendIPConfigurations []string
-		if configs := props.BackendIPConfigurations; configs != nil {
-			for _, backendConfig := range *configs {
-				if backendConfig.ID == nil {
-					continue
+			var backendIPConfigurations []string
+			if configs := properties.BackendIPConfigurations; configs != nil {
+				for _, backendConfig := range *configs {
+					if backendConfig.Id == nil {
+						continue
+					}
+					backendIPConfigurations = append(backendIPConfigurations, *backendConfig.Id)
 				}
-				backendIPConfigurations = append(backendIPConfigurations, *backendConfig.ID)
 			}
-		}
-		if err := d.Set("backend_ip_configurations", backendIPConfigurations); err != nil {
-			return fmt.Errorf("setting `backend_ip_configurations`: %v", err)
-		}
-
-		network := ""
-		if vnet := props.VirtualNetwork; vnet != nil && vnet.ID != nil {
-			network = *vnet.ID
-		}
-		d.Set("virtual_network_id", network)
+			if err := d.Set("backend_ip_configurations", backendIPConfigurations); err != nil {
+				return fmt.Errorf("setting `backend_ip_configurations`: %v", err)
+			}
 
-		var loadBalancingRules []string
-		if rules := props.LoadBalancingRules; rules != nil {
-			for _, rule := range *rules {
-				if rule.ID == nil {
-					continue
+			network := ""
+			if vnet := properties.VirtualNetwork; vnet != nil && vnet.Id != nil {
+				network = *vnet.Id
+			}
+			d.Set("virtual_network_id", network)
+
+			var loadBalancingRules []string
+			if rules := properties.LoadBalancingRules; rules != nil {
+				for _, rule := range *rules {
+					if rule.Id == nil {
+						continue
+					}
+					loadBalancingRules = append(loadBalancingRules, *rule.Id)
 				}
-				loadBalancingRules = append(loadBalancingRules, *rule.ID)
 			}
-		}
-		if err := d.Set("load_balancing_rules", loadBalancingRules); err != nil {
-			return fmt.Errorf("setting `load_balancing_rules`: %v", err)
-		}
+			if err := d.Set("load_balancing_rules", loadBalancingRules); err != nil {
+				return fmt.Errorf("setting `load_balancing_rules`: %v", err)
+			}
 
-		var outboundRules []string
-		if rules := props.OutboundRules; rules != nil {
-			for _, rule := range *rules {
-				if rule.ID == nil {
-					continue
+			var outboundRules []string
+			if rules := properties.OutboundRules; rules != nil {
+				for _, rule := range *rules {
+					if rule.Id == nil {
+						continue
+					}
+					outboundRules = append(outboundRules, *rule.Id)
 				}
-				outboundRules = append(outboundRules, *rule.ID)
 			}
-		}
-		if err := d.Set("outbound_rules", outboundRules); err != nil {
-			return fmt.Errorf("setting `outbound_rules`: %v", err)
-		}
+			if err := d.Set("outbound_rules", outboundRules); err != nil {
+				return fmt.Errorf("setting `outbound_rules`: %v", err)
+			}
 
-		var inboundNATRules []string
-		if rules := props.InboundNatRules; rules != nil {
-			for _, rule := range *rules {
-				if rule.ID == nil {
-					continue
+			var inboundNATRules []string
+			if rules := properties.InboundNatRules; rules != nil {
+				for _, rule := range *rules {
+					if rule.Id == nil {
+						continue
+					}
+					inboundNATRules = append(inboundNATRules, *rule.Id)
 				}
-				inboundNATRules = append(inboundNATRules, *rule.ID)
 			}
-		}
-		if err := d.Set("inbound_nat_rules", inboundNATRules); err != nil {
-			return fmt.Errorf("setting `inbound_nat_rules`: %v", err)
+			if err := d.Set("inbound_nat_rules", inboundNATRules); err != nil {
+				return fmt.Errorf("setting `inbound_nat_rules`: %v", err)
+			}
 		}
 	}
 
@@ -370,17 +364,16 @@ func resourceArmLoadBalancerBackendAddressPoolRead(d *pluginsdk.ResourceData, me
 }
 
 func resourceArmLoadBalancerBackendAddressPoolDelete(d *pluginsdk.ResourceData, meta interface{}) error {
-	client := meta.(*clients.Client).LoadBalancers.LoadBalancerBackendAddressPoolsClient
 	lbClient := meta.(*clients.Client).LoadBalancers.LoadBalancersClient
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerBackendAddressPoolID(d.Id())
+	id, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancerId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	loadBalancerId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
@@ -388,73 +381,73 @@ func resourceArmLoadBalancerBackendAddressPoolDelete(d *pluginsdk.ResourceData,
 	locks.ByName(id.BackendAddressPoolName, backendAddressPoolResourceName)
 	defer locks.UnlockByName(id.BackendAddressPoolName, backendAddressPoolResourceName)
 
-	lb, err := lbClient.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := lbClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
+		if response.WasNotFound(lb.HttpResponse) {
 			d.SetId("")
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Backend Address Pool %q: %+v", loadBalancerId.Name, loadBalancerId.ResourceGroup, id.BackendAddressPoolName, err)
+		return fmt.Errorf("retrieving %s: %+v", loadBalancerId, err)
 	}
 
-	sku := lb.Sku
+	if lb.Model == nil {
+		return fmt.Errorf("retrieving %s: `model` was nil", plbId)
+	}
+	sku := lb.Model.Sku
 	if sku == nil {
 		return fmt.Errorf("nil or empty `sku` for Load Balancer %q for Backend Address Pool %q was not found", loadBalancerId, id)
 	}
 
-	if sku.Name == network.LoadBalancerSkuNameBasic {
-		_, index, exists := FindLoadBalancerBackEndAddressPoolByName(&lb, id.BackendAddressPoolName)
+	if *sku.Name == loadbalancers.LoadBalancerSkuNameBasic {
+		_, index, exists := FindLoadBalancerBackEndAddressPoolByName(lb.Model, id.BackendAddressPoolName)
 		if !exists {
 			return nil
 		}
 
-		backEndPools := *lb.LoadBalancerPropertiesFormat.BackendAddressPools
+		if lb.Model.Properties == nil {
+			return fmt.Errorf("retrieving %s: properties was nil", *id)
+		}
+
+		backEndPools := *lb.Model.Properties.BackendAddressPools
 		backEndPools = append(backEndPools[:index], backEndPools[index+1:]...)
-		lb.LoadBalancerPropertiesFormat.BackendAddressPools = &backEndPools
+		lb.Model.Properties.BackendAddressPools = &backEndPools
 
-		future, err := lbClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, lb)
+		err := lbClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
 		if err != nil {
-			return fmt.Errorf("updating Load Balancer %q (resource group %q) to remove Backend Address Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.BackendAddressPoolName, err)
-		}
-
-		if err = future.WaitForCompletionRef(ctx, lbClient.Client); err != nil {
-			return fmt.Errorf("waiting for update of Load Balancer %q (resource group %q) for Backend Address Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.BackendAddressPoolName, err)
+			return fmt.Errorf("updating %s: %+v", loadBalancerId, err)
 		}
 	} else {
-		future, err := client.Delete(ctx, id.ResourceGroup, id.LoadBalancerName, id.BackendAddressPoolName)
+		err := lbClient.LoadBalancerBackendAddressPoolsDeleteThenPoll(ctx, *id)
 		if err != nil {
-			return fmt.Errorf("deleting Load Balancer Backend Address Pool %q: %+v", id, err)
-		}
-
-		if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-			return fmt.Errorf("waiting for deleting of Load Balancer Backend Address Pool %q: %+v", id, err)
+			return fmt.Errorf("deleting %s: %+v", *id, err)
 		}
 	}
 
 	return nil
 }
 
-func expandGatewayLoadBalancerTunnelInterfaces(input []interface{}) *[]network.GatewayLoadBalancerTunnelInterface {
+func expandGatewayLoadBalancerTunnelInterfaces(input []interface{}) *[]loadbalancers.GatewayLoadBalancerTunnelInterface {
 	if len(input) == 0 {
 		return nil
 	}
 
-	result := make([]network.GatewayLoadBalancerTunnelInterface, 0)
+	result := make([]loadbalancers.GatewayLoadBalancerTunnelInterface, 0)
 
 	for _, e := range input {
 		e := e.(map[string]interface{})
-		result = append(result, network.GatewayLoadBalancerTunnelInterface{
-			Identifier: utils.Int32(int32(e["identifier"].(int))),
-			Type:       network.GatewayLoadBalancerTunnelInterfaceType(e["type"].(string)),
-			Protocol:   network.GatewayLoadBalancerTunnelProtocol(e["protocol"].(string)),
-			Port:       utils.Int32(int32(e["port"].(int))),
+		result = append(result, loadbalancers.GatewayLoadBalancerTunnelInterface{
+			Identifier: pointer.To(int64(e["identifier"].(int))),
+			Type:       pointer.To(loadbalancers.GatewayLoadBalancerTunnelInterfaceType(e["type"].(string))),
+			Protocol:   pointer.To(loadbalancers.GatewayLoadBalancerTunnelProtocol(e["protocol"].(string))),
+			Port:       pointer.To(int64(e["port"].(int))),
 		})
 	}
 
 	return &result
 }
 
-func flattenGatewayLoadBalancerTunnelInterfaces(input *[]network.GatewayLoadBalancerTunnelInterface) []interface{} {
+func flattenGatewayLoadBalancerTunnelInterfaces(input *[]loadbalancers.GatewayLoadBalancerTunnelInterface) []interface{} {
 	if input == nil {
 		return []interface{}{}
 	}
@@ -467,9 +460,9 @@ func flattenGatewayLoadBalancerTunnelInterfaces(input *[]network.GatewayLoadBala
 			identifier = int(*e.Identifier)
 		}
 
-		t := string(e.Type)
+		t := string(pointer.From(e.Type))
 
-		protocol := string(e.Protocol)
+		protocol := string(pointer.From(e.Protocol))
 
 		var port int
 		if e.Port != nil {
diff --git a/internal/services/loadbalancer/backend_address_pool_resource_test.go b/internal/services/loadbalancer/backend_address_pool_resource_test.go
index 7de96c8432d4..a5c336d8e27b 100644
--- a/internal/services/loadbalancer/backend_address_pool_resource_test.go
+++ b/internal/services/loadbalancer/backend_address_pool_resource_test.go
@@ -8,13 +8,13 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type LoadBalancerBackendAddressPool struct{}
@@ -164,72 +164,76 @@ func TestAccBackendAddressPool_GatewaySkuUpdate(t *testing.T) {
 }
 
 func (r LoadBalancerBackendAddressPool) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerBackendAddressPoolID(state.ID)
+	id, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
-			return nil, fmt.Errorf("Load Balancer %q (resource group %q) not found for Backend Address Pool %q", id.LoadBalancerName, id.ResourceGroup, id.BackendAddressPoolName)
+		if response.WasNotFound(lb.HttpResponse) {
+			return nil, fmt.Errorf("%s was not found", plbId)
 		}
-		return nil, fmt.Errorf("failed reading Load Balancer %q (resource group %q) for Backend Address Pool %q", id.LoadBalancerName, id.ResourceGroup, id.BackendAddressPoolName)
-	}
-	props := lb.LoadBalancerPropertiesFormat
-	if props == nil || props.BackendAddressPools == nil || len(*props.BackendAddressPools) == 0 {
-		return nil, fmt.Errorf("Backend Pool %q not found in Load Balancer %q (resource group %q)", id.BackendAddressPoolName, id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
+	if model := lb.Model; model != nil {
+		props := model.Properties
+		if props == nil || props.BackendAddressPools == nil || len(*props.BackendAddressPools) == 0 {
+			return nil, fmt.Errorf("Backend Pool %q not found in Load Balancer %q (resource group %q)", id.BackendAddressPoolName, id.LoadBalancerName, id.ResourceGroupName)
+		}
 
-	found := false
-	for _, v := range *props.BackendAddressPools {
-		if v.Name != nil && *v.Name == id.BackendAddressPoolName {
-			found = true
+		found := false
+		for _, v := range *props.BackendAddressPools {
+			if v.Name != nil && *v.Name == id.BackendAddressPoolName {
+				found = true
+			}
+		}
+		if !found {
+			return nil, fmt.Errorf("Backend Pool %q not found in Load Balancer %q (resource group %q)", id.BackendAddressPoolName, id.LoadBalancerName, id.ResourceGroupName)
 		}
 	}
-	if !found {
-		return nil, fmt.Errorf("Backend Pool %q not found in Load Balancer %q (resource group %q)", id.BackendAddressPoolName, id.LoadBalancerName, id.ResourceGroup)
-	}
-	return utils.Bool(true), nil
+
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerBackendAddressPool) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerBackendAddressPoolID(state.ID)
+	id, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroupName)
+	}
+	if lb.Model == nil {
+		return nil, fmt.Errorf("`model` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat == nil {
+	if lb.Model.Properties == nil {
 		return nil, fmt.Errorf("`properties` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat.BackendAddressPools == nil {
+	if lb.Model.Properties.BackendAddressPools == nil {
 		return nil, fmt.Errorf("`properties.BackendAddressPools` was nil")
 	}
 
-	backendAddressPools := make([]network.BackendAddressPool, 0)
-	for _, backendAddressPool := range *lb.LoadBalancerPropertiesFormat.BackendAddressPools {
+	backendAddressPools := make([]loadbalancers.BackendAddressPool, 0)
+	for _, backendAddressPool := range *lb.Model.Properties.BackendAddressPools {
 		if backendAddressPool.Name == nil || *backendAddressPool.Name == id.BackendAddressPoolName {
 			continue
 		}
 
 		backendAddressPools = append(backendAddressPools, backendAddressPool)
 	}
-	lb.LoadBalancerPropertiesFormat.BackendAddressPools = &backendAddressPools
+	lb.Model.Properties.BackendAddressPools = &backendAddressPools
 
-	future, err := client.LoadBalancers.LoadBalancersClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, lb)
+	err = client.LoadBalancers.LoadBalancersClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
 	if err != nil {
-		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroupName, err)
 	}
 
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancersClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	return utils.Bool(true), nil
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerBackendAddressPool) basicSkuBasic(data acceptance.TestData) string {
@@ -395,6 +399,10 @@ locals {
   location = %q
 }
 
+provider "azurerm" {
+  features {}
+}
+
 resource "azurerm_resource_group" "test" {
   name     = "acctestRG-${local.number}"
   location = local.location
diff --git a/internal/services/loadbalancer/client/client.go b/internal/services/loadbalancer/client/client.go
index 54b718d7615b..d27a49956682 100644
--- a/internal/services/loadbalancer/client/client.go
+++ b/internal/services/loadbalancer/client/client.go
@@ -4,29 +4,23 @@
 package client
 
 import (
+	"fmt"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/common"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type Client struct {
-	LoadBalancersClient                   *network.LoadBalancersClient
-	LoadBalancerBackendAddressPoolsClient *network.LoadBalancerBackendAddressPoolsClient
-	LoadBalancingRulesClient              *network.LoadBalancerLoadBalancingRulesClient
+	LoadBalancersClient *loadbalancers.LoadBalancersClient
 }
 
-func NewClient(o *common.ClientOptions) *Client {
-	loadBalancersClient := network.NewLoadBalancersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&loadBalancersClient.Client, o.ResourceManagerAuthorizer)
-
-	loadBalancerBackendAddressPoolsClient := network.NewLoadBalancerBackendAddressPoolsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&loadBalancerBackendAddressPoolsClient.Client, o.ResourceManagerAuthorizer)
-
-	loadBalancingRulesClient := network.NewLoadBalancerLoadBalancingRulesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
-	o.ConfigureClient(&loadBalancingRulesClient.Client, o.ResourceManagerAuthorizer)
+func NewClient(o *common.ClientOptions) (*Client, error) {
+	loadBalancersClient, err := loadbalancers.NewLoadBalancersClientWithBaseURI(o.Environment.ResourceManager)
+	if err != nil {
+		return nil, fmt.Errorf("building loadBalancers client: %+v", err)
+	}
+	o.Configure(loadBalancersClient.Client, o.Authorizers.ResourceManager)
 
 	return &Client{
-		LoadBalancersClient:                   &loadBalancersClient,
-		LoadBalancerBackendAddressPoolsClient: &loadBalancerBackendAddressPoolsClient,
-		LoadBalancingRulesClient:              &loadBalancingRulesClient,
-	}
+		LoadBalancersClient: loadBalancersClient,
+	}, nil
 }
diff --git a/internal/services/loadbalancer/loadbalancer.go b/internal/services/loadbalancer/loadbalancer.go
index f825feaee187..31cf5e90f015 100644
--- a/internal/services/loadbalancer/loadbalancer.go
+++ b/internal/services/loadbalancer/loadbalancer.go
@@ -6,20 +6,19 @@ package loadbalancer
 import (
 	"context"
 
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 // TODO: refactor this
 
-func FindLoadBalancerBackEndAddressPoolByName(lb *network.LoadBalancer, name string) (*network.BackendAddressPool, int, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.BackendAddressPools == nil {
+func FindLoadBalancerBackEndAddressPoolByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.BackendAddressPool, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.BackendAddressPools == nil {
 		return nil, -1, false
 	}
 
-	for i, apc := range *lb.LoadBalancerPropertiesFormat.BackendAddressPools {
+	for i, apc := range *lb.Properties.BackendAddressPools {
 		if apc.Name != nil && *apc.Name == name {
 			return &apc, i, true
 		}
@@ -28,12 +27,12 @@ func FindLoadBalancerBackEndAddressPoolByName(lb *network.LoadBalancer, name str
 	return nil, -1, false
 }
 
-func FindLoadBalancerFrontEndIpConfigurationByName(lb *network.LoadBalancer, name string) (*network.FrontendIPConfiguration, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.FrontendIPConfigurations == nil {
+func FindLoadBalancerFrontEndIpConfigurationByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.FrontendIPConfiguration, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.FrontendIPConfigurations == nil {
 		return nil, false
 	}
 
-	for _, feip := range *lb.LoadBalancerPropertiesFormat.FrontendIPConfigurations {
+	for _, feip := range *lb.Properties.FrontendIPConfigurations {
 		if feip.Name != nil && *feip.Name == name {
 			return &feip, true
 		}
@@ -42,12 +41,12 @@ func FindLoadBalancerFrontEndIpConfigurationByName(lb *network.LoadBalancer, nam
 	return nil, false
 }
 
-func FindLoadBalancerRuleByName(lb *network.LoadBalancer, name string) (*network.LoadBalancingRule, int, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.LoadBalancingRules == nil {
+func FindLoadBalancerRuleByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.LoadBalancingRule, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.LoadBalancingRules == nil {
 		return nil, -1, false
 	}
 
-	for i, lbr := range *lb.LoadBalancerPropertiesFormat.LoadBalancingRules {
+	for i, lbr := range *lb.Properties.LoadBalancingRules {
 		if lbr.Name != nil && *lbr.Name == name {
 			return &lbr, i, true
 		}
@@ -56,12 +55,12 @@ func FindLoadBalancerRuleByName(lb *network.LoadBalancer, name string) (*network
 	return nil, -1, false
 }
 
-func FindLoadBalancerOutboundRuleByName(lb *network.LoadBalancer, name string) (*network.OutboundRule, int, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.OutboundRules == nil {
+func FindLoadBalancerOutboundRuleByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.OutboundRule, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.OutboundRules == nil {
 		return nil, -1, false
 	}
 
-	for i, or := range *lb.LoadBalancerPropertiesFormat.OutboundRules {
+	for i, or := range *lb.Properties.OutboundRules {
 		if or.Name != nil && *or.Name == name {
 			return &or, i, true
 		}
@@ -70,12 +69,12 @@ func FindLoadBalancerOutboundRuleByName(lb *network.LoadBalancer, name string) (
 	return nil, -1, false
 }
 
-func FindLoadBalancerNatRuleByName(lb *network.LoadBalancer, name string) (*network.InboundNatRule, int, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.InboundNatRules == nil {
+func FindLoadBalancerNatRuleByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.InboundNatRule, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.InboundNatRules == nil {
 		return nil, -1, false
 	}
 
-	for i, nr := range *lb.LoadBalancerPropertiesFormat.InboundNatRules {
+	for i, nr := range *lb.Properties.InboundNatRules {
 		if nr.Name != nil && *nr.Name == name {
 			return &nr, i, true
 		}
@@ -84,12 +83,12 @@ func FindLoadBalancerNatRuleByName(lb *network.LoadBalancer, name string) (*netw
 	return nil, -1, false
 }
 
-func FindLoadBalancerNatPoolByName(lb *network.LoadBalancer, name string) (*network.InboundNatPool, int, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.InboundNatPools == nil {
+func FindLoadBalancerNatPoolByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.InboundNatPool, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.InboundNatPools == nil {
 		return nil, -1, false
 	}
 
-	for i, np := range *lb.LoadBalancerPropertiesFormat.InboundNatPools {
+	for i, np := range *lb.Properties.InboundNatPools {
 		if np.Name != nil && *np.Name == name {
 			return &np, i, true
 		}
@@ -98,12 +97,12 @@ func FindLoadBalancerNatPoolByName(lb *network.LoadBalancer, name string) (*netw
 	return nil, -1, false
 }
 
-func FindLoadBalancerProbeByName(lb *network.LoadBalancer, name string) (*network.Probe, int, bool) {
-	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.LoadBalancerPropertiesFormat.Probes == nil {
+func FindLoadBalancerProbeByName(lb *loadbalancers.LoadBalancer, name string) (*loadbalancers.Probe, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.Probes == nil {
 		return nil, -1, false
 	}
 
-	for i, p := range *lb.LoadBalancerPropertiesFormat.Probes {
+	for i, p := range *lb.Properties.Probes {
 		if p.Name != nil && *p.Name == name {
 			return &p, i, true
 		}
@@ -112,7 +111,7 @@ func FindLoadBalancerProbeByName(lb *network.LoadBalancer, name string) (*networ
 	return nil, -1, false
 }
 
-func loadBalancerSubResourceImporter(parser func(input string) (*parse.LoadBalancerId, error)) *schema.ResourceImporter {
+func loadBalancerSubResourceImporter(parser func(input string) (*loadbalancers.LoadBalancerId, error)) *schema.ResourceImporter {
 	return pluginsdk.ImporterValidatingResourceIdThen(func(id string) error {
 		_, err := parser(id)
 		return err
diff --git a/internal/services/loadbalancer/loadbalancer_data_source.go b/internal/services/loadbalancer/loadbalancer_data_source.go
index f7be1ea3d639..f40c1e5e93be 100644
--- a/internal/services/loadbalancer/loadbalancer_data_source.go
+++ b/internal/services/loadbalancer/loadbalancer_data_source.go
@@ -7,17 +7,17 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/location"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/tags"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/zones"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/tags"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func dataSourceArmLoadBalancer() *pluginsdk.Resource {
@@ -113,10 +113,11 @@ func dataSourceArmLoadBalancerRead(d *pluginsdk.ResourceData, meta interface{})
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id := parse.NewLoadBalancerID(subscriptionId, d.Get("resource_group_name").(string), d.Get("name").(string))
-	resp, err := client.Get(ctx, id.ResourceGroup, id.Name, "")
+	id := loadbalancers.NewLoadBalancerID(subscriptionId, d.Get("resource_group_name").(string), d.Get("name").(string))
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: subscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	resp, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
+		if response.WasNotFound(resp.HttpResponse) {
 			return fmt.Errorf("%s was not found", id)
 		}
 
@@ -124,43 +125,48 @@ func dataSourceArmLoadBalancerRead(d *pluginsdk.ResourceData, meta interface{})
 	}
 
 	d.SetId(id.ID())
-	d.Set("location", location.NormalizeNilable(resp.Location))
-	if sku := resp.Sku; sku != nil {
-		d.Set("sku", string(sku.Name))
-	}
-
-	privateIpAddress := ""
-	privateIpAddresses := make([]string, 0)
-	frontendIpConfigurations := make([]interface{}, 0)
 
-	if props := resp.LoadBalancerPropertiesFormat; props != nil {
-		if feipConfigs := props.FrontendIPConfigurations; feipConfigs != nil {
-			frontendIpConfigurations = flattenLoadBalancerDataSourceFrontendIpConfiguration(feipConfigs)
+	if model := resp.Model; model != nil {
+		d.Set("location", location.NormalizeNilable(model.Location))
+		if sku := model.Sku; sku != nil {
+			d.Set("sku", string(pointer.From(sku.Name)))
+		}
 
-			for _, config := range *feipConfigs {
-				if feipProps := config.FrontendIPConfigurationPropertiesFormat; feipProps != nil {
-					if ip := feipProps.PrivateIPAddress; ip != nil {
-						if privateIpAddress == "" {
-							privateIpAddress = *feipProps.PrivateIPAddress
+		privateIpAddress := ""
+		privateIpAddresses := make([]string, 0)
+		frontendIpConfigurations := make([]interface{}, 0)
+
+		if props := model.Properties; props != nil {
+			if feipConfigs := props.FrontendIPConfigurations; feipConfigs != nil {
+				frontendIpConfigurations = flattenLoadBalancerDataSourceFrontendIpConfiguration(feipConfigs)
+				for _, config := range *feipConfigs {
+					if feipProps := config.Properties; feipProps != nil {
+						if ip := feipProps.PrivateIPAddress; ip != nil {
+							if privateIpAddress == "" {
+								privateIpAddress = pointer.From(ip)
+							}
+
+							privateIpAddresses = append(privateIpAddresses, pointer.From(ip))
 						}
-
-						privateIpAddresses = append(privateIpAddresses, *feipProps.PrivateIPAddress)
 					}
 				}
 			}
 		}
-	}
 
-	if err := d.Set("frontend_ip_configuration", frontendIpConfigurations); err != nil {
-		return fmt.Errorf("flattening `frontend_ip_configuration`: %+v", err)
+		if err := d.Set("frontend_ip_configuration", frontendIpConfigurations); err != nil {
+			return fmt.Errorf("flattening `frontend_ip_configuration`: %+v", err)
+		}
+		d.Set("private_ip_address", privateIpAddress)
+		d.Set("private_ip_addresses", privateIpAddresses)
+
+		return tags.FlattenAndSet(d, model.Tags)
 	}
-	d.Set("private_ip_address", privateIpAddress)
-	d.Set("private_ip_addresses", privateIpAddresses)
 
-	return tags.FlattenAndSet(d, resp.Tags)
+	return nil
+
 }
 
-func flattenLoadBalancerDataSourceFrontendIpConfiguration(ipConfigs *[]network.FrontendIPConfiguration) []interface{} {
+func flattenLoadBalancerDataSourceFrontendIpConfiguration(ipConfigs *[]loadbalancers.FrontendIPConfiguration) []interface{} {
 	result := make([]interface{}, 0)
 	if ipConfigs == nil {
 		return result
@@ -173,8 +179,8 @@ func flattenLoadBalancerDataSourceFrontendIpConfiguration(ipConfigs *[]network.F
 		}
 
 		id := ""
-		if config.ID != nil {
-			id = *config.ID
+		if config.Id != nil {
+			id = *config.Id
 		}
 
 		privateIpAddress := ""
@@ -182,23 +188,18 @@ func flattenLoadBalancerDataSourceFrontendIpConfiguration(ipConfigs *[]network.F
 		privateIpAddressVersion := ""
 		publicIpAddressId := ""
 		subnetId := ""
-		if props := config.FrontendIPConfigurationPropertiesFormat; props != nil {
-			privateIpAddressAllocation = string(props.PrivateIPAllocationMethod)
+		if props := config.Properties; props != nil {
+			privateIpAddressAllocation = string(pointer.From(props.PrivateIPAllocationMethod))
 
-			if subnet := props.Subnet; subnet != nil && subnet.ID != nil {
-				subnetId = *subnet.ID
+			if subnet := props.Subnet; subnet != nil {
+				subnetId = pointer.From(subnet.Id)
 			}
 
-			if pip := props.PrivateIPAddress; pip != nil {
-				privateIpAddress = *pip
-			}
-
-			if props.PrivateIPAddressVersion != "" {
-				privateIpAddressVersion = string(props.PrivateIPAddressVersion)
-			}
+			privateIpAddress = pointer.From(props.PrivateIPAddress)
+			privateIpAddressVersion = string(pointer.From(props.PrivateIPAddressVersion))
 
-			if pip := props.PublicIPAddress; pip != nil && pip.ID != nil {
-				publicIpAddressId = *pip.ID
+			if pip := props.PublicIPAddress; pip != nil {
+				publicIpAddressId = pointer.From(pip.Id)
 			}
 		}
 
diff --git a/internal/services/loadbalancer/loadbalancer_nat_pool_resource_test.go b/internal/services/loadbalancer/loadbalancer_nat_pool_resource_test.go
index 82e3bcd17c3f..b2ef3c2e0b39 100644
--- a/internal/services/loadbalancer/loadbalancer_nat_pool_resource_test.go
+++ b/internal/services/loadbalancer/loadbalancer_nat_pool_resource_test.go
@@ -8,13 +8,14 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type LoadBalancerNatPool struct{}
@@ -140,20 +141,21 @@ func (r LoadBalancerNatPool) Exists(ctx context.Context, client *clients.Client,
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
-			return nil, fmt.Errorf("Load Balancer %q (resource group %q) not found for Nat Pool %q", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName)
+		if response.WasNotFound(lb.HttpResponse) {
+			return nil, fmt.Errorf("%s was not found", plbId)
 		}
-		return nil, fmt.Errorf("failed reading Load Balancer %q (resource group %q) for Nat Pool %q", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
-	props := lb.LoadBalancerPropertiesFormat
-	if props == nil || props.InboundNatPools == nil || len(*props.InboundNatPools) == 0 {
+	model := lb.Model
+	if model == nil || model.Properties == nil || model.Properties.InboundNatPools == nil || len(*model.Properties.InboundNatPools) == 0 {
 		return nil, fmt.Errorf("Nat Pool %q not found in Load Balancer %q (resource group %q)", id.InboundNatPoolName, id.LoadBalancerName, id.ResourceGroup)
 	}
 
 	found := false
-	for _, v := range *props.InboundNatPools {
+	for _, v := range *model.Properties.InboundNatPools {
 		if v.Name != nil && *v.Name == id.InboundNatPoolName {
 			found = true
 		}
@@ -162,7 +164,7 @@ func (r LoadBalancerNatPool) Exists(ctx context.Context, client *clients.Client,
 		return nil, fmt.Errorf("Nat Pool %q not found in Load Balancer %q (resource group %q)", id.InboundNatPoolName, id.LoadBalancerName, id.ResourceGroup)
 	}
 
-	return utils.Bool(found), nil
+	return pointer.To(found), nil
 }
 
 func (r LoadBalancerNatPool) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
@@ -171,37 +173,36 @@ func (r LoadBalancerNatPool) Destroy(ctx context.Context, client *clients.Client
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
-	if lb.LoadBalancerPropertiesFormat == nil {
+	if lb.Model == nil {
+		return nil, fmt.Errorf("`model` was nil")
+	}
+	if lb.Model.Properties == nil {
 		return nil, fmt.Errorf("`properties` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat.InboundNatPools == nil {
+	if lb.Model.Properties.InboundNatPools == nil {
 		return nil, fmt.Errorf("`properties.InboundNatPools` was nil")
 	}
 
-	inboundNatPools := make([]network.InboundNatPool, 0)
-	for _, inboundNatPool := range *lb.LoadBalancerPropertiesFormat.InboundNatPools {
+	inboundNatPools := make([]loadbalancers.InboundNatPool, 0)
+	for _, inboundNatPool := range *lb.Model.Properties.InboundNatPools {
 		if inboundNatPool.Name == nil || *inboundNatPool.Name == id.InboundNatPoolName {
 			continue
 		}
 
 		inboundNatPools = append(inboundNatPools, inboundNatPool)
 	}
-	lb.LoadBalancerPropertiesFormat.InboundNatPools = &inboundNatPools
+	lb.Model.Properties.InboundNatPools = &inboundNatPools
 
-	future, err := client.LoadBalancers.LoadBalancersClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, lb)
+	err = client.LoadBalancers.LoadBalancersClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
 	if err != nil {
 		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
 	}
-
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancersClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	return utils.Bool(true), nil
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerNatPool) basic(data acceptance.TestData, sku string) string {
diff --git a/internal/services/loadbalancer/loadbalancer_nat_rule_resource_test.go b/internal/services/loadbalancer/loadbalancer_nat_rule_resource_test.go
index 8c618c2b738c..833aaf83b10d 100644
--- a/internal/services/loadbalancer/loadbalancer_nat_rule_resource_test.go
+++ b/internal/services/loadbalancer/loadbalancer_nat_rule_resource_test.go
@@ -8,13 +8,13 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type LoadBalancerNatRule struct{}
@@ -205,72 +205,73 @@ func TestAccAzureRMLoadBalancerNatRule_zeroPortNumber(t *testing.T) {
 }
 
 func (r LoadBalancerNatRule) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerInboundNatRuleID(state.ID)
+	id, err := loadbalancers.ParseInboundNatRuleID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
-			return nil, fmt.Errorf("Load Balancer %q (resource group %q) not found for Nat Rule %q", id.LoadBalancerName, id.ResourceGroup, id.InboundNatRuleName)
+		if response.WasNotFound(lb.HttpResponse) {
+			return nil, fmt.Errorf("%s was not found", plbId)
 		}
-		return nil, fmt.Errorf("failed reading Load Balancer %q (resource group %q) for Nat Rule %q", id.LoadBalancerName, id.ResourceGroup, id.InboundNatRuleName)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
-	props := lb.LoadBalancerPropertiesFormat
-	if props == nil || props.InboundNatRules == nil || len(*props.InboundNatRules) == 0 {
-		return nil, fmt.Errorf("Nat Rule %q not found in Load Balancer %q (resource group %q)", id.InboundNatRuleName, id.LoadBalancerName, id.ResourceGroup)
+	props := lb.Model
+	if props == nil || props.Properties == nil || len(*props.Properties.InboundNatRules) == 0 {
+		return nil, fmt.Errorf("Nat Rule %q not found in Load Balancer %q (resource group %q)", id.InboundNatRuleName, id.LoadBalancerName, id.ResourceGroupName)
 	}
 
 	found := false
-	for _, v := range *props.InboundNatRules {
+	for _, v := range *props.Properties.InboundNatRules {
 		if v.Name != nil && *v.Name == id.InboundNatRuleName {
 			found = true
 		}
 	}
 	if !found {
-		return nil, fmt.Errorf("Nat Rule %q not found in Load Balancer %q (resource group %q)", id.InboundNatRuleName, id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("Nat Rule %q not found in Load Balancer %q (resource group %q)", id.InboundNatRuleName, id.LoadBalancerName, id.ResourceGroupName)
 	}
-	return utils.Bool(found), nil
+	return pointer.To(found), nil
 }
 
 func (r LoadBalancerNatRule) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerInboundNatRuleID(state.ID)
+	id, err := loadbalancers.ParseInboundNatRuleID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
-	if lb.LoadBalancerPropertiesFormat == nil {
+	if lb.Model == nil {
+		return nil, fmt.Errorf("`model` was nil")
+	}
+	if lb.Model.Properties == nil {
 		return nil, fmt.Errorf("`properties` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat.InboundNatRules == nil {
+	if lb.Model.Properties.InboundNatRules == nil {
 		return nil, fmt.Errorf("`properties.InboundNatRules` was nil")
 	}
 
-	inboundNatRules := make([]network.InboundNatRule, 0)
-	for _, inboundNatRule := range *lb.LoadBalancerPropertiesFormat.InboundNatRules {
+	inboundNatRules := make([]loadbalancers.InboundNatRule, 0)
+	for _, inboundNatRule := range *lb.Model.Properties.InboundNatRules {
 		if inboundNatRule.Name == nil || *inboundNatRule.Name == id.InboundNatRuleName {
 			continue
 		}
 
 		inboundNatRules = append(inboundNatRules, inboundNatRule)
 	}
-	lb.LoadBalancerPropertiesFormat.InboundNatRules = &inboundNatRules
+	lb.Model.Properties.InboundNatRules = &inboundNatRules
 
-	future, err := client.LoadBalancers.LoadBalancersClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, lb)
+	err = client.LoadBalancers.LoadBalancersClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
 	if err != nil {
-		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancersClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+		return nil, fmt.Errorf("updating %s: %+v", *id, err)
 	}
 
-	return utils.Bool(true), nil
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerNatRule) template(data acceptance.TestData, sku string) string {
diff --git a/internal/services/loadbalancer/loadbalancer_outbound_rule_resource_test.go b/internal/services/loadbalancer/loadbalancer_outbound_rule_resource_test.go
index b6998172b4a5..30cfd51d5075 100644
--- a/internal/services/loadbalancer/loadbalancer_outbound_rule_resource_test.go
+++ b/internal/services/loadbalancer/loadbalancer_outbound_rule_resource_test.go
@@ -8,13 +8,13 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type LoadBalancerOutboundRule struct{}
@@ -126,72 +126,72 @@ func TestAccAzureRMLoadBalancerOutboundRule_allocatedOutboundPorts(t *testing.T)
 }
 
 func (r LoadBalancerOutboundRule) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerOutboundRuleID(state.ID)
+	id, err := loadbalancers.ParseOutboundRuleID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
-			return nil, fmt.Errorf("Load Balancer %q (resource group %q) not found for Outbound Rule %q", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName)
+		if response.WasNotFound(lb.HttpResponse) {
+			return nil, fmt.Errorf("%s was not found", plbId)
 		}
-		return nil, fmt.Errorf("failed reading Load Balancer %q (resource group %q) for Outbound Rule %q", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
-	props := lb.LoadBalancerPropertiesFormat
-	if props == nil || props.OutboundRules == nil || len(*props.OutboundRules) == 0 {
-		return nil, fmt.Errorf("Outbound Rule %q not found in Load Balancer %q (resource group %q)", id.OutboundRuleName, id.LoadBalancerName, id.ResourceGroup)
+	props := lb.Model
+	if props == nil || props.Properties == nil || len(*props.Properties.OutboundRules) == 0 {
+		return nil, fmt.Errorf("Outbound Rule %q not found in Load Balancer %q (resource group %q)", id.OutboundRuleName, id.LoadBalancerName, id.ResourceGroupName)
 	}
 
 	found := false
-	for _, v := range *props.OutboundRules {
+	for _, v := range *props.Properties.OutboundRules {
 		if v.Name != nil && *v.Name == id.OutboundRuleName {
 			found = true
 		}
 	}
 	if !found {
-		return nil, fmt.Errorf("Outbound Rule %q not found in Load Balancer %q (resource group %q)", id.OutboundRuleName, id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("Outbound Rule %q not found in Load Balancer %q (resource group %q)", id.OutboundRuleName, id.LoadBalancerName, id.ResourceGroupName)
 	}
-	return utils.Bool(found), nil
+	return pointer.To(found), nil
 }
 
 func (r LoadBalancerOutboundRule) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerOutboundRuleID(state.ID)
+	id, err := loadbalancers.ParseOutboundRuleID(state.ID)
 	if err != nil {
 		return nil, err
 	}
-
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
+	}
+	if lb.Model == nil {
+		return nil, fmt.Errorf("`model` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat == nil {
+	if lb.Model.Properties == nil {
 		return nil, fmt.Errorf("`properties` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat.OutboundRules == nil {
+	if lb.Model.Properties.OutboundRules == nil {
 		return nil, fmt.Errorf("`properties.OutboundRules` was nil")
 	}
 
-	outboundRules := make([]network.OutboundRule, 0)
-	for _, outboundRule := range *lb.LoadBalancerPropertiesFormat.OutboundRules {
+	outboundRules := make([]loadbalancers.OutboundRule, 0)
+	for _, outboundRule := range *lb.Model.Properties.OutboundRules {
 		if outboundRule.Name == nil || *outboundRule.Name == id.OutboundRuleName {
 			continue
 		}
 
 		outboundRules = append(outboundRules, outboundRule)
 	}
-	lb.LoadBalancerPropertiesFormat.OutboundRules = &outboundRules
+	lb.Model.Properties.OutboundRules = &outboundRules
 
-	future, err := client.LoadBalancers.LoadBalancersClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, lb)
+	err = client.LoadBalancers.LoadBalancersClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
 	if err != nil {
-		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancersClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+		return nil, fmt.Errorf("updating %s: %+v", *id, err)
 	}
 
-	return utils.Bool(true), nil
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerOutboundRule) basic(data acceptance.TestData) string {
diff --git a/internal/services/loadbalancer/loadbalancer_probe_resource_test.go b/internal/services/loadbalancer/loadbalancer_probe_resource_test.go
index d34baee2d247..ff5e3a32491e 100644
--- a/internal/services/loadbalancer/loadbalancer_probe_resource_test.go
+++ b/internal/services/loadbalancer/loadbalancer_probe_resource_test.go
@@ -8,13 +8,13 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type LoadBalancerProbe struct{}
@@ -128,72 +128,73 @@ func TestAccAzureRMLoadBalancerProbe_updateProtocol(t *testing.T) {
 }
 
 func (r LoadBalancerProbe) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerProbeID(state.ID)
+	id, err := loadbalancers.ParseProbeID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(lb.Response) {
-			return nil, fmt.Errorf("Load Balancer %q (resource group %q) not found for Probe %q", id.LoadBalancerName, id.ResourceGroup, id.ProbeName)
+		if response.WasNotFound(lb.HttpResponse) {
+			return nil, fmt.Errorf("%s was not found", plbId)
 		}
-		return nil, fmt.Errorf("failed reading Load Balancer %q (resource group %q) for Probe %q", id.LoadBalancerName, id.ResourceGroup, id.ProbeName)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
-	props := lb.LoadBalancerPropertiesFormat
-	if props == nil || props.Probes == nil || len(*props.Probes) == 0 {
-		return nil, fmt.Errorf("Probe %q not found in Load Balancer %q (resource group %q)", id.ProbeName, id.LoadBalancerName, id.ResourceGroup)
+	props := lb.Model
+	if props == nil || props.Properties.Probes == nil || len(*props.Properties.Probes) == 0 {
+		return nil, fmt.Errorf("Probe %q not found in Load Balancer %q (resource group %q)", id.ProbeName, id.LoadBalancerName, id.ResourceGroupName)
 	}
 
 	found := false
-	for _, v := range *props.Probes {
+	for _, v := range *props.Properties.Probes {
 		if v.Name != nil && *v.Name == id.ProbeName {
 			found = true
 		}
 	}
 	if !found {
-		return nil, fmt.Errorf("Probe %q not found in Load Balancer %q (resource group %q)", id.ProbeName, id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("Probe %q not found in Load Balancer %q (resource group %q)", id.ProbeName, id.LoadBalancerName, id.ResourceGroupName)
 	}
-	return utils.Bool(found), nil
+	return pointer.To(found), nil
 }
 
 func (r LoadBalancerProbe) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancerProbeID(state.ID)
+	id, err := loadbalancers.ParseProbeID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	lb, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroup)
+		return nil, fmt.Errorf("retrieving Load Balancer %q (Resource Group %q)", id.LoadBalancerName, id.ResourceGroupName)
 	}
-	if lb.LoadBalancerPropertiesFormat == nil {
+	if lb.Model == nil {
+		return nil, fmt.Errorf("`model` was nil")
+	}
+	if lb.Model.Properties == nil {
 		return nil, fmt.Errorf("`properties` was nil")
 	}
-	if lb.LoadBalancerPropertiesFormat.Probes == nil {
+	if lb.Model.Properties.Probes == nil {
 		return nil, fmt.Errorf("`properties.Probes` was nil")
 	}
 
-	probes := make([]network.Probe, 0)
-	for _, probe := range *lb.LoadBalancerPropertiesFormat.Probes {
+	probes := make([]loadbalancers.Probe, 0)
+	for _, probe := range *lb.Model.Properties.Probes {
 		if probe.Name == nil || *probe.Name == id.ProbeName {
 			continue
 		}
 
 		probes = append(probes, probe)
 	}
-	lb.LoadBalancerPropertiesFormat.Probes = &probes
+	lb.Model.Properties.Probes = &probes
 
-	future, err := client.LoadBalancers.LoadBalancersClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, lb)
+	err = client.LoadBalancers.LoadBalancersClient.CreateOrUpdateThenPoll(ctx, plbId, *lb.Model)
 	if err != nil {
-		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancersClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+		return nil, fmt.Errorf("updating %s: %+v", *id, err)
 	}
 
-	return utils.Bool(true), nil
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerProbe) basic(data acceptance.TestData) string {
diff --git a/internal/services/loadbalancer/loadbalancer_resource.go b/internal/services/loadbalancer/loadbalancer_resource.go
index 6ee2c825e8af..0b56225df848 100644
--- a/internal/services/loadbalancer/loadbalancer_resource.go
+++ b/internal/services/loadbalancer/loadbalancer_resource.go
@@ -12,25 +12,24 @@ import (
 	"strings"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/edgezones"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/location"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/tags"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/zones"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/azure"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	networkValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/network/validate"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/tags"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/suppress"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func resourceArmLoadBalancer() *pluginsdk.Resource {
@@ -41,7 +40,7 @@ func resourceArmLoadBalancer() *pluginsdk.Resource {
 		Delete: resourceArmLoadBalancerDelete,
 
 		Importer: pluginsdk.ImporterValidatingResourceId(func(id string) error {
-			_, err := parse.LoadBalancerID(id)
+			_, err := loadbalancers.ParseLoadBalancerID(id)
 			return err
 		}),
 
@@ -88,57 +87,53 @@ func resourceArmLoadBalancerCreateUpdate(d *pluginsdk.ResourceData, meta interfa
 
 	log.Printf("[INFO] preparing arguments for Azure ARM Load Balancer creation.")
 
-	id := parse.NewLoadBalancerID(subscriptionId, d.Get("resource_group_name").(string), d.Get("name").(string))
+	id := loadbalancers.NewLoadBalancerID(subscriptionId, d.Get("resource_group_name").(string), d.Get("name").(string))
 
+	plbId := loadbalancers.ProviderLoadBalancerId(id)
 	if d.IsNewResource() {
-		existing, err := client.Get(ctx, id.ResourceGroup, id.Name, "")
+		existing, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 		if err != nil {
-			if !utils.ResponseWasNotFound(existing.Response) {
+			if !response.WasNotFound(existing.HttpResponse) {
 				return fmt.Errorf("checking for presence of existing %s: %+v", id, err)
 			}
 		}
 
-		if !utils.ResponseWasNotFound(existing.Response) {
+		if !response.WasNotFound(existing.HttpResponse) {
 			return tf.ImportAsExistsError("azurerm_lb", id.ID())
 		}
 	}
 
-	if strings.EqualFold(d.Get("sku_tier").(string), string(network.LoadBalancerSkuTierGlobal)) {
-		if !strings.EqualFold(d.Get("sku").(string), string(network.LoadBalancerSkuNameStandard)) {
+	if strings.EqualFold(d.Get("sku_tier").(string), string(loadbalancers.LoadBalancerSkuTierGlobal)) {
+		if !strings.EqualFold(d.Get("sku").(string), string(loadbalancers.LoadBalancerSkuNameStandard)) {
 			return fmt.Errorf("global load balancing is only supported for standard SKU load balancers")
 		}
 	}
 
 	location := azure.NormalizeLocation(d.Get("location").(string))
-	sku := network.LoadBalancerSku{
-		Name: network.LoadBalancerSkuName(d.Get("sku").(string)),
-		Tier: network.LoadBalancerSkuTier(d.Get("sku_tier").(string)),
+	sku := loadbalancers.LoadBalancerSku{
+		Name: pointer.To(loadbalancers.LoadBalancerSkuName(d.Get("sku").(string))),
+		Tier: pointer.To(loadbalancers.LoadBalancerSkuTier(d.Get("sku_tier").(string))),
 	}
-	t := d.Get("tags").(map[string]interface{})
-	expandedTags := tags.Expand(t)
 
-	properties := network.LoadBalancerPropertiesFormat{}
+	properties := loadbalancers.LoadBalancerPropertiesFormat{}
 
 	if _, ok := d.GetOk("frontend_ip_configuration"); ok {
 		properties.FrontendIPConfigurations = expandAzureRmLoadBalancerFrontendIpConfigurations(d)
 	}
 
-	loadBalancer := network.LoadBalancer{
-		Name:                         utils.String(id.Name),
-		ExtendedLocation:             expandEdgeZone(d.Get("edge_zone").(string)),
-		Location:                     utils.String(location),
-		Tags:                         expandedTags,
-		Sku:                          &sku,
-		LoadBalancerPropertiesFormat: &properties,
+	loadBalancer := loadbalancers.LoadBalancer{
+		Name:             pointer.To(id.LoadBalancerName),
+		ExtendedLocation: expandEdgeZone(d.Get("edge_zone").(string)),
+		Location:         pointer.To(location),
+		Tags:             tags.Expand(d.Get("tags").(map[string]interface{})),
+		Sku:              pointer.To(sku),
+		Properties:       pointer.To(properties),
 	}
 
-	future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.Name, loadBalancer)
+	err := client.CreateOrUpdateThenPoll(ctx, plbId, loadBalancer)
 	if err != nil {
 		return fmt.Errorf("creating/updating %s: %+v", id, err)
 	}
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for creation/update of %s: %+v", id, err)
-	}
 
 	d.SetId(id.ID())
 
@@ -150,14 +145,15 @@ func resourceArmLoadBalancerRead(d *pluginsdk.ResourceData, meta interface{}) er
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerID(d.Id())
+	id, err := loadbalancers.ParseLoadBalancerID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	resp, err := client.Get(ctx, id.ResourceGroup, id.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	resp, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
+		if response.WasNotFound(resp.HttpResponse) {
 			log.Printf("[INFO] %s was not found - removing from state", *id)
 			d.SetId("")
 			return nil
@@ -165,42 +161,45 @@ func resourceArmLoadBalancerRead(d *pluginsdk.ResourceData, meta interface{}) er
 		return fmt.Errorf("retrieving %s: %+v", *id, err)
 	}
 
-	d.Set("name", id.Name)
-	d.Set("resource_group_name", id.ResourceGroup)
-	d.Set("location", location.NormalizeNilable(resp.Location))
-	d.Set("edge_zone", flattenEdgeZone(resp.ExtendedLocation))
+	d.Set("name", id.LoadBalancerName)
+	d.Set("resource_group_name", id.ResourceGroupName)
 
-	if sku := resp.Sku; sku != nil {
-		d.Set("sku", string(sku.Name))
-		d.Set("sku_tier", string(sku.Tier))
-	}
+	if model := resp.Model; model != nil {
+		d.Set("location", location.NormalizeNilable(model.Location))
+		d.Set("edge_zone", flattenEdgeZone(model.ExtendedLocation))
+		if sku := model.Sku; sku != nil {
+			d.Set("sku", string(pointer.From(sku.Name)))
+			d.Set("sku_tier", string(pointer.From(sku.Tier)))
+		}
 
-	if props := resp.LoadBalancerPropertiesFormat; props != nil {
-		if feipConfigs := props.FrontendIPConfigurations; feipConfigs != nil {
-			if err := d.Set("frontend_ip_configuration", flattenLoadBalancerFrontendIpConfiguration(feipConfigs)); err != nil {
-				return fmt.Errorf("flattening `frontend_ip_configuration`: %+v", err)
-			}
+		if props := model.Properties; props != nil {
+			if feipConfigs := props.FrontendIPConfigurations; feipConfigs != nil {
+				if err := d.Set("frontend_ip_configuration", flattenLoadBalancerFrontendIpConfiguration(feipConfigs)); err != nil {
+					return fmt.Errorf("flattening `frontend_ip_configuration`: %+v", err)
+				}
 
-			privateIpAddress := ""
-			privateIpAddresses := make([]string, 0)
-			for _, config := range *feipConfigs {
-				if feipProps := config.FrontendIPConfigurationPropertiesFormat; feipProps != nil {
-					if ip := feipProps.PrivateIPAddress; ip != nil {
-						if privateIpAddress == "" {
-							privateIpAddress = *feipProps.PrivateIPAddress
-						}
+				privateIpAddress := ""
+				privateIpAddresses := make([]string, 0)
+				for _, config := range *feipConfigs {
+					if feipProps := config.Properties; feipProps != nil {
+						if ip := feipProps.PrivateIPAddress; ip != nil {
+							if privateIpAddress == "" {
+								privateIpAddress = pointer.From(feipProps.PrivateIPAddress)
+							}
 
-						privateIpAddresses = append(privateIpAddresses, *feipProps.PrivateIPAddress)
+							privateIpAddresses = append(privateIpAddresses, *feipProps.PrivateIPAddress)
+						}
 					}
 				}
-			}
 
-			d.Set("private_ip_address", privateIpAddress)
-			d.Set("private_ip_addresses", privateIpAddresses)
+				d.Set("private_ip_address", privateIpAddress)
+				d.Set("private_ip_addresses", privateIpAddresses)
+			}
 		}
-	}
 
-	return tags.FlattenAndSet(d, resp.Tags)
+		return tags.FlattenAndSet(d, model.Tags)
+	}
+	return nil
 }
 
 func resourceArmLoadBalancerDelete(d *pluginsdk.ResourceData, meta interface{}) error {
@@ -208,70 +207,69 @@ func resourceArmLoadBalancerDelete(d *pluginsdk.ResourceData, meta interface{})
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerID(d.Id())
+	id, err := loadbalancers.ParseLoadBalancerID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	future, err := client.Delete(ctx, id.ResourceGroup, id.Name)
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+
+	err = client.DeleteThenPoll(ctx, plbId)
 	if err != nil {
 		return fmt.Errorf("deleting %s: %+v", *id, err)
 	}
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for the deletion of %s: %+v", *id, err)
-	}
-
 	return nil
 }
 
-func expandAzureRmLoadBalancerFrontendIpConfigurations(d *pluginsdk.ResourceData) *[]network.FrontendIPConfiguration {
+func expandAzureRmLoadBalancerFrontendIpConfigurations(d *pluginsdk.ResourceData) *[]loadbalancers.FrontendIPConfiguration {
 	configs := d.Get("frontend_ip_configuration").([]interface{})
-	frontEndConfigs := make([]network.FrontendIPConfiguration, 0, len(configs))
+	frontEndConfigs := make([]loadbalancers.FrontendIPConfiguration, 0, len(configs))
 
 	for _, configRaw := range configs {
 		data := configRaw.(map[string]interface{})
 
-		privateIpAllocationMethod := data["private_ip_address_allocation"].(string)
-		properties := network.FrontendIPConfigurationPropertiesFormat{
-			PrivateIPAllocationMethod: network.IPAllocationMethod(privateIpAllocationMethod),
+		properties := loadbalancers.FrontendIPConfigurationPropertiesFormat{}
+
+		if v := data["private_ip_address_allocation"].(string); v != "" {
+			properties.PrivateIPAllocationMethod = pointer.To(loadbalancers.IPAllocationMethod(v))
 		}
 
 		if v := data["gateway_load_balancer_frontend_ip_configuration_id"].(string); v != "" {
-			properties.GatewayLoadBalancer = &network.SubResource{
-				ID: utils.String(v),
+			properties.GatewayLoadBalancer = &loadbalancers.SubResource{
+				Id: pointer.To(v),
 			}
 		}
 
 		if v := data["private_ip_address"].(string); v != "" {
-			properties.PrivateIPAddress = &v
+			properties.PrivateIPAddress = pointer.To(v)
 		}
 
 		if v := data["public_ip_address_id"].(string); v != "" {
-			properties.PublicIPAddress = &network.PublicIPAddress{
-				ID: &v,
+			properties.PublicIPAddress = &loadbalancers.PublicIPAddress{
+				Id: pointer.To(v),
 			}
 		}
 
 		if v := data["public_ip_prefix_id"].(string); v != "" {
-			properties.PublicIPPrefix = &network.SubResource{
-				ID: &v,
+			properties.PublicIPPrefix = &loadbalancers.SubResource{
+				Id: pointer.To(v),
 			}
 		}
 
 		if v := data["subnet_id"].(string); v != "" {
-			properties.PrivateIPAddressVersion = network.IPVersionIPv4
+			properties.PrivateIPAddressVersion = pointer.To(loadbalancers.IPVersionIPvFour)
 			if v := data["private_ip_address_version"].(string); v != "" {
-				properties.PrivateIPAddressVersion = network.IPVersion(v)
+				properties.PrivateIPAddressVersion = pointer.To(loadbalancers.IPVersion(v))
 			}
-			properties.Subnet = &network.Subnet{
-				ID: &v,
+			properties.Subnet = &loadbalancers.Subnet{
+				Id: pointer.To(v),
 			}
 		}
 
-		frontEndConfig := network.FrontendIPConfiguration{
-			Name:                                    utils.String(data["name"].(string)),
-			FrontendIPConfigurationPropertiesFormat: &properties,
+		frontEndConfig := loadbalancers.FrontendIPConfiguration{
+			Name:       pointer.To(data["name"].(string)),
+			Properties: pointer.To(properties),
 		}
 
 		zones := zones.ExpandUntyped(data["zones"].(*pluginsdk.Set).List())
@@ -285,7 +283,7 @@ func expandAzureRmLoadBalancerFrontendIpConfigurations(d *pluginsdk.ResourceData
 	return &frontEndConfigs
 }
 
-func flattenLoadBalancerFrontendIpConfiguration(ipConfigs *[]network.FrontendIPConfiguration) []interface{} {
+func flattenLoadBalancerFrontendIpConfiguration(ipConfigs *[]loadbalancers.FrontendIPConfiguration) []interface{} {
 	result := make([]interface{}, 0)
 	if ipConfigs == nil {
 		return result
@@ -298,8 +296,8 @@ func flattenLoadBalancerFrontendIpConfiguration(ipConfigs *[]network.FrontendIPC
 		}
 
 		id := ""
-		if config.ID != nil {
-			id = *config.ID
+		if config.Id != nil {
+			id = *config.Id
 		}
 
 		var inboundNatRules []interface{}
@@ -313,52 +311,46 @@ func flattenLoadBalancerFrontendIpConfiguration(ipConfigs *[]network.FrontendIPC
 		subnetId := ""
 		privateIpAddress := ""
 
-		if props := config.FrontendIPConfigurationPropertiesFormat; props != nil {
-			privateIPAllocationMethod = string(props.PrivateIPAllocationMethod)
+		if props := config.Properties; props != nil {
+			privateIPAllocationMethod = string(pointer.From(props.PrivateIPAllocationMethod))
 
-			if props.GatewayLoadBalancer != nil && props.GatewayLoadBalancer.ID != nil {
-				gatewayLoadBalancerId = *props.GatewayLoadBalancer.ID
+			if props.GatewayLoadBalancer != nil {
+				gatewayLoadBalancerId = pointer.From(props.GatewayLoadBalancer.Id)
 			}
 
 			if subnet := props.Subnet; subnet != nil {
-				subnetId = *subnet.ID
-			}
-
-			if pip := props.PrivateIPAddress; pip != nil {
-				privateIpAddress = *pip
-			}
-
-			if props.PrivateIPAddressVersion != "" {
-				privateIpAddressVersion = string(props.PrivateIPAddressVersion)
+				subnetId = pointer.From(subnet.Id)
 			}
+			privateIpAddress = pointer.From(props.PrivateIPAddress)
+			privateIpAddressVersion = string(pointer.From(props.PrivateIPAddressVersion))
 
 			if pip := props.PublicIPAddress; pip != nil {
-				publicIpAddressId = *pip.ID
+				publicIpAddressId = pointer.From(pip.Id)
 			}
 
 			if pip := props.PublicIPPrefix; pip != nil {
-				publicIpPrefixId = *pip.ID
+				publicIpPrefixId = pointer.From(pip.Id)
 			}
 
 			if rules := props.LoadBalancingRules; rules != nil {
 				for _, rule := range *rules {
-					if rule.ID == nil {
+					if rule.Id == nil {
 						continue
 					}
 
-					loadBalancingRules = append(loadBalancingRules, *rule.ID)
+					loadBalancingRules = append(loadBalancingRules, pointer.From(rule.Id))
 				}
 			}
 
 			if rules := props.InboundNatRules; rules != nil {
 				for _, rule := range *rules {
-					inboundNatRules = append(inboundNatRules, *rule.ID)
+					inboundNatRules = append(inboundNatRules, pointer.From(rule.Id))
 				}
 			}
 
 			if rules := props.OutboundRules; rules != nil {
 				for _, rule := range *rules {
-					outboundRules = append(outboundRules, *rule.ID)
+					outboundRules = append(outboundRules, pointer.From(rule.Id))
 				}
 			}
 		}
@@ -401,23 +393,23 @@ func resourceArmLoadBalancerSchema() map[string]*pluginsdk.Schema {
 		"sku": {
 			Type:     pluginsdk.TypeString,
 			Optional: true,
-			Default:  string(network.LoadBalancerSkuNameBasic),
+			Default:  string(loadbalancers.LoadBalancerSkuNameBasic),
 			ForceNew: true,
 			ValidateFunc: validation.StringInSlice([]string{
-				string(network.LoadBalancerSkuNameBasic),
-				string(network.LoadBalancerSkuNameStandard),
-				string(network.LoadBalancerSkuNameGateway),
+				string(loadbalancers.LoadBalancerSkuNameBasic),
+				string(loadbalancers.LoadBalancerSkuNameStandard),
+				string(loadbalancers.LoadBalancerSkuNameGateway),
 			}, false),
 		},
 
 		"sku_tier": {
 			Type:     pluginsdk.TypeString,
 			Optional: true,
-			Default:  string(network.LoadBalancerSkuTierRegional),
+			Default:  string(loadbalancers.LoadBalancerSkuTierRegional),
 			ForceNew: true,
 			ValidateFunc: validation.StringInSlice([]string{
-				string(network.LoadBalancerSkuTierRegional),
-				string(network.LoadBalancerSkuTierGlobal),
+				string(loadbalancers.LoadBalancerSkuTierRegional),
+				string(loadbalancers.LoadBalancerSkuTierGlobal),
 			}, false),
 		},
 
@@ -455,8 +447,8 @@ func resourceArmLoadBalancerSchema() map[string]*pluginsdk.Schema {
 						Optional: true,
 						Computed: true, // TODO: why is this computed?
 						ValidateFunc: validation.StringInSlice([]string{
-							string(network.IPVersionIPv4),
-							string(network.IPVersionIPv6),
+							string(loadbalancers.IPVersionIPvFour),
+							string(loadbalancers.IPVersionIPvSix),
 						}, false),
 					},
 
@@ -479,8 +471,8 @@ func resourceArmLoadBalancerSchema() map[string]*pluginsdk.Schema {
 						Optional: true,
 						Computed: true,
 						ValidateFunc: validation.StringInSlice([]string{
-							string(network.IPAllocationMethodDynamic),
-							string(network.IPAllocationMethodStatic),
+							string(loadbalancers.IPAllocationMethodDynamic),
+							string(loadbalancers.IPAllocationMethodStatic),
 						}, true),
 						DiffSuppressFunc: suppress.CaseDifference,
 					},
@@ -489,7 +481,7 @@ func resourceArmLoadBalancerSchema() map[string]*pluginsdk.Schema {
 						Type:         pluginsdk.TypeString,
 						Optional:     true,
 						Computed:     true,
-						ValidateFunc: validate.LoadBalancerFrontendIpConfigurationID,
+						ValidateFunc: loadbalancers.ValidateFrontendIPConfigurationID,
 					},
 
 					"load_balancer_rules": {
@@ -544,25 +536,24 @@ func resourceArmLoadBalancerSchema() map[string]*pluginsdk.Schema {
 			},
 		},
 
-		"tags": tags.Schema(),
+		"tags": commonschema.Tags(),
 	}
 }
 
-func expandEdgeZone(input string) *network.ExtendedLocation {
+func expandEdgeZone(input string) *edgezones.Model {
 	normalized := edgezones.Normalize(input)
 	if normalized == "" {
 		return nil
 	}
 
-	return &network.ExtendedLocation{
-		Name: utils.String(normalized),
-		Type: network.ExtendedLocationTypesEdgeZone,
+	return &edgezones.Model{
+		Name: normalized,
 	}
 }
 
-func flattenEdgeZone(input *network.ExtendedLocation) string {
-	if input == nil || input.Type != network.ExtendedLocationTypesEdgeZone || input.Name == nil {
+func flattenEdgeZone(input *edgezones.Model) string {
+	if input == nil || input.Name == "" {
 		return ""
 	}
-	return edgezones.NormalizeNilable(input.Name)
+	return edgezones.NormalizeNilable(&input.Name)
 }
diff --git a/internal/services/loadbalancer/loadbalancer_resource_test.go b/internal/services/loadbalancer/loadbalancer_resource_test.go
index 58cca69e1b95..9eea89b3476a 100644
--- a/internal/services/loadbalancer/loadbalancer_resource_test.go
+++ b/internal/services/loadbalancer/loadbalancer_resource_test.go
@@ -6,14 +6,15 @@ package loadbalancer_test
 import (
 	"context"
 	"fmt"
-	"net/http"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 type LoadBalancer struct{}
@@ -249,19 +250,17 @@ func TestAccAzureRMLoadBalancer_edgeZone(t *testing.T) {
 }
 
 func (r LoadBalancer) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	loadBalancerName := state.Attributes["name"]
-	resourceGroup := state.Attributes["resource_group_name"]
-
-	resp, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, resourceGroup, loadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: client.Account.SubscriptionId, ResourceGroupName: state.Attributes["resource_group_name"], LoadBalancerName: state.Attributes["name"]}
+	resp, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if resp.StatusCode == http.StatusNotFound {
-			return nil, fmt.Errorf("Bad: Load Balancer %q (resource group: %q) does not exist", loadBalancerName, resourceGroup)
+		if response.WasNotFound(resp.HttpResponse) {
+			return nil, fmt.Errorf("%s was not found", plbId)
 		}
 
-		return nil, fmt.Errorf("Bad: Get on loadBalancerClient: %+v", err)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
 
-	return utils.Bool(resp.ID != nil), nil
+	return pointer.To(resp.Model != nil && resp.Model.Id != nil), nil
 }
 
 func (r LoadBalancer) basic(data acceptance.TestData) string {
diff --git a/internal/services/loadbalancer/loadbalancer_rule_resource_test.go b/internal/services/loadbalancer/loadbalancer_rule_resource_test.go
index 792569c1b493..af547f08ef26 100644
--- a/internal/services/loadbalancer/loadbalancer_rule_resource_test.go
+++ b/internal/services/loadbalancer/loadbalancer_rule_resource_test.go
@@ -8,13 +8,13 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 type LoadBalancerRule struct{}
@@ -213,59 +213,58 @@ func TestAccAzureRMLoadBalancerRule_gatewayLBRuleMultiple(t *testing.T) {
 }
 
 func (r LoadBalancerRule) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancingRuleID(state.ID)
+	id, err := loadbalancers.ParseLoadBalancingRuleID(state.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	rule, err := client.LoadBalancers.LoadBalancingRulesClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, id.Name)
+	rule, err := client.LoadBalancers.LoadBalancersClient.LoadBalancerLoadBalancingRulesGet(ctx, *id)
 	if err != nil {
-		if utils.ResponseWasNotFound(rule.Response) {
-			return utils.Bool(false), nil
+		if response.WasNotFound(rule.HttpResponse) {
+			return pointer.To(false), nil
 		}
 
-		return nil, fmt.Errorf("retrieving %s: %+v", id, err)
+		return nil, fmt.Errorf("retrieving %s: %+v", *id, err)
 	}
 
-	return utils.Bool(rule.ID != nil), nil
+	return pointer.To(rule.Model != nil && rule.Model.Id != nil), nil
 }
 
 func (r LoadBalancerRule) Destroy(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
-	id, err := parse.LoadBalancingRuleID(state.ID)
+	id, err := loadbalancers.ParseLoadBalancingRuleID(state.ID)
 	if err != nil {
 		return nil, err
 	}
-
-	loadBalancer, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.LoadBalancers.LoadBalancersClient.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("retrieving %s: %+v", id, err)
+		return nil, fmt.Errorf("retrieving %s: %+v", plbId, err)
+	}
+	if loadBalancer.Model == nil {
+		return nil, fmt.Errorf(`model was nil`)
 	}
-	if loadBalancer.LoadBalancerPropertiesFormat == nil {
+	if loadBalancer.Model.Properties == nil {
 		return nil, fmt.Errorf(`properties was nil`)
 	}
-	if loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules == nil {
+	if loadBalancer.Model.Properties.LoadBalancingRules == nil {
 		return nil, fmt.Errorf(`properties.LoadBalancingRules was nil`)
 	}
-	rules := make([]network.LoadBalancingRule, 0)
-	for _, v := range *loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules {
-		if v.Name == nil || *v.Name == id.Name {
+	rules := make([]loadbalancers.LoadBalancingRule, 0)
+	for _, v := range *loadBalancer.Model.Properties.LoadBalancingRules {
+		if v.Name == nil || *v.Name == id.LoadBalancingRuleName {
 			continue
 		}
 
 		rules = append(rules, v)
 	}
-	loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules = &rules
+	loadBalancer.Model.Properties.LoadBalancingRules = &rules
 
-	future, err := client.LoadBalancers.LoadBalancersClient.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, loadBalancer)
+	err = client.LoadBalancers.LoadBalancersClient.CreateOrUpdateThenPoll(ctx, plbId, *loadBalancer.Model)
 	if err != nil {
-		return nil, fmt.Errorf("updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	if err := future.WaitForCompletionRef(ctx, client.LoadBalancers.LoadBalancersClient.Client); err != nil {
-		return nil, fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+		return nil, fmt.Errorf("updating %s: %+v", *id, err)
 	}
 
-	return utils.Bool(true), nil
+	return pointer.To(true), nil
 }
 
 func (r LoadBalancerRule) template(data acceptance.TestData, sku string) string {
diff --git a/internal/services/loadbalancer/nat_pool_resource.go b/internal/services/loadbalancer/nat_pool_resource.go
index 8104ed5e004f..4cb209027500 100644
--- a/internal/services/loadbalancer/nat_pool_resource.go
+++ b/internal/services/loadbalancer/nat_pool_resource.go
@@ -8,18 +8,19 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	loadBalancerValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
 	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func resourceArmLoadBalancerNatPool() *pluginsdk.Resource {
@@ -29,13 +30,13 @@ func resourceArmLoadBalancerNatPool() *pluginsdk.Resource {
 		Update: resourceArmLoadBalancerNatPoolCreateUpdate,
 		Delete: resourceArmLoadBalancerNatPoolDelete,
 
-		Importer: loadBalancerSubResourceImporter(func(input string) (*parse.LoadBalancerId, error) {
+		Importer: loadBalancerSubResourceImporter(func(input string) (*loadbalancers.LoadBalancerId, error) {
 			id, err := parse.LoadBalancerInboundNatPoolID(input)
 			if err != nil {
 				return nil, err
 			}
 
-			lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+			lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
 			return &lbId, nil
 		}),
 
@@ -60,16 +61,16 @@ func resourceArmLoadBalancerNatPool() *pluginsdk.Resource {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
 				ForceNew:     true,
-				ValidateFunc: loadBalancerValidate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"protocol": {
 				Type:     pluginsdk.TypeString,
 				Required: true,
 				ValidateFunc: validation.StringInSlice([]string{
-					string(network.TransportProtocolAll),
-					string(network.TransportProtocolTCP),
-					string(network.TransportProtocolUDP),
+					string(loadbalancers.TransportProtocolAll),
+					string(loadbalancers.TransportProtocolTcp),
+					string(loadbalancers.TransportProtocolUdp),
 				}, false),
 			},
 
@@ -128,54 +129,57 @@ func resourceArmLoadBalancerNatPoolCreateUpdate(d *pluginsdk.ResourceData, meta
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return fmt.Errorf("parsing Load Balancer Name and Group: %+v", err)
 	}
 
-	id := parse.NewLoadBalancerInboundNatPoolID(subscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, d.Get("name").(string))
+	id := parse.NewLoadBalancerInboundNatPoolID(subscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, d.Get("name").(string))
 
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
-	newNatPool, err := expandAzureRmLoadBalancerNatPool(d, &loadBalancer)
-	if err != nil {
-		return fmt.Errorf("expanding NAT Pool: %+v", err)
-	}
-
-	natPools := append(*loadBalancer.LoadBalancerPropertiesFormat.InboundNatPools, *newNatPool)
 
-	existingNatPool, existingNatPoolIndex, exists := FindLoadBalancerNatPoolByName(&loadBalancer, id.InboundNatPoolName)
-	if exists {
-		if id.InboundNatPoolName == *existingNatPool.Name {
-			if d.IsNewResource() {
-				return tf.ImportAsExistsError("azurerm_lb_nat_pool", *existingNatPool.ID)
-			}
+	if model := loadBalancer.Model; model != nil {
+		newNatPool, err := expandAzureRmLoadBalancerNatPool(d, model)
+		if err != nil {
+			return fmt.Errorf("expanding NAT Pool: %+v", err)
+		}
 
-			// this pool is being updated/reapplied remove old copy from the slice
-			natPools = append(natPools[:existingNatPoolIndex], natPools[existingNatPoolIndex+1:]...)
+		natPools := make([]loadbalancers.InboundNatPool, 0)
+		if props := model.Properties; props != nil {
+			natPools = append(*props.InboundNatPools, *newNatPool)
 		}
-	}
 
-	loadBalancer.LoadBalancerPropertiesFormat.InboundNatPools = &natPools
+		existingNatPool, existingNatPoolIndex, exists := FindLoadBalancerNatPoolByName(model, id.InboundNatPoolName)
+		if exists {
+			if id.InboundNatPoolName == *existingNatPool.Name {
+				if d.IsNewResource() {
+					return tf.ImportAsExistsError("azurerm_lb_nat_pool", *existingNatPool.Id)
+				}
 
-	future, err := client.CreateOrUpdate(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
-	}
+				// this pool is being updated/reapplied remove old copy from the slice
+				natPools = append(natPools[:existingNatPoolIndex], natPools[existingNatPoolIndex+1:]...)
+			}
+		}
+
+		model.Properties.InboundNatPools = &natPools
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for the update of Load Balancer %q (Resource Group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
+		err = client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+		if err != nil {
+			return fmt.Errorf("creating/updating %s : %+v", id, err)
+		}
 	}
 
 	d.SetId(id.ID())
@@ -193,62 +197,51 @@ func resourceArmLoadBalancerNatPoolRead(d *pluginsdk.ResourceData, meta interfac
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
-	}
-
-	config, _, exists := FindLoadBalancerNatPoolByName(&loadBalancer, id.InboundNatPoolName)
-	if !exists {
-		d.SetId("")
-		log.Printf("[INFO] Load Balancer Nat Pool %q not found. Removing from state", id.InboundNatPoolName)
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
 
-	d.Set("name", config.Name)
-	d.Set("resource_group_name", id.ResourceGroup)
-
-	if props := config.InboundNatPoolPropertiesFormat; props != nil {
-		backendPort := 0
-		if props.BackendPort != nil {
-			backendPort = int(*props.BackendPort)
+	if model := loadBalancer.Model; model != nil {
+		config, _, exists := FindLoadBalancerNatPoolByName(model, id.InboundNatPoolName)
+		if !exists {
+			d.SetId("")
+			log.Printf("[INFO] Load Balancer Nat Pool %q not found. Removing from state", id.InboundNatPoolName)
+			return nil
 		}
-		d.Set("backend_port", backendPort)
-		d.Set("floating_ip_enabled", props.EnableFloatingIP)
-		d.Set("tcp_reset_enabled", props.EnableTCPReset)
-
-		frontendIPConfigName := ""
-		frontendIPConfigID := ""
-		if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.ID != nil {
-			feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*props.FrontendIPConfiguration.ID)
-			if err != nil {
-				return err
-			}
 
-			frontendIPConfigName = feid.FrontendIPConfigurationName
-			frontendIPConfigID = feid.ID()
-		}
-		d.Set("frontend_ip_configuration_id", frontendIPConfigID)
-		d.Set("frontend_ip_configuration_name", frontendIPConfigName)
+		d.Set("name", config.Name)
+		d.Set("resource_group_name", id.ResourceGroup)
 
-		frontendPortRangeEnd := 0
-		if props.FrontendPortRangeEnd != nil {
-			frontendPortRangeEnd = int(*props.FrontendPortRangeEnd)
-		}
-		d.Set("frontend_port_end", frontendPortRangeEnd)
+		if props := config.Properties; props != nil {
+			d.Set("backend_port", props.BackendPort)
+			d.Set("floating_ip_enabled", pointer.From(props.EnableFloatingIP))
+			d.Set("tcp_reset_enabled", pointer.From(props.EnableTcpReset))
+
+			frontendIPConfigName := ""
+			frontendIPConfigID := ""
+			if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.Id != nil {
+				feid, err := loadbalancers.ParseFrontendIPConfigurationIDInsensitively(*props.FrontendIPConfiguration.Id)
+				if err != nil {
+					return err
+				}
 
-		frontendPortRangeStart := 0
-		if props.FrontendPortRangeStart != nil {
-			frontendPortRangeStart = int(*props.FrontendPortRangeStart)
+				frontendIPConfigName = feid.FrontendIPConfigurationName
+				frontendIPConfigID = feid.ID()
+			}
+			d.Set("frontend_ip_configuration_id", frontendIPConfigID)
+			d.Set("frontend_ip_configuration_name", frontendIPConfigName)
+			d.Set("frontend_port_end", props.FrontendPortRangeEnd)
+			d.Set("frontend_port_start", props.FrontendPortRangeStart)
+			d.Set("idle_timeout_in_minutes", int(*props.IdleTimeoutInMinutes))
+			d.Set("protocol", string(props.Protocol))
 		}
-		d.Set("frontend_port_start", frontendPortRangeStart)
-		d.Set("idle_timeout_in_minutes", int(*props.IdleTimeoutInMinutes))
-		d.Set("protocol", string(props.Protocol))
 	}
 
 	return nil
@@ -264,47 +257,47 @@ func resourceArmLoadBalancerNatPoolDelete(d *pluginsdk.ResourceData, meta interf
 		return err
 	}
 
-	loadBalancerId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	loadBalancerId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroup, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for deletion of Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
-	}
-
-	_, index, exists := FindLoadBalancerNatPoolByName(&loadBalancer, id.InboundNatPoolName)
-	if !exists {
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", loadBalancerId, err)
 	}
 
-	natPools := *loadBalancer.LoadBalancerPropertiesFormat.InboundNatPools
-	natPools = append(natPools[:index], natPools[index+1:]...)
-	loadBalancer.LoadBalancerPropertiesFormat.InboundNatPools = &natPools
+	if model := loadBalancer.Model; model != nil {
+		_, index, exists := FindLoadBalancerNatPoolByName(model, id.InboundNatPoolName)
+		if !exists {
+			return nil
+		}
 
-	future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
-	}
+		if props := model.Properties; props != nil {
+			natPools := *props.InboundNatPools
+			natPools = append(natPools[:index], natPools[index+1:]...)
+			props.InboundNatPools = &natPools
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of the Load Balancer %q (Resource Group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for Nat Pool %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatPoolName, err)
+			}
+		}
 	}
-
 	return nil
 }
 
-func expandAzureRmLoadBalancerNatPool(d *pluginsdk.ResourceData, lb *network.LoadBalancer) (*network.InboundNatPool, error) {
-	properties := network.InboundNatPoolPropertiesFormat{
-		Protocol:               network.TransportProtocol(d.Get("protocol").(string)),
-		FrontendPortRangeStart: utils.Int32(int32(d.Get("frontend_port_start").(int))),
-		FrontendPortRangeEnd:   utils.Int32(int32(d.Get("frontend_port_end").(int))),
-		BackendPort:            utils.Int32(int32(d.Get("backend_port").(int))),
+func expandAzureRmLoadBalancerNatPool(d *pluginsdk.ResourceData, lb *loadbalancers.LoadBalancer) (*loadbalancers.InboundNatPool, error) {
+	properties := loadbalancers.InboundNatPoolPropertiesFormat{
+		Protocol:               loadbalancers.TransportProtocol(d.Get("protocol").(string)),
+		FrontendPortRangeStart: int64(d.Get("frontend_port_start").(int)),
+		FrontendPortRangeEnd:   int64(d.Get("frontend_port_end").(int)),
+		BackendPort:            int64(d.Get("backend_port").(int)),
 	}
 
 	if v, ok := d.GetOk("floating_ip_enabled"); ok {
@@ -312,10 +305,10 @@ func expandAzureRmLoadBalancerNatPool(d *pluginsdk.ResourceData, lb *network.Loa
 	}
 
 	if v, ok := d.GetOk("tcp_reset_enabled"); ok {
-		properties.EnableTCPReset = utils.Bool(v.(bool))
+		properties.EnableTcpReset = utils.Bool(v.(bool))
 	}
 
-	properties.IdleTimeoutInMinutes = utils.Int32(int32(d.Get("idle_timeout_in_minutes").(int)))
+	properties.IdleTimeoutInMinutes = pointer.To(int64(d.Get("idle_timeout_in_minutes").(int)))
 
 	if v := d.Get("frontend_ip_configuration_name").(string); v != "" {
 		rule, exists := FindLoadBalancerFrontEndIpConfigurationByName(lb, v)
@@ -323,13 +316,13 @@ func expandAzureRmLoadBalancerNatPool(d *pluginsdk.ResourceData, lb *network.Loa
 			return nil, fmt.Errorf("[ERROR] Cannot find FrontEnd IP Configuration with the name %s", v)
 		}
 
-		properties.FrontendIPConfiguration = &network.SubResource{
-			ID: rule.ID,
+		properties.FrontendIPConfiguration = &loadbalancers.SubResource{
+			Id: rule.Id,
 		}
 	}
 
-	return &network.InboundNatPool{
-		Name:                           utils.String(d.Get("name").(string)),
-		InboundNatPoolPropertiesFormat: &properties,
+	return &loadbalancers.InboundNatPool{
+		Name:       pointer.To(d.Get("name").(string)),
+		Properties: &properties,
 	}, nil
 }
diff --git a/internal/services/loadbalancer/nat_rule_resource.go b/internal/services/loadbalancer/nat_rule_resource.go
index 9bcae5826649..f5e73025471b 100644
--- a/internal/services/loadbalancer/nat_rule_resource.go
+++ b/internal/services/loadbalancer/nat_rule_resource.go
@@ -8,18 +8,17 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	loadBalancerValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func resourceArmLoadBalancerNatRule() *pluginsdk.Resource {
@@ -29,13 +28,13 @@ func resourceArmLoadBalancerNatRule() *pluginsdk.Resource {
 		Update: resourceArmLoadBalancerNatRuleCreateUpdate,
 		Delete: resourceArmLoadBalancerNatRuleDelete,
 
-		Importer: loadBalancerSubResourceImporter(func(input string) (*parse.LoadBalancerId, error) {
-			id, err := parse.LoadBalancerInboundNatRuleID(input)
+		Importer: loadBalancerSubResourceImporter(func(input string) (*loadbalancers.LoadBalancerId, error) {
+			id, err := loadbalancers.ParseInboundNatRuleID(input)
 			if err != nil {
 				return nil, err
 			}
 
-			lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+			lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 			return &lbId, nil
 		}),
 
@@ -60,16 +59,16 @@ func resourceArmLoadBalancerNatRule() *pluginsdk.Resource {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
 				ForceNew:     true,
-				ValidateFunc: loadBalancerValidate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"protocol": {
 				Type:     pluginsdk.TypeString,
 				Required: true,
 				ValidateFunc: validation.StringInSlice([]string{
-					string(network.TransportProtocolAll),
-					string(network.TransportProtocolTCP),
-					string(network.TransportProtocolUDP),
+					string(loadbalancers.TransportProtocolAll),
+					string(loadbalancers.TransportProtocolTcp),
+					string(loadbalancers.TransportProtocolUdp),
 				}, false),
 			},
 
@@ -108,7 +107,7 @@ func resourceArmLoadBalancerNatRule() *pluginsdk.Resource {
 			"backend_address_pool_id": {
 				Type:          pluginsdk.TypeString,
 				Optional:      true,
-				ValidateFunc:  loadBalancerValidate.LoadBalancerBackendAddressPoolID,
+				ValidateFunc:  loadbalancers.ValidateLoadBalancerBackendAddressPoolID,
 				ConflictsWith: []string{"frontend_port"},
 				RequiredWith:  []string{"frontend_port_start", "frontend_port_end"},
 			},
@@ -155,56 +154,57 @@ func resourceArmLoadBalancerNatRuleCreateUpdate(d *pluginsdk.ResourceData, meta
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return fmt.Errorf("retrieving Load Balancer Name and Group: %+v", err)
 	}
-	id := parse.NewLoadBalancerInboundNatRuleID(subscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, d.Get("name").(string))
+	id := loadbalancers.NewInboundNatRuleID(subscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, d.Get("name").(string))
 
 	loadBalancerIdRaw := loadBalancerId.ID()
 	locks.ByID(loadBalancerIdRaw)
 	defer locks.UnlockByID(loadBalancerIdRaw)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Nat Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatRuleName, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	newNatRule, err := expandAzureRmLoadBalancerNatRule(d, &loadBalancer, *loadBalancerId)
-	if err != nil {
-		return fmt.Errorf("expanding NAT Rule: %+v", err)
-	}
+	if model := loadBalancer.Model; model != nil {
+		newNatRule, err := expandAzureRmLoadBalancerNatRule(d, model, *loadBalancerId)
+		if err != nil {
+			return fmt.Errorf("expanding NAT Rule: %+v", err)
+		}
 
-	natRules := append(*loadBalancer.LoadBalancerPropertiesFormat.InboundNatRules, *newNatRule)
+		natRules := make([]loadbalancers.InboundNatRule, 0)
+		if props := model.Properties; props != nil {
+			natRules = append(*props.InboundNatRules, *newNatRule)
 
-	existingNatRule, existingNatRuleIndex, exists := FindLoadBalancerNatRuleByName(&loadBalancer, id.InboundNatRuleName)
-	if exists {
-		if id.InboundNatRuleName == *existingNatRule.Name {
-			if d.IsNewResource() {
-				return tf.ImportAsExistsError("azurerm_lb_nat_rule", *existingNatRule.ID)
-			}
+			existingNatRule, existingNatRuleIndex, exists := FindLoadBalancerNatRuleByName(model, id.InboundNatRuleName)
+			if exists {
+				if id.InboundNatRuleName == *existingNatRule.Name {
+					if d.IsNewResource() {
+						return tf.ImportAsExistsError("azurerm_lb_nat_rule", *existingNatRule.Id)
+					}
 
-			// this nat rule is being updated/reapplied remove old copy from the slice
-			natRules = append(natRules[:existingNatRuleIndex], natRules[existingNatRuleIndex+1:]...)
-		}
-	}
+					// this nat rule is being updated/reapplied remove old copy from the slice
+					natRules = append(natRules[:existingNatRuleIndex], natRules[existingNatRuleIndex+1:]...)
+				}
+			}
 
-	loadBalancer.LoadBalancerPropertiesFormat.InboundNatRules = &natRules
+			props.InboundNatRules = &natRules
 
-	future, err := client.CreateOrUpdate(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for Nat Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatRuleName, err)
-	}
-
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q) for Nat Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatRuleName, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("updating %s: %+v", id, err)
+			}
+		}
 	}
-
 	d.SetId(id.ID())
 
 	return resourceArmLoadBalancerNatRuleRead(d, meta)
@@ -215,85 +215,67 @@ func resourceArmLoadBalancerNatRuleRead(d *pluginsdk.ResourceData, meta interfac
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerInboundNatRuleID(d.Id())
+	id, err := loadbalancers.ParseInboundNatRuleID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Nat Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.InboundNatRuleName, err)
+		return fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
 
-	config, _, exists := FindLoadBalancerNatRuleByName(&loadBalancer, id.InboundNatRuleName)
-	if !exists {
-		d.SetId("")
-		log.Printf("[INFO] Load Balancer Nat Rule %q not found. Removing from state", id.InboundNatRuleName)
-		return nil
-	}
-
-	d.Set("name", config.Name)
-	d.Set("resource_group_name", id.ResourceGroup)
-
-	if props := config.InboundNatRulePropertiesFormat; props != nil {
-		backendIPConfigId := ""
-		if props.BackendIPConfiguration != nil && props.BackendIPConfiguration.ID != nil {
-			backendIPConfigId = *props.BackendIPConfiguration.ID
-		}
-		d.Set("backend_ip_configuration_id", backendIPConfigId)
-
-		backendPort := 0
-		if props.BackendPort != nil {
-			backendPort = int(*props.BackendPort)
-		}
-		d.Set("backend_port", backendPort)
-		d.Set("enable_floating_ip", props.EnableFloatingIP)
-		d.Set("enable_tcp_reset", props.EnableTCPReset)
-
-		frontendIPConfigName := ""
-		frontendIPConfigID := ""
-		if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.ID != nil {
-			feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*props.FrontendIPConfiguration.ID)
-			if err != nil {
-				return err
-			}
-
-			frontendIPConfigName = feid.FrontendIPConfigurationName
-			frontendIPConfigID = feid.ID()
-		}
-		d.Set("frontend_ip_configuration_name", frontendIPConfigName)
-		d.Set("frontend_ip_configuration_id", frontendIPConfigID)
-
-		if props.BackendAddressPool != nil && props.BackendAddressPool.ID != nil {
-			d.Set("backend_address_pool_id", props.BackendAddressPool.ID)
+	if model := loadBalancer.Model; model != nil {
+		config, _, exists := FindLoadBalancerNatRuleByName(model, id.InboundNatRuleName)
+		if !exists {
+			d.SetId("")
+			log.Printf("[INFO] Load Balancer Nat Rule %q not found. Removing from state", id.InboundNatRuleName)
+			return nil
 		}
 
-		frontendPort := 0
-		if props.FrontendPort != nil {
-			frontendPort = int(*props.FrontendPort)
-			d.Set("frontend_port", frontendPort)
-		}
+		d.Set("name", config.Name)
+		d.Set("resource_group_name", id.ResourceGroupName)
 
-		if props.FrontendPortRangeStart != nil {
-			d.Set("frontend_port_start", int(*props.FrontendPortRangeStart))
-		}
-		if props.FrontendPortRangeEnd != nil {
-			d.Set("frontend_port_end", int(*props.FrontendPortRangeEnd))
-		}
+		if props := config.Properties; props != nil {
+			backendIPConfigId := ""
+			if props.BackendIPConfiguration != nil && props.BackendIPConfiguration.Id != nil {
+				backendIPConfigId = *props.BackendIPConfiguration.Id
+			}
+			d.Set("backend_ip_configuration_id", backendIPConfigId)
+			d.Set("backend_port", pointer.From(props.BackendPort))
+			d.Set("enable_floating_ip", pointer.From(props.EnableFloatingIP))
+			d.Set("enable_tcp_reset", pointer.From(props.EnableTcpReset))
+
+			frontendIPConfigName := ""
+			frontendIPConfigID := ""
+			if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.Id != nil {
+				feid, err := loadbalancers.ParseFrontendIPConfigurationIDInsensitively(*props.FrontendIPConfiguration.Id)
+				if err != nil {
+					return err
+				}
+
+				frontendIPConfigName = feid.FrontendIPConfigurationName
+				frontendIPConfigID = feid.ID()
+			}
+			d.Set("frontend_ip_configuration_name", frontendIPConfigName)
+			d.Set("frontend_ip_configuration_id", frontendIPConfigID)
 
-		idleTimeoutInMinutes := 0
-		if props.IdleTimeoutInMinutes != nil {
-			idleTimeoutInMinutes = int(*props.IdleTimeoutInMinutes)
+			if props.BackendAddressPool != nil {
+				d.Set("backend_address_pool_id", pointer.From(props.BackendAddressPool.Id))
+			}
+			d.Set("frontend_port", pointer.From(props.FrontendPort))
+			d.Set("frontend_port_start", int(pointer.From(props.FrontendPortRangeStart)))
+			d.Set("frontend_port_end", int(pointer.From(props.FrontendPortRangeEnd)))
+			d.Set("idle_timeout_in_minutes", int(pointer.From(props.IdleTimeoutInMinutes)))
+			d.Set("protocol", string(pointer.From(props.Protocol)))
 		}
-		d.Set("idle_timeout_in_minutes", idleTimeoutInMinutes)
-		d.Set("protocol", string(props.Protocol))
 	}
-
 	return nil
 }
 
@@ -302,50 +284,50 @@ func resourceArmLoadBalancerNatRuleDelete(d *pluginsdk.ResourceData, meta interf
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerInboundNatRuleID(d.Id())
+	id, err := loadbalancers.ParseInboundNatRuleID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancerId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	loadBalancerId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Nat Rule %q: %+v", loadBalancerId.Name, loadBalancerId.ResourceGroup, id.InboundNatRuleName, err)
-	}
-	_, index, exists := FindLoadBalancerNatRuleByName(&loadBalancer, id.InboundNatRuleName)
-	if !exists {
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", loadBalancerId, err)
 	}
+	if model := loadBalancer.Model; model != nil {
+		_, index, exists := FindLoadBalancerNatRuleByName(model, id.InboundNatRuleName)
+		if !exists {
+			return nil
+		}
 
-	natRules := *loadBalancer.LoadBalancerPropertiesFormat.InboundNatRules
-	natRules = append(natRules[:index], natRules[index+1:]...)
-	loadBalancer.LoadBalancerPropertiesFormat.InboundNatRules = &natRules
+		if props := model.Properties; props != nil {
+			natRules := *props.InboundNatRules
+			natRules = append(natRules[:index], natRules[index+1:]...)
+			props.InboundNatRules = &natRules
 
-	future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("Creating/Updating Load Balancer %q (Resource Group %q) %+v", id.LoadBalancerName, id.ResourceGroup, err)
-	}
-
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for the completion of Load Balancer updates for %q (Resource Group %q) %+v", id.LoadBalancerName, id.ResourceGroup, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("Creating/Updating %s: %+v", *id, err)
+			}
+		}
 	}
-
 	return nil
 }
 
-func expandAzureRmLoadBalancerNatRule(d *pluginsdk.ResourceData, lb *network.LoadBalancer, loadBalancerId parse.LoadBalancerId) (*network.InboundNatRule, error) {
-	properties := network.InboundNatRulePropertiesFormat{
-		Protocol:       network.TransportProtocol(d.Get("protocol").(string)),
-		BackendPort:    utils.Int32(int32(d.Get("backend_port").(int))),
-		EnableTCPReset: utils.Bool(d.Get("enable_tcp_reset").(bool)),
+func expandAzureRmLoadBalancerNatRule(d *pluginsdk.ResourceData, lb *loadbalancers.LoadBalancer, loadBalancerId loadbalancers.LoadBalancerId) (*loadbalancers.InboundNatRule, error) {
+	properties := loadbalancers.InboundNatRulePropertiesFormat{
+		Protocol:       pointer.To(loadbalancers.TransportProtocol(d.Get("protocol").(string))),
+		BackendPort:    pointer.To(int64(d.Get("backend_port").(int))),
+		EnableTcpReset: pointer.To(d.Get("enable_tcp_reset").(bool)),
 	}
 
 	backendAddressPoolSet, frontendPort := false, false
@@ -357,26 +339,26 @@ func expandAzureRmLoadBalancerNatRule(d *pluginsdk.ResourceData, lb *network.Loa
 	}
 
 	if backendAddressPoolSet {
-		properties.FrontendPortRangeStart = utils.Int32(int32(d.Get("frontend_port_start").(int)))
-		properties.FrontendPortRangeEnd = utils.Int32(int32(d.Get("frontend_port_end").(int)))
-		properties.BackendAddressPool = &network.SubResource{
-			ID: utils.String(d.Get("backend_address_pool_id").(string)),
+		properties.FrontendPortRangeStart = pointer.To(int64(d.Get("frontend_port_start").(int)))
+		properties.FrontendPortRangeEnd = pointer.To(int64(d.Get("frontend_port_end").(int)))
+		properties.BackendAddressPool = &loadbalancers.SubResource{
+			Id: pointer.To(d.Get("backend_address_pool_id").(string)),
 		}
 	} else {
 		if frontendPort {
-			properties.FrontendPort = utils.Int32(int32(d.Get("frontend_port").(int)))
+			properties.FrontendPort = pointer.To(int64(d.Get("frontend_port").(int)))
 		} else {
-			properties.FrontendPortRangeStart = utils.Int32(int32(d.Get("frontend_port_start").(int)))
-			properties.FrontendPortRangeEnd = utils.Int32(int32(d.Get("frontend_port_end").(int)))
+			properties.FrontendPortRangeStart = pointer.To(int64(d.Get("frontend_port_start").(int)))
+			properties.FrontendPortRangeEnd = pointer.To(int64(d.Get("frontend_port_end").(int)))
 		}
 	}
 
 	if v, ok := d.GetOk("enable_floating_ip"); ok {
-		properties.EnableFloatingIP = utils.Bool(v.(bool))
+		properties.EnableFloatingIP = pointer.To(v.(bool))
 	}
 
 	if v, ok := d.GetOk("idle_timeout_in_minutes"); ok {
-		properties.IdleTimeoutInMinutes = utils.Int32(int32(v.(int)))
+		properties.IdleTimeoutInMinutes = pointer.To(int64(v.(int)))
 	}
 
 	if v := d.Get("frontend_ip_configuration_name").(string); v != "" {
@@ -384,15 +366,15 @@ func expandAzureRmLoadBalancerNatRule(d *pluginsdk.ResourceData, lb *network.Loa
 			return nil, fmt.Errorf("[ERROR] Cannot find FrontEnd IP Configuration with the name %s", v)
 		}
 
-		id := parse.NewLoadBalancerFrontendIpConfigurationID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, v).ID()
-		properties.FrontendIPConfiguration = &network.SubResource{
-			ID: utils.String(id),
+		id := loadbalancers.NewFrontendIPConfigurationID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, v).ID()
+		properties.FrontendIPConfiguration = &loadbalancers.SubResource{
+			Id: pointer.To(id),
 		}
 	}
 
-	natRule := network.InboundNatRule{
-		Name:                           utils.String(d.Get("name").(string)),
-		InboundNatRulePropertiesFormat: &properties,
+	natRule := loadbalancers.InboundNatRule{
+		Name:       pointer.To(d.Get("name").(string)),
+		Properties: &properties,
 	}
 
 	return &natRule, nil
diff --git a/internal/services/loadbalancer/outbound_rule_data_source.go b/internal/services/loadbalancer/outbound_rule_data_source.go
index 8beaf6a47eaa..973394e19359 100644
--- a/internal/services/loadbalancer/outbound_rule_data_source.go
+++ b/internal/services/loadbalancer/outbound_rule_data_source.go
@@ -7,13 +7,13 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 func dataSourceArmLoadBalancerOutboundRule() *pluginsdk.Resource {
@@ -34,7 +34,7 @@ func dataSourceArmLoadBalancerOutboundRule() *pluginsdk.Resource {
 			"loadbalancer_id": {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
-				ValidateFunc: validate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"frontend_ip_configuration": {
@@ -89,71 +89,66 @@ func dataSourceArmLoadBalancerOutboundRuleRead(d *pluginsdk.ResourceData, meta i
 	defer cancel()
 
 	name := d.Get("name").(string)
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: loadBalancerId.SubscriptionId, ResourceGroupName: loadBalancerId.ResourceGroupName, LoadBalancerName: loadBalancerId.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
-			return fmt.Errorf("parent %s was not found", *loadBalancerId)
+		if response.WasNotFound(loadBalancer.HttpResponse) {
+			return fmt.Errorf("%s was not found", *loadBalancerId)
 		}
-		return fmt.Errorf("retrieving parent %s: %+v", *loadBalancerId, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	id := parse.NewLoadBalancerOutboundRuleID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, name)
-	config, _, exists := FindLoadBalancerOutboundRuleByName(&loadBalancer, id.OutboundRuleName)
-	if !exists {
-		return fmt.Errorf("%s was not found", id)
-	}
+	id := loadbalancers.NewOutboundRuleID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, name)
 
-	d.SetId(id.ID())
-	if props := config.OutboundRulePropertiesFormat; props != nil {
-		allocatedOutboundPorts := 0
-		if props.AllocatedOutboundPorts != nil {
-			allocatedOutboundPorts = int(*props.AllocatedOutboundPorts)
+	if model := loadBalancer.Model; model != nil {
+		config, _, exists := FindLoadBalancerOutboundRuleByName(model, id.OutboundRuleName)
+		if !exists {
+			return fmt.Errorf("%s was not found", id)
 		}
-		d.Set("allocated_outbound_ports", allocatedOutboundPorts)
 
-		backendAddressPoolId := ""
-		if props.BackendAddressPool != nil && props.BackendAddressPool.ID != nil {
-			bapid, err := parse.LoadBalancerBackendAddressPoolID(*props.BackendAddressPool.ID)
-			if err != nil {
-				return err
-			}
+		d.SetId(id.ID())
 
-			backendAddressPoolId = bapid.ID()
-		}
-		d.Set("backend_address_pool_id", backendAddressPoolId)
-		d.Set("tcp_reset_enabled", props.EnableTCPReset)
-
-		frontendIpConfigurations := make([]interface{}, 0)
-		if configs := props.FrontendIPConfigurations; configs != nil {
-			for _, feConfig := range *configs {
-				if feConfig.ID == nil {
-					continue
-				}
-				feid, err := parse.LoadBalancerFrontendIpConfigurationID(*feConfig.ID)
+		if props := config.Properties; props != nil {
+			d.Set("allocated_outbound_ports", int(pointer.From(props.AllocatedOutboundPorts)))
+
+			backendAddressPoolId := ""
+			if props.BackendAddressPool.Id != nil {
+				bapid, err := loadbalancers.ParseLoadBalancerBackendAddressPoolID(*props.BackendAddressPool.Id)
 				if err != nil {
 					return err
 				}
 
-				frontendIpConfigurations = append(frontendIpConfigurations, map[string]interface{}{
-					"id":   feid.ID(),
-					"name": feid.FrontendIPConfigurationName,
-				})
+				backendAddressPoolId = bapid.ID()
 			}
+			d.Set("backend_address_pool_id", backendAddressPoolId)
+			d.Set("tcp_reset_enabled", pointer.From(props.EnableTcpReset))
+
+			frontendIpConfigurations := make([]interface{}, 0)
+			if configs := props.FrontendIPConfigurations; configs != nil {
+				for _, feConfig := range configs {
+					if feConfig.Id == nil {
+						continue
+					}
+					feid, err := loadbalancers.ParseFrontendIPConfigurationID(*feConfig.Id)
+					if err != nil {
+						return err
+					}
+
+					frontendIpConfigurations = append(frontendIpConfigurations, map[string]interface{}{
+						"id":   feid.ID(),
+						"name": feid.FrontendIPConfigurationName,
+					})
+				}
+			}
+			d.Set("frontend_ip_configuration", frontendIpConfigurations)
+			d.Set("idle_timeout_in_minutes", int(pointer.From(props.IdleTimeoutInMinutes)))
+			d.Set("protocol", string(props.Protocol))
 		}
-		d.Set("frontend_ip_configuration", frontendIpConfigurations)
-
-		idleTimeoutInMinutes := 0
-		if props.IdleTimeoutInMinutes != nil {
-			idleTimeoutInMinutes = int(*props.IdleTimeoutInMinutes)
-		}
-		d.Set("idle_timeout_in_minutes", idleTimeoutInMinutes)
-		d.Set("protocol", string(props.Protocol))
 	}
-
 	return nil
 }
diff --git a/internal/services/loadbalancer/outbound_rule_resource.go b/internal/services/loadbalancer/outbound_rule_resource.go
index 9e757198ea96..c6e1b301e2e2 100644
--- a/internal/services/loadbalancer/outbound_rule_resource.go
+++ b/internal/services/loadbalancer/outbound_rule_resource.go
@@ -8,16 +8,15 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func resourceArmLoadBalancerOutboundRule() *pluginsdk.Resource {
@@ -27,13 +26,13 @@ func resourceArmLoadBalancerOutboundRule() *pluginsdk.Resource {
 		Update: resourceArmLoadBalancerOutboundRuleCreateUpdate,
 		Delete: resourceArmLoadBalancerOutboundRuleDelete,
 
-		Importer: loadBalancerSubResourceImporter(func(input string) (*parse.LoadBalancerId, error) {
-			id, err := parse.LoadBalancerOutboundRuleID(input)
+		Importer: loadBalancerSubResourceImporter(func(input string) (*loadbalancers.LoadBalancerId, error) {
+			id, err := loadbalancers.ParseOutboundRuleID(input)
 			if err != nil {
 				return nil, err
 			}
 
-			lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+			lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 			return &lbId, nil
 		}),
 
@@ -56,7 +55,7 @@ func resourceArmLoadBalancerOutboundRule() *pluginsdk.Resource {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
 				ForceNew:     true,
-				ValidateFunc: validate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"frontend_ip_configuration": {
@@ -88,9 +87,9 @@ func resourceArmLoadBalancerOutboundRule() *pluginsdk.Resource {
 				Type:     pluginsdk.TypeString,
 				Required: true,
 				ValidateFunc: validation.StringInSlice([]string{
-					string(network.TransportProtocolAll),
-					string(network.TransportProtocolTCP),
-					string(network.TransportProtocolUDP),
+					string(loadbalancers.TransportProtocolAll),
+					string(loadbalancers.TransportProtocolTcp),
+					string(loadbalancers.TransportProtocolUdp),
 				}, false),
 			},
 
@@ -123,59 +122,60 @@ func resourceArmLoadBalancerOutboundRuleCreateUpdate(d *pluginsdk.ResourceData,
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return err
 	}
 	loadBalancerIDRaw := loadBalancerId.ID()
-	id := parse.NewLoadBalancerOutboundRuleID(subscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, d.Get("name").(string))
+	id := loadbalancers.NewOutboundRuleID(subscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, d.Get("name").(string))
 	locks.ByID(loadBalancerIDRaw)
 	defer locks.UnlockByID(loadBalancerIDRaw)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	newOutboundRule, err := expandAzureRmLoadBalancerOutboundRule(d, &loadBalancer)
-	if err != nil {
-		return fmt.Errorf("expanding Load Balancer Outbound Rule: %+v", err)
-	}
-
-	outboundRules := make([]network.OutboundRule, 0)
+	if model := loadBalancer.Model; model != nil {
+		newOutboundRule, err := expandAzureRmLoadBalancerOutboundRule(d, model)
+		if err != nil {
+			return fmt.Errorf("expanding Load Balancer Outbound Rule: %+v", err)
+		}
 
-	if loadBalancer.LoadBalancerPropertiesFormat.OutboundRules != nil {
-		outboundRules = *loadBalancer.LoadBalancerPropertiesFormat.OutboundRules
-	}
+		outboundRules := make([]loadbalancers.OutboundRule, 0)
 
-	existingOutboundRule, existingOutboundRuleIndex, exists := FindLoadBalancerOutboundRuleByName(&loadBalancer, id.OutboundRuleName)
-	if exists {
-		if id.OutboundRuleName == *existingOutboundRule.Name {
-			if d.IsNewResource() {
-				return tf.ImportAsExistsError("azurerm_lb_outbound_rule", *existingOutboundRule.ID)
+		if props := model.Properties; props != nil {
+			if props.OutboundRules != nil {
+				outboundRules = pointer.From(props.OutboundRules)
 			}
 
-			// this outbound rule is being updated/reapplied remove old copy from the slice
-			outboundRules = append(outboundRules[:existingOutboundRuleIndex], outboundRules[existingOutboundRuleIndex+1:]...)
-		}
-	}
+			existingOutboundRule, existingOutboundRuleIndex, exists := FindLoadBalancerOutboundRuleByName(model, id.OutboundRuleName)
+			if exists {
+				if id.OutboundRuleName == *existingOutboundRule.Name {
+					if d.IsNewResource() {
+						return tf.ImportAsExistsError("azurerm_lb_outbound_rule", *existingOutboundRule.Id)
+					}
 
-	outboundRules = append(outboundRules, *newOutboundRule)
+					// this outbound rule is being updated/reapplied remove old copy from the slice
+					outboundRules = append(outboundRules[:existingOutboundRuleIndex], outboundRules[existingOutboundRuleIndex+1:]...)
+				}
+			}
 
-	loadBalancer.LoadBalancerPropertiesFormat.OutboundRules = &outboundRules
+			outboundRules = append(outboundRules, *newOutboundRule)
 
-	future, err := client.CreateOrUpdate(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating LoadBalancer %q (resource group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
-	}
+			props.OutboundRules = &outboundRules
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of Load Balancer %q (resource group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("creating/updating %s: %+v", id, err)
+			}
+		}
 	}
 
 	d.SetId(id.ID())
@@ -188,74 +188,72 @@ func resourceArmLoadBalancerOutboundRuleRead(d *pluginsdk.ResourceData, meta int
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerOutboundRuleID(d.Id())
+	id, err := loadbalancers.ParseOutboundRuleID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
-	}
-
-	config, _, exists := FindLoadBalancerOutboundRuleByName(&loadBalancer, id.OutboundRuleName)
-	if !exists {
-		d.SetId("")
-		log.Printf("[INFO] Load Balancer Outbound Rule %q not found. Removing from state", id.OutboundRuleName)
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
 
-	d.Set("name", config.Name)
-
-	if props := config.OutboundRulePropertiesFormat; props != nil {
-		allocatedOutboundPorts := 0
-		if props.AllocatedOutboundPorts != nil {
-			allocatedOutboundPorts = int(*props.AllocatedOutboundPorts)
+	if model := loadBalancer.Model; model != nil {
+		config, _, exists := FindLoadBalancerOutboundRuleByName(model, id.OutboundRuleName)
+		if !exists {
+			d.SetId("")
+			log.Printf("[INFO] Load Balancer Outbound Rule %q not found. Removing from state", id.OutboundRuleName)
+			return nil
 		}
-		d.Set("allocated_outbound_ports", allocatedOutboundPorts)
 
-		backendAddressPoolId := ""
-		if props.BackendAddressPool != nil && props.BackendAddressPool.ID != nil {
-			bapid, err := parse.LoadBalancerBackendAddressPoolIDInsensitively(*props.BackendAddressPool.ID)
-			if err != nil {
-				return err
+		d.Set("name", config.Name)
+
+		if props := config.Properties; props != nil {
+			allocatedOutboundPorts := 0
+			if props.AllocatedOutboundPorts != nil {
+				allocatedOutboundPorts = int(*props.AllocatedOutboundPorts)
 			}
+			d.Set("allocated_outbound_ports", allocatedOutboundPorts)
 
-			backendAddressPoolId = bapid.ID()
-		}
-		d.Set("backend_address_pool_id", backendAddressPoolId)
-		d.Set("enable_tcp_reset", props.EnableTCPReset)
-
-		frontendIpConfigurations := make([]interface{}, 0)
-		if configs := props.FrontendIPConfigurations; configs != nil {
-			for _, feConfig := range *configs {
-				if feConfig.ID == nil {
-					continue
-				}
-				feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*feConfig.ID)
+			backendAddressPoolId := ""
+			if props.BackendAddressPool.Id != nil {
+				bapid, err := loadbalancers.ParseLoadBalancerBackendAddressPoolIDInsensitively(*props.BackendAddressPool.Id)
 				if err != nil {
 					return err
 				}
 
-				frontendIpConfigurations = append(frontendIpConfigurations, map[string]interface{}{
-					"id":   feid.ID(),
-					"name": feid.FrontendIPConfigurationName,
-				})
+				backendAddressPoolId = bapid.ID()
 			}
+			d.Set("backend_address_pool_id", backendAddressPoolId)
+			d.Set("enable_tcp_reset", props.EnableTcpReset)
+
+			frontendIpConfigurations := make([]interface{}, 0)
+			if configs := props.FrontendIPConfigurations; configs != nil {
+				for _, feConfig := range configs {
+					if feConfig.Id == nil {
+						continue
+					}
+					feid, err := loadbalancers.ParseFrontendIPConfigurationIDInsensitively(*feConfig.Id)
+					if err != nil {
+						return err
+					}
+
+					frontendIpConfigurations = append(frontendIpConfigurations, map[string]interface{}{
+						"id":   feid.ID(),
+						"name": feid.FrontendIPConfigurationName,
+					})
+				}
+			}
+			d.Set("frontend_ip_configuration", frontendIpConfigurations)
+			d.Set("idle_timeout_in_minutes", int(pointer.From(props.IdleTimeoutInMinutes)))
+			d.Set("protocol", string(props.Protocol))
 		}
-		d.Set("frontend_ip_configuration", frontendIpConfigurations)
-
-		idleTimeoutInMinutes := 0
-		if props.IdleTimeoutInMinutes != nil {
-			idleTimeoutInMinutes = int(*props.IdleTimeoutInMinutes)
-		}
-		d.Set("idle_timeout_in_minutes", idleTimeoutInMinutes)
-		d.Set("protocol", string(props.Protocol))
 	}
 
 	return nil
@@ -266,54 +264,54 @@ func resourceArmLoadBalancerOutboundRuleDelete(d *pluginsdk.ResourceData, meta i
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerOutboundRuleID(d.Id())
+	id, err := loadbalancers.ParseOutboundRuleID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancerId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	loadBalancerId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
-	}
-
-	_, index, exists := FindLoadBalancerOutboundRuleByName(&loadBalancer, id.OutboundRuleName)
-	if !exists {
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", loadBalancerId, err)
 	}
 
-	outboundRules := *loadBalancer.LoadBalancerPropertiesFormat.OutboundRules
-	outboundRules = append(outboundRules[:index], outboundRules[index+1:]...)
-	loadBalancer.LoadBalancerPropertiesFormat.OutboundRules = &outboundRules
+	if model := loadBalancer.Model; model != nil {
+		_, index, exists := FindLoadBalancerOutboundRuleByName(model, id.OutboundRuleName)
+		if !exists {
+			return nil
+		}
 
-	future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
-	}
+		if props := model.Properties; props != nil {
+			outboundRules := *props.OutboundRules
+			outboundRules = append(outboundRules[:index], outboundRules[index+1:]...)
+			props.OutboundRules = &outboundRules
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q) for Outbound Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.OutboundRuleName, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("updating %s: %+v", *id, err)
+			}
+		}
 	}
-
 	return nil
 }
 
-func expandAzureRmLoadBalancerOutboundRule(d *pluginsdk.ResourceData, lb *network.LoadBalancer) (*network.OutboundRule, error) {
-	properties := network.OutboundRulePropertiesFormat{
-		Protocol:               network.LoadBalancerOutboundRuleProtocol(d.Get("protocol").(string)),
-		AllocatedOutboundPorts: utils.Int32(int32(d.Get("allocated_outbound_ports").(int))),
+func expandAzureRmLoadBalancerOutboundRule(d *pluginsdk.ResourceData, lb *loadbalancers.LoadBalancer) (*loadbalancers.OutboundRule, error) {
+	properties := loadbalancers.OutboundRulePropertiesFormat{
+		Protocol:               loadbalancers.LoadBalancerOutboundRuleProtocol(d.Get("protocol").(string)),
+		AllocatedOutboundPorts: pointer.To(int64(d.Get("allocated_outbound_ports").(int))),
 	}
 
 	feConfigs := d.Get("frontend_ip_configuration").([]interface{})
-	feConfigSubResources := make([]network.SubResource, 0)
+	feConfigSubResources := make([]loadbalancers.SubResource, 0)
 
 	for _, raw := range feConfigs {
 		v := raw.(map[string]interface{})
@@ -322,31 +320,31 @@ func expandAzureRmLoadBalancerOutboundRule(d *pluginsdk.ResourceData, lb *networ
 			return nil, fmt.Errorf("[ERROR] Cannot find FrontEnd IP Configuration with the name %s", v["name"])
 		}
 
-		feConfigSubResource := network.SubResource{
-			ID: rule.ID,
+		feConfigSubResource := loadbalancers.SubResource{
+			Id: rule.Id,
 		}
 
 		feConfigSubResources = append(feConfigSubResources, feConfigSubResource)
 	}
 
-	properties.FrontendIPConfigurations = &feConfigSubResources
+	properties.FrontendIPConfigurations = feConfigSubResources
 
 	if v := d.Get("backend_address_pool_id").(string); v != "" {
-		properties.BackendAddressPool = &network.SubResource{
-			ID: &v,
+		properties.BackendAddressPool = loadbalancers.SubResource{
+			Id: &v,
 		}
 	}
 
 	if v, ok := d.GetOk("idle_timeout_in_minutes"); ok {
-		properties.IdleTimeoutInMinutes = utils.Int32(int32(v.(int)))
+		properties.IdleTimeoutInMinutes = pointer.To(int64(v.(int)))
 	}
 
 	if v, ok := d.GetOk("enable_tcp_reset"); ok {
-		properties.EnableTCPReset = utils.Bool(v.(bool))
+		properties.EnableTcpReset = pointer.To(v.(bool))
 	}
 
-	return &network.OutboundRule{
-		Name:                         utils.String(d.Get("name").(string)),
-		OutboundRulePropertiesFormat: &properties,
+	return &loadbalancers.OutboundRule{
+		Name:       pointer.To(d.Get("name").(string)),
+		Properties: &properties,
 	}, nil
 }
diff --git a/internal/services/loadbalancer/parse/load_balancer_outbound_rule.go b/internal/services/loadbalancer/parse/load_balancer_outbound_rule.go
deleted file mode 100644
index 5b9c96949a98..000000000000
--- a/internal/services/loadbalancer/parse/load_balancer_outbound_rule.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-type LoadBalancerOutboundRuleId struct {
-	SubscriptionId   string
-	ResourceGroup    string
-	LoadBalancerName string
-	OutboundRuleName string
-}
-
-func NewLoadBalancerOutboundRuleID(subscriptionId, resourceGroup, loadBalancerName, outboundRuleName string) LoadBalancerOutboundRuleId {
-	return LoadBalancerOutboundRuleId{
-		SubscriptionId:   subscriptionId,
-		ResourceGroup:    resourceGroup,
-		LoadBalancerName: loadBalancerName,
-		OutboundRuleName: outboundRuleName,
-	}
-}
-
-func (id LoadBalancerOutboundRuleId) String() string {
-	segments := []string{
-		fmt.Sprintf("Outbound Rule Name %q", id.OutboundRuleName),
-		fmt.Sprintf("Load Balancer Name %q", id.LoadBalancerName),
-		fmt.Sprintf("Resource Group %q", id.ResourceGroup),
-	}
-	segmentsStr := strings.Join(segments, " / ")
-	return fmt.Sprintf("%s: (%s)", "Load Balancer Outbound Rule", segmentsStr)
-}
-
-func (id LoadBalancerOutboundRuleId) ID() string {
-	fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/loadBalancers/%s/outboundRules/%s"
-	return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.OutboundRuleName)
-}
-
-// LoadBalancerOutboundRuleID parses a LoadBalancerOutboundRule ID into an LoadBalancerOutboundRuleId struct
-func LoadBalancerOutboundRuleID(input string) (*LoadBalancerOutboundRuleId, error) {
-	id, err := resourceids.ParseAzureResourceID(input)
-	if err != nil {
-		return nil, fmt.Errorf("parsing %q as an LoadBalancerOutboundRule ID: %+v", input, err)
-	}
-
-	resourceId := LoadBalancerOutboundRuleId{
-		SubscriptionId: id.SubscriptionID,
-		ResourceGroup:  id.ResourceGroup,
-	}
-
-	if resourceId.SubscriptionId == "" {
-		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
-	}
-
-	if resourceId.ResourceGroup == "" {
-		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
-	}
-
-	if resourceId.LoadBalancerName, err = id.PopSegment("loadBalancers"); err != nil {
-		return nil, err
-	}
-	if resourceId.OutboundRuleName, err = id.PopSegment("outboundRules"); err != nil {
-		return nil, err
-	}
-
-	if err := id.ValidateNoEmptySegments(input); err != nil {
-		return nil, err
-	}
-
-	return &resourceId, nil
-}
diff --git a/internal/services/loadbalancer/parse/load_balancer_outbound_rule_test.go b/internal/services/loadbalancer/parse/load_balancer_outbound_rule_test.go
deleted file mode 100644
index fb58638b7588..000000000000
--- a/internal/services/loadbalancer/parse/load_balancer_outbound_rule_test.go
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"testing"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-var _ resourceids.Id = LoadBalancerOutboundRuleId{}
-
-func TestLoadBalancerOutboundRuleIDFormatter(t *testing.T) {
-	actual := NewLoadBalancerOutboundRuleID("12345678-1234-9876-4563-123456789012", "resGroup1", "loadBalancer1", "rule1").ID()
-	expected := "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/outboundRules/rule1"
-	if actual != expected {
-		t.Fatalf("Expected %q but got %q", expected, actual)
-	}
-}
-
-func TestLoadBalancerOutboundRuleID(t *testing.T) {
-	testData := []struct {
-		Input    string
-		Error    bool
-		Expected *LoadBalancerOutboundRuleId
-	}{
-
-		{
-			// empty
-			Input: "",
-			Error: true,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Error: true,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Error: true,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Error: true,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Error: true,
-		},
-
-		{
-			// missing LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Error: true,
-		},
-
-		{
-			// missing value for LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Error: true,
-		},
-
-		{
-			// missing OutboundRuleName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
-			Error: true,
-		},
-
-		{
-			// missing value for OutboundRuleName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/outboundRules/",
-			Error: true,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/outboundRules/rule1",
-			Expected: &LoadBalancerOutboundRuleId{
-				SubscriptionId:   "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:    "resGroup1",
-				LoadBalancerName: "loadBalancer1",
-				OutboundRuleName: "rule1",
-			},
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1/OUTBOUNDRULES/RULE1",
-			Error: true,
-		},
-	}
-
-	for _, v := range testData {
-		t.Logf("[DEBUG] Testing %q", v.Input)
-
-		actual, err := LoadBalancerOutboundRuleID(v.Input)
-		if err != nil {
-			if v.Error {
-				continue
-			}
-
-			t.Fatalf("Expect a value but got an error: %s", err)
-		}
-		if v.Error {
-			t.Fatal("Expect an error but didn't get one")
-		}
-
-		if actual.SubscriptionId != v.Expected.SubscriptionId {
-			t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId)
-		}
-		if actual.ResourceGroup != v.Expected.ResourceGroup {
-			t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup)
-		}
-		if actual.LoadBalancerName != v.Expected.LoadBalancerName {
-			t.Fatalf("Expected %q but got %q for LoadBalancerName", v.Expected.LoadBalancerName, actual.LoadBalancerName)
-		}
-		if actual.OutboundRuleName != v.Expected.OutboundRuleName {
-			t.Fatalf("Expected %q but got %q for OutboundRuleName", v.Expected.OutboundRuleName, actual.OutboundRuleName)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/parse/load_balancer_probe.go b/internal/services/loadbalancer/parse/load_balancer_probe.go
deleted file mode 100644
index 6f76badcd173..000000000000
--- a/internal/services/loadbalancer/parse/load_balancer_probe.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-type LoadBalancerProbeId struct {
-	SubscriptionId   string
-	ResourceGroup    string
-	LoadBalancerName string
-	ProbeName        string
-}
-
-func NewLoadBalancerProbeID(subscriptionId, resourceGroup, loadBalancerName, probeName string) LoadBalancerProbeId {
-	return LoadBalancerProbeId{
-		SubscriptionId:   subscriptionId,
-		ResourceGroup:    resourceGroup,
-		LoadBalancerName: loadBalancerName,
-		ProbeName:        probeName,
-	}
-}
-
-func (id LoadBalancerProbeId) String() string {
-	segments := []string{
-		fmt.Sprintf("Probe Name %q", id.ProbeName),
-		fmt.Sprintf("Load Balancer Name %q", id.LoadBalancerName),
-		fmt.Sprintf("Resource Group %q", id.ResourceGroup),
-	}
-	segmentsStr := strings.Join(segments, " / ")
-	return fmt.Sprintf("%s: (%s)", "Load Balancer Probe", segmentsStr)
-}
-
-func (id LoadBalancerProbeId) ID() string {
-	fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/loadBalancers/%s/probes/%s"
-	return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.ProbeName)
-}
-
-// LoadBalancerProbeID parses a LoadBalancerProbe ID into an LoadBalancerProbeId struct
-func LoadBalancerProbeID(input string) (*LoadBalancerProbeId, error) {
-	id, err := resourceids.ParseAzureResourceID(input)
-	if err != nil {
-		return nil, fmt.Errorf("parsing %q as an LoadBalancerProbe ID: %+v", input, err)
-	}
-
-	resourceId := LoadBalancerProbeId{
-		SubscriptionId: id.SubscriptionID,
-		ResourceGroup:  id.ResourceGroup,
-	}
-
-	if resourceId.SubscriptionId == "" {
-		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
-	}
-
-	if resourceId.ResourceGroup == "" {
-		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
-	}
-
-	if resourceId.LoadBalancerName, err = id.PopSegment("loadBalancers"); err != nil {
-		return nil, err
-	}
-	if resourceId.ProbeName, err = id.PopSegment("probes"); err != nil {
-		return nil, err
-	}
-
-	if err := id.ValidateNoEmptySegments(input); err != nil {
-		return nil, err
-	}
-
-	return &resourceId, nil
-}
diff --git a/internal/services/loadbalancer/parse/load_balancer_probe_test.go b/internal/services/loadbalancer/parse/load_balancer_probe_test.go
deleted file mode 100644
index db671b8d865f..000000000000
--- a/internal/services/loadbalancer/parse/load_balancer_probe_test.go
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"testing"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-var _ resourceids.Id = LoadBalancerProbeId{}
-
-func TestLoadBalancerProbeIDFormatter(t *testing.T) {
-	actual := NewLoadBalancerProbeID("12345678-1234-9876-4563-123456789012", "resGroup1", "loadBalancer1", "probe1").ID()
-	expected := "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/probes/probe1"
-	if actual != expected {
-		t.Fatalf("Expected %q but got %q", expected, actual)
-	}
-}
-
-func TestLoadBalancerProbeID(t *testing.T) {
-	testData := []struct {
-		Input    string
-		Error    bool
-		Expected *LoadBalancerProbeId
-	}{
-
-		{
-			// empty
-			Input: "",
-			Error: true,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Error: true,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Error: true,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Error: true,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Error: true,
-		},
-
-		{
-			// missing LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Error: true,
-		},
-
-		{
-			// missing value for LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Error: true,
-		},
-
-		{
-			// missing ProbeName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
-			Error: true,
-		},
-
-		{
-			// missing value for ProbeName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/probes/",
-			Error: true,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/probes/probe1",
-			Expected: &LoadBalancerProbeId{
-				SubscriptionId:   "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:    "resGroup1",
-				LoadBalancerName: "loadBalancer1",
-				ProbeName:        "probe1",
-			},
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1/PROBES/PROBE1",
-			Error: true,
-		},
-	}
-
-	for _, v := range testData {
-		t.Logf("[DEBUG] Testing %q", v.Input)
-
-		actual, err := LoadBalancerProbeID(v.Input)
-		if err != nil {
-			if v.Error {
-				continue
-			}
-
-			t.Fatalf("Expect a value but got an error: %s", err)
-		}
-		if v.Error {
-			t.Fatal("Expect an error but didn't get one")
-		}
-
-		if actual.SubscriptionId != v.Expected.SubscriptionId {
-			t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId)
-		}
-		if actual.ResourceGroup != v.Expected.ResourceGroup {
-			t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup)
-		}
-		if actual.LoadBalancerName != v.Expected.LoadBalancerName {
-			t.Fatalf("Expected %q but got %q for LoadBalancerName", v.Expected.LoadBalancerName, actual.LoadBalancerName)
-		}
-		if actual.ProbeName != v.Expected.ProbeName {
-			t.Fatalf("Expected %q but got %q for ProbeName", v.Expected.ProbeName, actual.ProbeName)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/parse/load_balancer_test.go b/internal/services/loadbalancer/parse/load_balancer_test.go
deleted file mode 100644
index be3636c47641..000000000000
--- a/internal/services/loadbalancer/parse/load_balancer_test.go
+++ /dev/null
@@ -1,232 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"testing"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-var _ resourceids.Id = LoadBalancerId{}
-
-func TestLoadBalancerIDFormatter(t *testing.T) {
-	actual := NewLoadBalancerID("12345678-1234-9876-4563-123456789012", "resGroup1", "loadBalancer1").ID()
-	expected := "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1"
-	if actual != expected {
-		t.Fatalf("Expected %q but got %q", expected, actual)
-	}
-}
-
-func TestLoadBalancerID(t *testing.T) {
-	testData := []struct {
-		Input    string
-		Error    bool
-		Expected *LoadBalancerId
-	}{
-
-		{
-			// empty
-			Input: "",
-			Error: true,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Error: true,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Error: true,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Error: true,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Error: true,
-		},
-
-		{
-			// missing Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Error: true,
-		},
-
-		{
-			// missing value for Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Error: true,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1",
-			Expected: &LoadBalancerId{
-				SubscriptionId: "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:  "resGroup1",
-				Name:           "loadBalancer1",
-			},
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1",
-			Error: true,
-		},
-	}
-
-	for _, v := range testData {
-		t.Logf("[DEBUG] Testing %q", v.Input)
-
-		actual, err := LoadBalancerID(v.Input)
-		if err != nil {
-			if v.Error {
-				continue
-			}
-
-			t.Fatalf("Expect a value but got an error: %s", err)
-		}
-		if v.Error {
-			t.Fatal("Expect an error but didn't get one")
-		}
-
-		if actual.SubscriptionId != v.Expected.SubscriptionId {
-			t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId)
-		}
-		if actual.ResourceGroup != v.Expected.ResourceGroup {
-			t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup)
-		}
-		if actual.Name != v.Expected.Name {
-			t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name)
-		}
-	}
-}
-
-func TestLoadBalancerIDInsensitively(t *testing.T) {
-	testData := []struct {
-		Input    string
-		Error    bool
-		Expected *LoadBalancerId
-	}{
-
-		{
-			// empty
-			Input: "",
-			Error: true,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Error: true,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Error: true,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Error: true,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Error: true,
-		},
-
-		{
-			// missing Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Error: true,
-		},
-
-		{
-			// missing value for Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Error: true,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1",
-			Expected: &LoadBalancerId{
-				SubscriptionId: "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:  "resGroup1",
-				Name:           "loadBalancer1",
-			},
-		},
-
-		{
-			// lower-cased segment names
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadbalancers/loadBalancer1",
-			Expected: &LoadBalancerId{
-				SubscriptionId: "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:  "resGroup1",
-				Name:           "loadBalancer1",
-			},
-		},
-
-		{
-			// upper-cased segment names
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/LOADBALANCERS/loadBalancer1",
-			Expected: &LoadBalancerId{
-				SubscriptionId: "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:  "resGroup1",
-				Name:           "loadBalancer1",
-			},
-		},
-
-		{
-			// mixed-cased segment names
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/LoAdBaLaNcErS/loadBalancer1",
-			Expected: &LoadBalancerId{
-				SubscriptionId: "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:  "resGroup1",
-				Name:           "loadBalancer1",
-			},
-		},
-	}
-
-	for _, v := range testData {
-		t.Logf("[DEBUG] Testing %q", v.Input)
-
-		actual, err := LoadBalancerIDInsensitively(v.Input)
-		if err != nil {
-			if v.Error {
-				continue
-			}
-
-			t.Fatalf("Expect a value but got an error: %s", err)
-		}
-		if v.Error {
-			t.Fatal("Expect an error but didn't get one")
-		}
-
-		if actual.SubscriptionId != v.Expected.SubscriptionId {
-			t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId)
-		}
-		if actual.ResourceGroup != v.Expected.ResourceGroup {
-			t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup)
-		}
-		if actual.Name != v.Expected.Name {
-			t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/parse/load_balancing_rule.go b/internal/services/loadbalancer/parse/load_balancing_rule.go
deleted file mode 100644
index 6b66a6b5c1b9..000000000000
--- a/internal/services/loadbalancer/parse/load_balancing_rule.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-type LoadBalancingRuleId struct {
-	SubscriptionId   string
-	ResourceGroup    string
-	LoadBalancerName string
-	Name             string
-}
-
-func NewLoadBalancingRuleID(subscriptionId, resourceGroup, loadBalancerName, name string) LoadBalancingRuleId {
-	return LoadBalancingRuleId{
-		SubscriptionId:   subscriptionId,
-		ResourceGroup:    resourceGroup,
-		LoadBalancerName: loadBalancerName,
-		Name:             name,
-	}
-}
-
-func (id LoadBalancingRuleId) String() string {
-	segments := []string{
-		fmt.Sprintf("Name %q", id.Name),
-		fmt.Sprintf("Load Balancer Name %q", id.LoadBalancerName),
-		fmt.Sprintf("Resource Group %q", id.ResourceGroup),
-	}
-	segmentsStr := strings.Join(segments, " / ")
-	return fmt.Sprintf("%s: (%s)", "Load Balancing Rule", segmentsStr)
-}
-
-func (id LoadBalancingRuleId) ID() string {
-	fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/loadBalancers/%s/loadBalancingRules/%s"
-	return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName, id.Name)
-}
-
-// LoadBalancingRuleID parses a LoadBalancingRule ID into an LoadBalancingRuleId struct
-func LoadBalancingRuleID(input string) (*LoadBalancingRuleId, error) {
-	id, err := resourceids.ParseAzureResourceID(input)
-	if err != nil {
-		return nil, fmt.Errorf("parsing %q as an LoadBalancingRule ID: %+v", input, err)
-	}
-
-	resourceId := LoadBalancingRuleId{
-		SubscriptionId: id.SubscriptionID,
-		ResourceGroup:  id.ResourceGroup,
-	}
-
-	if resourceId.SubscriptionId == "" {
-		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
-	}
-
-	if resourceId.ResourceGroup == "" {
-		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
-	}
-
-	if resourceId.LoadBalancerName, err = id.PopSegment("loadBalancers"); err != nil {
-		return nil, err
-	}
-	if resourceId.Name, err = id.PopSegment("loadBalancingRules"); err != nil {
-		return nil, err
-	}
-
-	if err := id.ValidateNoEmptySegments(input); err != nil {
-		return nil, err
-	}
-
-	return &resourceId, nil
-}
diff --git a/internal/services/loadbalancer/parse/load_balancing_rule_test.go b/internal/services/loadbalancer/parse/load_balancing_rule_test.go
deleted file mode 100644
index 57175fe8fff7..000000000000
--- a/internal/services/loadbalancer/parse/load_balancing_rule_test.go
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package parse
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"testing"
-
-	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
-)
-
-var _ resourceids.Id = LoadBalancingRuleId{}
-
-func TestLoadBalancingRuleIDFormatter(t *testing.T) {
-	actual := NewLoadBalancingRuleID("12345678-1234-9876-4563-123456789012", "resGroup1", "loadBalancer1", "rule1").ID()
-	expected := "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/loadBalancingRules/rule1"
-	if actual != expected {
-		t.Fatalf("Expected %q but got %q", expected, actual)
-	}
-}
-
-func TestLoadBalancingRuleID(t *testing.T) {
-	testData := []struct {
-		Input    string
-		Error    bool
-		Expected *LoadBalancingRuleId
-	}{
-
-		{
-			// empty
-			Input: "",
-			Error: true,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Error: true,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Error: true,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Error: true,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Error: true,
-		},
-
-		{
-			// missing LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Error: true,
-		},
-
-		{
-			// missing value for LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Error: true,
-		},
-
-		{
-			// missing Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
-			Error: true,
-		},
-
-		{
-			// missing value for Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/loadBalancingRules/",
-			Error: true,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/loadBalancingRules/rule1",
-			Expected: &LoadBalancingRuleId{
-				SubscriptionId:   "12345678-1234-9876-4563-123456789012",
-				ResourceGroup:    "resGroup1",
-				LoadBalancerName: "loadBalancer1",
-				Name:             "rule1",
-			},
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1/LOADBALANCINGRULES/RULE1",
-			Error: true,
-		},
-	}
-
-	for _, v := range testData {
-		t.Logf("[DEBUG] Testing %q", v.Input)
-
-		actual, err := LoadBalancingRuleID(v.Input)
-		if err != nil {
-			if v.Error {
-				continue
-			}
-
-			t.Fatalf("Expect a value but got an error: %s", err)
-		}
-		if v.Error {
-			t.Fatal("Expect an error but didn't get one")
-		}
-
-		if actual.SubscriptionId != v.Expected.SubscriptionId {
-			t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId)
-		}
-		if actual.ResourceGroup != v.Expected.ResourceGroup {
-			t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup)
-		}
-		if actual.LoadBalancerName != v.Expected.LoadBalancerName {
-			t.Fatalf("Expected %q but got %q for LoadBalancerName", v.Expected.LoadBalancerName, actual.LoadBalancerName)
-		}
-		if actual.Name != v.Expected.Name {
-			t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/probe_resource.go b/internal/services/loadbalancer/probe_resource.go
index 002d05dabeba..54c3c1fec3c4 100644
--- a/internal/services/loadbalancer/probe_resource.go
+++ b/internal/services/loadbalancer/probe_resource.go
@@ -8,17 +8,16 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-	loadBalancerValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func resourceArmLoadBalancerProbe() *pluginsdk.Resource {
@@ -28,13 +27,13 @@ func resourceArmLoadBalancerProbe() *pluginsdk.Resource {
 		Update: resourceArmLoadBalancerProbeCreateUpdate,
 		Delete: resourceArmLoadBalancerProbeDelete,
 
-		Importer: loadBalancerSubResourceImporter(func(input string) (*parse.LoadBalancerId, error) {
-			id, err := parse.LoadBalancerProbeID(input)
+		Importer: loadBalancerSubResourceImporter(func(input string) (*loadbalancers.LoadBalancerId, error) {
+			id, err := loadbalancers.ParseProbeID(input)
 			if err != nil {
 				return nil, err
 			}
 
-			lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+			lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 			return &lbId, nil
 		}),
 
@@ -57,7 +56,7 @@ func resourceArmLoadBalancerProbe() *pluginsdk.Resource {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
 				ForceNew:     true,
-				ValidateFunc: loadBalancerValidate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"protocol": {
@@ -65,9 +64,9 @@ func resourceArmLoadBalancerProbe() *pluginsdk.Resource {
 				Computed: true,
 				Optional: true,
 				ValidateFunc: validation.StringInSlice([]string{
-					string(network.ProbeProtocolHTTP),
-					string(network.ProbeProtocolHTTPS),
-					string(network.ProbeProtocolTCP),
+					string(loadbalancers.ProbeProtocolHTTP),
+					string(loadbalancers.ProbeProtocolHTTPS),
+					string(loadbalancers.ProbeProtocolTcp),
 				}, false),
 			},
 
@@ -121,49 +120,49 @@ func resourceArmLoadBalancerProbeCreateUpdate(d *pluginsdk.ResourceData, meta in
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return err
 	}
 	loadBalancerIDRaw := loadBalancerId.ID()
-	id := parse.NewLoadBalancerProbeID(subscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, d.Get("name").(string))
+	id := loadbalancers.NewProbeID(subscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, d.Get("name").(string))
 	locks.ByID(loadBalancerIDRaw)
 	defer locks.UnlockByID(loadBalancerIDRaw)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing Proe %q from state", id.LoadBalancerName, id.ProbeName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Probe %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.ProbeName, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	newProbe := expandAzureRmLoadBalancerProbe(d)
-	probes := append(*loadBalancer.LoadBalancerPropertiesFormat.Probes, *newProbe)
-
-	existingProbe, existingProbeIndex, exists := FindLoadBalancerProbeByName(&loadBalancer, id.ProbeName)
-	if exists {
-		if id.ProbeName == *existingProbe.Name {
-			if d.IsNewResource() {
-				return tf.ImportAsExistsError("azurerm_lb_probe", *existingProbe.ID)
+	if model := loadBalancer.Model; model != nil {
+		if props := model.Properties; props != nil {
+			newProbe := expandAzureRmLoadBalancerProbe(d)
+			probes := append(*props.Probes, *newProbe)
+			existingProbe, existingProbeIndex, exists := FindLoadBalancerProbeByName(model, id.ProbeName)
+			if exists {
+				if id.ProbeName == *existingProbe.Name {
+					if d.IsNewResource() {
+						return tf.ImportAsExistsError("azurerm_lb_probe", *existingProbe.Id)
+					}
+
+					// this probe is being updated/reapplied remove old copy from the slice
+					probes = append(probes[:existingProbeIndex], probes[existingProbeIndex+1:]...)
+				}
 			}
 
-			// this probe is being updated/reapplied remove old copy from the slice
-			probes = append(probes[:existingProbeIndex], probes[existingProbeIndex+1:]...)
-		}
-	}
-
-	loadBalancer.LoadBalancerPropertiesFormat.Probes = &probes
+			props.Probes = &probes
 
-	future, err := client.CreateOrUpdate(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for Probe %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.ProbeName, err)
-	}
-
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q) for Probe %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.ProbeName, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("updating %s: %+v", id, err)
+			}
+		}
 	}
 
 	d.SetId(id.ID())
@@ -176,71 +175,54 @@ func resourceArmLoadBalancerProbeRead(d *pluginsdk.ResourceData, meta interface{
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerProbeID(d.Id())
+	id, err := loadbalancers.ParseProbeID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Probe %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.ProbeName, err)
+		return fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
 
-	config, _, exists := FindLoadBalancerProbeByName(&loadBalancer, id.ProbeName)
-	if !exists {
-		d.SetId("")
-		log.Printf("[INFO] Load Balancer Probe %q not found. Removing from state", id.ProbeName)
-		return nil
-	}
-
-	d.Set("name", config.Name)
-
-	if props := config.ProbePropertiesFormat; props != nil {
-		intervalInSeconds := 0
-		if props.IntervalInSeconds != nil {
-			intervalInSeconds = int(*props.IntervalInSeconds)
-		}
-		d.Set("interval_in_seconds", intervalInSeconds)
-
-		numberOfProbes := 0
-		if props.NumberOfProbes != nil {
-			numberOfProbes = int(*props.NumberOfProbes)
-		}
-		d.Set("number_of_probes", numberOfProbes)
-
-		port := 0
-		if props.Port != nil {
-			port = int(*props.Port)
+	if model := loadBalancer.Model; model != nil {
+		config, _, exists := FindLoadBalancerProbeByName(model, id.ProbeName)
+		if !exists {
+			d.SetId("")
+			log.Printf("[INFO] Load Balancer Probe %q not found. Removing from state", id.ProbeName)
+			return nil
 		}
-		d.Set("port", port)
-		d.Set("protocol", string(props.Protocol))
-		d.Set("request_path", props.RequestPath)
 
-		var threshold int
-		if v := props.ProbeThreshold; v != nil {
-			threshold = int(*v)
-		}
-		d.Set("probe_threshold", threshold)
-
-		// TODO: parse/make these consistent
-		var loadBalancerRules []string
-		if rules := props.LoadBalancingRules; rules != nil {
-			for _, ruleConfig := range *rules {
-				if id := ruleConfig.ID; id != nil {
-					loadBalancerRules = append(loadBalancerRules, *id)
+		d.Set("name", config.Name)
+
+		if props := config.Properties; props != nil {
+			d.Set("interval_in_seconds", int(pointer.From(props.IntervalInSeconds)))
+			d.Set("number_of_probes", int(pointer.From(props.NumberOfProbes)))
+			d.Set("port", int(props.Port))
+			d.Set("protocol", string(props.Protocol))
+			d.Set("request_path", pointer.From(props.RequestPath))
+			d.Set("probe_threshold", int(pointer.From(props.ProbeThreshold)))
+
+			// TODO: parse/make these consistent
+			var loadBalancerRules []string
+			if rules := props.LoadBalancingRules; rules != nil {
+				for _, ruleConfig := range *rules {
+					if id := ruleConfig.Id; id != nil {
+						loadBalancerRules = append(loadBalancerRules, *id)
+					}
 				}
 			}
-		}
-		if err := d.Set("load_balancer_rules", loadBalancerRules); err != nil {
-			return fmt.Errorf("setting `load_balancer_rules` (Load Balancer %q Probe %q): %+v", id.LoadBalancerName, id.ProbeName, err)
+			if err := d.Set("load_balancer_rules", loadBalancerRules); err != nil {
+				return fmt.Errorf("setting `load_balancer_rules` (Load Balancer %q Probe %q): %+v", id.LoadBalancerName, id.ProbeName, err)
+			}
 		}
 	}
-
 	return nil
 }
 
@@ -249,67 +231,66 @@ func resourceArmLoadBalancerProbeDelete(d *pluginsdk.ResourceData, meta interfac
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancerProbeID(d.Id())
+	id, err := loadbalancers.ParseProbeID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancerId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	loadBalancerId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Probe %q: %+v", loadBalancerId.Name, loadBalancerId.ResourceGroup, id.ProbeName, err)
-	}
-
-	_, index, exists := FindLoadBalancerProbeByName(&loadBalancer, id.ProbeName)
-	if !exists {
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", loadBalancerId, err)
 	}
+	if model := loadBalancer.Model; model != nil {
+		_, index, exists := FindLoadBalancerProbeByName(model, id.ProbeName)
+		if !exists {
+			return nil
+		}
 
-	probes := *loadBalancer.LoadBalancerPropertiesFormat.Probes
-	probes = append(probes[:index], probes[index+1:]...)
-	loadBalancer.LoadBalancerPropertiesFormat.Probes = &probes
-
-	future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, loadBalancer)
-	if err != nil {
-		return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for deletion of Probe %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.ProbeName, err)
-	}
+		if props := model.Properties; props != nil {
+			probes := *props.Probes
+			probes = append(probes[:index], probes[index+1:]...)
+			props.Probes = &probes
 
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of Load Balancer %q (Resource Group %q) for deletion of Probe %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.ProbeName, err)
+			err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+			if err != nil {
+				return fmt.Errorf("updating Load Balancer %q (Resource Group %q) for deletion of Probe %q: %+v", id.LoadBalancerName, id.ResourceGroupName, id.ProbeName, err)
+			}
+		}
 	}
-
 	return nil
 }
 
-func expandAzureRmLoadBalancerProbe(d *pluginsdk.ResourceData) *network.Probe {
-	properties := network.ProbePropertiesFormat{
-		NumberOfProbes:    utils.Int32(int32(d.Get("number_of_probes").(int))),
-		IntervalInSeconds: utils.Int32(int32(d.Get("interval_in_seconds").(int))),
-		Port:              utils.Int32(int32(d.Get("port").(int))),
+func expandAzureRmLoadBalancerProbe(d *pluginsdk.ResourceData) *loadbalancers.Probe {
+	properties := loadbalancers.ProbePropertiesFormat{
+		NumberOfProbes:    pointer.To(int64(d.Get("number_of_probes").(int))),
+		IntervalInSeconds: pointer.To(int64(d.Get("interval_in_seconds").(int))),
+		Port:              int64(d.Get("port").(int)),
 	}
 
 	if v, ok := d.GetOk("protocol"); ok {
-		properties.Protocol = network.ProbeProtocol(v.(string))
+		properties.Protocol = loadbalancers.ProbeProtocol(v.(string))
 	}
 
 	if v, ok := d.GetOk("request_path"); ok {
-		properties.RequestPath = utils.String(v.(string))
+		properties.RequestPath = pointer.To(v.(string))
 	}
 
 	if v, ok := d.GetOk("probe_threshold"); ok {
-		properties.ProbeThreshold = utils.Int32(int32(v.(int)))
+		properties.ProbeThreshold = pointer.To(int64(v.(int)))
 	}
 
-	return &network.Probe{
-		Name:                  utils.String(d.Get("name").(string)),
-		ProbePropertiesFormat: &properties,
+	return &loadbalancers.Probe{
+		Name:       pointer.To(d.Get("name").(string)),
+		Properties: &properties,
 	}
 }
diff --git a/internal/services/loadbalancer/rule_data_source.go b/internal/services/loadbalancer/rule_data_source.go
index 3d6141283ab5..81dafc4a94bb 100644
--- a/internal/services/loadbalancer/rule_data_source.go
+++ b/internal/services/loadbalancer/rule_data_source.go
@@ -7,12 +7,13 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
 )
 
 func dataSourceArmLoadBalancerRule() *pluginsdk.Resource {
@@ -33,7 +34,7 @@ func dataSourceArmLoadBalancerRule() *pluginsdk.Resource {
 			"loadbalancer_id": {
 				Type:         pluginsdk.TypeString,
 				Required:     true,
-				ValidateFunc: validate.LoadBalancerID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 			},
 
 			"frontend_ip_configuration_name": {
@@ -98,28 +99,28 @@ func dataSourceArmLoadBalancerRule() *pluginsdk.Resource {
 
 func dataSourceArmLoadBalancerRuleRead(d *pluginsdk.ResourceData, meta interface{}) error {
 	client := meta.(*clients.Client).LoadBalancers.LoadBalancersClient
-	lbRuleClient := meta.(*clients.Client).LoadBalancers.LoadBalancingRulesClient
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
 	name := d.Get("name").(string)
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: loadBalancerId.SubscriptionId, ResourceGroupName: loadBalancerId.ResourceGroupName, LoadBalancerName: loadBalancerId.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
-			return fmt.Errorf("parent %s was not found", *loadBalancerId)
+		if response.WasNotFound(loadBalancer.HttpResponse) {
+			return fmt.Errorf("%s was not found", *loadBalancerId)
 		}
-		return fmt.Errorf("retrieving parent %s: %+v", *loadBalancerId, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	id := parse.NewLoadBalancingRuleID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, name)
-	resp, err := lbRuleClient.Get(ctx, id.ResourceGroup, *loadBalancer.Name, name)
+	id := loadbalancers.NewLoadBalancingRuleID(loadBalancerId.SubscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, name)
+	resp, err := client.LoadBalancerLoadBalancingRulesGet(ctx, id)
 	if err != nil {
-		if utils.ResponseWasNotFound(resp.Response) {
+		if response.WasNotFound(resp.HttpResponse) {
 			return fmt.Errorf("%s was not found", id)
 		}
 
@@ -127,49 +128,50 @@ func dataSourceArmLoadBalancerRuleRead(d *pluginsdk.ResourceData, meta interface
 	}
 
 	d.SetId(id.ID())
-	if props := resp.LoadBalancingRulePropertiesFormat; props != nil {
-		frontendIPConfigurationName, err := parse.LoadBalancerFrontendIpConfigurationID(*props.FrontendIPConfiguration.ID)
-		if err != nil {
-			return err
-		}
+	if model := resp.Model; model != nil {
+		if props := model.Properties; props != nil {
+			frontendIPConfigurationName, err := loadbalancers.ParseFrontendIPConfigurationID(*props.FrontendIPConfiguration.Id)
+			if err != nil {
+				return err
+			}
 
-		d.Set("frontend_ip_configuration_name", frontendIPConfigurationName.FrontendIPConfigurationName)
-		d.Set("protocol", props.Protocol)
-		d.Set("frontend_port", props.FrontendPort)
-		d.Set("backend_port", props.BackendPort)
+			d.Set("frontend_ip_configuration_name", frontendIPConfigurationName.FrontendIPConfigurationName)
+			d.Set("protocol", string(props.Protocol))
+			d.Set("frontend_port", props.FrontendPort)
+			d.Set("backend_port", pointer.From(props.BackendPort))
 
-		if props.BackendAddressPool != nil {
-			if err := d.Set("backend_address_pool_id", props.BackendAddressPool.ID); err != nil {
-				return fmt.Errorf("setting `backend_address_pool_id`: %+v", err)
+			if props.BackendAddressPool != nil {
+				if err := d.Set("backend_address_pool_id", pointer.From(props.BackendAddressPool.Id)); err != nil {
+					return fmt.Errorf("setting `backend_address_pool_id`: %+v", err)
+				}
 			}
-		}
 
-		if props.Probe != nil {
-			if err := d.Set("probe_id", props.Probe.ID); err != nil {
-				return fmt.Errorf("setting `probe_id`: %+v", err)
+			if props.Probe != nil {
+				if err := d.Set("probe_id", pointer.From(props.Probe.Id)); err != nil {
+					return fmt.Errorf("setting `probe_id`: %+v", err)
+				}
 			}
-		}
 
-		if err := d.Set("enable_floating_ip", props.EnableFloatingIP); err != nil {
-			return fmt.Errorf("setting `enable_floating_ip`: %+v", err)
-		}
+			if err := d.Set("enable_floating_ip", pointer.From(props.EnableFloatingIP)); err != nil {
+				return fmt.Errorf("setting `enable_floating_ip`: %+v", err)
+			}
 
-		if err := d.Set("enable_tcp_reset", props.EnableTCPReset); err != nil {
-			return fmt.Errorf("setting `enable_tcp_reset`: %+v", err)
-		}
+			if err := d.Set("enable_tcp_reset", pointer.From(props.EnableTcpReset)); err != nil {
+				return fmt.Errorf("setting `enable_tcp_reset`: %+v", err)
+			}
 
-		if err := d.Set("disable_outbound_snat", props.DisableOutboundSnat); err != nil {
-			return fmt.Errorf("setting `disable_outbound_snat`: %+v", err)
-		}
+			if err := d.Set("disable_outbound_snat", pointer.From(props.DisableOutboundSnat)); err != nil {
+				return fmt.Errorf("setting `disable_outbound_snat`: %+v", err)
+			}
 
-		if err := d.Set("idle_timeout_in_minutes", props.IdleTimeoutInMinutes); err != nil {
-			return fmt.Errorf("setting `idle_timeout_in_minutes`: %+v", err)
-		}
+			if err := d.Set("idle_timeout_in_minutes", int(pointer.From(props.IdleTimeoutInMinutes))); err != nil {
+				return fmt.Errorf("setting `idle_timeout_in_minutes`: %+v", err)
+			}
 
-		if err := d.Set("load_distribution", props.LoadDistribution); err != nil {
-			return fmt.Errorf("setting `load_distribution`: %+v", err)
+			if err := d.Set("load_distribution", string(pointer.From(props.LoadDistribution))); err != nil {
+				return fmt.Errorf("setting `load_distribution`: %+v", err)
+			}
 		}
 	}
-
 	return nil
 }
diff --git a/internal/services/loadbalancer/rule_resource.go b/internal/services/loadbalancer/rule_resource.go
index 0cf346687a9b..74365aa9721e 100644
--- a/internal/services/loadbalancer/rule_resource.go
+++ b/internal/services/loadbalancer/rule_resource.go
@@ -8,18 +8,18 @@ import (
 	"log"
 	"time"
 
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2023-06-01/loadbalancers"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/locks"
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
 	loadBalancerValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/suppress"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/timeouts"
-	"github.com/hashicorp/terraform-provider-azurerm/utils"
-	"github.com/tombuildsstuff/kermit/sdk/network/2022-07-01/network"
 )
 
 func resourceArmLoadBalancerRule() *pluginsdk.Resource {
@@ -29,13 +29,13 @@ func resourceArmLoadBalancerRule() *pluginsdk.Resource {
 		Update: resourceArmLoadBalancerRuleCreateUpdate,
 		Delete: resourceArmLoadBalancerRuleDelete,
 
-		Importer: loadBalancerSubResourceImporter(func(input string) (*parse.LoadBalancerId, error) {
-			id, err := parse.LoadBalancingRuleID(input)
+		Importer: loadBalancerSubResourceImporter(func(input string) (*loadbalancers.LoadBalancerId, error) {
+			id, err := loadbalancers.ParseLoadBalancingRuleID(input)
 			if err != nil {
 				return nil, err
 			}
 
-			lbId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+			lbId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 			return &lbId, nil
 		}),
 
@@ -56,43 +56,47 @@ func resourceArmLoadBalancerRuleCreateUpdate(d *pluginsdk.ResourceData, meta int
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	loadBalancerId, err := parse.LoadBalancerID(d.Get("loadbalancer_id").(string))
+	loadBalancerId, err := loadbalancers.ParseLoadBalancerID(d.Get("loadbalancer_id").(string))
 	if err != nil {
 		return err
 	}
 
-	id := parse.NewLoadBalancingRuleID(subscriptionId, loadBalancerId.ResourceGroup, loadBalancerId.Name, d.Get("name").(string))
+	id := loadbalancers.NewLoadBalancingRuleID(subscriptionId, loadBalancerId.ResourceGroupName, loadBalancerId.LoadBalancerName, d.Get("name").(string))
 
 	loadBalancerID := loadBalancerId.ID()
 	locks.ByID(loadBalancerID)
 	defer locks.UnlockByID(loadBalancerID)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.Name, err)
+		return fmt.Errorf("retrieving %s: %+v", *loadBalancerId, err)
 	}
 
-	if loadBalancer.LoadBalancerPropertiesFormat == nil {
+	if loadBalancer.Model == nil {
+		return fmt.Errorf("retrieving Load Balancer %s: `model` was nil", id)
+	}
+	if loadBalancer.Model.Properties == nil {
 		return fmt.Errorf("retrieving Load Balancer %s: `properties` was nil", id)
 	}
 
-	newLbRule, err := expandAzureRmLoadBalancerRule(d, &loadBalancer)
+	newLbRule, err := expandAzureRmLoadBalancerRule(d, loadBalancer.Model)
 	if err != nil {
 		return fmt.Errorf("expanding Load Balancer Rule: %+v", err)
 	}
 
-	lbRules := append(*loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules, *newLbRule)
+	lbRules := append(*loadBalancer.Model.Properties.LoadBalancingRules, *newLbRule)
 
-	existingRule, existingRuleIndex, exists := FindLoadBalancerRuleByName(&loadBalancer, id.Name)
+	existingRule, existingRuleIndex, exists := FindLoadBalancerRuleByName(loadBalancer.Model, id.LoadBalancingRuleName)
 	if exists {
-		if id.Name == *existingRule.Name {
+		if id.LoadBalancingRuleName == *existingRule.Name {
 			if d.IsNewResource() {
-				return tf.ImportAsExistsError("azurerm_lb_rule", *existingRule.ID)
+				return tf.ImportAsExistsError("azurerm_lb_rule", *existingRule.Id)
 			}
 
 			// this rule is being updated/reapplied remove old copy from the slice
@@ -100,15 +104,11 @@ func resourceArmLoadBalancerRuleCreateUpdate(d *pluginsdk.ResourceData, meta int
 		}
 	}
 
-	loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules = &lbRules
+	loadBalancer.Model.Properties.LoadBalancingRules = &lbRules
 
-	future, err := client.CreateOrUpdate(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, loadBalancer)
+	err = client.CreateOrUpdateThenPoll(ctx, plbId, *loadBalancer.Model)
 	if err != nil {
-		return fmt.Errorf("updating Loadbalancer %q (resource group %q) for Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.Name, err)
-	}
-
-	if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-		return fmt.Errorf("waiting for update of Load Balancer %q (resource group %q) for Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.Name, err)
+		return fmt.Errorf("updating %s: %+v", id, err)
 	}
 
 	d.SetId(id.ID())
@@ -121,110 +121,92 @@ func resourceArmLoadBalancerRuleRead(d *pluginsdk.ResourceData, meta interface{}
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancingRuleID(d.Id())
+	id, err := loadbalancers.ParseLoadBalancingRuleID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancer, err := client.Get(ctx, id.ResourceGroup, id.LoadBalancerName, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			log.Printf("[INFO] Load Balancer %q not found. Removing from state", id.LoadBalancerName)
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.Name, err)
-	}
-
-	config, _, exists := FindLoadBalancerRuleByName(&loadBalancer, id.Name)
-	if !exists {
-		d.SetId("")
-		log.Printf("[INFO] Load Balancer Rule %q not found. Removing from state", id.Name)
-		return nil
+		return fmt.Errorf("retrieving %s: %+v", plbId, err)
 	}
 
-	d.Set("name", config.Name)
+	if model := loadBalancer.Model; model != nil {
+		config, _, exists := FindLoadBalancerRuleByName(model, id.LoadBalancingRuleName)
+		if !exists {
+			d.SetId("")
+			log.Printf("[INFO] Load Balancer Rule %q not found. Removing from state", id.LoadBalancerName)
+			return nil
+		}
 
-	if props := config.LoadBalancingRulePropertiesFormat; props != nil {
-		d.Set("disable_outbound_snat", props.DisableOutboundSnat)
-		d.Set("enable_floating_ip", props.EnableFloatingIP)
-		d.Set("enable_tcp_reset", props.EnableTCPReset)
-		d.Set("protocol", string(props.Protocol))
+		d.Set("name", config.Name)
 
-		backendPort := 0
-		if props.BackendPort != nil {
-			backendPort = int(*props.BackendPort)
-		}
-		d.Set("backend_port", backendPort)
+		if props := config.Properties; props != nil {
+			d.Set("disable_outbound_snat", pointer.From(props.DisableOutboundSnat))
+			d.Set("enable_floating_ip", pointer.From(props.EnableFloatingIP))
+			d.Set("enable_tcp_reset", pointer.From(props.EnableTcpReset))
+			d.Set("protocol", string(props.Protocol))
+			d.Set("backend_port", int(pointer.From(props.BackendPort)))
 
-		// The backendAddressPools is designed for Gateway LB, while the backendAddressPool is designed for other skus.
-		// Thought currently the API returns both, but for the sake of stability, we do use different fields here depending on the LB sku.
-		var isGateway bool
-		if loadBalancer.Sku != nil && loadBalancer.Sku.Name == network.LoadBalancerSkuNameGateway {
-			isGateway = true
-		}
-		var (
-			backendAddressPoolId  string
-			backendAddressPoolIds []interface{}
-		)
-		if isGateway {
-			// The gateway LB rule can have up to 2 backend address pools.
-			// In case there is only one BAP, we set it to both "backendAddressPoolId" and "backendAddressPoolIds".
-			// Otherwise, we leave the "backendAddressPoolId" as empty.
-			if props.BackendAddressPools != nil {
-				for _, p := range *props.BackendAddressPools {
-					if p.ID != nil {
-						backendAddressPoolIds = append(backendAddressPoolIds, *p.ID)
+			// The backendAddressPools is designed for Gateway LB, while the backendAddressPool is designed for other skus.
+			// Thought currently the API returns both, but for the sake of stability, we do use different fields here depending on the LB sku.
+			var isGateway bool
+			if model.Sku != nil && pointer.From(model.Sku.Name) == loadbalancers.LoadBalancerSkuNameGateway {
+				isGateway = true
+			}
+			var (
+				backendAddressPoolId  string
+				backendAddressPoolIds []interface{}
+			)
+			if isGateway {
+				// The gateway LB rule can have up to 2 backend address pools.
+				// In case there is only one BAP, we set it to both "backendAddressPoolId" and "backendAddressPoolIds".
+				// Otherwise, we leave the "backendAddressPoolId" as empty.
+				if props.BackendAddressPools != nil {
+					for _, p := range *props.BackendAddressPools {
+						if p.Id != nil {
+							backendAddressPoolIds = append(backendAddressPoolIds, *p.Id)
+						}
 					}
 				}
+			} else {
+				if props.BackendAddressPool != nil && props.BackendAddressPool.Id != nil {
+					backendAddressPoolId = *props.BackendAddressPool.Id
+					backendAddressPoolIds = []interface{}{backendAddressPoolId}
+				}
 			}
-		} else {
-			if props.BackendAddressPool != nil && props.BackendAddressPool.ID != nil {
-				backendAddressPoolId = *props.BackendAddressPool.ID
-				backendAddressPoolIds = []interface{}{backendAddressPoolId}
-			}
-		}
-		d.Set("backend_address_pool_ids", backendAddressPoolIds)
+			d.Set("backend_address_pool_ids", backendAddressPoolIds)
+
+			frontendIPConfigName := ""
+			frontendIPConfigID := ""
+			if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.Id != nil {
+				feid, err := loadbalancers.ParseFrontendIPConfigurationIDInsensitively(*props.FrontendIPConfiguration.Id)
+				if err != nil {
+					return err
+				}
 
-		frontendIPConfigName := ""
-		frontendIPConfigID := ""
-		if props.FrontendIPConfiguration != nil && props.FrontendIPConfiguration.ID != nil {
-			feid, err := parse.LoadBalancerFrontendIpConfigurationIDInsensitively(*props.FrontendIPConfiguration.ID)
-			if err != nil {
-				return err
+				frontendIPConfigName = feid.FrontendIPConfigurationName
+				frontendIPConfigID = feid.ID()
 			}
-
-			frontendIPConfigName = feid.FrontendIPConfigurationName
-			frontendIPConfigID = feid.ID()
-		}
-		d.Set("frontend_ip_configuration_name", frontendIPConfigName)
-		d.Set("frontend_ip_configuration_id", frontendIPConfigID)
-
-		frontendPort := 0
-		if props.FrontendPort != nil {
-			frontendPort = int(*props.FrontendPort)
-		}
-		d.Set("frontend_port", frontendPort)
-
-		idleTimeoutInMinutes := 0
-		if props.IdleTimeoutInMinutes != nil {
-			idleTimeoutInMinutes = int(*props.IdleTimeoutInMinutes)
-		}
-		d.Set("idle_timeout_in_minutes", idleTimeoutInMinutes)
-
-		loadDistribution := ""
-		if props.LoadDistribution != "" {
-			loadDistribution = string(props.LoadDistribution)
-		}
-		d.Set("load_distribution", loadDistribution)
-
-		probeId := ""
-		if props.Probe != nil && props.Probe.ID != nil {
-			probeId = *props.Probe.ID
+			d.Set("frontend_ip_configuration_name", frontendIPConfigName)
+			d.Set("frontend_ip_configuration_id", frontendIPConfigID)
+			d.Set("frontend_port", int(props.FrontendPort))
+			d.Set("idle_timeout_in_minutes", int(pointer.From(props.IdleTimeoutInMinutes)))
+			d.Set("load_distribution", string(pointer.From(props.LoadDistribution)))
+
+			probeId := ""
+			if props.Probe != nil {
+				probeId = pointer.From(props.Probe.Id)
+			}
+			d.Set("probe_id", probeId)
 		}
-		d.Set("probe_id", probeId)
 	}
-
 	return nil
 }
 
@@ -233,64 +215,65 @@ func resourceArmLoadBalancerRuleDelete(d *pluginsdk.ResourceData, meta interface
 	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
-	id, err := parse.LoadBalancingRuleID(d.Id())
+	id, err := loadbalancers.ParseLoadBalancingRuleID(d.Id())
 	if err != nil {
 		return err
 	}
 
-	loadBalancerId := parse.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroup, id.LoadBalancerName)
+	loadBalancerId := loadbalancers.NewLoadBalancerID(id.SubscriptionId, id.ResourceGroupName, id.LoadBalancerName)
 	loadBalancerIDRaw := loadBalancerId.ID()
 	locks.ByID(loadBalancerIDRaw)
 	defer locks.UnlockByID(loadBalancerIDRaw)
 
-	loadBalancer, err := client.Get(ctx, loadBalancerId.ResourceGroup, loadBalancerId.Name, "")
+	plbId := loadbalancers.ProviderLoadBalancerId{SubscriptionId: id.SubscriptionId, ResourceGroupName: id.ResourceGroupName, LoadBalancerName: id.LoadBalancerName}
+	loadBalancer, err := client.Get(ctx, plbId, loadbalancers.GetOperationOptions{})
 	if err != nil {
-		if utils.ResponseWasNotFound(loadBalancer.Response) {
+		if response.WasNotFound(loadBalancer.HttpResponse) {
 			d.SetId("")
 			return nil
 		}
-		return fmt.Errorf("failed to retrieve Load Balancer %q (resource group %q) for Rule %q: %+v", id.LoadBalancerName, id.ResourceGroup, id.Name, err)
+		return fmt.Errorf("retrieving %s: %+v", loadBalancerId, err)
 	}
 
-	if loadBalancer.LoadBalancerPropertiesFormat != nil && loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules != nil {
-		_, index, exists := FindLoadBalancerRuleByName(&loadBalancer, d.Get("name").(string))
-		if !exists {
-			return nil
-		}
-
-		lbRules := *loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules
-		lbRules = append(lbRules[:index], lbRules[index+1:]...)
-		loadBalancer.LoadBalancerPropertiesFormat.LoadBalancingRules = &lbRules
+	if model := loadBalancer.Model; model != nil {
+		if props := model.Properties; props != nil {
+			if props.LoadBalancingRules != nil {
+				_, index, exists := FindLoadBalancerRuleByName(model, d.Get("name").(string))
+				if !exists {
+					return nil
+				}
 
-		future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.LoadBalancerName, loadBalancer)
-		if err != nil {
-			return fmt.Errorf("Creating/Updating Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
-		}
+				lbRules := *props.LoadBalancingRules
+				lbRules = append(lbRules[:index], lbRules[index+1:]...)
+				props.LoadBalancingRules = &lbRules
 
-		if err = future.WaitForCompletionRef(ctx, client.Client); err != nil {
-			return fmt.Errorf("waiting for completion of Load Balancer %q (Resource Group %q): %+v", id.LoadBalancerName, id.ResourceGroup, err)
+				err := client.CreateOrUpdateThenPoll(ctx, plbId, *model)
+				if err != nil {
+					return fmt.Errorf("Creating/Updating %s: %+v", id, err)
+				}
+			}
 		}
 	}
 
 	return nil
 }
 
-func expandAzureRmLoadBalancerRule(d *pluginsdk.ResourceData, lb *network.LoadBalancer) (*network.LoadBalancingRule, error) {
-	properties := network.LoadBalancingRulePropertiesFormat{
-		Protocol:            network.TransportProtocol(d.Get("protocol").(string)),
-		FrontendPort:        utils.Int32(int32(d.Get("frontend_port").(int))),
-		BackendPort:         utils.Int32(int32(d.Get("backend_port").(int))),
-		EnableFloatingIP:    utils.Bool(d.Get("enable_floating_ip").(bool)),
-		EnableTCPReset:      utils.Bool(d.Get("enable_tcp_reset").(bool)),
-		DisableOutboundSnat: utils.Bool(d.Get("disable_outbound_snat").(bool)),
+func expandAzureRmLoadBalancerRule(d *pluginsdk.ResourceData, lb *loadbalancers.LoadBalancer) (*loadbalancers.LoadBalancingRule, error) {
+	properties := loadbalancers.LoadBalancingRulePropertiesFormat{
+		Protocol:            loadbalancers.TransportProtocol(d.Get("protocol").(string)),
+		FrontendPort:        int64(d.Get("frontend_port").(int)),
+		BackendPort:         pointer.To(int64(d.Get("backend_port").(int))),
+		EnableFloatingIP:    pointer.To(d.Get("enable_floating_ip").(bool)),
+		EnableTcpReset:      pointer.To(d.Get("enable_tcp_reset").(bool)),
+		DisableOutboundSnat: pointer.To(d.Get("disable_outbound_snat").(bool)),
 	}
 
 	if v, ok := d.GetOk("idle_timeout_in_minutes"); ok {
-		properties.IdleTimeoutInMinutes = utils.Int32(int32(v.(int)))
+		properties.IdleTimeoutInMinutes = pointer.To(int64(v.(int)))
 	}
 
 	if v := d.Get("load_distribution").(string); v != "" {
-		properties.LoadDistribution = network.LoadDistribution(v)
+		properties.LoadDistribution = pointer.To(loadbalancers.LoadDistribution(v))
 	}
 
 	// TODO: ensure these ID's are consistent
@@ -300,23 +283,23 @@ func expandAzureRmLoadBalancerRule(d *pluginsdk.ResourceData, lb *network.LoadBa
 			return nil, fmt.Errorf("[ERROR] Cannot find FrontEnd IP Configuration with the name %s", v)
 		}
 
-		properties.FrontendIPConfiguration = &network.SubResource{
-			ID: rule.ID,
+		properties.FrontendIPConfiguration = &loadbalancers.SubResource{
+			Id: rule.Id,
 		}
 	}
 
 	var isGateway bool
-	if lb != nil && lb.Sku != nil && lb.Sku.Name == network.LoadBalancerSkuNameGateway {
+	if lb != nil && lb.Sku != nil && pointer.From(lb.Sku.Name) == loadbalancers.LoadBalancerSkuNameGateway {
 		isGateway = true
 	}
 
 	if l := d.Get("backend_address_pool_ids").([]interface{}); len(l) != 0 {
 		if isGateway {
-			var baps []network.SubResource
+			var baps []loadbalancers.SubResource
 			for _, p := range l {
 				p := p.(string)
-				baps = append(baps, network.SubResource{
-					ID: &p,
+				baps = append(baps, loadbalancers.SubResource{
+					Id: &p,
 				})
 			}
 			properties.BackendAddressPools = &baps
@@ -324,21 +307,21 @@ func expandAzureRmLoadBalancerRule(d *pluginsdk.ResourceData, lb *network.LoadBa
 			if len(l) > 1 {
 				return nil, fmt.Errorf(`only Gateway SKU Load Balancer can have more than one "backend_address_pool_ids"`)
 			}
-			properties.BackendAddressPool = &network.SubResource{
-				ID: utils.String(l[0].(string)),
+			properties.BackendAddressPool = &loadbalancers.SubResource{
+				Id: pointer.To(l[0].(string)),
 			}
 		}
 	}
 
 	if v := d.Get("probe_id").(string); v != "" {
-		properties.Probe = &network.SubResource{
-			ID: &v,
+		properties.Probe = &loadbalancers.SubResource{
+			Id: &v,
 		}
 	}
 
-	return &network.LoadBalancingRule{
-		Name:                              utils.String(d.Get("name").(string)),
-		LoadBalancingRulePropertiesFormat: &properties,
+	return &loadbalancers.LoadBalancingRule{
+		Name:       pointer.To(d.Get("name").(string)),
+		Properties: &properties,
 	}, nil
 }
 
@@ -355,7 +338,7 @@ func resourceArmLoadBalancerRuleSchema() map[string]*pluginsdk.Schema {
 			Type:         pluginsdk.TypeString,
 			Required:     true,
 			ForceNew:     true,
-			ValidateFunc: loadBalancerValidate.LoadBalancerID,
+			ValidateFunc: loadbalancers.ValidateLoadBalancerID,
 		},
 
 		"frontend_ip_configuration_name": {
@@ -376,7 +359,7 @@ func resourceArmLoadBalancerRuleSchema() map[string]*pluginsdk.Schema {
 			MaxItems: 2, // Only Gateway SKU LB can have 2 backend address pools
 			Elem: &pluginsdk.Schema{
 				Type:         pluginsdk.TypeString,
-				ValidateFunc: loadBalancerValidate.LoadBalancerBackendAddressPoolID,
+				ValidateFunc: loadbalancers.ValidateLoadBalancerBackendAddressPoolID,
 			},
 		},
 
@@ -385,9 +368,9 @@ func resourceArmLoadBalancerRuleSchema() map[string]*pluginsdk.Schema {
 			Required:         true,
 			DiffSuppressFunc: suppress.CaseDifference,
 			ValidateFunc: validation.StringInSlice([]string{
-				string(network.TransportProtocolAll),
-				string(network.TransportProtocolTCP),
-				string(network.TransportProtocolUDP),
+				string(loadbalancers.TransportProtocolAll),
+				string(loadbalancers.TransportProtocolTcp),
+				string(loadbalancers.TransportProtocolUdp),
 			}, false),
 		},
 
diff --git a/internal/services/loadbalancer/validate/load_balancer_id_test.go b/internal/services/loadbalancer/validate/load_balancer_id_test.go
deleted file mode 100644
index 402862a0219f..000000000000
--- a/internal/services/loadbalancer/validate/load_balancer_id_test.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import "testing"
-
-func TestLoadBalancerID(t *testing.T) {
-	cases := []struct {
-		Input string
-		Valid bool
-	}{
-
-		{
-			// empty
-			Input: "",
-			Valid: false,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Valid: false,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Valid: false,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Valid: false,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Valid: false,
-		},
-
-		{
-			// missing Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Valid: false,
-		},
-
-		{
-			// missing value for Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Valid: false,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1",
-			Valid: true,
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1",
-			Valid: false,
-		},
-	}
-	for _, tc := range cases {
-		t.Logf("[DEBUG] Testing Value %s", tc.Input)
-		_, errors := LoadBalancerID(tc.Input, "test")
-		valid := len(errors) == 0
-
-		if tc.Valid != valid {
-			t.Fatalf("Expected %t but got %t", tc.Valid, valid)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/validate/load_balancer_outbound_rule_id.go b/internal/services/loadbalancer/validate/load_balancer_outbound_rule_id.go
deleted file mode 100644
index 4cb659dae49f..000000000000
--- a/internal/services/loadbalancer/validate/load_balancer_outbound_rule_id.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"fmt"
-
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-)
-
-func LoadBalancerOutboundRuleID(input interface{}, key string) (warnings []string, errors []error) {
-	v, ok := input.(string)
-	if !ok {
-		errors = append(errors, fmt.Errorf("expected %q to be a string", key))
-		return
-	}
-
-	if _, err := parse.LoadBalancerOutboundRuleID(v); err != nil {
-		errors = append(errors, err)
-	}
-
-	return
-}
diff --git a/internal/services/loadbalancer/validate/load_balancer_outbound_rule_id_test.go b/internal/services/loadbalancer/validate/load_balancer_outbound_rule_id_test.go
deleted file mode 100644
index 648001936d6f..000000000000
--- a/internal/services/loadbalancer/validate/load_balancer_outbound_rule_id_test.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import "testing"
-
-func TestLoadBalancerOutboundRuleID(t *testing.T) {
-	cases := []struct {
-		Input string
-		Valid bool
-	}{
-
-		{
-			// empty
-			Input: "",
-			Valid: false,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Valid: false,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Valid: false,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Valid: false,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Valid: false,
-		},
-
-		{
-			// missing LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Valid: false,
-		},
-
-		{
-			// missing value for LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Valid: false,
-		},
-
-		{
-			// missing OutboundRuleName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
-			Valid: false,
-		},
-
-		{
-			// missing value for OutboundRuleName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/outboundRules/",
-			Valid: false,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/outboundRules/rule1",
-			Valid: true,
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1/OUTBOUNDRULES/RULE1",
-			Valid: false,
-		},
-	}
-	for _, tc := range cases {
-		t.Logf("[DEBUG] Testing Value %s", tc.Input)
-		_, errors := LoadBalancerOutboundRuleID(tc.Input, "test")
-		valid := len(errors) == 0
-
-		if tc.Valid != valid {
-			t.Fatalf("Expected %t but got %t", tc.Valid, valid)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/validate/load_balancer_probe_id.go b/internal/services/loadbalancer/validate/load_balancer_probe_id.go
deleted file mode 100644
index 845a83aa2723..000000000000
--- a/internal/services/loadbalancer/validate/load_balancer_probe_id.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"fmt"
-
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-)
-
-func LoadBalancerProbeID(input interface{}, key string) (warnings []string, errors []error) {
-	v, ok := input.(string)
-	if !ok {
-		errors = append(errors, fmt.Errorf("expected %q to be a string", key))
-		return
-	}
-
-	if _, err := parse.LoadBalancerProbeID(v); err != nil {
-		errors = append(errors, err)
-	}
-
-	return
-}
diff --git a/internal/services/loadbalancer/validate/load_balancer_probe_id_test.go b/internal/services/loadbalancer/validate/load_balancer_probe_id_test.go
deleted file mode 100644
index bde8c63da89e..000000000000
--- a/internal/services/loadbalancer/validate/load_balancer_probe_id_test.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import "testing"
-
-func TestLoadBalancerProbeID(t *testing.T) {
-	cases := []struct {
-		Input string
-		Valid bool
-	}{
-
-		{
-			// empty
-			Input: "",
-			Valid: false,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Valid: false,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Valid: false,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Valid: false,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Valid: false,
-		},
-
-		{
-			// missing LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Valid: false,
-		},
-
-		{
-			// missing value for LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Valid: false,
-		},
-
-		{
-			// missing ProbeName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
-			Valid: false,
-		},
-
-		{
-			// missing value for ProbeName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/probes/",
-			Valid: false,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/probes/probe1",
-			Valid: true,
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1/PROBES/PROBE1",
-			Valid: false,
-		},
-	}
-	for _, tc := range cases {
-		t.Logf("[DEBUG] Testing Value %s", tc.Input)
-		_, errors := LoadBalancerProbeID(tc.Input, "test")
-		valid := len(errors) == 0
-
-		if tc.Valid != valid {
-			t.Fatalf("Expected %t but got %t", tc.Valid, valid)
-		}
-	}
-}
diff --git a/internal/services/loadbalancer/validate/load_balancing_rule_id.go b/internal/services/loadbalancer/validate/load_balancing_rule_id.go
deleted file mode 100644
index 486e69c01462..000000000000
--- a/internal/services/loadbalancer/validate/load_balancing_rule_id.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import (
-	"fmt"
-
-	"github.com/hashicorp/terraform-provider-azurerm/internal/services/loadbalancer/parse"
-)
-
-func LoadBalancingRuleID(input interface{}, key string) (warnings []string, errors []error) {
-	v, ok := input.(string)
-	if !ok {
-		errors = append(errors, fmt.Errorf("expected %q to be a string", key))
-		return
-	}
-
-	if _, err := parse.LoadBalancingRuleID(v); err != nil {
-		errors = append(errors, err)
-	}
-
-	return
-}
diff --git a/internal/services/loadbalancer/validate/load_balancing_rule_id_test.go b/internal/services/loadbalancer/validate/load_balancing_rule_id_test.go
deleted file mode 100644
index 43828b4a741e..000000000000
--- a/internal/services/loadbalancer/validate/load_balancing_rule_id_test.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) HashiCorp, Inc.
-// SPDX-License-Identifier: MPL-2.0
-
-package validate
-
-// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
-
-import "testing"
-
-func TestLoadBalancingRuleID(t *testing.T) {
-	cases := []struct {
-		Input string
-		Valid bool
-	}{
-
-		{
-			// empty
-			Input: "",
-			Valid: false,
-		},
-
-		{
-			// missing SubscriptionId
-			Input: "/",
-			Valid: false,
-		},
-
-		{
-			// missing value for SubscriptionId
-			Input: "/subscriptions/",
-			Valid: false,
-		},
-
-		{
-			// missing ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/",
-			Valid: false,
-		},
-
-		{
-			// missing value for ResourceGroup
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/",
-			Valid: false,
-		},
-
-		{
-			// missing LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/",
-			Valid: false,
-		},
-
-		{
-			// missing value for LoadBalancerName
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/",
-			Valid: false,
-		},
-
-		{
-			// missing Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/",
-			Valid: false,
-		},
-
-		{
-			// missing value for Name
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/loadBalancingRules/",
-			Valid: false,
-		},
-
-		{
-			// valid
-			Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/resGroup1/providers/Microsoft.Network/loadBalancers/loadBalancer1/loadBalancingRules/rule1",
-			Valid: true,
-		},
-
-		{
-			// upper-cased
-			Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/RESGROUP1/PROVIDERS/MICROSOFT.NETWORK/LOADBALANCERS/LOADBALANCER1/LOADBALANCINGRULES/RULE1",
-			Valid: false,
-		},
-	}
-	for _, tc := range cases {
-		t.Logf("[DEBUG] Testing Value %s", tc.Input)
-		_, errors := LoadBalancingRuleID(tc.Input, "test")
-		valid := len(errors) == 0
-
-		if tc.Valid != valid {
-			t.Fatalf("Expected %t but got %t", tc.Valid, valid)
-		}
-	}
-}