web/armweb/zz_generated_appservicecertificateorders_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"
	"strings"
	"time"
)

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

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

// BeginCreateOrUpdate - Description for Create or update a certificate purchase order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrder, options *AppServiceCertificateOrdersBeginCreateOrUpdateOptions) (AppServiceCertificateOrdersCreateOrUpdatePollerResponse, error) {
	resp, err := client.createOrUpdate(ctx, resourceGroupName, certificateOrderName, certificateDistinguishedName, options)
	if err != nil {
		return AppServiceCertificateOrdersCreateOrUpdatePollerResponse{}, err
	}
	result := AppServiceCertificateOrdersCreateOrUpdatePollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceCertificateOrdersClient.CreateOrUpdate", "", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
	if err != nil {
		return AppServiceCertificateOrdersCreateOrUpdatePollerResponse{}, err
	}
	poller := &appServiceCertificateOrdersCreateOrUpdatePoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceCertificateOrdersCreateOrUpdateResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

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

// CreateOrUpdate - Description for Create or update a certificate purchase order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) createOrUpdate(ctx context.Context, resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrder, options *AppServiceCertificateOrdersBeginCreateOrUpdateOptions) (*azcore.Response, error) {
	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, certificateOrderName, certificateDistinguishedName, 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) {
		return nil, client.createOrUpdateHandleError(resp)
	}
	return resp, nil
}

// createOrUpdateCreateRequest creates the CreateOrUpdate request.
func (client *AppServiceCertificateOrdersClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrder, options *AppServiceCertificateOrdersBeginCreateOrUpdateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(certificateDistinguishedName)
}

// createOrUpdateHandleError handles the CreateOrUpdate error response.
func (client *AppServiceCertificateOrdersClient) 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)
}

// BeginCreateOrUpdateCertificate - Description for Creates or updates a certificate and associates with key vault secret.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) BeginCreateOrUpdateCertificate(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificateResource, options *AppServiceCertificateOrdersBeginCreateOrUpdateCertificateOptions) (AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse, error) {
	resp, err := client.createOrUpdateCertificate(ctx, resourceGroupName, certificateOrderName, name, keyVaultCertificate, options)
	if err != nil {
		return AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse{}, err
	}
	result := AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse{
		RawResponse: resp.Response,
	}
	pt, err := armcore.NewLROPoller("AppServiceCertificateOrdersClient.CreateOrUpdateCertificate", "", resp, client.con.Pipeline(), client.createOrUpdateCertificateHandleError)
	if err != nil {
		return AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse{}, err
	}
	poller := &appServiceCertificateOrdersCreateOrUpdateCertificatePoller{
		pt: pt,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceCertificateOrdersCreateOrUpdateCertificateResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// ResumeCreateOrUpdateCertificate creates a new AppServiceCertificateOrdersCreateOrUpdateCertificatePoller from the specified resume token.
// token - The value must come from a previous call to AppServiceCertificateOrdersCreateOrUpdateCertificatePoller.ResumeToken().
func (client *AppServiceCertificateOrdersClient) ResumeCreateOrUpdateCertificate(ctx context.Context, token string) (AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse, error) {
	pt, err := armcore.NewLROPollerFromResumeToken("AppServiceCertificateOrdersClient.CreateOrUpdateCertificate", token, client.con.Pipeline(), client.createOrUpdateCertificateHandleError)
	if err != nil {
		return AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse{}, err
	}
	poller := &appServiceCertificateOrdersCreateOrUpdateCertificatePoller{
		pt: pt,
	}
	resp, err := poller.Poll(ctx)
	if err != nil {
		return AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse{}, err
	}
	result := AppServiceCertificateOrdersCreateOrUpdateCertificatePollerResponse{
		RawResponse: resp,
	}
	result.Poller = poller
	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (AppServiceCertificateOrdersCreateOrUpdateCertificateResponse, error) {
		return poller.pollUntilDone(ctx, frequency)
	}
	return result, nil
}

// CreateOrUpdateCertificate - Description for Creates or updates a certificate and associates with key vault secret.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) createOrUpdateCertificate(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificateResource, options *AppServiceCertificateOrdersBeginCreateOrUpdateCertificateOptions) (*azcore.Response, error) {
	req, err := client.createOrUpdateCertificateCreateRequest(ctx, resourceGroupName, certificateOrderName, name, keyVaultCertificate, 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) {
		return nil, client.createOrUpdateCertificateHandleError(resp)
	}
	return resp, nil
}

