github.com/hashicorp/go-azure-sdk/resource-manager/web/2022-09-01/webapps Documentation

The webapps SDK allows for interaction with the Azure Resource Manager Service web (API Version 2022-09-01).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
import "github.com/hashicorp/go-azure-sdk/resource-manager/web/2022-09-01/webapps"

Client Initialization

client := webapps.NewWebAppsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: WebAppsClient.AddPremierAddOn

ctx := context.TODO()
id := webapps.NewPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "premierAddonValue")

payload := webapps.PremierAddOn{
	// ...
}


read, err := client.AddPremierAddOn(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.AddPremierAddOnSlot

ctx := context.TODO()
id := webapps.NewSlotPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "premierAddonValue")

payload := webapps.PremierAddOn{
	// ...
}


read, err := client.AddPremierAddOnSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.AnalyzeCustomHostname

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.AnalyzeCustomHostname(ctx, id, webapps.DefaultAnalyzeCustomHostnameOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.AnalyzeCustomHostnameSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.AnalyzeCustomHostnameSlot(ctx, id, webapps.DefaultAnalyzeCustomHostnameSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ApplySlotConfigToProduction

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.CsmSlotEntity{
	// ...
}


read, err := client.ApplySlotConfigToProduction(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ApplySlotConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.CsmSlotEntity{
	// ...
}


read, err := client.ApplySlotConfigurationSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ApproveOrRejectPrivateEndpointConnection

ctx := context.TODO()
id := webapps.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "privateEndpointConnectionValue")

payload := webapps.RemotePrivateEndpointConnectionARMResource{
	// ...
}


if err := client.ApproveOrRejectPrivateEndpointConnectionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.ApproveOrRejectPrivateEndpointConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "privateEndpointConnectionValue")

payload := webapps.RemotePrivateEndpointConnectionARMResource{
	// ...
}


if err := client.ApproveOrRejectPrivateEndpointConnectionSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.Backup

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.BackupRequest{
	// ...
}


read, err := client.Backup(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.BackupSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.BackupRequest{
	// ...
}


read, err := client.BackupSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateDeployment

ctx := context.TODO()
id := webapps.NewDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "deploymentValue")

payload := webapps.Deployment{
	// ...
}


read, err := client.CreateDeployment(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateDeploymentSlot

ctx := context.TODO()
id := webapps.NewSlotDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "deploymentValue")

payload := webapps.Deployment{
	// ...
}


read, err := client.CreateDeploymentSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateFunction

ctx := context.TODO()
id := webapps.NewFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue")

payload := webapps.FunctionEnvelope{
	// ...
}


if err := client.CreateFunctionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateInstanceFunctionSlot

ctx := context.TODO()
id := webapps.NewSlotFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue")

payload := webapps.FunctionEnvelope{
	// ...
}


if err := client.CreateInstanceFunctionSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateInstanceMSDeployOperation

ctx := context.TODO()
id := webapps.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue")

payload := webapps.MSDeploy{
	// ...
}


if err := client.CreateInstanceMSDeployOperationThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateInstanceMSDeployOperationSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue")

payload := webapps.MSDeploy{
	// ...
}


if err := client.CreateInstanceMSDeployOperationSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateMSDeployOperation

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.MSDeploy{
	// ...
}


if err := client.CreateMSDeployOperationThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateMSDeployOperationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.MSDeploy{
	// ...
}


if err := client.CreateMSDeployOperationSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateOneDeployOperation

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.CreateOneDeployOperation(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdate

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.Site{
	// ...
}


if err := client.CreateOrUpdateThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateOrUpdateConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteConfigResource{
	// ...
}


read, err := client.CreateOrUpdateConfiguration(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteConfigResource{
	// ...
}


read, err := client.CreateOrUpdateConfigurationSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateDomainOwnershipIdentifier

ctx := context.TODO()
id := webapps.NewDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "domainOwnershipIdentifierValue")

payload := webapps.Identifier{
	// ...
}


read, err := client.CreateOrUpdateDomainOwnershipIdentifier(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateDomainOwnershipIdentifierSlot

ctx := context.TODO()
id := webapps.NewSlotDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "domainOwnershipIdentifierValue")

payload := webapps.Identifier{
	// ...
}


read, err := client.CreateOrUpdateDomainOwnershipIdentifierSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateFunctionSecret

ctx := context.TODO()
id := webapps.NewKeyID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue", "keyValue")

payload := webapps.KeyInfo{
	// ...
}


read, err := client.CreateOrUpdateFunctionSecret(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateFunctionSecretSlot

ctx := context.TODO()
id := webapps.NewFunctionKeyID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue", "keyValue")

payload := webapps.KeyInfo{
	// ...
}


read, err := client.CreateOrUpdateFunctionSecretSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateHostNameBinding

ctx := context.TODO()
id := webapps.NewHostNameBindingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hostNameBindingValue")

payload := webapps.HostNameBinding{
	// ...
}


read, err := client.CreateOrUpdateHostNameBinding(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateHostNameBindingSlot

ctx := context.TODO()
id := webapps.NewSlotHostNameBindingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hostNameBindingValue")

payload := webapps.HostNameBinding{
	// ...
}


read, err := client.CreateOrUpdateHostNameBindingSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateHostSecret

ctx := context.TODO()
id := webapps.NewDefaultID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "defaultValue", "keyValue")

payload := webapps.KeyInfo{
	// ...
}


read, err := client.CreateOrUpdateHostSecret(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateHostSecretSlot

ctx := context.TODO()
id := webapps.NewHostDefaultID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "defaultValue", "keyValue")

payload := webapps.KeyInfo{
	// ...
}


read, err := client.CreateOrUpdateHostSecretSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateHybridConnection

ctx := context.TODO()
id := webapps.NewRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionNamespaceValue", "relayValue")

payload := webapps.HybridConnection{
	// ...
}


read, err := client.CreateOrUpdateHybridConnection(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateHybridConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionNamespaceRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionNamespaceValue", "relayValue")

payload := webapps.HybridConnection{
	// ...
}


read, err := client.CreateOrUpdateHybridConnectionSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdatePublicCertificate

ctx := context.TODO()
id := webapps.NewPublicCertificateID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "publicCertificateValue")

payload := webapps.PublicCertificate{
	// ...
}


read, err := client.CreateOrUpdatePublicCertificate(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdatePublicCertificateSlot

ctx := context.TODO()
id := webapps.NewSlotPublicCertificateID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "publicCertificateValue")

payload := webapps.PublicCertificate{
	// ...
}


read, err := client.CreateOrUpdatePublicCertificateSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateRelayServiceConnection

ctx := context.TODO()
id := webapps.NewHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionValue")

payload := webapps.RelayServiceConnectionEntity{
	// ...
}


read, err := client.CreateOrUpdateRelayServiceConnection(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateRelayServiceConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionValue")

payload := webapps.RelayServiceConnectionEntity{
	// ...
}


read, err := client.CreateOrUpdateRelayServiceConnectionSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.Site{
	// ...
}


if err := client.CreateOrUpdateSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateOrUpdateSourceControl

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteSourceControl{
	// ...
}


if err := client.CreateOrUpdateSourceControlThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateOrUpdateSourceControlSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteSourceControl{
	// ...
}


if err := client.CreateOrUpdateSourceControlSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.CreateOrUpdateSwiftVirtualNetworkConnectionWithCheck

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SwiftVirtualNetwork{
	// ...
}


read, err := client.CreateOrUpdateSwiftVirtualNetworkConnectionWithCheck(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateSwiftVirtualNetworkConnectionWithCheckSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SwiftVirtualNetwork{
	// ...
}


read, err := client.CreateOrUpdateSwiftVirtualNetworkConnectionWithCheckSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateVnetConnection

ctx := context.TODO()
id := webapps.NewVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue")

payload := webapps.VnetInfoResource{
	// ...
}


read, err := client.CreateOrUpdateVnetConnection(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateVnetConnectionGateway

ctx := context.TODO()
id := webapps.NewGatewayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue", "gatewayValue")

payload := webapps.VnetGateway{
	// ...
}


read, err := client.CreateOrUpdateVnetConnectionGateway(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateVnetConnectionGatewaySlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionGatewayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue", "gatewayValue")

payload := webapps.VnetGateway{
	// ...
}


read, err := client.CreateOrUpdateVnetConnectionGatewaySlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.CreateOrUpdateVnetConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue")

payload := webapps.VnetInfoResource{
	// ...
}


read, err := client.CreateOrUpdateVnetConnectionSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Delete

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.Delete(ctx, id, webapps.DefaultDeleteOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteBackup

ctx := context.TODO()
id := webapps.NewBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "backupIdValue")

read, err := client.DeleteBackup(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteBackupConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.DeleteBackupConfiguration(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteBackupConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.DeleteBackupConfigurationSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteBackupSlot

ctx := context.TODO()
id := webapps.NewSlotBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "backupIdValue")

read, err := client.DeleteBackupSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteContinuousWebJob

ctx := context.TODO()
id := webapps.NewContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "continuousWebJobValue")

read, err := client.DeleteContinuousWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteContinuousWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "continuousWebJobValue")

read, err := client.DeleteContinuousWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteDeployment

ctx := context.TODO()
id := webapps.NewDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "deploymentValue")

read, err := client.DeleteDeployment(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteDeploymentSlot

ctx := context.TODO()
id := webapps.NewSlotDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "deploymentValue")

read, err := client.DeleteDeploymentSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteDomainOwnershipIdentifier

ctx := context.TODO()
id := webapps.NewDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "domainOwnershipIdentifierValue")

read, err := client.DeleteDomainOwnershipIdentifier(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteDomainOwnershipIdentifierSlot

ctx := context.TODO()
id := webapps.NewSlotDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "domainOwnershipIdentifierValue")

read, err := client.DeleteDomainOwnershipIdentifierSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteFunction

ctx := context.TODO()
id := webapps.NewFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue")

read, err := client.DeleteFunction(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteFunctionSecret

ctx := context.TODO()
id := webapps.NewKeyID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue", "keyValue")

read, err := client.DeleteFunctionSecret(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteFunctionSecretSlot

ctx := context.TODO()
id := webapps.NewFunctionKeyID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue", "keyValue")

read, err := client.DeleteFunctionSecretSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteHostNameBinding

ctx := context.TODO()
id := webapps.NewHostNameBindingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hostNameBindingValue")

read, err := client.DeleteHostNameBinding(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteHostNameBindingSlot

ctx := context.TODO()
id := webapps.NewSlotHostNameBindingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hostNameBindingValue")

read, err := client.DeleteHostNameBindingSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteHostSecret

ctx := context.TODO()
id := webapps.NewDefaultID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "defaultValue", "keyValue")

read, err := client.DeleteHostSecret(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteHostSecretSlot

ctx := context.TODO()
id := webapps.NewHostDefaultID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "defaultValue", "keyValue")

read, err := client.DeleteHostSecretSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteHybridConnection

ctx := context.TODO()
id := webapps.NewRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionNamespaceValue", "relayValue")

read, err := client.DeleteHybridConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteHybridConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionNamespaceRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionNamespaceValue", "relayValue")

read, err := client.DeleteHybridConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteInstanceFunctionSlot

ctx := context.TODO()
id := webapps.NewSlotFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue")

read, err := client.DeleteInstanceFunctionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteInstanceProcess

ctx := context.TODO()
id := webapps.NewInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue", "processIdValue")

read, err := client.DeleteInstanceProcess(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteInstanceProcessSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue", "processIdValue")

read, err := client.DeleteInstanceProcessSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeletePremierAddOn

ctx := context.TODO()
id := webapps.NewPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "premierAddonValue")

read, err := client.DeletePremierAddOn(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeletePremierAddOnSlot

ctx := context.TODO()
id := webapps.NewSlotPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "premierAddonValue")

read, err := client.DeletePremierAddOnSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeletePrivateEndpointConnection

ctx := context.TODO()
id := webapps.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "privateEndpointConnectionValue")

if err := client.DeletePrivateEndpointConnectionThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.DeletePrivateEndpointConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "privateEndpointConnectionValue")

if err := client.DeletePrivateEndpointConnectionSlotThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.DeleteProcess

ctx := context.TODO()
id := webapps.NewProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "processIdValue")

read, err := client.DeleteProcess(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteProcessSlot

ctx := context.TODO()
id := webapps.NewSlotProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "processIdValue")

read, err := client.DeleteProcessSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeletePublicCertificate

ctx := context.TODO()
id := webapps.NewPublicCertificateID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "publicCertificateValue")

read, err := client.DeletePublicCertificate(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeletePublicCertificateSlot

ctx := context.TODO()
id := webapps.NewSlotPublicCertificateID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "publicCertificateValue")

read, err := client.DeletePublicCertificateSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteRelayServiceConnection

ctx := context.TODO()
id := webapps.NewHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionValue")

read, err := client.DeleteRelayServiceConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteRelayServiceConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionValue")

read, err := client.DeleteRelayServiceConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSiteExtension

ctx := context.TODO()
id := webapps.NewSiteExtensionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "siteExtensionIdValue")

read, err := client.DeleteSiteExtension(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSiteExtensionSlot

ctx := context.TODO()
id := webapps.NewSlotSiteExtensionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "siteExtensionIdValue")

read, err := client.DeleteSiteExtensionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.DeleteSlot(ctx, id, webapps.DefaultDeleteSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSourceControl

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.DeleteSourceControl(ctx, id, webapps.DefaultDeleteSourceControlOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSourceControlSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.DeleteSourceControlSlot(ctx, id, webapps.DefaultDeleteSourceControlSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSwiftVirtualNetwork

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.DeleteSwiftVirtualNetwork(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteSwiftVirtualNetworkSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.DeleteSwiftVirtualNetworkSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteTriggeredWebJob

ctx := context.TODO()
id := webapps.NewTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "triggeredWebJobValue")

read, err := client.DeleteTriggeredWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteTriggeredWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "triggeredWebJobValue")

read, err := client.DeleteTriggeredWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteVnetConnection

ctx := context.TODO()
id := webapps.NewVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue")

read, err := client.DeleteVnetConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeleteVnetConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue")

read, err := client.DeleteVnetConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeployWorkflowArtifacts

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.WorkflowArtifacts{
	// ...
}


read, err := client.DeployWorkflowArtifacts(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DeployWorkflowArtifactsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.WorkflowArtifacts{
	// ...
}


read, err := client.DeployWorkflowArtifactsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DiscoverBackup

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.RestoreRequest{
	// ...
}


read, err := client.DiscoverBackup(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.DiscoverBackupSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.RestoreRequest{
	// ...
}


read, err := client.DiscoverBackupSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GenerateNewSitePublishingPassword

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GenerateNewSitePublishingPassword(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GenerateNewSitePublishingPasswordSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GenerateNewSitePublishingPasswordSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Get

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.Get(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAppSettingKeyVaultReference

ctx := context.TODO()
id := webapps.NewAppSettingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "appSettingKeyValue")

read, err := client.GetAppSettingKeyVaultReference(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAppSettingKeyVaultReferenceSlot

ctx := context.TODO()
id := webapps.NewConfigReferenceAppSettingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "appSettingKeyValue")

read, err := client.GetAppSettingKeyVaultReferenceSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAppSettingsKeyVaultReferences

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.GetAppSettingsKeyVaultReferences(ctx, id)` can be used to do batched pagination
items, err := client.GetAppSettingsKeyVaultReferencesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.GetAppSettingsKeyVaultReferencesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.GetAppSettingsKeyVaultReferencesSlot(ctx, id)` can be used to do batched pagination
items, err := client.GetAppSettingsKeyVaultReferencesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.GetAuthSettings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetAuthSettings(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAuthSettingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetAuthSettingsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAuthSettingsV2

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetAuthSettingsV2(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAuthSettingsV2Slot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetAuthSettingsV2Slot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAuthSettingsV2WithoutSecrets

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetAuthSettingsV2WithoutSecrets(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetAuthSettingsV2WithoutSecretsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetAuthSettingsV2WithoutSecretsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetBackupConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetBackupConfiguration(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetBackupConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetBackupConfigurationSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetBackupStatus

ctx := context.TODO()
id := webapps.NewBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "backupIdValue")

read, err := client.GetBackupStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetBackupStatusSlot

ctx := context.TODO()
id := webapps.NewSlotBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "backupIdValue")

read, err := client.GetBackupStatusSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetConfiguration(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetConfigurationSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetConfigurationSnapshot

ctx := context.TODO()
id := webapps.NewSnapshotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "snapshotIdValue")

read, err := client.GetConfigurationSnapshot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetConfigurationSnapshotSlot

ctx := context.TODO()
id := webapps.NewWebSnapshotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "snapshotIdValue")

read, err := client.GetConfigurationSnapshotSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetContainerLogsZip

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetContainerLogsZip(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetContainerLogsZipSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetContainerLogsZipSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetContinuousWebJob

ctx := context.TODO()
id := webapps.NewContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "continuousWebJobValue")

read, err := client.GetContinuousWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetContinuousWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "continuousWebJobValue")

read, err := client.GetContinuousWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetDeployment

ctx := context.TODO()
id := webapps.NewDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "deploymentValue")

read, err := client.GetDeployment(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetDeploymentSlot

ctx := context.TODO()
id := webapps.NewSlotDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "deploymentValue")

read, err := client.GetDeploymentSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetDiagnosticLogsConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetDiagnosticLogsConfiguration(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetDiagnosticLogsConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetDiagnosticLogsConfigurationSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetDomainOwnershipIdentifier

ctx := context.TODO()
id := webapps.NewDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "domainOwnershipIdentifierValue")

read, err := client.GetDomainOwnershipIdentifier(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetDomainOwnershipIdentifierSlot

ctx := context.TODO()
id := webapps.NewSlotDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "domainOwnershipIdentifierValue")

read, err := client.GetDomainOwnershipIdentifierSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetFtpAllowed

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetFtpAllowed(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetFtpAllowedSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetFtpAllowedSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetFunction

ctx := context.TODO()
id := webapps.NewFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue")

read, err := client.GetFunction(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetFunctionsAdminToken

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetFunctionsAdminToken(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetFunctionsAdminTokenSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetFunctionsAdminTokenSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetHostNameBinding

ctx := context.TODO()
id := webapps.NewHostNameBindingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hostNameBindingValue")

read, err := client.GetHostNameBinding(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetHostNameBindingSlot

ctx := context.TODO()
id := webapps.NewSlotHostNameBindingID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hostNameBindingValue")

read, err := client.GetHostNameBindingSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetHybridConnection

ctx := context.TODO()
id := webapps.NewRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionNamespaceValue", "relayValue")

read, err := client.GetHybridConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetHybridConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionNamespaceRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionNamespaceValue", "relayValue")

read, err := client.GetHybridConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceFunctionSlot

ctx := context.TODO()
id := webapps.NewSlotFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue")

read, err := client.GetInstanceFunctionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceInfo

ctx := context.TODO()
id := webapps.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue")

read, err := client.GetInstanceInfo(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceInfoSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue")

read, err := client.GetInstanceInfoSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceMSDeployLog

ctx := context.TODO()
id := webapps.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue")

read, err := client.GetInstanceMSDeployLog(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceMSDeployLogSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue")

read, err := client.GetInstanceMSDeployLogSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceMsDeployStatus

ctx := context.TODO()
id := webapps.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue")

read, err := client.GetInstanceMsDeployStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceMsDeployStatusSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue")

read, err := client.GetInstanceMsDeployStatusSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceProcess

ctx := context.TODO()
id := webapps.NewInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue", "processIdValue")

read, err := client.GetInstanceProcess(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceProcessDump

ctx := context.TODO()
id := webapps.NewInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue", "processIdValue")

read, err := client.GetInstanceProcessDump(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceProcessDumpSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue", "processIdValue")

read, err := client.GetInstanceProcessDumpSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceProcessModule

ctx := context.TODO()
id := webapps.NewInstanceProcessModuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue", "processIdValue", "moduleValue")

read, err := client.GetInstanceProcessModule(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceProcessModuleSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceProcessModuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue", "processIdValue", "moduleValue")

read, err := client.GetInstanceProcessModuleSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceProcessSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue", "processIdValue")

read, err := client.GetInstanceProcessSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetInstanceWorkflowSlot

ctx := context.TODO()
id := webapps.NewSlotWorkflowID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "workflowValue")

read, err := client.GetInstanceWorkflowSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetMSDeployLog

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetMSDeployLog(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetMSDeployLogSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetMSDeployLogSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetMSDeployStatus

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetMSDeployStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetMSDeployStatusSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetMSDeployStatusSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetMigrateMySqlStatus

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetMigrateMySqlStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetMigrateMySqlStatusSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetMigrateMySqlStatusSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetNetworkTraces

ctx := context.TODO()
id := webapps.NewNetworkTraceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "operationIdValue")

read, err := client.GetNetworkTraces(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetNetworkTracesSlot

ctx := context.TODO()
id := webapps.NewSlotNetworkTraceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "operationIdValue")

read, err := client.GetNetworkTracesSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetNetworkTracesSlotV2

ctx := context.TODO()
id := webapps.NewSiteSlotNetworkTraceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "operationIdValue")

read, err := client.GetNetworkTracesSlotV2(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetNetworkTracesV2

ctx := context.TODO()
id := webapps.NewSiteNetworkTraceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "operationIdValue")

read, err := client.GetNetworkTracesV2(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetOneDeployStatus

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetOneDeployStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPremierAddOn

ctx := context.TODO()
id := webapps.NewPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "premierAddonValue")

read, err := client.GetPremierAddOn(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPremierAddOnSlot

ctx := context.TODO()
id := webapps.NewSlotPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "premierAddonValue")

read, err := client.GetPremierAddOnSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPrivateAccess

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetPrivateAccess(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPrivateAccessSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetPrivateAccessSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPrivateEndpointConnection

ctx := context.TODO()
id := webapps.NewPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "privateEndpointConnectionValue")

read, err := client.GetPrivateEndpointConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPrivateEndpointConnectionList

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.GetPrivateEndpointConnectionList(ctx, id)` can be used to do batched pagination
items, err := client.GetPrivateEndpointConnectionListComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.GetPrivateEndpointConnectionListSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.GetPrivateEndpointConnectionListSlot(ctx, id)` can be used to do batched pagination
items, err := client.GetPrivateEndpointConnectionListSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.GetPrivateEndpointConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotPrivateEndpointConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "privateEndpointConnectionValue")

read, err := client.GetPrivateEndpointConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPrivateLinkResources

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetPrivateLinkResources(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPrivateLinkResourcesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetPrivateLinkResourcesSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetProcess

ctx := context.TODO()
id := webapps.NewProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "processIdValue")

read, err := client.GetProcess(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetProcessDump

ctx := context.TODO()
id := webapps.NewProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "processIdValue")

read, err := client.GetProcessDump(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetProcessDumpSlot

ctx := context.TODO()
id := webapps.NewSlotProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "processIdValue")

read, err := client.GetProcessDumpSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetProcessModule

ctx := context.TODO()
id := webapps.NewModuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "processIdValue", "moduleValue")

read, err := client.GetProcessModule(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetProcessModuleSlot

ctx := context.TODO()
id := webapps.NewProcessModuleID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "processIdValue", "moduleValue")

read, err := client.GetProcessModuleSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetProcessSlot

ctx := context.TODO()
id := webapps.NewSlotProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "processIdValue")

read, err := client.GetProcessSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPublicCertificate

ctx := context.TODO()
id := webapps.NewPublicCertificateID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "publicCertificateValue")

read, err := client.GetPublicCertificate(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetPublicCertificateSlot

ctx := context.TODO()
id := webapps.NewSlotPublicCertificateID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "publicCertificateValue")

read, err := client.GetPublicCertificateSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetRelayServiceConnection

ctx := context.TODO()
id := webapps.NewHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionValue")

read, err := client.GetRelayServiceConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetRelayServiceConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionValue")

read, err := client.GetRelayServiceConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetScmAllowed

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetScmAllowed(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetScmAllowedSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetScmAllowedSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSiteConnectionStringKeyVaultReference

ctx := context.TODO()
id := webapps.NewConnectionStringID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "connectionStringKeyValue")

read, err := client.GetSiteConnectionStringKeyVaultReference(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSiteConnectionStringKeyVaultReferenceSlot

ctx := context.TODO()
id := webapps.NewConfigReferenceConnectionStringID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "connectionStringKeyValue")

read, err := client.GetSiteConnectionStringKeyVaultReferenceSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSiteConnectionStringKeyVaultReferences

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.GetSiteConnectionStringKeyVaultReferences(ctx, id)` can be used to do batched pagination
items, err := client.GetSiteConnectionStringKeyVaultReferencesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.GetSiteConnectionStringKeyVaultReferencesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.GetSiteConnectionStringKeyVaultReferencesSlot(ctx, id)` can be used to do batched pagination
items, err := client.GetSiteConnectionStringKeyVaultReferencesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.GetSiteExtension

ctx := context.TODO()
id := webapps.NewSiteExtensionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "siteExtensionIdValue")

read, err := client.GetSiteExtension(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSiteExtensionSlot

ctx := context.TODO()
id := webapps.NewSlotSiteExtensionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "siteExtensionIdValue")

read, err := client.GetSiteExtensionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSitePhpErrorLogFlag

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetSitePhpErrorLogFlag(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSitePhpErrorLogFlagSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetSitePhpErrorLogFlagSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSourceControl

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetSourceControl(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSourceControlSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetSourceControlSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSwiftVirtualNetworkConnection

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetSwiftVirtualNetworkConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetSwiftVirtualNetworkConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetSwiftVirtualNetworkConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetTriggeredWebJob

ctx := context.TODO()
id := webapps.NewTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "triggeredWebJobValue")

read, err := client.GetTriggeredWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetTriggeredWebJobHistory

ctx := context.TODO()
id := webapps.NewHistoryID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "triggeredWebJobValue", "historyValue")

read, err := client.GetTriggeredWebJobHistory(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetTriggeredWebJobHistorySlot

ctx := context.TODO()
id := webapps.NewTriggeredWebJobHistoryID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "triggeredWebJobValue", "historyValue")

read, err := client.GetTriggeredWebJobHistorySlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetTriggeredWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "triggeredWebJobValue")

read, err := client.GetTriggeredWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetVnetConnection

ctx := context.TODO()
id := webapps.NewVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue")

read, err := client.GetVnetConnection(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetVnetConnectionGateway

ctx := context.TODO()
id := webapps.NewGatewayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue", "gatewayValue")

read, err := client.GetVnetConnectionGateway(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetVnetConnectionGatewaySlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionGatewayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue", "gatewayValue")

read, err := client.GetVnetConnectionGatewaySlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetVnetConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue")

read, err := client.GetVnetConnectionSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetWebJob

ctx := context.TODO()
id := webapps.NewWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "webJobValue")

read, err := client.GetWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "webJobValue")

read, err := client.GetWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetWebSiteContainerLogs

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.GetWebSiteContainerLogs(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetWebSiteContainerLogsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.GetWebSiteContainerLogsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.GetWorkflow

ctx := context.TODO()
id := webapps.NewWorkflowID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "workflowValue")

read, err := client.GetWorkflow(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.InstallSiteExtension

ctx := context.TODO()
id := webapps.NewSiteExtensionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "siteExtensionIdValue")

if err := client.InstallSiteExtensionThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.InstallSiteExtensionSlot

ctx := context.TODO()
id := webapps.NewSlotSiteExtensionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "siteExtensionIdValue")

if err := client.InstallSiteExtensionSlotThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.IsCloneable

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.IsCloneable(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.IsCloneableSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.IsCloneableSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.List

ctx := context.TODO()
id := commonids.NewSubscriptionID("12345678-1234-9876-4563-123456789012")

// alternatively `client.List(ctx, id)` can be used to do batched pagination
items, err := client.ListComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListApplicationSettings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListApplicationSettings(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListApplicationSettingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListApplicationSettingsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListAzureStorageAccounts

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListAzureStorageAccounts(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListAzureStorageAccountsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListAzureStorageAccountsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListBackupStatusSecrets

ctx := context.TODO()
id := webapps.NewBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "backupIdValue")

payload := webapps.BackupRequest{
	// ...
}


read, err := client.ListBackupStatusSecrets(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListBackupStatusSecretsSlot

ctx := context.TODO()
id := webapps.NewSlotBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "backupIdValue")

payload := webapps.BackupRequest{
	// ...
}


read, err := client.ListBackupStatusSecretsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListBackups

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListBackups(ctx, id)` can be used to do batched pagination
items, err := client.ListBackupsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListBackupsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListBackupsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListBackupsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListBasicPublishingCredentialsPolicies

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListBasicPublishingCredentialsPolicies(ctx, id)` can be used to do batched pagination
items, err := client.ListBasicPublishingCredentialsPoliciesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListBasicPublishingCredentialsPoliciesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListBasicPublishingCredentialsPoliciesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListBasicPublishingCredentialsPoliciesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListByResourceGroup

ctx := context.TODO()
id := commonids.NewResourceGroupID("12345678-1234-9876-4563-123456789012", "example-resource-group")

// alternatively `client.ListByResourceGroup(ctx, id, webapps.DefaultListByResourceGroupOperationOptions())` can be used to do batched pagination
items, err := client.ListByResourceGroupComplete(ctx, id, webapps.DefaultListByResourceGroupOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListConfigurationSnapshotInfo

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListConfigurationSnapshotInfo(ctx, id)` can be used to do batched pagination
items, err := client.ListConfigurationSnapshotInfoComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListConfigurationSnapshotInfoSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListConfigurationSnapshotInfoSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListConfigurationSnapshotInfoSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListConfigurations

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListConfigurations(ctx, id)` can be used to do batched pagination
items, err := client.ListConfigurationsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListConfigurationsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListConfigurationsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListConfigurationsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListConnectionStrings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListConnectionStrings(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListConnectionStringsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListConnectionStringsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListContinuousWebJobs

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListContinuousWebJobs(ctx, id)` can be used to do batched pagination
items, err := client.ListContinuousWebJobsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListContinuousWebJobsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListContinuousWebJobsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListContinuousWebJobsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListDeploymentLog

ctx := context.TODO()
id := webapps.NewDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "deploymentValue")

read, err := client.ListDeploymentLog(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListDeploymentLogSlot

ctx := context.TODO()
id := webapps.NewSlotDeploymentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "deploymentValue")

read, err := client.ListDeploymentLogSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListDeployments

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListDeployments(ctx, id)` can be used to do batched pagination
items, err := client.ListDeploymentsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListDeploymentsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListDeploymentsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListDeploymentsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListDomainOwnershipIdentifiers

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListDomainOwnershipIdentifiers(ctx, id)` can be used to do batched pagination
items, err := client.ListDomainOwnershipIdentifiersComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListDomainOwnershipIdentifiersSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListDomainOwnershipIdentifiersSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListDomainOwnershipIdentifiersSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListFunctionKeys

ctx := context.TODO()
id := webapps.NewFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue")

read, err := client.ListFunctionKeys(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListFunctionKeysSlot

ctx := context.TODO()
id := webapps.NewSlotFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue")

read, err := client.ListFunctionKeysSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListFunctionSecrets

ctx := context.TODO()
id := webapps.NewFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "functionValue")

read, err := client.ListFunctionSecrets(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListFunctionSecretsSlot

ctx := context.TODO()
id := webapps.NewSlotFunctionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "functionValue")

read, err := client.ListFunctionSecretsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListFunctions

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListFunctions(ctx, id)` can be used to do batched pagination
items, err := client.ListFunctionsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListHostKeys

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListHostKeys(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListHostKeysSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListHostKeysSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListHostNameBindings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListHostNameBindings(ctx, id)` can be used to do batched pagination
items, err := client.ListHostNameBindingsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListHostNameBindingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListHostNameBindingsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListHostNameBindingsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListHybridConnections

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListHybridConnections(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListHybridConnectionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListHybridConnectionsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListInstanceFunctionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListInstanceFunctionsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceFunctionsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceIdentifiers

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListInstanceIdentifiers(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceIdentifiersComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceIdentifiersSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListInstanceIdentifiersSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceIdentifiersSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceProcessModules

ctx := context.TODO()
id := webapps.NewInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue", "processIdValue")

// alternatively `client.ListInstanceProcessModules(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceProcessModulesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceProcessModulesSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue", "processIdValue")

// alternatively `client.ListInstanceProcessModulesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceProcessModulesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceProcessThreads

ctx := context.TODO()
id := webapps.NewInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue", "processIdValue")

// alternatively `client.ListInstanceProcessThreads(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceProcessThreadsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceProcessThreadsSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue", "processIdValue")

// alternatively `client.ListInstanceProcessThreadsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceProcessThreadsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceProcesses

ctx := context.TODO()
id := webapps.NewInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "instanceIdValue")

// alternatively `client.ListInstanceProcesses(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceProcessesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceProcessesSlot

ctx := context.TODO()
id := webapps.NewSlotInstanceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "instanceIdValue")

// alternatively `client.ListInstanceProcessesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceProcessesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListInstanceWorkflowsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListInstanceWorkflowsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListInstanceWorkflowsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListMetadata

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListMetadata(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListMetadataSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListMetadataSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListNetworkFeatures

ctx := context.TODO()
id := webapps.NewNetworkFeatureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "networkFeatureValue")

read, err := client.ListNetworkFeatures(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListNetworkFeaturesSlot

ctx := context.TODO()
id := webapps.NewSlotNetworkFeatureID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "networkFeatureValue")

read, err := client.ListNetworkFeaturesSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListPerfMonCounters

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListPerfMonCounters(ctx, id, webapps.DefaultListPerfMonCountersOperationOptions())` can be used to do batched pagination
items, err := client.ListPerfMonCountersComplete(ctx, id, webapps.DefaultListPerfMonCountersOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListPerfMonCountersSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListPerfMonCountersSlot(ctx, id, webapps.DefaultListPerfMonCountersSlotOperationOptions())` can be used to do batched pagination
items, err := client.ListPerfMonCountersSlotComplete(ctx, id, webapps.DefaultListPerfMonCountersSlotOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListPremierAddOns

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListPremierAddOns(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListPremierAddOnsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListPremierAddOnsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListProcessModules

ctx := context.TODO()
id := webapps.NewProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "processIdValue")

// alternatively `client.ListProcessModules(ctx, id)` can be used to do batched pagination
items, err := client.ListProcessModulesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListProcessModulesSlot

ctx := context.TODO()
id := webapps.NewSlotProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "processIdValue")

// alternatively `client.ListProcessModulesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListProcessModulesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListProcessThreads

ctx := context.TODO()
id := webapps.NewProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "processIdValue")

// alternatively `client.ListProcessThreads(ctx, id)` can be used to do batched pagination
items, err := client.ListProcessThreadsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListProcessThreadsSlot

ctx := context.TODO()
id := webapps.NewSlotProcessID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "processIdValue")

// alternatively `client.ListProcessThreadsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListProcessThreadsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListProcesses

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListProcesses(ctx, id)` can be used to do batched pagination
items, err := client.ListProcessesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListProcessesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListProcessesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListProcessesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListProductionSiteDeploymentStatuses

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListProductionSiteDeploymentStatuses(ctx, id)` can be used to do batched pagination
items, err := client.ListProductionSiteDeploymentStatusesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListPublicCertificates

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListPublicCertificates(ctx, id)` can be used to do batched pagination
items, err := client.ListPublicCertificatesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListPublicCertificatesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListPublicCertificatesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListPublicCertificatesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListPublishingCredentials

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

if err := client.ListPublishingCredentialsThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.ListPublishingCredentialsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

if err := client.ListPublishingCredentialsSlotThenPoll(ctx, id); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.ListPublishingProfileXmlWithSecrets

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.CsmPublishingProfileOptions{
	// ...
}


read, err := client.ListPublishingProfileXmlWithSecrets(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListPublishingProfileXmlWithSecretsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.CsmPublishingProfileOptions{
	// ...
}


read, err := client.ListPublishingProfileXmlWithSecretsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListRelayServiceConnections

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListRelayServiceConnections(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListRelayServiceConnectionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListRelayServiceConnectionsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSiteBackups

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSiteBackups(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteBackupsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSiteBackupsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSiteBackupsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteBackupsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSiteExtensions

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSiteExtensions(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteExtensionsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSiteExtensionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSiteExtensionsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteExtensionsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSitePushSettings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListSitePushSettings(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSitePushSettingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListSitePushSettingsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSlotConfigurationNames

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListSlotConfigurationNames(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSlotDifferencesFromProduction

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.CsmSlotEntity{
	// ...
}


// alternatively `client.ListSlotDifferencesFromProduction(ctx, id, payload)` can be used to do batched pagination
items, err := client.ListSlotDifferencesFromProductionComplete(ctx, id, payload)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSlotDifferencesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.CsmSlotEntity{
	// ...
}


// alternatively `client.ListSlotDifferencesSlot(ctx, id, payload)` can be used to do batched pagination
items, err := client.ListSlotDifferencesSlotComplete(ctx, id, payload)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSlotSiteDeploymentStatusesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSlotSiteDeploymentStatusesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSlotSiteDeploymentStatusesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSlots

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSlots(ctx, id)` can be used to do batched pagination
items, err := client.ListSlotsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSnapshots

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSnapshots(ctx, id)` can be used to do batched pagination
items, err := client.ListSnapshotsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSnapshotsFromDRSecondary

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSnapshotsFromDRSecondary(ctx, id)` can be used to do batched pagination
items, err := client.ListSnapshotsFromDRSecondaryComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSnapshotsFromDRSecondarySlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSnapshotsFromDRSecondarySlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSnapshotsFromDRSecondarySlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSnapshotsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSnapshotsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSnapshotsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListSyncFunctionTriggers

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListSyncFunctionTriggers(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSyncFunctionTriggersSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListSyncFunctionTriggersSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSyncStatus

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListSyncStatus(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListSyncStatusSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListSyncStatusSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListTriggeredWebJobHistory

ctx := context.TODO()
id := webapps.NewTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "triggeredWebJobValue")

// alternatively `client.ListTriggeredWebJobHistory(ctx, id)` can be used to do batched pagination
items, err := client.ListTriggeredWebJobHistoryComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListTriggeredWebJobHistorySlot

ctx := context.TODO()
id := webapps.NewSlotTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "triggeredWebJobValue")

// alternatively `client.ListTriggeredWebJobHistorySlot(ctx, id)` can be used to do batched pagination
items, err := client.ListTriggeredWebJobHistorySlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListTriggeredWebJobs

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListTriggeredWebJobs(ctx, id)` can be used to do batched pagination
items, err := client.ListTriggeredWebJobsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListTriggeredWebJobsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListTriggeredWebJobsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListTriggeredWebJobsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListUsages

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListUsages(ctx, id, webapps.DefaultListUsagesOperationOptions())` can be used to do batched pagination
items, err := client.ListUsagesComplete(ctx, id, webapps.DefaultListUsagesOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListUsagesSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListUsagesSlot(ctx, id, webapps.DefaultListUsagesSlotOperationOptions())` can be used to do batched pagination
items, err := client.ListUsagesSlotComplete(ctx, id, webapps.DefaultListUsagesSlotOperationOptions())
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListVnetConnections

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListVnetConnections(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListVnetConnectionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListVnetConnectionsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListWebJobs

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListWebJobs(ctx, id)` can be used to do batched pagination
items, err := client.ListWebJobsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListWebJobsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListWebJobsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListWebJobsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListWorkflows

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListWorkflows(ctx, id)` can be used to do batched pagination
items, err := client.ListWorkflowsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: WebAppsClient.ListWorkflowsConnections

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ListWorkflowsConnections(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ListWorkflowsConnectionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ListWorkflowsConnectionsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.MigrateMySql

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.MigrateMySqlRequest{
	// ...
}


if err := client.MigrateMySqlThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.MigrateStorage

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.StorageMigrationOptions{
	// ...
}


if err := client.MigrateStorageThenPoll(ctx, id, payload, webapps.DefaultMigrateStorageOperationOptions()); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.PutPrivateAccessVnet

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.PrivateAccess{
	// ...
}


read, err := client.PutPrivateAccessVnet(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.PutPrivateAccessVnetSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.PrivateAccess{
	// ...
}


read, err := client.PutPrivateAccessVnetSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.RecoverSiteConfigurationSnapshot

ctx := context.TODO()
id := webapps.NewSnapshotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "snapshotIdValue")

read, err := client.RecoverSiteConfigurationSnapshot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.RecoverSiteConfigurationSnapshotSlot

ctx := context.TODO()
id := webapps.NewWebSnapshotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "snapshotIdValue")

read, err := client.RecoverSiteConfigurationSnapshotSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ResetProductionSlotConfig

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.ResetProductionSlotConfig(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.ResetSlotConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.ResetSlotConfigurationSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Restart

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.Restart(ctx, id, webapps.DefaultRestartOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.RestartSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.RestartSlot(ctx, id, webapps.DefaultRestartSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Restore

ctx := context.TODO()
id := webapps.NewBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "backupIdValue")

payload := webapps.RestoreRequest{
	// ...
}


if err := client.RestoreThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreFromBackupBlob

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.RestoreRequest{
	// ...
}


if err := client.RestoreFromBackupBlobThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreFromBackupBlobSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.RestoreRequest{
	// ...
}


if err := client.RestoreFromBackupBlobSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreFromDeletedApp

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.DeletedAppRestoreRequest{
	// ...
}


if err := client.RestoreFromDeletedAppThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreFromDeletedAppSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.DeletedAppRestoreRequest{
	// ...
}


if err := client.RestoreFromDeletedAppSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreSlot

ctx := context.TODO()
id := webapps.NewSlotBackupID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "backupIdValue")

payload := webapps.RestoreRequest{
	// ...
}


if err := client.RestoreSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreSnapshot

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SnapshotRestoreRequest{
	// ...
}


if err := client.RestoreSnapshotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RestoreSnapshotSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SnapshotRestoreRequest{
	// ...
}


if err := client.RestoreSnapshotSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.RunTriggeredWebJob

ctx := context.TODO()
id := webapps.NewTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "triggeredWebJobValue")

read, err := client.RunTriggeredWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.RunTriggeredWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotTriggeredWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "triggeredWebJobValue")

read, err := client.RunTriggeredWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Start

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.Start(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StartContinuousWebJob

ctx := context.TODO()
id := webapps.NewContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "continuousWebJobValue")

read, err := client.StartContinuousWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StartContinuousWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "continuousWebJobValue")

read, err := client.StartContinuousWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StartNetworkTrace

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

if err := client.StartNetworkTraceThenPoll(ctx, id, webapps.DefaultStartNetworkTraceOperationOptions()); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.StartNetworkTraceSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

if err := client.StartNetworkTraceSlotThenPoll(ctx, id, webapps.DefaultStartNetworkTraceSlotOperationOptions()); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.StartSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.StartSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StartWebSiteNetworkTrace

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.StartWebSiteNetworkTrace(ctx, id, webapps.DefaultStartWebSiteNetworkTraceOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StartWebSiteNetworkTraceOperation

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

if err := client.StartWebSiteNetworkTraceOperationThenPoll(ctx, id, webapps.DefaultStartWebSiteNetworkTraceOperationOperationOptions()); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.StartWebSiteNetworkTraceOperationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

if err := client.StartWebSiteNetworkTraceOperationSlotThenPoll(ctx, id, webapps.DefaultStartWebSiteNetworkTraceOperationSlotOperationOptions()); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.StartWebSiteNetworkTraceSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.StartWebSiteNetworkTraceSlot(ctx, id, webapps.DefaultStartWebSiteNetworkTraceSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Stop

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.Stop(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopContinuousWebJob

ctx := context.TODO()
id := webapps.NewContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "continuousWebJobValue")

read, err := client.StopContinuousWebJob(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopContinuousWebJobSlot

ctx := context.TODO()
id := webapps.NewSlotContinuousWebJobID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "continuousWebJobValue")

read, err := client.StopContinuousWebJobSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopNetworkTrace

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.StopNetworkTrace(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopNetworkTraceSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.StopNetworkTraceSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.StopSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopWebSiteNetworkTrace

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.StopWebSiteNetworkTrace(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.StopWebSiteNetworkTraceSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.StopWebSiteNetworkTraceSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.SwapSlotSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.CsmSlotEntity{
	// ...
}


if err := client.SwapSlotSlotThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.SwapSlotWithProduction

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.CsmSlotEntity{
	// ...
}


if err := client.SwapSlotWithProductionThenPoll(ctx, id, payload); err != nil {
	// handle the error
}

Example Usage: WebAppsClient.SyncFunctionTriggers

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.SyncFunctionTriggers(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.SyncFunctionTriggersSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.SyncFunctionTriggersSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.SyncFunctions

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.SyncFunctions(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.SyncFunctionsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.SyncFunctionsSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.SyncRepository

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

read, err := client.SyncRepository(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.SyncRepositorySlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

read, err := client.SyncRepositorySlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.Update

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SitePatchResource{
	// ...
}


read, err := client.Update(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateApplicationSettings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.StringDictionary{
	// ...
}


read, err := client.UpdateApplicationSettings(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateApplicationSettingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.StringDictionary{
	// ...
}


read, err := client.UpdateApplicationSettingsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateAuthSettings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteAuthSettings{
	// ...
}


read, err := client.UpdateAuthSettings(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateAuthSettingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteAuthSettings{
	// ...
}


read, err := client.UpdateAuthSettingsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateAuthSettingsV2

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteAuthSettingsV2{
	// ...
}


read, err := client.UpdateAuthSettingsV2(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateAuthSettingsV2Slot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteAuthSettingsV2{
	// ...
}


read, err := client.UpdateAuthSettingsV2Slot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateAzureStorageAccounts

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.AzureStoragePropertyDictionaryResource{
	// ...
}


read, err := client.UpdateAzureStorageAccounts(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateAzureStorageAccountsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.AzureStoragePropertyDictionaryResource{
	// ...
}


read, err := client.UpdateAzureStorageAccountsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateBackupConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.BackupRequest{
	// ...
}


read, err := client.UpdateBackupConfiguration(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateBackupConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.BackupRequest{
	// ...
}


read, err := client.UpdateBackupConfigurationSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateConfiguration

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteConfigResource{
	// ...
}


read, err := client.UpdateConfiguration(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateConfigurationSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteConfigResource{
	// ...
}


read, err := client.UpdateConfigurationSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateConnectionStrings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.ConnectionStringDictionary{
	// ...
}


read, err := client.UpdateConnectionStrings(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateConnectionStringsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.ConnectionStringDictionary{
	// ...
}


read, err := client.UpdateConnectionStringsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateDiagnosticLogsConfig

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteLogsConfig{
	// ...
}


read, err := client.UpdateDiagnosticLogsConfig(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateDiagnosticLogsConfigSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteLogsConfig{
	// ...
}


read, err := client.UpdateDiagnosticLogsConfigSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateDomainOwnershipIdentifier

ctx := context.TODO()
id := webapps.NewDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "domainOwnershipIdentifierValue")

payload := webapps.Identifier{
	// ...
}


read, err := client.UpdateDomainOwnershipIdentifier(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateDomainOwnershipIdentifierSlot

ctx := context.TODO()
id := webapps.NewSlotDomainOwnershipIdentifierID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "domainOwnershipIdentifierValue")

payload := webapps.Identifier{
	// ...
}


read, err := client.UpdateDomainOwnershipIdentifierSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateFtpAllowed

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.CsmPublishingCredentialsPoliciesEntity{
	// ...
}


read, err := client.UpdateFtpAllowed(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateFtpAllowedSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.CsmPublishingCredentialsPoliciesEntity{
	// ...
}


read, err := client.UpdateFtpAllowedSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateHybridConnection

ctx := context.TODO()
id := webapps.NewRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionNamespaceValue", "relayValue")

payload := webapps.HybridConnection{
	// ...
}


read, err := client.UpdateHybridConnection(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateHybridConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionNamespaceRelayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionNamespaceValue", "relayValue")

payload := webapps.HybridConnection{
	// ...
}


read, err := client.UpdateHybridConnectionSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateMetadata

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.StringDictionary{
	// ...
}


read, err := client.UpdateMetadata(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateMetadataSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.StringDictionary{
	// ...
}


read, err := client.UpdateMetadataSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdatePremierAddOn

ctx := context.TODO()
id := webapps.NewPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "premierAddonValue")

payload := webapps.PremierAddOnPatchResource{
	// ...
}


read, err := client.UpdatePremierAddOn(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdatePremierAddOnSlot

ctx := context.TODO()
id := webapps.NewSlotPremierAddonID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "premierAddonValue")

payload := webapps.PremierAddOnPatchResource{
	// ...
}


read, err := client.UpdatePremierAddOnSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateRelayServiceConnection

ctx := context.TODO()
id := webapps.NewHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "hybridConnectionValue")

payload := webapps.RelayServiceConnectionEntity{
	// ...
}


read, err := client.UpdateRelayServiceConnection(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateRelayServiceConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotHybridConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "hybridConnectionValue")

payload := webapps.RelayServiceConnectionEntity{
	// ...
}


read, err := client.UpdateRelayServiceConnectionSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateScmAllowed

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.CsmPublishingCredentialsPoliciesEntity{
	// ...
}


read, err := client.UpdateScmAllowed(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateScmAllowedSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.CsmPublishingCredentialsPoliciesEntity{
	// ...
}


read, err := client.UpdateScmAllowedSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSitePushSettings

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.PushSettings{
	// ...
}


read, err := client.UpdateSitePushSettings(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSitePushSettingsSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.PushSettings{
	// ...
}


read, err := client.UpdateSitePushSettingsSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SitePatchResource{
	// ...
}


read, err := client.UpdateSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSlotConfigurationNames

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SlotConfigNamesResource{
	// ...
}


read, err := client.UpdateSlotConfigurationNames(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSourceControl

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SiteSourceControl{
	// ...
}


read, err := client.UpdateSourceControl(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSourceControlSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SiteSourceControl{
	// ...
}


read, err := client.UpdateSourceControlSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSwiftVirtualNetworkConnectionWithCheck

ctx := context.TODO()
id := commonids.NewAppServiceID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

payload := webapps.SwiftVirtualNetwork{
	// ...
}


read, err := client.UpdateSwiftVirtualNetworkConnectionWithCheck(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateSwiftVirtualNetworkConnectionWithCheckSlot

ctx := context.TODO()
id := webapps.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

payload := webapps.SwiftVirtualNetwork{
	// ...
}


read, err := client.UpdateSwiftVirtualNetworkConnectionWithCheckSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateVnetConnection

ctx := context.TODO()
id := webapps.NewVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue")

payload := webapps.VnetInfoResource{
	// ...
}


read, err := client.UpdateVnetConnection(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateVnetConnectionGateway

ctx := context.TODO()
id := webapps.NewGatewayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "virtualNetworkConnectionValue", "gatewayValue")

payload := webapps.VnetGateway{
	// ...
}


read, err := client.UpdateVnetConnectionGateway(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateVnetConnectionGatewaySlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionGatewayID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue", "gatewayValue")

payload := webapps.VnetGateway{
	// ...
}


read, err := client.UpdateVnetConnectionGatewaySlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: WebAppsClient.UpdateVnetConnectionSlot

ctx := context.TODO()
id := webapps.NewSlotVirtualNetworkConnectionID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "virtualNetworkConnectionValue")

payload := webapps.VnetInfoResource{
	// ...
}


read, err := client.UpdateVnetConnectionSlot(ctx, id, payload)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}