web/armweb/zz_generated_appserviceenvironments_client.go

// +build go1.13

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package armweb

import (
	"context"
	"errors"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)

// AppServiceEnvironmentsClient contains the methods for the AppServiceEnvironments group.
// Don't use this type directly, use NewAppServiceEnvironmentsClient() instead.
type AppServiceEnvironmentsClient struct {
	con            *armcore.Connection
	subscriptionID string
}

// NewAppServiceEnvironmentsClient creates a new instance of AppServiceEnvironmentsClient with the specified values.
func NewAppServiceEnvironmentsClient(con *armcore.Connection, subscriptionID string) *AppServiceEnvironmentsClient {
	return &AppServiceEnvironmentsClient{con: con, subscriptionID: subscriptionID}
}

// BeginApproveOrRejectPrivateEndpointConnection - Description for Approves or rejects a private endpoint connection
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginApproveOrRejectPrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, privateEndpointWrapper PrivateLinkConnectionApprovalRequestResource, options *AppServiceEnvironmentsBeginApproveOrRejectPrivateEndpointConnectionOptions) (AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse, error) {
	resp, err := client.approveOrRejectPrivateEndpointConnection(ctx, resourceGroupName, name, privateEndpointConnectionName, privateEndpointWrapper, options)
	if err != nil {
		return AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse{}, err
	}
	result := AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.ApproveOrRejectPrivateEndpointConnection", "", resp, client.con.Pipeline(), client.approveOrRejectPrivateEndpointConnectionHandleError)
	if err != nil {
		return AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeApproveOrRejectPrivateEndpointConnection creates a new AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeApproveOrRejectPrivateEndpointConnection(ctx context.Context, token string) (AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.ApproveOrRejectPrivateEndpointConnection", token, client.con.Pipeline(), client.approveOrRejectPrivateEndpointConnectionHandleError)
	if err != nil {
		return AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse{}, err
	}
	result := AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionPollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsApproveOrRejectPrivateEndpointConnectionResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ApproveOrRejectPrivateEndpointConnection - Description for Approves or rejects a private endpoint connection
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) approveOrRejectPrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, privateEndpointWrapper PrivateLinkConnectionApprovalRequestResource, options *AppServiceEnvironmentsBeginApproveOrRejectPrivateEndpointConnectionOptions) (*azcore.Response, error) {
	req, err := client.approveOrRejectPrivateEndpointConnectionCreateRequest(ctx, resourceGroupName, name, privateEndpointConnectionName, privateEndpointWrapper, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return nil, client.approveOrRejectPrivateEndpointConnectionHandleError(resp)
	}
	return resp, nil
}

// approveOrRejectPrivateEndpointConnectionCreateRequest creates the ApproveOrRejectPrivateEndpointConnection request.
func (client *AppServiceEnvironmentsClient) approveOrRejectPrivateEndpointConnectionCreateRequest(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, privateEndpointWrapper PrivateLinkConnectionApprovalRequestResource, options *AppServiceEnvironmentsBeginApproveOrRejectPrivateEndpointConnectionOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/privateEndpointConnections/{privateEndpointConnectionName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if privateEndpointConnectionName == "" {
		return nil, errors.New("parameter privateEndpointConnectionName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{privateEndpointConnectionName}", url.PathEscape(privateEndpointConnectionName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(privateEndpointWrapper)
}

// approveOrRejectPrivateEndpointConnectionHandleError handles the ApproveOrRejectPrivateEndpointConnection error response.
func (client *AppServiceEnvironmentsClient) approveOrRejectPrivateEndpointConnectionHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginChangeVnet - Description for Move an App Service Environment to a different VNET.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginChangeVnet(ctx context.Context, resourceGroupName string, name string, vnetInfo VirtualNetworkProfile, options *AppServiceEnvironmentsBeginChangeVnetOptions) (AppServiceEnvironmentsChangeVnetPollerResponse, error) {
	resp, err := client.changeVnet(ctx, resourceGroupName, name, vnetInfo, options)
	if err != nil {
		return AppServiceEnvironmentsChangeVnetPollerResponse{}, err
	}
	result := AppServiceEnvironmentsChangeVnetPollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.ChangeVnet", "", resp, client.con.Pipeline(), client.changeVnetHandleError)
	if err != nil {
		return AppServiceEnvironmentsChangeVnetPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsChangeVnetPoller{
		pt:     pt,
		client: client,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsChangeVnetPager, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeChangeVnet creates a new AppServiceEnvironmentsChangeVnetPoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsChangeVnetPoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeChangeVnet(ctx context.Context, token string) (AppServiceEnvironmentsChangeVnetPollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.ChangeVnet", token, client.con.Pipeline(), client.changeVnetHandleError)
	if err != nil {
		return AppServiceEnvironmentsChangeVnetPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsChangeVnetPoller{
		pt:     pt,
		client: client,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsChangeVnetPollerResponse{}, err
	}
	result := AppServiceEnvironmentsChangeVnetPollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsChangeVnetPager, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ChangeVnet - Description for Move an App Service Environment to a different VNET.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) changeVnet(ctx context.Context, resourceGroupName string, name string, vnetInfo VirtualNetworkProfile, options *AppServiceEnvironmentsBeginChangeVnetOptions) (*azcore.Response, error) {
	req, err := client.changeVnetCreateRequest(ctx, resourceGroupName, name, vnetInfo, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return nil, client.changeVnetHandleError(resp)
	}
	return resp, nil
}

// changeVnetCreateRequest creates the ChangeVnet request.
func (client *AppServiceEnvironmentsClient) changeVnetCreateRequest(ctx context.Context, resourceGroupName string, name string, vnetInfo VirtualNetworkProfile, options *AppServiceEnvironmentsBeginChangeVnetOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/changeVirtualNetwork"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(vnetInfo)
}

// changeVnetHandleResponse handles the ChangeVnet response.
func (client *AppServiceEnvironmentsClient) changeVnetHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsChangeVnetResponse, error) {
	result := AppServiceEnvironmentsChangeVnetResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WebAppCollection); err != nil {
		return AppServiceEnvironmentsChangeVnetResponse{}, err
	}
	return result, nil
}

// changeVnetHandleError handles the ChangeVnet error response.
func (client *AppServiceEnvironmentsClient) changeVnetHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginCreateOrUpdate - Description for Create or update an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentResource, options *AppServiceEnvironmentsBeginCreateOrUpdateOptions) (AppServiceEnvironmentsCreateOrUpdatePollerResponse, error) {
	resp, err := client.createOrUpdate(ctx, resourceGroupName, name, hostingEnvironmentEnvelope, options)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdatePollerResponse{}, err
	}
	result := AppServiceEnvironmentsCreateOrUpdatePollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.CreateOrUpdate", "", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdatePollerResponse{}, err
	}
	poller := &appServiceEnvironmentsCreateOrUpdatePoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsCreateOrUpdateResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeCreateOrUpdate creates a new AppServiceEnvironmentsCreateOrUpdatePoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsCreateOrUpdatePoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeCreateOrUpdate(ctx context.Context, token string) (AppServiceEnvironmentsCreateOrUpdatePollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdatePollerResponse{}, err
	}
	poller := &appServiceEnvironmentsCreateOrUpdatePoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdatePollerResponse{}, err
	}
	result := AppServiceEnvironmentsCreateOrUpdatePollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsCreateOrUpdateResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// CreateOrUpdate - Description for Create or update an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) createOrUpdate(ctx context.Context, resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentResource, options *AppServiceEnvironmentsBeginCreateOrUpdateOptions) (*azcore.Response, error) {
	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, name, hostingEnvironmentEnvelope, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted) {
		return nil, client.createOrUpdateHandleError(resp)
	}
	return resp, nil
}

// createOrUpdateCreateRequest creates the CreateOrUpdate request.
func (client *AppServiceEnvironmentsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentResource, options *AppServiceEnvironmentsBeginCreateOrUpdateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(hostingEnvironmentEnvelope)
}

// createOrUpdateHandleError handles the CreateOrUpdate error response.
func (client *AppServiceEnvironmentsClient) createOrUpdateHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginCreateOrUpdateMultiRolePool - Description for Create or update a multi-role pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginCreateOrUpdateMultiRolePool(ctx context.Context, resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsBeginCreateOrUpdateMultiRolePoolOptions) (AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse, error) {
	resp, err := client.createOrUpdateMultiRolePool(ctx, resourceGroupName, name, multiRolePoolEnvelope, options)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse{}, err
	}
	result := AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.CreateOrUpdateMultiRolePool", "", resp, client.con.Pipeline(), client.createOrUpdateMultiRolePoolHandleError)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsCreateOrUpdateMultiRolePoolPoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsCreateOrUpdateMultiRolePoolResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeCreateOrUpdateMultiRolePool creates a new AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeCreateOrUpdateMultiRolePool(ctx context.Context, token string) (AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.CreateOrUpdateMultiRolePool", token, client.con.Pipeline(), client.createOrUpdateMultiRolePoolHandleError)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsCreateOrUpdateMultiRolePoolPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse{}, err
	}
	result := AppServiceEnvironmentsCreateOrUpdateMultiRolePoolPollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsCreateOrUpdateMultiRolePoolResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// CreateOrUpdateMultiRolePool - Description for Create or update a multi-role pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) createOrUpdateMultiRolePool(ctx context.Context, resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsBeginCreateOrUpdateMultiRolePoolOptions) (*azcore.Response, error) {
	req, err := client.createOrUpdateMultiRolePoolCreateRequest(ctx, resourceGroupName, name, multiRolePoolEnvelope, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return nil, client.createOrUpdateMultiRolePoolHandleError(resp)
	}
	return resp, nil
}