// createOrUpdateCertificateCreateRequest creates the CreateOrUpdateCertificate request.
func (client *AppServiceCertificateOrdersClient) createOrUpdateCertificateCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificateResource, options *AppServiceCertificateOrdersBeginCreateOrUpdateCertificateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(keyVaultCertificate)
}

// createOrUpdateCertificateHandleError handles the CreateOrUpdateCertificate error response.
func (client *AppServiceCertificateOrdersClient) createOrUpdateCertificateHandleError(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)
}

// Delete - Description for Delete an existing certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) Delete(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersDeleteOptions) (AppServiceCertificateOrdersDeleteResponse, error) {
	req, err := client.deleteCreateRequest(ctx, resourceGroupName, certificateOrderName, options)
	if err != nil {
		return AppServiceCertificateOrdersDeleteResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersDeleteResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusNoContent) {
		return AppServiceCertificateOrdersDeleteResponse{}, client.deleteHandleError(resp)
	}
	return AppServiceCertificateOrdersDeleteResponse{RawResponse: resp.Response}, nil
}

// deleteCreateRequest creates the Delete request.
func (client *AppServiceCertificateOrdersClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersDeleteOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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
}

// deleteHandleError handles the Delete error response.
func (client *AppServiceCertificateOrdersClient) 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)
}

// DeleteCertificate - Description for Delete the certificate associated with a certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) DeleteCertificate(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, options *AppServiceCertificateOrdersDeleteCertificateOptions) (AppServiceCertificateOrdersDeleteCertificateResponse, error) {
	req, err := client.deleteCertificateCreateRequest(ctx, resourceGroupName, certificateOrderName, name, options)
	if err != nil {
		return AppServiceCertificateOrdersDeleteCertificateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersDeleteCertificateResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusNoContent) {
		return AppServiceCertificateOrdersDeleteCertificateResponse{}, client.deleteCertificateHandleError(resp)
	}
	return AppServiceCertificateOrdersDeleteCertificateResponse{RawResponse: resp.Response}, nil
}

// deleteCertificateCreateRequest creates the DeleteCertificate request.
func (client *AppServiceCertificateOrdersClient) deleteCertificateCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, options *AppServiceCertificateOrdersDeleteCertificateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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()
	reqQP.Set("api-version", "2021-01-15")
	req.URL.RawQuery = reqQP.Encode()
	req.Header.Set("Accept", "application/json")
	return req, nil
}

// deleteCertificateHandleError handles the DeleteCertificate error response.
func (client *AppServiceCertificateOrdersClient) deleteCertificateHandleError(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 a certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) Get(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersGetOptions) (AppServiceCertificateOrdersGetResponse, error) {
	req, err := client.getCreateRequest(ctx, resourceGroupName, certificateOrderName, options)
	if err != nil {
		return AppServiceCertificateOrdersGetResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersGetResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceCertificateOrdersGetResponse{}, client.getHandleError(resp)
	}
	return client.getHandleResponse(resp)
}

// getCreateRequest creates the Get request.
func (client *AppServiceCertificateOrdersClient) getCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersGetOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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 *AppServiceCertificateOrdersClient) getHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersGetResponse, error) {
	result := AppServiceCertificateOrdersGetResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceCertificateOrder); err != nil {
		return AppServiceCertificateOrdersGetResponse{}, err
	}
	return result, nil
}

// getHandleError handles the Get error response.
func (client *AppServiceCertificateOrdersClient) 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)
}