// createOrUpdateMultiRolePoolCreateRequest creates the CreateOrUpdateMultiRolePool request.
func (client *AppServiceEnvironmentsClient) createOrUpdateMultiRolePoolCreateRequest(ctx context.Context, resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsBeginCreateOrUpdateMultiRolePoolOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(multiRolePoolEnvelope)
}

// createOrUpdateMultiRolePoolHandleError handles the CreateOrUpdateMultiRolePool error response.
func (client *AppServiceEnvironmentsClient) createOrUpdateMultiRolePoolHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginCreateOrUpdateWorkerPool - Description for Create or update a worker pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginCreateOrUpdateWorkerPool(ctx context.Context, resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsBeginCreateOrUpdateWorkerPoolOptions) (AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse, error) {
	resp, err := client.createOrUpdateWorkerPool(ctx, resourceGroupName, name, workerPoolName, workerPoolEnvelope, options)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse{}, err
	}
	result := AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.CreateOrUpdateWorkerPool", "", resp, client.con.Pipeline(), client.createOrUpdateWorkerPoolHandleError)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsCreateOrUpdateWorkerPoolPoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsCreateOrUpdateWorkerPoolResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeCreateOrUpdateWorkerPool creates a new AppServiceEnvironmentsCreateOrUpdateWorkerPoolPoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsCreateOrUpdateWorkerPoolPoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeCreateOrUpdateWorkerPool(ctx context.Context, token string) (AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.CreateOrUpdateWorkerPool", token, client.con.Pipeline(), client.createOrUpdateWorkerPoolHandleError)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsCreateOrUpdateWorkerPoolPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse{}, err
	}
	result := AppServiceEnvironmentsCreateOrUpdateWorkerPoolPollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsCreateOrUpdateWorkerPoolResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// CreateOrUpdateWorkerPool - Description for Create or update a worker pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) createOrUpdateWorkerPool(ctx context.Context, resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsBeginCreateOrUpdateWorkerPoolOptions) (*azcore.Response, error) {
	req, err := client.createOrUpdateWorkerPoolCreateRequest(ctx, resourceGroupName, name, workerPoolName, workerPoolEnvelope, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return nil, client.createOrUpdateWorkerPoolHandleError(resp)
	}
	return resp, nil
}

// createOrUpdateWorkerPoolCreateRequest creates the CreateOrUpdateWorkerPool request.
func (client *AppServiceEnvironmentsClient) createOrUpdateWorkerPoolCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsBeginCreateOrUpdateWorkerPoolOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(workerPoolEnvelope)
}

// createOrUpdateWorkerPoolHandleError handles the CreateOrUpdateWorkerPool error response.
func (client *AppServiceEnvironmentsClient) createOrUpdateWorkerPoolHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginDelete - Description for Delete an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginDelete(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginDeleteOptions) (AppServiceEnvironmentsDeletePollerResponse, error) {
	resp, err := client.deleteOperation(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsDeletePollerResponse{}, err
	}
	result := AppServiceEnvironmentsDeletePollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.Delete", "", resp, client.con.Pipeline(), client.deleteHandleError)
	if err != nil {
		return AppServiceEnvironmentsDeletePollerResponse{}, err
	}
	poller := &appServiceEnvironmentsDeletePoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsDeleteResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeDelete creates a new AppServiceEnvironmentsDeletePoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsDeletePoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeDelete(ctx context.Context, token string) (AppServiceEnvironmentsDeletePollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
	if err != nil {
		return AppServiceEnvironmentsDeletePollerResponse{}, err
	}
	poller := &appServiceEnvironmentsDeletePoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsDeletePollerResponse{}, err
	}
	result := AppServiceEnvironmentsDeletePollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsDeleteResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// Delete - Description for Delete an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) deleteOperation(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginDeleteOptions) (*azcore.Response, error) {
	req, err := client.deleteCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusAccepted, http.StatusNoContent) {
		return nil, client.deleteHandleError(resp)
	}
	return resp, nil
}

// deleteCreateRequest creates the Delete request.
func (client *AppServiceEnvironmentsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginDeleteOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	if options != nil && options.ForceDelete != nil {
		reqQP.Set("forceDelete", strconv.FormatBool(*options.ForceDelete))
	}
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// deleteHandleError handles the Delete error response.
func (client *AppServiceEnvironmentsClient) deleteHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginDeletePrivateEndpointConnection - Description for Deletes a private endpoint connection
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginDeletePrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, options *AppServiceEnvironmentsBeginDeletePrivateEndpointConnectionOptions) (AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse, error) {
	resp, err := client.deletePrivateEndpointConnection(ctx, resourceGroupName, name, privateEndpointConnectionName, options)
	if err != nil {
		return AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse{}, err
	}
	result := AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.DeletePrivateEndpointConnection", "", resp, client.con.Pipeline(), client.deletePrivateEndpointConnectionHandleError)
	if err != nil {
		return AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsDeletePrivateEndpointConnectionPoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsDeletePrivateEndpointConnectionResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeDeletePrivateEndpointConnection creates a new AppServiceEnvironmentsDeletePrivateEndpointConnectionPoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsDeletePrivateEndpointConnectionPoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeDeletePrivateEndpointConnection(ctx context.Context, token string) (AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.DeletePrivateEndpointConnection", token, client.con.Pipeline(), client.deletePrivateEndpointConnectionHandleError)
	if err != nil {
		return AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsDeletePrivateEndpointConnectionPoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse{}, err
	}
	result := AppServiceEnvironmentsDeletePrivateEndpointConnectionPollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsDeletePrivateEndpointConnectionResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// DeletePrivateEndpointConnection - Description for Deletes a private endpoint connection
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) deletePrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, options *AppServiceEnvironmentsBeginDeletePrivateEndpointConnectionOptions) (*azcore.Response, error) {
	req, err := client.deletePrivateEndpointConnectionCreateRequest(ctx, resourceGroupName, name, privateEndpointConnectionName, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
		return nil, client.deletePrivateEndpointConnectionHandleError(resp)
	}
	return resp, nil
}

// deletePrivateEndpointConnectionCreateRequest creates the DeletePrivateEndpointConnection request.
func (client *AppServiceEnvironmentsClient) deletePrivateEndpointConnectionCreateRequest(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, options *AppServiceEnvironmentsBeginDeletePrivateEndpointConnectionOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/privateEndpointConnections/{privateEndpointConnectionName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if privateEndpointConnectionName == "" {
		return nil, errors.New("parameter privateEndpointConnectionName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{privateEndpointConnectionName}", url.PathEscape(privateEndpointConnectionName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// deletePrivateEndpointConnectionHandleError handles the DeletePrivateEndpointConnection error response.
func (client *AppServiceEnvironmentsClient) deletePrivateEndpointConnectionHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// Get - Description for Get the properties of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) Get(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetOptions) (AppServiceEnvironmentsGetResponse, error) {
	req, err := client.getCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsGetResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetResponse{}, client.getHandleError(resp)
	}
	return client.getHandleResponse(resp)
}

// getCreateRequest creates the Get request.
func (client *AppServiceEnvironmentsClient) getCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getHandleResponse handles the Get response.
func (client *AppServiceEnvironmentsClient) getHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetResponse, error) {
	result := AppServiceEnvironmentsGetResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceEnvironmentResource); err != nil {
		return AppServiceEnvironmentsGetResponse{}, err
	}
	return result, nil
}

// getHandleError handles the Get error response.
func (client *AppServiceEnvironmentsClient) getHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetAseV3NetworkingConfiguration - Description for Get networking configuration of an App Service Environment
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetAseV3NetworkingConfiguration(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetAseV3NetworkingConfigurationOptions) (AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse, error) {
	req, err := client.getAseV3NetworkingConfigurationCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse{}, client.getAseV3NetworkingConfigurationHandleError(resp)
	}
	return client.getAseV3NetworkingConfigurationHandleResponse(resp)
}

// getAseV3NetworkingConfigurationCreateRequest creates the GetAseV3NetworkingConfiguration request.
func (client *AppServiceEnvironmentsClient) getAseV3NetworkingConfigurationCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetAseV3NetworkingConfigurationOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/configurations/networking"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getAseV3NetworkingConfigurationHandleResponse handles the GetAseV3NetworkingConfiguration response.
func (client *AppServiceEnvironmentsClient) getAseV3NetworkingConfigurationHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse, error) {
	result := AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AseV3NetworkingConfiguration); err != nil {
		return AppServiceEnvironmentsGetAseV3NetworkingConfigurationResponse{}, err
	}
	return result, nil
}