// GetCertificate - Description for Get the certificate associated with a certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) GetCertificate(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, options *AppServiceCertificateOrdersGetCertificateOptions) (AppServiceCertificateOrdersGetCertificateResponse, error) {
	req, err := client.getCertificateCreateRequest(ctx, resourceGroupName, certificateOrderName, name, options)
	if err != nil {
		return AppServiceCertificateOrdersGetCertificateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersGetCertificateResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceCertificateOrdersGetCertificateResponse{}, client.getCertificateHandleError(resp)
	}
	return client.getCertificateHandleResponse(resp)
}

// getCertificateCreateRequest creates the GetCertificate request.
func (client *AppServiceCertificateOrdersClient) getCertificateCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, options *AppServiceCertificateOrdersGetCertificateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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
}

// getCertificateHandleResponse handles the GetCertificate response.
func (client *AppServiceCertificateOrdersClient) getCertificateHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersGetCertificateResponse, error) {
	result := AppServiceCertificateOrdersGetCertificateResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceCertificateResource); err != nil {
		return AppServiceCertificateOrdersGetCertificateResponse{}, err
	}
	return result, nil
}

// getCertificateHandleError handles the GetCertificate error response.
func (client *AppServiceCertificateOrdersClient) getCertificateHandleError(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 List all certificate orders in a subscription.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) List(options *AppServiceCertificateOrdersListOptions) AppServiceCertificateOrdersListPager {
	return &appServiceCertificateOrdersListPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listCreateRequest(ctx, options)
		},
		advancer: func(ctx context.Context, resp AppServiceCertificateOrdersListResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.AppServiceCertificateOrderCollection.NextLink)
		},
	}
}

// listCreateRequest creates the List request.
func (client *AppServiceCertificateOrdersClient) listCreateRequest(ctx context.Context, options *AppServiceCertificateOrdersListOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.CertificateRegistration/certificateOrders"
	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 *AppServiceCertificateOrdersClient) listHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersListResponse, error) {
	result := AppServiceCertificateOrdersListResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceCertificateOrderCollection); err != nil {
		return AppServiceCertificateOrdersListResponse{}, err
	}
	return result, nil
}

// listHandleError handles the List error response.
func (client *AppServiceCertificateOrdersClient) 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)
}

// ListByResourceGroup - Description for Get certificate orders in a resource group.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) ListByResourceGroup(resourceGroupName string, options *AppServiceCertificateOrdersListByResourceGroupOptions) AppServiceCertificateOrdersListByResourceGroupPager {
	return &appServiceCertificateOrdersListByResourceGroupPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options)
		},
		advancer: func(ctx context.Context, resp AppServiceCertificateOrdersListByResourceGroupResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.AppServiceCertificateOrderCollection.NextLink)
		},
	}
}

// listByResourceGroupCreateRequest creates the ListByResourceGroup request.
func (client *AppServiceCertificateOrdersClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *AppServiceCertificateOrdersListByResourceGroupOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders"
	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 *AppServiceCertificateOrdersClient) listByResourceGroupHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersListByResourceGroupResponse, error) {
	result := AppServiceCertificateOrdersListByResourceGroupResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceCertificateOrderCollection); err != nil {
		return AppServiceCertificateOrdersListByResourceGroupResponse{}, err
	}
	return result, nil
}

// listByResourceGroupHandleError handles the ListByResourceGroup error response.
func (client *AppServiceCertificateOrdersClient) 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)
}

// ListCertificates - Description for List all certificates associated with a certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) ListCertificates(resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersListCertificatesOptions) AppServiceCertificateOrdersListCertificatesPager {
	return &appServiceCertificateOrdersListCertificatesPager{
		client: client,
		requester: func(ctx context.Context) (*azcore.Request, error) {
			return client.listCertificatesCreateRequest(ctx, resourceGroupName, certificateOrderName, options)
		},
		advancer: func(ctx context.Context, resp AppServiceCertificateOrdersListCertificatesResponse) (*azcore.Request, error) {
			return azcore.NewRequest(ctx, http.MethodGet, *resp.AppServiceCertificateCollection.NextLink)
		},
	}
}

// listCertificatesCreateRequest creates the ListCertificates request.
func (client *AppServiceCertificateOrdersClient) listCertificatesCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersListCertificatesOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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
}

// listCertificatesHandleResponse handles the ListCertificates response.
func (client *AppServiceCertificateOrdersClient) listCertificatesHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersListCertificatesResponse, error) {
	result := AppServiceCertificateOrdersListCertificatesResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceCertificateCollection); err != nil {
		return AppServiceCertificateOrdersListCertificatesResponse{}, err
	}
	return result, nil
}

// listCertificatesHandleError handles the ListCertificates error response.
func (client *AppServiceCertificateOrdersClient) listCertificatesHandleError(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)
}

// Reissue - Description for Reissue an existing certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) Reissue(ctx context.Context, resourceGroupName string, certificateOrderName string, reissueCertificateOrderRequest ReissueCertificateOrderRequest, options *AppServiceCertificateOrdersReissueOptions) (AppServiceCertificateOrdersReissueResponse, error) {
	req, err := client.reissueCreateRequest(ctx, resourceGroupName, certificateOrderName, reissueCertificateOrderRequest, options)
	if err != nil {
		return AppServiceCertificateOrdersReissueResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersReissueResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusNoContent) {
		return AppServiceCertificateOrdersReissueResponse{}, client.reissueHandleError(resp)
	}
	return AppServiceCertificateOrdersReissueResponse{RawResponse: resp.Response}, nil
}

// reissueCreateRequest creates the Reissue request.
func (client *AppServiceCertificateOrdersClient) reissueCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, reissueCertificateOrderRequest ReissueCertificateOrderRequest, options *AppServiceCertificateOrdersReissueOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/reissue"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(reissueCertificateOrderRequest)
}

// reissueHandleError handles the Reissue error response.
func (client *AppServiceCertificateOrdersClient) reissueHandleError(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)
}

// Renew - Description for Renew an existing certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) Renew(ctx context.Context, resourceGroupName string, certificateOrderName string, renewCertificateOrderRequest RenewCertificateOrderRequest, options *AppServiceCertificateOrdersRenewOptions) (AppServiceCertificateOrdersRenewResponse, error) {
	req, err := client.renewCreateRequest(ctx, resourceGroupName, certificateOrderName, renewCertificateOrderRequest, options)
	if err != nil {
		return AppServiceCertificateOrdersRenewResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersRenewResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusNoContent) {
		return AppServiceCertificateOrdersRenewResponse{}, client.renewHandleError(resp)
	}
	return AppServiceCertificateOrdersRenewResponse{RawResponse: resp.Response}, nil
}

// renewCreateRequest creates the Renew request.
func (client *AppServiceCertificateOrdersClient) renewCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, renewCertificateOrderRequest RenewCertificateOrderRequest, options *AppServiceCertificateOrdersRenewOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/renew"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(renewCertificateOrderRequest)
}

// renewHandleError handles the Renew error response.
func (client *AppServiceCertificateOrdersClient) renewHandleError(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)
}

// ResendEmail - Description for Resend certificate email.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) ResendEmail(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersResendEmailOptions) (AppServiceCertificateOrdersResendEmailResponse, error) {
	req, err := client.resendEmailCreateRequest(ctx, resourceGroupName, certificateOrderName, options)
	if err != nil {
		return AppServiceCertificateOrdersResendEmailResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersResendEmailResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusNoContent) {
		return AppServiceCertificateOrdersResendEmailResponse{}, client.resendEmailHandleError(resp)
	}
	return AppServiceCertificateOrdersResendEmailResponse{RawResponse: resp.Response}, nil
}

// resendEmailCreateRequest creates the ResendEmail request.
func (client *AppServiceCertificateOrdersClient) resendEmailCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersResendEmailOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/resendEmail"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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
}

// resendEmailHandleError handles the ResendEmail error response.
func (client *AppServiceCertificateOrdersClient) resendEmailHandleError(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)
}