// getAseV3NetworkingConfigurationHandleError handles the GetAseV3NetworkingConfiguration error response.
func (client *AppServiceEnvironmentsClient) getAseV3NetworkingConfigurationHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetDiagnosticsItem - Description for Get a diagnostics item for an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetDiagnosticsItem(ctx context.Context, resourceGroupName string, name string, diagnosticsName string, options *AppServiceEnvironmentsGetDiagnosticsItemOptions) (AppServiceEnvironmentsGetDiagnosticsItemResponse, error) {
	req, err := client.getDiagnosticsItemCreateRequest(ctx, resourceGroupName, name, diagnosticsName, options)
	if err != nil {
		return AppServiceEnvironmentsGetDiagnosticsItemResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetDiagnosticsItemResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetDiagnosticsItemResponse{}, client.getDiagnosticsItemHandleError(resp)
	}
	return client.getDiagnosticsItemHandleResponse(resp)
}

// getDiagnosticsItemCreateRequest creates the GetDiagnosticsItem request.
func (client *AppServiceEnvironmentsClient) getDiagnosticsItemCreateRequest(ctx context.Context, resourceGroupName string, name string, diagnosticsName string, options *AppServiceEnvironmentsGetDiagnosticsItemOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/diagnostics/{diagnosticsName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if diagnosticsName == "" {
		return nil, errors.New("parameter diagnosticsName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{diagnosticsName}", url.PathEscape(diagnosticsName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getDiagnosticsItemHandleResponse handles the GetDiagnosticsItem response.
func (client *AppServiceEnvironmentsClient) getDiagnosticsItemHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetDiagnosticsItemResponse, error) {
	result := AppServiceEnvironmentsGetDiagnosticsItemResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.HostingEnvironmentDiagnostics); err != nil {
		return AppServiceEnvironmentsGetDiagnosticsItemResponse{}, err
	}
	return result, nil
}

// getDiagnosticsItemHandleError handles the GetDiagnosticsItem error response.
func (client *AppServiceEnvironmentsClient) getDiagnosticsItemHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetInboundNetworkDependenciesEndpoints - Description for Get the network endpoints of all inbound dependencies of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetInboundNetworkDependenciesEndpoints(resourceGroupName string, name string, options *AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsOptions) AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsPager {
	return &appServiceEnvironmentsGetInboundNetworkDependenciesEndpointsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.getInboundNetworkDependenciesEndpointsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.InboundEnvironmentEndpointCollection.NextLink)
		},
	}
}

// getInboundNetworkDependenciesEndpointsCreateRequest creates the GetInboundNetworkDependenciesEndpoints request.
func (client *AppServiceEnvironmentsClient) getInboundNetworkDependenciesEndpointsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/inboundNetworkDependenciesEndpoints"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getInboundNetworkDependenciesEndpointsHandleResponse handles the GetInboundNetworkDependenciesEndpoints response.
func (client *AppServiceEnvironmentsClient) getInboundNetworkDependenciesEndpointsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsResponse, error) {
	result := AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.InboundEnvironmentEndpointCollection); err != nil {
		return AppServiceEnvironmentsGetInboundNetworkDependenciesEndpointsResponse{}, err
	}
	return result, nil
}

// getInboundNetworkDependenciesEndpointsHandleError handles the GetInboundNetworkDependenciesEndpoints error response.
func (client *AppServiceEnvironmentsClient) getInboundNetworkDependenciesEndpointsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetMultiRolePool - Description for Get properties of a multi-role pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetMultiRolePool(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetMultiRolePoolOptions) (AppServiceEnvironmentsGetMultiRolePoolResponse, error) {
	req, err := client.getMultiRolePoolCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsGetMultiRolePoolResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetMultiRolePoolResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetMultiRolePoolResponse{}, client.getMultiRolePoolHandleError(resp)
	}
	return client.getMultiRolePoolHandleResponse(resp)
}

// getMultiRolePoolCreateRequest creates the GetMultiRolePool request.
func (client *AppServiceEnvironmentsClient) getMultiRolePoolCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetMultiRolePoolOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getMultiRolePoolHandleResponse handles the GetMultiRolePool response.
func (client *AppServiceEnvironmentsClient) getMultiRolePoolHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetMultiRolePoolResponse, error) {
	result := AppServiceEnvironmentsGetMultiRolePoolResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WorkerPoolResource); err != nil {
		return AppServiceEnvironmentsGetMultiRolePoolResponse{}, err
	}
	return result, nil
}

// getMultiRolePoolHandleError handles the GetMultiRolePool error response.
func (client *AppServiceEnvironmentsClient) getMultiRolePoolHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetOutboundNetworkDependenciesEndpoints - Description for Get the network endpoints of all outbound dependencies of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetOutboundNetworkDependenciesEndpoints(resourceGroupName string, name string, options *AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsOptions) AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsPager {
	return &appServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.getOutboundNetworkDependenciesEndpointsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.OutboundEnvironmentEndpointCollection.NextLink)
		},
	}
}

// getOutboundNetworkDependenciesEndpointsCreateRequest creates the GetOutboundNetworkDependenciesEndpoints request.
func (client *AppServiceEnvironmentsClient) getOutboundNetworkDependenciesEndpointsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/outboundNetworkDependenciesEndpoints"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getOutboundNetworkDependenciesEndpointsHandleResponse handles the GetOutboundNetworkDependenciesEndpoints response.
func (client *AppServiceEnvironmentsClient) getOutboundNetworkDependenciesEndpointsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsResponse, error) {
	result := AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.OutboundEnvironmentEndpointCollection); err != nil {
		return AppServiceEnvironmentsGetOutboundNetworkDependenciesEndpointsResponse{}, err
	}
	return result, nil
}