// ResendRequestEmails - Description for Verify domain ownership for this certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) ResendRequestEmails(ctx context.Context, resourceGroupName string, certificateOrderName string, nameIdentifier NameIdentifier, options *AppServiceCertificateOrdersResendRequestEmailsOptions) (AppServiceCertificateOrdersResendRequestEmailsResponse, error) {
	req, err := client.resendRequestEmailsCreateRequest(ctx, resourceGroupName, certificateOrderName, nameIdentifier, options)
	if err != nil {
		return AppServiceCertificateOrdersResendRequestEmailsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersResendRequestEmailsResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusNoContent) {
		return AppServiceCertificateOrdersResendRequestEmailsResponse{}, client.resendRequestEmailsHandleError(resp)
	}
	return AppServiceCertificateOrdersResendRequestEmailsResponse{RawResponse: resp.Response}, nil
}

// resendRequestEmailsCreateRequest creates the ResendRequestEmails request.
func (client *AppServiceCertificateOrdersClient) resendRequestEmailsCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, nameIdentifier NameIdentifier, options *AppServiceCertificateOrdersResendRequestEmailsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/resendRequestEmails"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(nameIdentifier)
}

// resendRequestEmailsHandleError handles the ResendRequestEmails error response.
func (client *AppServiceCertificateOrdersClient) resendRequestEmailsHandleError(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)
}

// RetrieveCertificateActions - Description for Retrieve the list of certificate actions.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) RetrieveCertificateActions(ctx context.Context, resourceGroupName string, name string, options *AppServiceCertificateOrdersRetrieveCertificateActionsOptions) (AppServiceCertificateOrdersRetrieveCertificateActionsResponse, error) {
	req, err := client.retrieveCertificateActionsCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceCertificateOrdersRetrieveCertificateActionsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersRetrieveCertificateActionsResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceCertificateOrdersRetrieveCertificateActionsResponse{}, client.retrieveCertificateActionsHandleError(resp)
	}
	return client.retrieveCertificateActionsHandleResponse(resp)
}

// retrieveCertificateActionsCreateRequest creates the RetrieveCertificateActions request.
func (client *AppServiceCertificateOrdersClient) retrieveCertificateActionsCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceCertificateOrdersRetrieveCertificateActionsOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{name}/retrieveCertificateActions"
	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
}

// retrieveCertificateActionsHandleResponse handles the RetrieveCertificateActions response.
func (client *AppServiceCertificateOrdersClient) retrieveCertificateActionsHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersRetrieveCertificateActionsResponse, error) {
	result := AppServiceCertificateOrdersRetrieveCertificateActionsResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.CertificateOrderActionArray); err != nil {
		return AppServiceCertificateOrdersRetrieveCertificateActionsResponse{}, err
	}
	return result, nil
}

// retrieveCertificateActionsHandleError handles the RetrieveCertificateActions error response.
func (client *AppServiceCertificateOrdersClient) retrieveCertificateActionsHandleError(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)
}

// RetrieveCertificateEmailHistory - Description for Retrieve email history.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistory(ctx context.Context, resourceGroupName string, name string, options *AppServiceCertificateOrdersRetrieveCertificateEmailHistoryOptions) (AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse, error) {
	req, err := client.retrieveCertificateEmailHistoryCreateRequest(ctx, resourceGroupName, name, options)
	if err != nil {
		return AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse{}, client.retrieveCertificateEmailHistoryHandleError(resp)
	}
	return client.retrieveCertificateEmailHistoryHandleResponse(resp)
}

// retrieveCertificateEmailHistoryCreateRequest creates the RetrieveCertificateEmailHistory request.
func (client *AppServiceCertificateOrdersClient) retrieveCertificateEmailHistoryCreateRequest(ctx context.Context, resourceGroupName string, name string, options *AppServiceCertificateOrdersRetrieveCertificateEmailHistoryOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{name}/retrieveEmailHistory"
	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
}

// retrieveCertificateEmailHistoryHandleResponse handles the RetrieveCertificateEmailHistory response.
func (client *AppServiceCertificateOrdersClient) retrieveCertificateEmailHistoryHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse, error) {
	result := AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.CertificateEmailArray); err != nil {
		return AppServiceCertificateOrdersRetrieveCertificateEmailHistoryResponse{}, err
	}
	return result, nil
}

// retrieveCertificateEmailHistoryHandleError handles the RetrieveCertificateEmailHistory error response.
func (client *AppServiceCertificateOrdersClient) retrieveCertificateEmailHistoryHandleError(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)
}

// RetrieveSiteSeal - Description for Verify domain ownership for this certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) RetrieveSiteSeal(ctx context.Context, resourceGroupName string, certificateOrderName string, siteSealRequest SiteSealRequest, options *AppServiceCertificateOrdersRetrieveSiteSealOptions) (AppServiceCertificateOrdersRetrieveSiteSealResponse, error) {
	req, err := client.retrieveSiteSealCreateRequest(ctx, resourceGroupName, certificateOrderName, siteSealRequest, options)
	if err != nil {
		return AppServiceCertificateOrdersRetrieveSiteSealResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersRetrieveSiteSealResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK) {
		return AppServiceCertificateOrdersRetrieveSiteSealResponse{}, client.retrieveSiteSealHandleError(resp)
	}
	return client.retrieveSiteSealHandleResponse(resp)
}

// retrieveSiteSealCreateRequest creates the RetrieveSiteSeal request.
func (client *AppServiceCertificateOrdersClient) retrieveSiteSealCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, siteSealRequest SiteSealRequest, options *AppServiceCertificateOrdersRetrieveSiteSealOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/retrieveSiteSeal"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(siteSealRequest)
}

// retrieveSiteSealHandleResponse handles the RetrieveSiteSeal response.
func (client *AppServiceCertificateOrdersClient) retrieveSiteSealHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersRetrieveSiteSealResponse, error) {
	result := AppServiceCertificateOrdersRetrieveSiteSealResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.SiteSeal); err != nil {
		return AppServiceCertificateOrdersRetrieveSiteSealResponse{}, err
	}
	return result, nil
}

// retrieveSiteSealHandleError handles the RetrieveSiteSeal error response.
func (client *AppServiceCertificateOrdersClient) retrieveSiteSealHandleError(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 a certificate purchase order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) Update(ctx context.Context, resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrderPatchResource, options *AppServiceCertificateOrdersUpdateOptions) (AppServiceCertificateOrdersUpdateResponse, error) {
	req, err := client.updateCreateRequest(ctx, resourceGroupName, certificateOrderName, certificateDistinguishedName, options)
	if err != nil {
		return AppServiceCertificateOrdersUpdateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersUpdateResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
		return AppServiceCertificateOrdersUpdateResponse{}, client.updateHandleError(resp)
	}
	return client.updateHandleResponse(resp)
}

// updateCreateRequest creates the Update request.
func (client *AppServiceCertificateOrdersClient) updateCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrderPatchResource, options *AppServiceCertificateOrdersUpdateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(certificateDistinguishedName)
}

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

// updateHandleError handles the Update error response.
func (client *AppServiceCertificateOrdersClient) 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)
}

// UpdateCertificate - Description for Creates or updates a certificate and associates with key vault secret.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) UpdateCertificate(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificatePatchResource, options *AppServiceCertificateOrdersUpdateCertificateOptions) (AppServiceCertificateOrdersUpdateCertificateResponse, error) {
	req, err := client.updateCertificateCreateRequest(ctx, resourceGroupName, certificateOrderName, name, keyVaultCertificate, options)
	if err != nil {
		return AppServiceCertificateOrdersUpdateCertificateResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersUpdateCertificateResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
		return AppServiceCertificateOrdersUpdateCertificateResponse{}, client.updateCertificateHandleError(resp)
	}
	return client.updateCertificateHandleResponse(resp)
}

// updateCertificateCreateRequest creates the UpdateCertificate request.
func (client *AppServiceCertificateOrdersClient) updateCertificateCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificatePatchResource, options *AppServiceCertificateOrdersUpdateCertificateOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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(keyVaultCertificate)
}