// getOutboundNetworkDependenciesEndpointsHandleError handles the GetOutboundNetworkDependenciesEndpoints error response.
func (client *AppServiceEnvironmentsClient) getOutboundNetworkDependenciesEndpointsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetPrivateEndpointConnection - Description for Gets a private endpoint connection
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetPrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, options *AppServiceEnvironmentsGetPrivateEndpointConnectionOptions) (AppServiceEnvironmentsGetPrivateEndpointConnectionResponse, error) {
	req, err := client.getPrivateEndpointConnectionCreateRequest(ctx, resourceGroupName, name, privateEndpointConnectionName, options)
	if err != nil {
		return AppServiceEnvironmentsGetPrivateEndpointConnectionResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetPrivateEndpointConnectionResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetPrivateEndpointConnectionResponse{}, client.getPrivateEndpointConnectionHandleError(resp)
	}
	return client.getPrivateEndpointConnectionHandleResponse(resp)
}

// getPrivateEndpointConnectionCreateRequest creates the GetPrivateEndpointConnection request.
func (client *AppServiceEnvironmentsClient) getPrivateEndpointConnectionCreateRequest(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, options *AppServiceEnvironmentsGetPrivateEndpointConnectionOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/privateEndpointConnections/{privateEndpointConnectionName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if privateEndpointConnectionName == "" {
		return nil, errors.New("parameter privateEndpointConnectionName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{privateEndpointConnectionName}", url.PathEscape(privateEndpointConnectionName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getPrivateEndpointConnectionHandleResponse handles the GetPrivateEndpointConnection response.
func (client *AppServiceEnvironmentsClient) getPrivateEndpointConnectionHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetPrivateEndpointConnectionResponse, error) {
	result := AppServiceEnvironmentsGetPrivateEndpointConnectionResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.RemotePrivateEndpointConnectionARMResource); err != nil {
		return AppServiceEnvironmentsGetPrivateEndpointConnectionResponse{}, err
	}
	return result, nil
}

// getPrivateEndpointConnectionHandleError handles the GetPrivateEndpointConnection error response.
func (client *AppServiceEnvironmentsClient) getPrivateEndpointConnectionHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetPrivateEndpointConnectionList - Description for Gets the list of private endpoints associated with a hosting environment
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetPrivateEndpointConnectionList(resourceGroupName string, name string, options *AppServiceEnvironmentsGetPrivateEndpointConnectionListOptions) AppServiceEnvironmentsGetPrivateEndpointConnectionListPager {
	return &appServiceEnvironmentsGetPrivateEndpointConnectionListPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.getPrivateEndpointConnectionListCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsGetPrivateEndpointConnectionListResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.PrivateEndpointConnectionCollection.NextLink)
		},
	}
}

// getPrivateEndpointConnectionListCreateRequest creates the GetPrivateEndpointConnectionList request.
func (client *AppServiceEnvironmentsClient) getPrivateEndpointConnectionListCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetPrivateEndpointConnectionListOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/privateEndpointConnections"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getPrivateEndpointConnectionListHandleResponse handles the GetPrivateEndpointConnectionList response.
func (client *AppServiceEnvironmentsClient) getPrivateEndpointConnectionListHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetPrivateEndpointConnectionListResponse, error) {
	result := AppServiceEnvironmentsGetPrivateEndpointConnectionListResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.PrivateEndpointConnectionCollection); err != nil {
		return AppServiceEnvironmentsGetPrivateEndpointConnectionListResponse{}, err
	}
	return result, nil
}

// getPrivateEndpointConnectionListHandleError handles the GetPrivateEndpointConnectionList error response.
func (client *AppServiceEnvironmentsClient) getPrivateEndpointConnectionListHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetPrivateLinkResources - Description for Gets the private link resources
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetPrivateLinkResources(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetPrivateLinkResourcesOptions) (AppServiceEnvironmentsGetPrivateLinkResourcesResponse, error) {
	req, err := client.getPrivateLinkResourcesCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsGetPrivateLinkResourcesResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetPrivateLinkResourcesResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetPrivateLinkResourcesResponse{}, client.getPrivateLinkResourcesHandleError(resp)
	}
	return client.getPrivateLinkResourcesHandleResponse(resp)
}

// getPrivateLinkResourcesCreateRequest creates the GetPrivateLinkResources request.
func (client *AppServiceEnvironmentsClient) getPrivateLinkResourcesCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetPrivateLinkResourcesOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/privateLinkResources"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getPrivateLinkResourcesHandleResponse handles the GetPrivateLinkResources response.
func (client *AppServiceEnvironmentsClient) getPrivateLinkResourcesHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetPrivateLinkResourcesResponse, error) {
	result := AppServiceEnvironmentsGetPrivateLinkResourcesResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.PrivateLinkResourcesWrapper); err != nil {
		return AppServiceEnvironmentsGetPrivateLinkResourcesResponse{}, err
	}
	return result, nil
}

// getPrivateLinkResourcesHandleError handles the GetPrivateLinkResources error response.
func (client *AppServiceEnvironmentsClient) getPrivateLinkResourcesHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetVipInfo - Description for Get IP addresses assigned to an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetVipInfo(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetVipInfoOptions) (AppServiceEnvironmentsGetVipInfoResponse, error) {
	req, err := client.getVipInfoCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsGetVipInfoResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetVipInfoResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetVipInfoResponse{}, client.getVipInfoHandleError(resp)
	}
	return client.getVipInfoHandleResponse(resp)
}

// getVipInfoCreateRequest creates the GetVipInfo request.
func (client *AppServiceEnvironmentsClient) getVipInfoCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsGetVipInfoOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/capacities/virtualip"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getVipInfoHandleResponse handles the GetVipInfo response.
func (client *AppServiceEnvironmentsClient) getVipInfoHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetVipInfoResponse, error) {
	result := AppServiceEnvironmentsGetVipInfoResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AddressResponse); err != nil {
		return AppServiceEnvironmentsGetVipInfoResponse{}, err
	}
	return result, nil
}

// getVipInfoHandleError handles the GetVipInfo error response.
func (client *AppServiceEnvironmentsClient) getVipInfoHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// GetWorkerPool - Description for Get properties of a worker pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) GetWorkerPool(ctx context.Context, resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsGetWorkerPoolOptions) (AppServiceEnvironmentsGetWorkerPoolResponse, error) {
	req, err := client.getWorkerPoolCreateRequest(ctx, resourceGroupName, name, workerPoolName, options)
	if err != nil {
		return AppServiceEnvironmentsGetWorkerPoolResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsGetWorkerPoolResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsGetWorkerPoolResponse{}, client.getWorkerPoolHandleError(resp)
	}
	return client.getWorkerPoolHandleResponse(resp)
}

// getWorkerPoolCreateRequest creates the GetWorkerPool request.
func (client *AppServiceEnvironmentsClient) getWorkerPoolCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsGetWorkerPoolOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// getWorkerPoolHandleResponse handles the GetWorkerPool response.
func (client *AppServiceEnvironmentsClient) getWorkerPoolHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsGetWorkerPoolResponse, error) {
	result := AppServiceEnvironmentsGetWorkerPoolResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WorkerPoolResource); err != nil {
		return AppServiceEnvironmentsGetWorkerPoolResponse{}, err
	}
	return result, nil
}

// getWorkerPoolHandleError handles the GetWorkerPool error response.
func (client *AppServiceEnvironmentsClient) getWorkerPoolHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// List - Description for Get all App Service Environments for a subscription.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) List(options *AppServiceEnvironmentsListOptions) AppServiceEnvironmentsListPager {
	return &appServiceEnvironmentsListPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.AppServiceEnvironmentCollection.NextLink)
		},
	}
}

// listCreateRequest creates the List request.
func (client *AppServiceEnvironmentsClient) listCreateRequest(ctx context.Context, options *AppServiceEnvironmentsListOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Web/hostingEnvironments"
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listHandleResponse handles the List response.
func (client *AppServiceEnvironmentsClient) listHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListResponse, error) {
	result := AppServiceEnvironmentsListResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceEnvironmentCollection); err != nil {
		return AppServiceEnvironmentsListResponse{}, err
	}
	return result, nil
}

// listHandleError handles the List error response.
func (client *AppServiceEnvironmentsClient) listHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListAppServicePlans - Description for Get all App Service plans in an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListAppServicePlans(resourceGroupName string, name string, options *AppServiceEnvironmentsListAppServicePlansOptions) AppServiceEnvironmentsListAppServicePlansPager {
	return &appServiceEnvironmentsListAppServicePlansPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listAppServicePlansCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListAppServicePlansResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.AppServicePlanCollection.NextLink)
		},
	}
}