// updateCertificateHandleResponse handles the UpdateCertificate response.
func (client *AppServiceCertificateOrdersClient) updateCertificateHandleResponse(resp *azcore.Response) (AppServiceCertificateOrdersUpdateCertificateResponse, error) {
	result := AppServiceCertificateOrdersUpdateCertificateResponse{RawResponse: resp.Response}
	if err := resp.UnmarshalAsJSON(&result.AppServiceCertificateResource); err != nil {
		return AppServiceCertificateOrdersUpdateCertificateResponse{}, err
	}
	return result, nil
}

// updateCertificateHandleError handles the UpdateCertificate error response.
func (client *AppServiceCertificateOrdersClient) updateCertificateHandleError(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)
}

// ValidatePurchaseInformation - Description for Validate information for a certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) ValidatePurchaseInformation(ctx context.Context, appServiceCertificateOrder AppServiceCertificateOrder, options *AppServiceCertificateOrdersValidatePurchaseInformationOptions) (AppServiceCertificateOrdersValidatePurchaseInformationResponse, error) {
	req, err := client.validatePurchaseInformationCreateRequest(ctx, appServiceCertificateOrder, options)
	if err != nil {
		return AppServiceCertificateOrdersValidatePurchaseInformationResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersValidatePurchaseInformationResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusNoContent) {
		return AppServiceCertificateOrdersValidatePurchaseInformationResponse{}, client.validatePurchaseInformationHandleError(resp)
	}
	return AppServiceCertificateOrdersValidatePurchaseInformationResponse{RawResponse: resp.Response}, nil
}

// validatePurchaseInformationCreateRequest creates the ValidatePurchaseInformation request.
func (client *AppServiceCertificateOrdersClient) validatePurchaseInformationCreateRequest(ctx context.Context, appServiceCertificateOrder AppServiceCertificateOrder, options *AppServiceCertificateOrdersValidatePurchaseInformationOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.CertificateRegistration/validateCertificateRegistrationInformation"
	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(appServiceCertificateOrder)
}

// validatePurchaseInformationHandleError handles the ValidatePurchaseInformation error response.
func (client *AppServiceCertificateOrdersClient) validatePurchaseInformationHandleError(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)
}

// VerifyDomainOwnership - Description for Verify domain ownership for this certificate order.
// If the operation fails it returns the *DefaultErrorResponse error type.
func (client *AppServiceCertificateOrdersClient) VerifyDomainOwnership(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersVerifyDomainOwnershipOptions) (AppServiceCertificateOrdersVerifyDomainOwnershipResponse, error) {
	req, err := client.verifyDomainOwnershipCreateRequest(ctx, resourceGroupName, certificateOrderName, options)
	if err != nil {
		return AppServiceCertificateOrdersVerifyDomainOwnershipResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return AppServiceCertificateOrdersVerifyDomainOwnershipResponse{}, err
	}
	if !resp.HasStatusCode(http.StatusNoContent) {
		return AppServiceCertificateOrdersVerifyDomainOwnershipResponse{}, client.verifyDomainOwnershipHandleError(resp)
	}
	return AppServiceCertificateOrdersVerifyDomainOwnershipResponse{RawResponse: resp.Response}, nil
}

// verifyDomainOwnershipCreateRequest creates the VerifyDomainOwnership request.
func (client *AppServiceCertificateOrdersClient) verifyDomainOwnershipCreateRequest(ctx context.Context, resourceGroupName string, certificateOrderName string, options *AppServiceCertificateOrdersVerifyDomainOwnershipOptions) (*azcore.Request, error) {
	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/verifyDomainOwnership"
	if resourceGroupName == "" {
		return nil, errors.New("parameter resourceGroupName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
	if certificateOrderName == "" {
		return nil, errors.New("parameter certificateOrderName cannot be empty")
	}
	urlPath = strings.ReplaceAll(urlPath, "{certificateOrderName}", url.PathEscape(certificateOrderName))
	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
}

// verifyDomainOwnershipHandleError handles the VerifyDomainOwnership error response.
func (client *AppServiceCertificateOrdersClient) verifyDomainOwnershipHandleError(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)
}