// listAppServicePlansCreateRequest creates the ListAppServicePlans request.
func (client *AppServiceEnvironmentsClient) listAppServicePlansCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListAppServicePlansOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/serverfarms"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listAppServicePlansHandleResponse handles the ListAppServicePlans response.
func (client *AppServiceEnvironmentsClient) listAppServicePlansHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListAppServicePlansResponse, error) {
	result := AppServiceEnvironmentsListAppServicePlansResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServicePlanCollection); err != nil {
		return AppServiceEnvironmentsListAppServicePlansResponse{}, err
	}
	return result, nil
}

// listAppServicePlansHandleError handles the ListAppServicePlans error response.
func (client *AppServiceEnvironmentsClient) listAppServicePlansHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListByResourceGroup - Description for Get all App Service Environments in a resource group.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListByResourceGroup(resourceGroupName string, options *AppServiceEnvironmentsListByResourceGroupOptions) AppServiceEnvironmentsListByResourceGroupPager {
	return &appServiceEnvironmentsListByResourceGroupPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListByResourceGroupResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.AppServiceEnvironmentCollection.NextLink)
		},
	}
}

// listByResourceGroupCreateRequest creates the ListByResourceGroup request.
func (client *AppServiceEnvironmentsClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *AppServiceEnvironmentsListByResourceGroupOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listByResourceGroupHandleResponse handles the ListByResourceGroup response.
func (client *AppServiceEnvironmentsClient) listByResourceGroupHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListByResourceGroupResponse, error) {
	result := AppServiceEnvironmentsListByResourceGroupResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceEnvironmentCollection); err != nil {
		return AppServiceEnvironmentsListByResourceGroupResponse{}, err
	}
	return result, nil
}

// listByResourceGroupHandleError handles the ListByResourceGroup error response.
func (client *AppServiceEnvironmentsClient) listByResourceGroupHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListCapacities - Description for Get the used, available, and total worker capacity an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListCapacities(resourceGroupName string, name string, options *AppServiceEnvironmentsListCapacitiesOptions) AppServiceEnvironmentsListCapacitiesPager {
	return &appServiceEnvironmentsListCapacitiesPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listCapacitiesCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListCapacitiesResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.StampCapacityCollection.NextLink)
		},
	}
}

// listCapacitiesCreateRequest creates the ListCapacities request.
func (client *AppServiceEnvironmentsClient) listCapacitiesCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListCapacitiesOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/capacities/compute"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listCapacitiesHandleResponse handles the ListCapacities response.
func (client *AppServiceEnvironmentsClient) listCapacitiesHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListCapacitiesResponse, error) {
	result := AppServiceEnvironmentsListCapacitiesResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.StampCapacityCollection); err != nil {
		return AppServiceEnvironmentsListCapacitiesResponse{}, err
	}
	return result, nil
}

// listCapacitiesHandleError handles the ListCapacities error response.
func (client *AppServiceEnvironmentsClient) listCapacitiesHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListDiagnostics - Description for Get diagnostic information for an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListDiagnostics(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListDiagnosticsOptions) (AppServiceEnvironmentsListDiagnosticsResponse, error) {
	req, err := client.listDiagnosticsCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsListDiagnosticsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsListDiagnosticsResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsListDiagnosticsResponse{}, client.listDiagnosticsHandleError(resp)
	}
	return client.listDiagnosticsHandleResponse(resp)
}

// listDiagnosticsCreateRequest creates the ListDiagnostics request.
func (client *AppServiceEnvironmentsClient) listDiagnosticsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListDiagnosticsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/diagnostics"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listDiagnosticsHandleResponse handles the ListDiagnostics response.
func (client *AppServiceEnvironmentsClient) listDiagnosticsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListDiagnosticsResponse, error) {
	result := AppServiceEnvironmentsListDiagnosticsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.HostingEnvironmentDiagnosticsArray); err != nil {
		return AppServiceEnvironmentsListDiagnosticsResponse{}, err
	}
	return result, nil
}

// listDiagnosticsHandleError handles the ListDiagnostics error response.
func (client *AppServiceEnvironmentsClient) listDiagnosticsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListMultiRoleMetricDefinitions - Description for Get metric definitions for a multi-role pool of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitions(resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRoleMetricDefinitionsOptions) AppServiceEnvironmentsListMultiRoleMetricDefinitionsPager {
	return &appServiceEnvironmentsListMultiRoleMetricDefinitionsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listMultiRoleMetricDefinitionsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListMultiRoleMetricDefinitionsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.ResourceMetricDefinitionCollection.NextLink)
		},
	}
}

// listMultiRoleMetricDefinitionsCreateRequest creates the ListMultiRoleMetricDefinitions request.
func (client *AppServiceEnvironmentsClient) listMultiRoleMetricDefinitionsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRoleMetricDefinitionsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/metricdefinitions"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listMultiRoleMetricDefinitionsHandleResponse handles the ListMultiRoleMetricDefinitions response.
func (client *AppServiceEnvironmentsClient) listMultiRoleMetricDefinitionsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListMultiRoleMetricDefinitionsResponse, error) {
	result := AppServiceEnvironmentsListMultiRoleMetricDefinitionsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.ResourceMetricDefinitionCollection); err != nil {
		return AppServiceEnvironmentsListMultiRoleMetricDefinitionsResponse{}, err
	}
	return result, nil
}

// listMultiRoleMetricDefinitionsHandleError handles the ListMultiRoleMetricDefinitions error response.
func (client *AppServiceEnvironmentsClient) listMultiRoleMetricDefinitionsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListMultiRolePoolInstanceMetricDefinitions - Description for Get metric definitions for a specific instance of a multi-role pool of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitions(resourceGroupName string, name string, instance string, options *AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsOptions) AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsPager {
	return &appServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listMultiRolePoolInstanceMetricDefinitionsCreateRequest(ctx, resourceGroupName, name, instance, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.ResourceMetricDefinitionCollection.NextLink)
		},
	}
}

// listMultiRolePoolInstanceMetricDefinitionsCreateRequest creates the ListMultiRolePoolInstanceMetricDefinitions request.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolInstanceMetricDefinitionsCreateRequest(ctx context.Context, resourceGroupName string, name string, instance string, options *AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/instances/{instance}/metricdefinitions"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if instance == "" {
		return nil, errors.New("parameter instance cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{instance}", url.PathEscape(instance))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listMultiRolePoolInstanceMetricDefinitionsHandleResponse handles the ListMultiRolePoolInstanceMetricDefinitions response.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolInstanceMetricDefinitionsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsResponse, error) {
	result := AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.ResourceMetricDefinitionCollection); err != nil {
		return AppServiceEnvironmentsListMultiRolePoolInstanceMetricDefinitionsResponse{}, err
	}
	return result, nil
}

// listMultiRolePoolInstanceMetricDefinitionsHandleError handles the ListMultiRolePoolInstanceMetricDefinitions error response.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolInstanceMetricDefinitionsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListMultiRolePoolSKUs - Description for Get available SKUs for scaling a multi-role pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListMultiRolePoolSKUs(resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRolePoolSKUsOptions) AppServiceEnvironmentsListMultiRolePoolSKUsPager {
	return &appServiceEnvironmentsListMultiRolePoolSKUsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listMultiRolePoolSKUsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListMultiRolePoolSKUsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.SKUInfoCollection.NextLink)
		},
	}
}

// listMultiRolePoolSKUsCreateRequest creates the ListMultiRolePoolSKUs request.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolSKUsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRolePoolSKUsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/skus"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listMultiRolePoolSKUsHandleResponse handles the ListMultiRolePoolSKUs response.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolSKUsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListMultiRolePoolSKUsResponse, error) {
	result := AppServiceEnvironmentsListMultiRolePoolSKUsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.SKUInfoCollection); err != nil {
		return AppServiceEnvironmentsListMultiRolePoolSKUsResponse{}, err
	}
	return result, nil
}

// listMultiRolePoolSKUsHandleError handles the ListMultiRolePoolSKUs error response.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolSKUsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListMultiRolePools - Description for Get all multi-role pools.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListMultiRolePools(resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRolePoolsOptions) AppServiceEnvironmentsListMultiRolePoolsPager {
	return &appServiceEnvironmentsListMultiRolePoolsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listMultiRolePoolsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListMultiRolePoolsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.WorkerPoolCollection.NextLink)
		},
	}
}

// listMultiRolePoolsCreateRequest creates the ListMultiRolePools request.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRolePoolsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listMultiRolePoolsHandleResponse handles the ListMultiRolePools response.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListMultiRolePoolsResponse, error) {
	result := AppServiceEnvironmentsListMultiRolePoolsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WorkerPoolCollection); err != nil {
		return AppServiceEnvironmentsListMultiRolePoolsResponse{}, err
	}
	return result, nil
}

// listMultiRolePoolsHandleError handles the ListMultiRolePools error response.
func (client *AppServiceEnvironmentsClient) listMultiRolePoolsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListMultiRoleUsages - Description for Get usage metrics for a multi-role pool of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListMultiRoleUsages(resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRoleUsagesOptions) AppServiceEnvironmentsListMultiRoleUsagesPager {
	return &appServiceEnvironmentsListMultiRoleUsagesPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listMultiRoleUsagesCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListMultiRoleUsagesResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.UsageCollection.NextLink)
		},
	}
}

// listMultiRoleUsagesCreateRequest creates the ListMultiRoleUsages request.
func (client *AppServiceEnvironmentsClient) listMultiRoleUsagesCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListMultiRoleUsagesOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/usages"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listMultiRoleUsagesHandleResponse handles the ListMultiRoleUsages response.
func (client *AppServiceEnvironmentsClient) listMultiRoleUsagesHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListMultiRoleUsagesResponse, error) {
	result := AppServiceEnvironmentsListMultiRoleUsagesResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.UsageCollection); err != nil {
		return AppServiceEnvironmentsListMultiRoleUsagesResponse{}, err
	}
	return result, nil
}

// listMultiRoleUsagesHandleError handles the ListMultiRoleUsages error response.
func (client *AppServiceEnvironmentsClient) listMultiRoleUsagesHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListOperations - Description for List all currently running operations on the App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListOperations(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListOperationsOptions) (AppServiceEnvironmentsListOperationsResponse, error) {
	req, err := client.listOperationsCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsListOperationsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsListOperationsResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsListOperationsResponse{}, client.listOperationsHandleError(resp)
	}
	return client.listOperationsHandleResponse(resp)
}

// listOperationsCreateRequest creates the ListOperations request.
func (client *AppServiceEnvironmentsClient) listOperationsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListOperationsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/operations"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listOperationsHandleResponse handles the ListOperations response.
func (client *AppServiceEnvironmentsClient) listOperationsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListOperationsResponse, error) {
	result := AppServiceEnvironmentsListOperationsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.OperationArray); err != nil {
		return AppServiceEnvironmentsListOperationsResponse{}, err
	}
	return result, nil
}

// listOperationsHandleError handles the ListOperations error response.
func (client *AppServiceEnvironmentsClient) listOperationsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListUsages - Description for Get global usage metrics of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListUsages(resourceGroupName string, name string, options *AppServiceEnvironmentsListUsagesOptions) AppServiceEnvironmentsListUsagesPager {
	return &appServiceEnvironmentsListUsagesPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listUsagesCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListUsagesResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.CsmUsageQuotaCollection.NextLink)
		},
	}
}

// listUsagesCreateRequest creates the ListUsages request.
func (client *AppServiceEnvironmentsClient) listUsagesCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListUsagesOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/usages"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	unencodedParams := []string{req.URL.RawQuery}
	if options != nil && options.Filter != nil {
		unencodedParams = append(unencodedParams, "$filter="+*options.Filter)
	}
	req.URL.RawQuery = strings.Join(unencodedParams, "&")
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listUsagesHandleResponse handles the ListUsages response.
func (client *AppServiceEnvironmentsClient) listUsagesHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListUsagesResponse, error) {
	result := AppServiceEnvironmentsListUsagesResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.CsmUsageQuotaCollection); err != nil {
		return AppServiceEnvironmentsListUsagesResponse{}, err
	}
	return result, nil
}

// listUsagesHandleError handles the ListUsages error response.
func (client *AppServiceEnvironmentsClient) listUsagesHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListWebApps - Description for Get all apps in an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListWebApps(resourceGroupName string, name string, options *AppServiceEnvironmentsListWebAppsOptions) AppServiceEnvironmentsListWebAppsPager {
	return &appServiceEnvironmentsListWebAppsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listWebAppsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListWebAppsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.WebAppCollection.NextLink)
		},
	}
}

// listWebAppsCreateRequest creates the ListWebApps request.
func (client *AppServiceEnvironmentsClient) listWebAppsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListWebAppsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/sites"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	if options != nil && options.PropertiesToInclude != nil {
		reqQP.Set("propertiesToInclude", *options.PropertiesToInclude)
	}
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listWebAppsHandleResponse handles the ListWebApps response.
func (client *AppServiceEnvironmentsClient) listWebAppsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListWebAppsResponse, error) {
	result := AppServiceEnvironmentsListWebAppsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WebAppCollection); err != nil {
		return AppServiceEnvironmentsListWebAppsResponse{}, err
	}
	return result, nil
}

// listWebAppsHandleError handles the ListWebApps error response.
func (client *AppServiceEnvironmentsClient) listWebAppsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListWebWorkerMetricDefinitions - Description for Get metric definitions for a worker pool of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitions(resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsListWebWorkerMetricDefinitionsOptions) AppServiceEnvironmentsListWebWorkerMetricDefinitionsPager {
	return &appServiceEnvironmentsListWebWorkerMetricDefinitionsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listWebWorkerMetricDefinitionsCreateRequest(ctx, resourceGroupName, name, workerPoolName, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListWebWorkerMetricDefinitionsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.ResourceMetricDefinitionCollection.NextLink)
		},
	}
}

// listWebWorkerMetricDefinitionsCreateRequest creates the ListWebWorkerMetricDefinitions request.
func (client *AppServiceEnvironmentsClient) listWebWorkerMetricDefinitionsCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsListWebWorkerMetricDefinitionsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/metricdefinitions"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listWebWorkerMetricDefinitionsHandleResponse handles the ListWebWorkerMetricDefinitions response.
func (client *AppServiceEnvironmentsClient) listWebWorkerMetricDefinitionsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListWebWorkerMetricDefinitionsResponse, error) {
	result := AppServiceEnvironmentsListWebWorkerMetricDefinitionsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.ResourceMetricDefinitionCollection); err != nil {
		return AppServiceEnvironmentsListWebWorkerMetricDefinitionsResponse{}, err
	}
	return result, nil
}

// listWebWorkerMetricDefinitionsHandleError handles the ListWebWorkerMetricDefinitions error response.
func (client *AppServiceEnvironmentsClient) listWebWorkerMetricDefinitionsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListWebWorkerUsages - Description for Get usage metrics for a worker pool of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListWebWorkerUsages(resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsListWebWorkerUsagesOptions) AppServiceEnvironmentsListWebWorkerUsagesPager {
	return &appServiceEnvironmentsListWebWorkerUsagesPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listWebWorkerUsagesCreateRequest(ctx, resourceGroupName, name, workerPoolName, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListWebWorkerUsagesResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.UsageCollection.NextLink)
		},
	}
}

// listWebWorkerUsagesCreateRequest creates the ListWebWorkerUsages request.
func (client *AppServiceEnvironmentsClient) listWebWorkerUsagesCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsListWebWorkerUsagesOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/usages"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listWebWorkerUsagesHandleResponse handles the ListWebWorkerUsages response.
func (client *AppServiceEnvironmentsClient) listWebWorkerUsagesHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListWebWorkerUsagesResponse, error) {
	result := AppServiceEnvironmentsListWebWorkerUsagesResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.UsageCollection); err != nil {
		return AppServiceEnvironmentsListWebWorkerUsagesResponse{}, err
	}
	return result, nil
}

// listWebWorkerUsagesHandleError handles the ListWebWorkerUsages error response.
func (client *AppServiceEnvironmentsClient) listWebWorkerUsagesHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListWorkerPoolInstanceMetricDefinitions - Description for Get metric definitions for a specific instance of a worker pool of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitions(resourceGroupName string, name string, workerPoolName string, instance string, options *AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsOptions) AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsPager {
	return &appServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listWorkerPoolInstanceMetricDefinitionsCreateRequest(ctx, resourceGroupName, name, workerPoolName, instance, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.ResourceMetricDefinitionCollection.NextLink)
		},
	}
}

// listWorkerPoolInstanceMetricDefinitionsCreateRequest creates the ListWorkerPoolInstanceMetricDefinitions request.
func (client *AppServiceEnvironmentsClient) listWorkerPoolInstanceMetricDefinitionsCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, instance string, options *AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/instances/{instance}/metricdefinitions"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if instance == "" {
		return nil, errors.New("parameter instance cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{instance}", url.PathEscape(instance))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listWorkerPoolInstanceMetricDefinitionsHandleResponse handles the ListWorkerPoolInstanceMetricDefinitions response.
func (client *AppServiceEnvironmentsClient) listWorkerPoolInstanceMetricDefinitionsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsResponse, error) {
	result := AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.ResourceMetricDefinitionCollection); err != nil {
		return AppServiceEnvironmentsListWorkerPoolInstanceMetricDefinitionsResponse{}, err
	}
	return result, nil
}

// listWorkerPoolInstanceMetricDefinitionsHandleError handles the ListWorkerPoolInstanceMetricDefinitions error response.
func (client *AppServiceEnvironmentsClient) listWorkerPoolInstanceMetricDefinitionsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListWorkerPoolSKUs - Description for Get available SKUs for scaling a worker pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListWorkerPoolSKUs(resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsListWorkerPoolSKUsOptions) AppServiceEnvironmentsListWorkerPoolSKUsPager {
	return &appServiceEnvironmentsListWorkerPoolSKUsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listWorkerPoolSKUsCreateRequest(ctx, resourceGroupName, name, workerPoolName, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListWorkerPoolSKUsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.SKUInfoCollection.NextLink)
		},
	}
}

// listWorkerPoolSKUsCreateRequest creates the ListWorkerPoolSKUs request.
func (client *AppServiceEnvironmentsClient) listWorkerPoolSKUsCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, options *AppServiceEnvironmentsListWorkerPoolSKUsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/skus"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listWorkerPoolSKUsHandleResponse handles the ListWorkerPoolSKUs response.
func (client *AppServiceEnvironmentsClient) listWorkerPoolSKUsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListWorkerPoolSKUsResponse, error) {
	result := AppServiceEnvironmentsListWorkerPoolSKUsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.SKUInfoCollection); err != nil {
		return AppServiceEnvironmentsListWorkerPoolSKUsResponse{}, err
	}
	return result, nil
}

// listWorkerPoolSKUsHandleError handles the ListWorkerPoolSKUs error response.
func (client *AppServiceEnvironmentsClient) listWorkerPoolSKUsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// ListWorkerPools - Description for Get all worker pools of an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) ListWorkerPools(resourceGroupName string, name string, options *AppServiceEnvironmentsListWorkerPoolsOptions) AppServiceEnvironmentsListWorkerPoolsPager {
	return &appServiceEnvironmentsListWorkerPoolsPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listWorkerPoolsCreateRequest(ctx, resourceGroupName, name, options)
		},
		advancer: func(ctx context.Context, resp AppServiceEnvironmentsListWorkerPoolsResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.WorkerPoolCollection.NextLink)
		},
	}
}

// listWorkerPoolsCreateRequest creates the ListWorkerPools request.
func (client *AppServiceEnvironmentsClient) listWorkerPoolsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsListWorkerPoolsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// listWorkerPoolsHandleResponse handles the ListWorkerPools response.
func (client *AppServiceEnvironmentsClient) listWorkerPoolsHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsListWorkerPoolsResponse, error) {
	result := AppServiceEnvironmentsListWorkerPoolsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WorkerPoolCollection); err != nil {
		return AppServiceEnvironmentsListWorkerPoolsResponse{}, err
	}
	return result, nil
}

// listWorkerPoolsHandleError handles the ListWorkerPools error response.
func (client *AppServiceEnvironmentsClient) listWorkerPoolsHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// Reboot - Description for Reboot all machines in an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) Reboot(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsRebootOptions) (AppServiceEnvironmentsRebootResponse, error) {
	req, err := client.rebootCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsRebootResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsRebootResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusAccepted) {
		return AppServiceEnvironmentsRebootResponse{}, client.rebootHandleError(resp)
	}
	return AppServiceEnvironmentsRebootResponse{RawResponse: resp.Response}, nil
}

// rebootCreateRequest creates the Reboot request.
func (client *AppServiceEnvironmentsClient) rebootCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsRebootOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/reboot"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// rebootHandleError handles the Reboot error response.
func (client *AppServiceEnvironmentsClient) rebootHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginResume - Description for Resume an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginResume(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginResumeOptions) (AppServiceEnvironmentsResumePollerResponse, error) {
	resp, err := client.resume(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsResumePollerResponse{}, err
	}
	result := AppServiceEnvironmentsResumePollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.Resume", "", resp, client.con.Pipeline(), client.resumeHandleError)
	if err != nil {
		return AppServiceEnvironmentsResumePollerResponse{}, err
	}
	poller := &appServiceEnvironmentsResumePoller{
		pt:     pt,
		client: client,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsResumePager, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeResume creates a new AppServiceEnvironmentsResumePoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsResumePoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeResume(ctx context.Context, token string) (AppServiceEnvironmentsResumePollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.Resume", token, client.con.Pipeline(), client.resumeHandleError)
	if err != nil {
		return AppServiceEnvironmentsResumePollerResponse{}, err
	}
	poller := &appServiceEnvironmentsResumePoller{
		pt:     pt,
		client: client,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsResumePollerResponse{}, err
	}
	result := AppServiceEnvironmentsResumePollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsResumePager, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// Resume - Description for Resume an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) resume(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginResumeOptions) (*azcore.Response, error) {
	req, err := client.resumeCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return nil, client.resumeHandleError(resp)
	}
	return resp, nil
}

// resumeCreateRequest creates the Resume request.
func (client *AppServiceEnvironmentsClient) resumeCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginResumeOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/resume"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// resumeHandleResponse handles the Resume response.
func (client *AppServiceEnvironmentsClient) resumeHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsResumeResponse, error) {
	result := AppServiceEnvironmentsResumeResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WebAppCollection); err != nil {
		return AppServiceEnvironmentsResumeResponse{}, err
	}
	return result, nil
}

// resumeHandleError handles the Resume error response.
func (client *AppServiceEnvironmentsClient) resumeHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// BeginSuspend - Description for Suspend an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) BeginSuspend(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginSuspendOptions) (AppServiceEnvironmentsSuspendPollerResponse, error) {
	resp, err := client.suspend(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceEnvironmentsSuspendPollerResponse{}, err
	}
	result := AppServiceEnvironmentsSuspendPollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceEnvironmentsClient.Suspend", "", resp, client.con.Pipeline(), client.suspendHandleError)
	if err != nil {
		return AppServiceEnvironmentsSuspendPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsSuspendPoller{
		pt:     pt,
		client: client,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsSuspendPager, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeSuspend creates a new AppServiceEnvironmentsSuspendPoller from the specified resume token.
// token - The value must come from a previous call to AppServiceEnvironmentsSuspendPoller.ResumeToken().
func (client *AppServiceEnvironmentsClient) ResumeSuspend(ctx context.Context, token string) (AppServiceEnvironmentsSuspendPollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceEnvironmentsClient.Suspend", token, client.con.Pipeline(), client.suspendHandleError)
	if err != nil {
		return AppServiceEnvironmentsSuspendPollerResponse{}, err
	}
	poller := &appServiceEnvironmentsSuspendPoller{
		pt:     pt,
		client: client,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceEnvironmentsSuspendPollerResponse{}, err
	}
	result := AppServiceEnvironmentsSuspendPollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceEnvironmentsSuspendPager, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// Suspend - Description for Suspend an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) suspend(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginSuspendOptions) (*azcore.Response, error) {
	req, err := client.suspendCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return nil, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return nil, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return nil, client.suspendHandleError(resp)
	}
	return resp, nil
}

// suspendCreateRequest creates the Suspend request.
func (client *AppServiceEnvironmentsClient) suspendCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceEnvironmentsBeginSuspendOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/suspend"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// suspendHandleResponse handles the Suspend response.
func (client *AppServiceEnvironmentsClient) suspendHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsSuspendResponse, error) {
	result := AppServiceEnvironmentsSuspendResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WebAppCollection); err != nil {
		return AppServiceEnvironmentsSuspendResponse{}, err
	}
	return result, nil
}

// suspendHandleError handles the Suspend error response.
func (client *AppServiceEnvironmentsClient) suspendHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// Update - Description for Create or update an App Service Environment.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) Update(ctx context.Context, resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentPatchResource, options *AppServiceEnvironmentsUpdateOptions) (AppServiceEnvironmentsUpdateResponse, error) {
	req, err := client.updateCreateRequest(ctx, resourceGroupName, name, hostingEnvironmentEnvelope, options)
	if err != nil {
		return AppServiceEnvironmentsUpdateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsUpdateResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted) {
		return AppServiceEnvironmentsUpdateResponse{}, client.updateHandleError(resp)
	}
	return client.updateHandleResponse(resp)
}

// updateCreateRequest creates the Update request.
func (client *AppServiceEnvironmentsClient) updateCreateRequest(ctx context.Context, resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentPatchResource, options *AppServiceEnvironmentsUpdateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(hostingEnvironmentEnvelope)
}

// updateHandleResponse handles the Update response.
func (client *AppServiceEnvironmentsClient) updateHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsUpdateResponse, error) {
	result := AppServiceEnvironmentsUpdateResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceEnvironmentResource); err != nil {
		return AppServiceEnvironmentsUpdateResponse{}, err
	}
	return result, nil
}

// updateHandleError handles the Update error response.
func (client *AppServiceEnvironmentsClient) updateHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// UpdateAseNetworkingConfiguration - Description for Update networking configuration of an App Service Environment
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) UpdateAseNetworkingConfiguration(ctx context.Context, resourceGroupName string, name string, aseNetworkingConfiguration AseV3NetworkingConfiguration, options *AppServiceEnvironmentsUpdateAseNetworkingConfigurationOptions) (AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse, error) {
	req, err := client.updateAseNetworkingConfigurationCreateRequest(ctx, resourceGroupName, name, aseNetworkingConfiguration, options)
	if err != nil {
		return AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse{}, client.updateAseNetworkingConfigurationHandleError(resp)
	}
	return client.updateAseNetworkingConfigurationHandleResponse(resp)
}

// updateAseNetworkingConfigurationCreateRequest creates the UpdateAseNetworkingConfiguration request.
func (client *AppServiceEnvironmentsClient) updateAseNetworkingConfigurationCreateRequest(ctx context.Context, resourceGroupName string, name string, aseNetworkingConfiguration AseV3NetworkingConfiguration, options *AppServiceEnvironmentsUpdateAseNetworkingConfigurationOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/configurations/networking"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(aseNetworkingConfiguration)
}

// updateAseNetworkingConfigurationHandleResponse handles the UpdateAseNetworkingConfiguration response.
func (client *AppServiceEnvironmentsClient) updateAseNetworkingConfigurationHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse, error) {
	result := AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AseV3NetworkingConfiguration); err != nil {
		return AppServiceEnvironmentsUpdateAseNetworkingConfigurationResponse{}, err
	}
	return result, nil
}

// updateAseNetworkingConfigurationHandleError handles the UpdateAseNetworkingConfiguration error response.
func (client *AppServiceEnvironmentsClient) updateAseNetworkingConfigurationHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// UpdateMultiRolePool - Description for Create or update a multi-role pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) UpdateMultiRolePool(ctx context.Context, resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsUpdateMultiRolePoolOptions) (AppServiceEnvironmentsUpdateMultiRolePoolResponse, error) {
	req, err := client.updateMultiRolePoolCreateRequest(ctx, resourceGroupName, name, multiRolePoolEnvelope, options)
	if err != nil {
		return AppServiceEnvironmentsUpdateMultiRolePoolResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsUpdateMultiRolePoolResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return AppServiceEnvironmentsUpdateMultiRolePoolResponse{}, client.updateMultiRolePoolHandleError(resp)
	}
	return client.updateMultiRolePoolHandleResponse(resp)
}

// updateMultiRolePoolCreateRequest creates the UpdateMultiRolePool request.
func (client *AppServiceEnvironmentsClient) updateMultiRolePoolCreateRequest(ctx context.Context, resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsUpdateMultiRolePoolOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(multiRolePoolEnvelope)
}

// updateMultiRolePoolHandleResponse handles the UpdateMultiRolePool response.
func (client *AppServiceEnvironmentsClient) updateMultiRolePoolHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsUpdateMultiRolePoolResponse, error) {
	result := AppServiceEnvironmentsUpdateMultiRolePoolResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WorkerPoolResource); err != nil {
		return AppServiceEnvironmentsUpdateMultiRolePoolResponse{}, err
	}
	return result, nil
}

// updateMultiRolePoolHandleError handles the UpdateMultiRolePool error response.
func (client *AppServiceEnvironmentsClient) updateMultiRolePoolHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}

// UpdateWorkerPool - Description for Create or update a worker pool.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceEnvironmentsClient) UpdateWorkerPool(ctx context.Context, resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsUpdateWorkerPoolOptions) (AppServiceEnvironmentsUpdateWorkerPoolResponse, error) {
	req, err := client.updateWorkerPoolCreateRequest(ctx, resourceGroupName, name, workerPoolName, workerPoolEnvelope, options)
	if err != nil {
		return AppServiceEnvironmentsUpdateWorkerPoolResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceEnvironmentsUpdateWorkerPoolResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
		return AppServiceEnvironmentsUpdateWorkerPoolResponse{}, client.updateWorkerPoolHandleError(resp)
	}
	return client.updateWorkerPoolHandleResponse(resp)
}

// updateWorkerPoolCreateRequest creates the UpdateWorkerPool request.
func (client *AppServiceEnvironmentsClient) updateWorkerPoolCreateRequest(ctx context.Context, resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, options *AppServiceEnvironmentsUpdateWorkerPoolOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if name == "" {
		return nil, errors.New("parameter name cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{name}", url.PathEscape(name))
	if workerPoolName == "" {
		return nil, errors.New("parameter workerPoolName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{workerPoolName}", url.PathEscape(workerPoolName))
	if client.subscriptionID == "" {
		return nil, errors.New("parameter client.subscriptionID cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Telemetry(telemetryInfo)
	reqQP := req.URL.Query()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, req.MarshalAsJSON(workerPoolEnvelope)
}

// updateWorkerPoolHandleResponse handles the UpdateWorkerPool response.
func (client *AppServiceEnvironmentsClient) updateWorkerPoolHandleResponse(resp *azcore.Response) (AppServiceEnvironmentsUpdateWorkerPoolResponse, error) {
	result := AppServiceEnvironmentsUpdateWorkerPoolResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.WorkerPoolResource); err != nil {
		return AppServiceEnvironmentsUpdateWorkerPoolResponse{}, err
	}
	return result, nil
}

// updateWorkerPoolHandleError handles the UpdateWorkerPool error response.
func (client *AppServiceEnvironmentsClient) updateWorkerPoolHandleError(resp *azcore.Response) error {
	body, err := resp.Payload()
	if err != nil {
		return azcore.NewResponseError(err, resp.Response)
	}
	errType := DefaultErrorResponse{raw: string(body)}
	if err := resp.UnmarshalAsJSON(&errType); err != nil {
		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
	}
	return azcore.NewResponseError(&errType, resp.Response)
}